Avoid allocations of size 0 since they mess with the nursery. Explicitly specify how much memory to preserve when calling Realloc. Try recycling large allocs ASAP.

hughsando · hughsando · commit 82b90eeddf2a · 2020-06-14T23:20:53.000+08:00
diff --git a/include/hx/GC.h b/include/hx/GC.h
@@ -114,7 +114,9 @@ namespace hx
 void *InternalNew(int inSize,bool inIsObject);
 
 // Used internall - realloc array data
-void *InternalRealloc(void *inData,int inSize,bool inAllowExpansion=false);
+void *InternalRealloc(int inFromSize, void *inData,int inSize,bool inAllowExpansion=false);
+
+void InternalReleaseMem(void *inMem);
 
 unsigned int ObjectSizeSafe(void *inData);
 
diff --git a/src/Array.cpp b/src/Array.cpp
@@ -42,19 +42,20 @@ void ArrayBase::reserve(int inSize) const
 {
    if (mAlloc<inSize)
    {
-      int bytes = inSize * GetElementSize();
+      int elemSize = GetElementSize();
+      int bytes = inSize * elemSize;
 
       if (mBase)
       {
          bool wasUnamanaged = mAlloc<0;
          if (wasUnamanaged)
          {
             char *base=(char *)hx::InternalNew(bytes,false);
-            memcpy(base,mBase,length*GetElementSize());
+            memcpy(base,mBase,length*elemSize);
             mBase = base;
          }
          else
-            mBase = (char *)hx::InternalRealloc(mBase, bytes );
+            mBase = (char *)hx::InternalRealloc(length*elemSize,mBase, bytes );
       }
       else
       {
@@ -101,12 +102,12 @@ void ArrayBase::Realloc(int inSize) const
          if (wasUnamanaged)
          {
             char *base=(char *)hx::InternalNew(bytes,false);
-            memcpy(base,mBase,length*GetElementSize());
+            memcpy(base,mBase,length*elemSize);
             mBase = base;
          }
          else
          {
-            mBase = (char *)hx::InternalRealloc(mBase, bytes, true);
+            mBase = (char *)hx::InternalRealloc(length*elemSize,mBase, bytes, true);
             int o = bytes;
             bytes = hx::ObjectSizeSafe(mBase);
          }
@@ -213,21 +214,28 @@ String ArrayBase::toString()
 
 void ArrayBase::__SetSizeExact(int inSize)
 {
-   if (inSize!=length || inSize!=mAlloc)
+   if (inSize==0)
    {
-      int bytes = inSize * GetElementSize();
+      InternalReleaseMem(mBase);
+      mBase = 0;
+      mAlloc = length = 0;
+   }
+   else if (inSize!=length || inSize!=mAlloc)
+   {
+      int elemSize = GetElementSize();
+      int bytes = inSize * elemSize;
       if (mBase)
       {
          bool wasUnamanaged = mAlloc<0;
 
          if (wasUnamanaged)
          {
             char *base=(char *)(AllocAtomic() ? hx::NewGCPrivate(0,bytes) : hx::NewGCBytes(0,bytes));
-            memcpy(base,mBase,std::min(length,inSize)*GetElementSize());
+            memcpy(base,mBase,std::min(length,inSize)*elemSize);
             mBase = base;
          }
          else
-            mBase = (char *)hx::InternalRealloc(mBase, bytes );
+            mBase = (char *)hx::InternalRealloc(length*elemSize,mBase, bytes );
       }
       else if (AllocAtomic())
       {
@@ -732,6 +740,7 @@ void ArrayBase::__boot()
 
 bool DynamicEq(const Dynamic &a, const Dynamic &b)
 {
+   // ? return hx::IsInstanceEq(a,b);
    return hx::IsEq(a,b);
 }
 
diff --git a/src/hx/Hash.h b/src/hx/Hash.h
@@ -328,7 +328,7 @@ struct Hash : public HashBase< typename ELEMENT::Key >
 #endif
       mask = inNewCount-1;
       //printf("expand %d -> %d\n",bucketCount, inNewCount);
-      bucket = (Element **)InternalRealloc(bucket,inNewCount*sizeof(ELEMENT *));
+      bucket = (Element **)InternalRealloc(bucketCount*sizeof(ELEMENT *), bucket,inNewCount*sizeof(ELEMENT *));
       HX_OBJ_WB_GET(this, bucket);
       //for(int b=bucketCount;b<inNewCount;b++)
       //   bucket[b] = 0;
@@ -369,6 +369,7 @@ struct Hash : public HashBase< typename ELEMENT::Key >
 
    void compact()
    {
+      int origSize = bucketCount;
       int newSize = bucketCount>>1;
       // printf("compact -> %d\n", newSize);
       mask = newSize-1;
@@ -392,7 +393,7 @@ struct Hash : public HashBase< typename ELEMENT::Key >
          }
       }
       bucketCount = newSize;
-      bucket = (Element **)InternalRealloc(bucket, sizeof(ELEMENT *)*bucketCount );
+      bucket = (Element **)InternalRealloc(origSize*sizeof(ELEMENT *),bucket, sizeof(ELEMENT *)*bucketCount );
       HX_OBJ_WB_GET(this, bucket);
    }
 
diff --git a/src/hx/gc/Immix.cpp b/src/hx/gc/Immix.cpp
@@ -2815,14 +2815,17 @@ void *InternalCreateConstBuffer(const void *inData,int inSize,bool inAddStringHa
    {
       memcpy(result,inData,inSize);
    }
-   else
+   else if (inSize)
    {
       ZERO_MEM(result,inSize);
    }
 
    return result;
 }
 
+// Used when the allocation size is zero for a non-null pointer
+void *emptyAlloc = InternalCreateConstBuffer(0,0,false);
+
 
 } // namespace hx
 
@@ -3116,6 +3119,31 @@ class GlobalAllocator
       }
    }
 
+   void FreeLarge(void *inLarge)
+   {
+      ((unsigned char *)inLarge)[HX_ENDIAN_MARK_ID_BYTE] = 0;
+      // AllocLarge will not lock this list unless it decides there is a suitable
+      //  value, so we can't doa realloc without potentially crashing it.
+      if (largeObjectRecycle.hasExtraCapacity(1))
+      {
+         unsigned int *blob = ((unsigned int *)inLarge) - 2;
+         unsigned int size = *blob;
+         mLargeListLock.Lock();
+         mLargeAllocated -= size;
+         // Could somehow keep it in the list, but mark as recycled?
+         mLargeList.qerase_val(blob);
+         // We could maybe free anyhow?
+         if (!largeObjectRecycle.hasExtraCapacity(1))
+         {
+            mLargeListLock.Unlock();
+            HxFree(blob);
+            return;
+         }
+         largeObjectRecycle.push(blob);
+         mLargeListLock.Unlock();
+      }
+   }
+
    void *AllocLarge(int inSize, bool inClear)
    {
       if (hx::gPauseForCollect)
@@ -6027,6 +6055,9 @@ class LocalAllocator : public hx::StackContext
          PauseForCollect();
       #endif
 
+      if (inSize==0)
+         return hx::emptyAlloc;
+
       #if defined(HXCPP_VISIT_ALLOCS) && defined(HXCPP_M64)
       // Make sure we can fit a relocation pointer
       int allocSize = sizeof(int) + std::max(8,inSize);
@@ -6485,6 +6516,9 @@ inline unsigned int ObjectSize(void *inData)
 unsigned int ObjectSizeSafe(void *inData)
 {
    unsigned int header = ((unsigned int *)(inData))[-1];
+   if (header & HX_GC_CONST_ALLOC_BIT)
+      return 0;
+
    #ifdef HXCPP_GC_NURSERY
    if (!(header & 0xff000000))
    {
@@ -6495,6 +6529,7 @@ unsigned int ObjectSizeSafe(void *inData)
    }
    #endif
 
+
    return (header & IMMIX_ALLOC_ROW_COUNT) ?
             ( (header & IMMIX_ALLOC_SIZE_MASK) >> IMMIX_ALLOC_SIZE_SHIFT) :
              ((unsigned int *)(inData))[-2];
@@ -6505,11 +6540,29 @@ void GCChangeManagedMemory(int inDelta, const char *inWhy)
    sGlobalAlloc->onMemoryChange(inDelta, inWhy);
 }
 
+void InternalReleaseMem(void *inMem)
+{
+   if (inMem)
+   {
+      unsigned int s = ObjectSizeSafe(inMem);
+      if (s>=IMMIX_LARGE_OBJ_SIZE)
+      {
+         //Can release asap
+         sGlobalAlloc->FreeLarge(inMem);
+      }
+   }
+}
+
+
 
-void *InternalRealloc(void *inData,int inSize, bool inExpand)
+void *InternalRealloc(int inFromSize, void *inData,int inSize, bool inExpand)
 {
-   if (inData==0)
+   if (inData==0 || inFromSize==0)
+   {
+      if (inData)
+         InternalReleaseMem(inData);
       return hx::InternalNew(inSize,false);
+   }
 
    HX_STACK_FRAME("GC", "realloc", 0, "GC::relloc", __FILE__ , __LINE__, 0)
 
@@ -6522,15 +6575,16 @@ void *InternalRealloc(void *inData,int inSize, bool inExpand)
    sgAllocsSinceLastSpam++;
    #endif
 
-   unsigned int s = ObjectSizeSafe(inData);
-
    void *new_data = 0;
-
-   if (inSize>=IMMIX_LARGE_OBJ_SIZE)
+   if (inSize==0)
+   {
+      new_data = hx::emptyAlloc;
+   }
+   else if (inSize>=IMMIX_LARGE_OBJ_SIZE)
    {
       new_data = sGlobalAlloc->AllocLarge(inSize, false);
-      if (inSize>s)
-         ZERO_MEM((char *)new_data + s,inSize-s);
+      if (inSize>inFromSize)
+         ZERO_MEM((char *)new_data + inFromSize,inSize-inFromSize);
    }
    else
    {
@@ -6541,12 +6595,13 @@ void *InternalRealloc(void *inData,int inSize, bool inExpand)
           new_data =  tla->CallAlloc(8,0);
       else
       #endif
+      {
+         inSize = (inSize+3) & ~3;
+         if (inExpand)
+            tla->ExpandAlloc(inSize);
 
-      inSize = (inSize+3) & ~3;
-      if (inExpand)
-         tla->ExpandAlloc(inSize);
-
-      new_data = tla->CallAlloc(inSize,0);
+         new_data = tla->CallAlloc(inSize,0);
+      }
    }
 
 
@@ -6555,17 +6610,12 @@ void *InternalRealloc(void *inData,int inSize, bool inExpand)
    __hxt_gc_realloc(inData, new_data, inSize);
 #endif
 
-   int min_size = s < inSize ? s : inSize;
+   int min_size = inFromSize < inSize ? inFromSize : inSize;
 
-   memcpy(new_data, inData, min_size );
+   if (min_size)
+      memcpy(new_data, inData, min_size );
 
-   #ifdef HXCPP_GC_GENERATIONAL
-   if (s>=IMMIX_LARGE_OBJ_SIZE && sGcMode==gcmGenerational)
-   {
-      //Can release asap
-      ((unsigned char *)inData)[HX_ENDIAN_MARK_ID_BYTE] = 0;
-   }
-   #endif
+   InternalReleaseMem(inData);
 
    return new_data;
 }
diff --git a/test/haxe/TestStringHash.hx b/test/haxe/TestStringHash.hx
@@ -34,7 +34,11 @@ class TestStringHash extends haxe.unit.TestCase
                values[idxInt] = j;
             }
          }
+         var arr = [0,1,2];
          var keys = h.keys();
+         // Empty allocations can mess with the GC nursery
+         cpp.NativeArray.setSize(arr,0);
+         cpp.NativeArray.setSize(arr,3);
          var keyed = new Array<Bool>();
          for(i in 0...values.length)
             keyed[i] = false;

Original file line number	Diff line number	Diff line change
`@@ -42,19 +42,20 @@ void ArrayBase::reserve(int inSize) const`
`42`	`42`	`{`
`43`	`43`	`if (mAlloc<inSize)`
`44`	`44`	`{`
`45`		`- int bytes = inSize * GetElementSize();`
	`45`	`+ int elemSize = GetElementSize();`
	`46`	`+ int bytes = inSize * elemSize;`
`46`	`47`
`47`	`48`	`if (mBase)`
`48`	`49`	`{`
`49`	`50`	`bool wasUnamanaged = mAlloc<0;`
`50`	`51`	`if (wasUnamanaged)`
`51`	`52`	`{`
`52`	`53`	`char base=(char )hx::InternalNew(bytes,false);`
`53`		`- memcpy(base,mBase,length*GetElementSize());`
	`54`	`+ memcpy(base,mBase,length*elemSize);`
`54`	`55`	`mBase = base;`
`55`	`56`	`}`
`56`	`57`	`else`
`57`		`- mBase = (char *)hx::InternalRealloc(mBase, bytes );`
	`58`	`+ mBase = (char )hx::InternalRealloc(lengthelemSize,mBase, bytes );`
`58`	`59`	`}`
`59`	`60`	`else`
`60`	`61`	`{`
`@@ -101,12 +102,12 @@ void ArrayBase::Realloc(int inSize) const`
`101`	`102`	`if (wasUnamanaged)`
`102`	`103`	`{`
`103`	`104`	`char base=(char )hx::InternalNew(bytes,false);`
`104`		`- memcpy(base,mBase,length*GetElementSize());`
	`105`	`+ memcpy(base,mBase,length*elemSize);`
`105`	`106`	`mBase = base;`
`106`	`107`	`}`
`107`	`108`	`else`
`108`	`109`	`{`
`109`		`- mBase = (char *)hx::InternalRealloc(mBase, bytes, true);`
	`110`	`+ mBase = (char )hx::InternalRealloc(lengthelemSize,mBase, bytes, true);`
`110`	`111`	`int o = bytes;`
`111`	`112`	`bytes = hx::ObjectSizeSafe(mBase);`
`112`	`113`	`}`
`@@ -213,21 +214,28 @@ String ArrayBase::toString()`
`213`	`214`
`214`	`215`	`void ArrayBase::__SetSizeExact(int inSize)`
`215`	`216`	`{`
`216`		`- if (inSize!=length \|\| inSize!=mAlloc)`
	`217`	`+ if (inSize==0)`
`217`	`218`	`{`
`218`		`- int bytes = inSize * GetElementSize();`
	`219`	`+ InternalReleaseMem(mBase);`
	`220`	`+ mBase = 0;`
	`221`	`+ mAlloc = length = 0;`
	`222`	`+ }`
	`223`	`+ else if (inSize!=length \|\| inSize!=mAlloc)`
	`224`	`+ {`
	`225`	`+ int elemSize = GetElementSize();`
	`226`	`+ int bytes = inSize * elemSize;`
`219`	`227`	`if (mBase)`
`220`	`228`	`{`
`221`	`229`	`bool wasUnamanaged = mAlloc<0;`
`222`	`230`
`223`	`231`	`if (wasUnamanaged)`
`224`	`232`	`{`
`225`	`233`	`char base=(char )(AllocAtomic() ? hx::NewGCPrivate(0,bytes) : hx::NewGCBytes(0,bytes));`
`226`		`- memcpy(base,mBase,std::min(length,inSize)*GetElementSize());`
	`234`	`+ memcpy(base,mBase,std::min(length,inSize)*elemSize);`
`227`	`235`	`mBase = base;`
`228`	`236`	`}`
`229`	`237`	`else`
`230`		`- mBase = (char *)hx::InternalRealloc(mBase, bytes );`
	`238`	`+ mBase = (char )hx::InternalRealloc(lengthelemSize,mBase, bytes );`
`231`	`239`	`}`
`232`	`240`	`else if (AllocAtomic())`
`233`	`241`	`{`
`@@ -732,6 +740,7 @@ void ArrayBase::__boot()`
`732`	`740`
`733`	`741`	`bool DynamicEq(const Dynamic &a, const Dynamic &b)`
`734`	`742`	`{`
	`743`	`+ // ? return hx::IsInstanceEq(a,b);`
`735`	`744`	`return hx::IsEq(a,b);`
`736`	`745`	`}`
`737`	`746`
Original file line number	Diff line number	Diff line change
`@@ -328,7 +328,7 @@ struct Hash : public HashBase< typename ELEMENT::Key >`
`328`	`328`	`#endif`
`329`	`329`	`mask = inNewCount-1;`
`330`	`330`	`//printf("expand %d -> %d\n",bucketCount, inNewCount);`
`331`		`- bucket = (Element *)InternalRealloc(bucket,inNewCountsizeof(ELEMENT *));`
	`331`	`+ bucket = (Element *)InternalRealloc(bucketCountsizeof(ELEMENT ), bucket,inNewCountsizeof(ELEMENT *));`
`332`	`332`	`HX_OBJ_WB_GET(this, bucket);`
`333`	`333`	`//for(int b=bucketCount;b<inNewCount;b++)`
`334`	`334`	`// bucket[b] = 0;`
`@@ -369,6 +369,7 @@ struct Hash : public HashBase< typename ELEMENT::Key >`
`369`	`369`
`370`	`370`	`void compact()`
`371`	`371`	`{`
	`372`	`+ int origSize = bucketCount;`
`372`	`373`	`int newSize = bucketCount>>1;`
`373`	`374`	`// printf("compact -> %d\n", newSize);`
`374`	`375`	`mask = newSize-1;`
`@@ -392,7 +393,7 @@ struct Hash : public HashBase< typename ELEMENT::Key >`
`392`	`393`	`}`
`393`	`394`	`}`
`394`	`395`	`bucketCount = newSize;`
`395`		`- bucket = (Element *)InternalRealloc(bucket, sizeof(ELEMENT )*bucketCount );`
	`396`	`+ bucket = (Element *)InternalRealloc(origSizesizeof(ELEMENT ),bucket, sizeof(ELEMENT )*bucketCount );`
`396`	`397`	`HX_OBJ_WB_GET(this, bucket);`
`397`	`398`	`}`
`398`	`399`
Original file line number	Diff line number	Diff line change
`@@ -34,7 +34,11 @@ class TestStringHash extends haxe.unit.TestCase`
`34`	`34`	`values[idxInt] = j;`
`35`	`35`	`}`
`36`	`36`	`}`
	`37`	`+ var arr = [0,1,2];`
`37`	`38`	`var keys = h.keys();`
	`39`	`+ // Empty allocations can mess with the GC nursery`
	`40`	`+ cpp.NativeArray.setSize(arr,0);`
	`41`	`+ cpp.NativeArray.setSize(arr,3);`
`38`	`42`	`var keyed = new Array<Bool>();`
`39`	`43`	`for(i in 0...values.length)`
`40`	`44`	`keyed[i] = false;`