koffi 2.16.1 → 3.0.0-alpha.2

package/lib/native/base/base.cc

@@ -169,67 +169,46 @@ void *MemMem(const void *src, Size src_len, const void *needle, Size needle_len)
 // Memory / Allocator
 // ------------------------------------------------------------------------
 
-// This Allocator design should allow efficient and mostly-transparent use of memory
-// arenas and simple pointer-bumping allocator. This will be implemented later, for
-// now it's just a doubly linked list of malloc() memory blocks.
+static K_DEFAULT_ALLOCATOR default_allocator;
+static NullAllocator null_allocator;
 
-class MallocAllocator: public Allocator {
-protected:
-    void *Allocate(Size size, unsigned int flags) override
-    {
-        void *ptr = malloc((size_t)size);
-        K_CRITICAL(ptr, "Failed to allocate %1 of memory", FmtMemSize(size));
-
-        if (flags & (int)AllocFlag::Zero) {
-            MemSet(ptr, 0, size);
-        }
-
-        return ptr;
-    }
-
-    void *Resize(void *ptr, Size old_size, Size new_size, unsigned int flags) override
-    {
-        if (!new_size) {
-            Release(ptr, old_size);
-            ptr = nullptr;
-        } else {
-            void *new_ptr = realloc(ptr, (size_t)new_size);
-            K_CRITICAL(new_ptr || !new_size, "Failed to resize %1 memory block to %2",
-                                              FmtMemSize(old_size), FmtMemSize(new_size));
+void *MallocAllocator::Allocate(Size size)
+{
+    void *ptr = malloc((size_t)size);
+    K_CRITICAL(ptr, "Failed to allocate %1 of memory", FmtMemSize(size));
 
-            if ((flags & (int)AllocFlag::Zero) && new_size > old_size) {
-                MemSet((uint8_t *)new_ptr + old_size, 0, new_size - old_size);
-            }
+    return ptr;
+}
 
-            ptr = new_ptr;
-        }
+void *MallocAllocator::Resize(void *ptr, Size old_size, Size new_size)
+{
+    if (!new_size) {
+        Release(ptr, old_size);
+        ptr = nullptr;
+    } else {
+        void *new_ptr = realloc(ptr, (size_t)new_size);
+        K_CRITICAL(new_ptr || !new_size, "Failed to resize %1 memory block to %2",
+                                          FmtMemSize(old_size), FmtMemSize(new_size));
 
-        return ptr;
+        ptr = new_ptr;
     }
 
-    void Release(const void *ptr, Size) override
-    {
-        free((void *)ptr);
-    }
-};
+    return ptr;
+}
 
-class NullAllocator: public Allocator {
-protected:
-    void *Allocate(Size, unsigned int) override { K_UNREACHABLE(); }
-    void *Resize(void *, Size, Size, unsigned int) override { K_UNREACHABLE(); }
-    void Release(const void *, Size) override {}
-};
+void MallocAllocator::Release(const void *ptr, Size)
+{
+    free((void *)ptr);
+}
 
-Allocator *GetDefaultAllocator()
+K_DEFAULT_ALLOCATOR *GetDefaultAllocator()
 {
-    static Allocator *default_allocator = new K_DEFAULT_ALLOCATOR;
-    return default_allocator;
+    return &default_allocator;
 }
 
 Allocator *GetNullAllocator()
 {
-    static Allocator *null_allocator = new NullAllocator;
-    return null_allocator;
+    return &null_allocator;
 }
 
 LinkedAllocator& LinkedAllocator::operator=(LinkedAllocator &&other)
@@ -250,7 +229,7 @@ void LinkedAllocator::ReleaseAll()
 
     do {
         Bucket *next = bucket->next;
-        ReleaseRaw(allocator, bucket, -1);
+        allocator->Release(bucket, -1);
         bucket = next;
     } while (bucket != list);
 
@@ -266,7 +245,7 @@ void LinkedAllocator::ReleaseAllExcept(void *ptr)
 
     while (bucket != keep) {
         Bucket *next = bucket->next;
-        ReleaseRaw(allocator, bucket, -1);
+        allocator->Release(bucket, -1);
         bucket = next;
     }
 
@@ -276,9 +255,15 @@ void LinkedAllocator::ReleaseAllExcept(void *ptr)
     keep->next = keep;
 }
 
-void *LinkedAllocator::Allocate(Size size, unsigned int flags)
+void *LinkedAllocator::Allocate(Size size)
 {
-    Bucket *bucket = (Bucket *)AllocateRaw(allocator, K_SIZE(Bucket) + size, flags);
+    K_ASSERT(size >= 0 && size <= K_SIZE_MAX - K_SIZE(Bucket));
+
+    Bucket *bucket = (Bucket *)allocator->Allocate(K_SIZE(Bucket) + size);
+
+#if defined(K_DEBUG)
+    bucket->size = size;
+#endif
 
     bucket->prev = bucket;
     bucket->next = bucket;
@@ -293,10 +278,10 @@ void *LinkedAllocator::Allocate(Size size, unsigned int flags)
     return (void *)bucket->data;
 }
 
-void *LinkedAllocator::Resize(void *ptr, Size old_size, Size new_size, unsigned int flags)
+void *LinkedAllocator::Resize(void *ptr, Size old_size, Size new_size)
 {
     if (!ptr) {
-        ptr = Allocate(new_size, flags);
+        ptr = Allocate(new_size);
     } else if (!new_size) {
         Release(ptr, old_size);
         ptr = nullptr;
@@ -304,8 +289,13 @@ void *LinkedAllocator::Resize(void *ptr, Size old_size, Size new_size, unsigned
         Bucket *bucket = PointerToBucket(ptr);
         bool single = (bucket->next == bucket);
 
-        bucket = (Bucket *)ResizeRaw(allocator, bucket, K_SIZE(Bucket) + old_size,
-                                                        K_SIZE(Bucket) + new_size, flags);
+        bucket = (Bucket *)allocator->Resize(bucket, K_SIZE(Bucket) + old_size,
+                                                     K_SIZE(Bucket) + new_size);
+
+#if defined(K_DEBUG)
+        K_ASSERT(bucket->size == old_size);
+        bucket->size = new_size;
+#endif
 
         list = bucket;
 
@@ -323,7 +313,7 @@ void *LinkedAllocator::Resize(void *ptr, Size old_size, Size new_size, unsigned
     return ptr;
 }
 
-void LinkedAllocator::Release(const void *ptr, Size size)
+void LinkedAllocator::Release(const void *ptr, [[maybe_unused]] Size size)
 {
     if (!ptr)
         return;
@@ -331,12 +321,16 @@ void LinkedAllocator::Release(const void *ptr, Size size)
     Bucket *bucket = PointerToBucket((void *)ptr);
     bool single = (bucket->next == bucket);
 
+#if defined(K_DEBUG)
+    K_ASSERT(bucket->size == size);
+#endif
+
     list = single ? nullptr : bucket->next;
 
     bucket->prev->next = bucket->next;
     bucket->next->prev = bucket->prev;
 
-    ReleaseRaw(allocator, bucket, K_SIZE(Bucket) + size);
+    allocator->Release(bucket, -1);
 }
 
 void LinkedAllocator::GiveTo(LinkedAllocator *alloc)
@@ -396,7 +390,7 @@ void BlockAllocator::ReleaseAll()
     allocator.ReleaseAll();
 }
 
-void *BlockAllocator::Allocate(Size size, unsigned int flags)
+void *BlockAllocator::Allocate(Size size)
 {
     K_ASSERT(size >= 0);
 
@@ -404,28 +398,23 @@ void *BlockAllocator::Allocate(Size size, unsigned int flags)
     Size aligned_size = AlignLen(size, 8);
 
     if (AllocateSeparately(aligned_size)) {
-        uint8_t *ptr = (uint8_t *)AllocateRaw(&allocator, size, flags);
+        uint8_t *ptr = (uint8_t *)allocator.Allocate(size);
         return ptr;
     } else {
         if (!current_bucket || (current_bucket->used + aligned_size) > block_size) {
-            current_bucket = (Bucket *)AllocateRaw(&allocator, K_SIZE(Bucket) + block_size,
-                                                   flags & ~(int)AllocFlag::Zero);
+            current_bucket = (Bucket *)allocator.Allocate(K_SIZE(Bucket) + block_size);
             current_bucket->used = 0;
         }
 
         uint8_t *ptr = current_bucket->data + current_bucket->used;
         current_bucket->used += aligned_size;
 
-        if (flags & (int)AllocFlag::Zero) {
-            MemSet(ptr, 0, size);
-        }
-
         last_alloc = ptr;
         return ptr;
     }
 }
 
-void *BlockAllocator::Resize(void *ptr, Size old_size, Size new_size, unsigned int flags)
+void *BlockAllocator::Resize(void *ptr, Size old_size, Size new_size)
 {
     K_ASSERT(old_size >= 0);
     K_ASSERT(new_size >= 0);
@@ -447,24 +436,13 @@ void *BlockAllocator::Resize(void *ptr, Size old_size, Size new_size, unsigned i
                 (current_bucket->used + aligned_delta) <= block_size &&
                 !AllocateSeparately(aligned_new_size)) {
             current_bucket->used += aligned_delta;
-
-            if ((flags & (int)AllocFlag::Zero) && new_size > old_size) {
-                MemSet((uint8_t *)ptr + old_size, 0, new_size - old_size);
-            }
         } else if (AllocateSeparately(aligned_old_size)) {
-            ptr = ResizeRaw(&allocator, ptr, old_size, new_size, flags);
+            ptr = allocator.Resize(ptr, old_size, new_size);
         } else {
-            void *new_ptr = Allocate(new_size, flags & ~(int)AllocFlag::Zero);
-
-            if (new_size > old_size) {
-                MemCpy(new_ptr, ptr, old_size);
+            void *new_ptr = Allocate(new_size);
 
-                if (flags & (int)AllocFlag::Zero) {
-                    MemSet((uint8_t *)ptr + old_size, 0, new_size - old_size);
-                }
-            } else {
-                MemCpy(new_ptr, ptr, new_size);
-            }
+            Size copy = std::min(old_size, new_size);
+            MemCpy(new_ptr, ptr, copy);
 
             ptr = new_ptr;
         }
@@ -484,13 +462,13 @@ void BlockAllocator::Release(const void *ptr, Size size)
             current_bucket->used -= aligned_size;
 
             if (!current_bucket->used) {
-                ReleaseRaw(&allocator, current_bucket, K_SIZE(Bucket) + block_size);
+                allocator.Release(current_bucket, K_SIZE(Bucket) + block_size);
                 current_bucket = nullptr;
             }
 
             last_alloc = nullptr;
         } else if (AllocateSeparately(aligned_size)) {
-            ReleaseRaw(&allocator, ptr, size);
+            allocator.Release(ptr, size);
         }
     }
 }
@@ -4272,7 +4250,7 @@ bool FlushFile(int fd, const char *filename)
     if (!FlushFileBuffers(h)) {
         DWORD err = GetLastError();
 
-        if (err != ERROR_INVALID_HANDLE) {
+        if (err != ERROR_INVALID_FUNCTION && err != ERROR_INVALID_HANDLE) {
             LogError("Failed to sync '%1': %2", filename, GetWin32ErrorString(err));
             return false;
         }