koffi 3.0.2 → 3.1.1

package/lib/native/base/base.cc

@@ -186,15 +186,12 @@ 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));
-
-        ptr = new_ptr;
+        return nullptr;
     }
 
+    ptr = realloc(ptr, (size_t)new_size);
+    K_CRITICAL(ptr || !new_size, "Failed to resize %1 memory block to %2", FmtMemSize(old_size), FmtMemSize(new_size));
+
     return ptr;
 }
 
@@ -216,6 +213,8 @@ Allocator *GetNullAllocator()
 LinkedAllocator& LinkedAllocator::operator=(LinkedAllocator &&other)
 {
     ReleaseAll();
+
+    allocator = other.allocator;
     list = other.list;
     other.list = nullptr;
 
@@ -363,10 +362,13 @@ BlockAllocator& BlockAllocator::operator=(BlockAllocator &&other)
     allocator.operator=(std::move(other.allocator));
 
     block_size = other.block_size;
-    current_bucket = other.current_bucket;
+
+    bucket_ptr = other.bucket_ptr;
+    bucket_end = other.bucket_end;
     last_alloc = other.last_alloc;
 
-    other.current_bucket = nullptr;
+    other.bucket_ptr = nullptr;
+    other.bucket_end = nullptr;
     other.last_alloc = nullptr;
 
     return *this;
@@ -374,19 +376,23 @@ BlockAllocator& BlockAllocator::operator=(BlockAllocator &&other)
 
 void BlockAllocator::Reset()
 {
-    last_alloc = nullptr;
+    if (bucket_ptr) {
+        bucket_ptr = bucket_end - block_size;
+
+        // Not true but Resize code assumes that last_alloc is not null when a bucket exists.
+        // I could also let it as-is, but for some reason I find that less clean.
+        last_alloc = bucket_ptr;
 
-    if (current_bucket) {
-        current_bucket->used = 0;
-        allocator.ReleaseAllExcept(current_bucket);
+        allocator.ReleaseAllExcept(bucket_ptr);
     } else {
-        allocator.ReleaseAll();
+        ReleaseAll();
     }
 }
 
 void BlockAllocator::ReleaseAll()
 {
-    current_bucket = nullptr;
+    bucket_ptr = nullptr;
+    bucket_end = nullptr;
     last_alloc = nullptr;
 
     allocator.ReleaseAll();
@@ -396,88 +402,78 @@ void *BlockAllocator::Allocate(Size size)
 {
     K_ASSERT(size >= 0);
 
-    // Keep alignement requirements
-    Size aligned_size = AlignLen(size, 8);
+    uint8_t *ptr = bucket_ptr;
+
+    // Fast path
+    if (uint8_t *new_ptr = AlignUp(ptr + size, 8); new_ptr <= bucket_end) [[likely]] {
+        bucket_ptr = new_ptr;
 
-    if (AllocateSeparately(aligned_size)) {
-        uint8_t *ptr = (uint8_t *)allocator.Allocate(size);
+        last_alloc = ptr;
         return ptr;
-    } else {
-        if (!current_bucket || (current_bucket->used + aligned_size) > block_size) {
-            current_bucket = (Bucket *)allocator.Allocate(K_SIZE(Bucket) + block_size);
-            current_bucket->used = 0;
-        }
+    }
+
+    if (size <= block_size) {
+        bucket_ptr = (uint8_t *)allocator.Allocate(block_size);
+        bucket_end = bucket_ptr + block_size;
 
-        uint8_t *ptr = current_bucket->data + current_bucket->used;
-        current_bucket->used += aligned_size;
+        ptr = bucket_ptr;
+        bucket_ptr = AlignUp(ptr + size, 8);
 
         last_alloc = ptr;
         return ptr;
     }
+
+    // Fallback for big allocations
+    return allocator.Allocate(size);
 }
 
 void *BlockAllocator::Resize(void *ptr, Size old_size, Size new_size)
 {
     K_ASSERT(old_size >= 0);
     K_ASSERT(new_size >= 0);
+    K_ASSERT(ptr || !old_size);
 
     if (!new_size) {
         Release(ptr, old_size);
-        ptr = nullptr;
-    } else {
-        if (!ptr) {
-            old_size = 0;
-        }
+        return nullptr;
+    }
 
-        Size aligned_old_size = AlignLen(old_size, 8);
-        Size aligned_new_size = AlignLen(new_size, 8);
-        Size aligned_delta = aligned_new_size - aligned_old_size;
+    // Fast path
+    if (uint8_t *new_ptr = AlignUp((uint8_t *)ptr + new_size, 8); ptr == last_alloc && new_ptr <= bucket_end) {
+        K_ASSERT(ptr);
 
-        // Try fast path
-        if (ptr && ptr == last_alloc &&
-                (current_bucket->used + aligned_delta) <= block_size &&
-                !AllocateSeparately(aligned_new_size)) {
-            current_bucket->used += aligned_delta;
-        } else if (AllocateSeparately(aligned_old_size)) {
-            ptr = allocator.Resize(ptr, old_size, new_size);
-        } else {
-            void *new_ptr = Allocate(new_size);
+        bucket_ptr = new_ptr;
+        return ptr;
+    }
 
-            Size copy = std::min(old_size, new_size);
-            MemCpy(new_ptr, ptr, copy);
+    if (old_size <= block_size) {
+        uint8_t *copy_ptr = (uint8_t *)Allocate(new_size);
+        Size copy_len = std::min(old_size, new_size);
 
-            ptr = new_ptr;
-        }
+        MemCpy(copy_ptr, ptr, copy_len);
+
+        return copy_ptr;
     }
 
-    return ptr;
+    // Old allocation fell back to separate allocation, we can resize at will now!
+    return allocator.Resize(ptr, old_size, new_size);
 }
 
 void BlockAllocator::Release(const void *ptr, Size size)
 {
     K_ASSERT(size >= 0);
 
-    if (ptr) {
-        Size aligned_size = AlignLen(size, 8);
-
-        if (ptr == last_alloc) {
-            current_bucket->used -= aligned_size;
-
-            if (!current_bucket->used) {
-                allocator.Release(current_bucket, K_SIZE(Bucket) + block_size);
-                current_bucket = nullptr;
-            }
-
-            last_alloc = nullptr;
-        } else if (AllocateSeparately(aligned_size)) {
-            allocator.Release(ptr, size);
-        }
+    if (ptr == last_alloc) {
+        bucket_ptr = last_alloc;
+    } else if (size > block_size) {
+        allocator.Release(ptr, size);
     }
 }
 
 void BlockAllocator::GiveTo(LinkedAllocator *alloc)
 {
-    current_bucket = nullptr;
+    bucket_ptr = nullptr;
+    bucket_end = nullptr;
     last_alloc = nullptr;
 
     allocator.GiveTo(alloc);
@@ -1511,7 +1507,7 @@ static inline void ProcessArg(const FmtArg &arg, AppendFunc append)
             append(FormatUnsignedToDecimal((uint64_t)arg.u.date.st.day, buf));
         } break;
 
-        case FmtType::TimeISO: {
+        case FmtType::TimeBasic: {
             const TimeSpec &spec = arg.u.time.spec;
 
             LocalArray<char, 128> buf;
@@ -1548,6 +1544,43 @@ static inline void ProcessArg(const FmtArg &arg, AppendFunc append)
 
             append(buf);
         } break;
+        case FmtType::TimeIso: {
+            const TimeSpec &spec = arg.u.time.spec;
+
+            LocalArray<char, 128> buf;
+
+            if (spec.offset && arg.u.time.ms) {
+                int offset_h = spec.offset / 60;
+                int offset_m = spec.offset % 60;
+
+                buf.len = Fmt(buf.data, "%1-%2-%3T%4:%5:%6.%7%8%9%10",
+                              FmtInt(spec.year, 2), FmtInt(spec.month, 2),
+                              FmtInt(spec.day, 2), FmtInt(spec.hour, 2),
+                              FmtInt(spec.min, 2), FmtInt(spec.sec, 2), FmtInt(spec.msec, 3),
+                              offset_h >= 0 ? "+" : "", FmtInt(offset_h, 2), FmtInt(offset_m, 2)).len;
+            } else if (spec.offset) {
+                int offset_h = spec.offset / 60;
+                int offset_m = spec.offset % 60;
+
+                buf.len = Fmt(buf.data, "%1-%2-%3T%4:%5:%6%7%8%9",
+                              FmtInt(spec.year, 2), FmtInt(spec.month, 2),
+                              FmtInt(spec.day, 2), FmtInt(spec.hour, 2),
+                              FmtInt(spec.min, 2), FmtInt(spec.sec, 2),
+                              offset_h >= 0 ? "+" : "", FmtInt(offset_h, 2), FmtInt(offset_m, 2)).len;
+            } else if (arg.u.time.ms) {
+                buf.len = Fmt(buf.data, "%1-%2-%3T%4:%5:%6.%7Z",
+                              FmtInt(spec.year, 2), FmtInt(spec.month, 2),
+                              FmtInt(spec.day, 2), FmtInt(spec.hour, 2),
+                              FmtInt(spec.min, 2), FmtInt(spec.sec, 2), FmtInt(spec.msec, 3)).len;
+            } else {
+                buf.len = Fmt(buf.data, "%1-%2-%3T%4:%5:%6Z",
+                              FmtInt(spec.year, 2), FmtInt(spec.month, 2),
+                              FmtInt(spec.day, 2), FmtInt(spec.hour, 2),
+                              FmtInt(spec.min, 2), FmtInt(spec.sec, 2)).len;
+            }
+
+            append(buf);
+        } break;
         case FmtType::TimeNice: {
             const TimeSpec &spec = arg.u.time.spec;
 
@@ -1947,7 +1980,7 @@ void FmtUrlSafe::Format(FunctionRef<void(Span<const char>)> append) const
     }
 }
 
-void FmtHtmlSafe::Format(FunctionRef<void(Span<const char>)> append) const
+void FmtXmlSafe::Format(FunctionRef<void(Span<const char>)> append) const
 {
     for (char c: str) {
         switch (c) {
@@ -5171,7 +5204,7 @@ bool ExecuteCommandLine(const char *cmd_line, const ExecuteInfo &info,
 
     // Read and write standard process streams
     {
-        bool running = true;
+        bool running = in_func.IsValid() || out_func.IsValid();
 
         PendingIO proc_in;
         Span<const uint8_t> write_buf = {};
@@ -5201,6 +5234,7 @@ bool ExecuteCommandLine(const char *cmd_line, const ExecuteInfo &info,
                         }
                     } else {
                         CloseHandleSafe(&in_pipe[1]);
+                        running &= out_func.IsValid();
                     }
                 }
 
@@ -5632,7 +5666,7 @@ bool ExecuteCommandLine(const char *cmd_line, const ExecuteInfo &info,
     return true;
 }
 
-Size ReadCommandOutput(const char *cmd_line, Span<char> out_output)
+Size ReadCommandOutput(const char *cmd_line, Span<uint8_t> out_output)
 {
     static ExecuteInfo::KeyValue variables[] = {
         { "LANG", "C" },
@@ -5651,34 +5685,48 @@ Size ReadCommandOutput(const char *cmd_line, Span<char> out_output)
     };
 
     int exit_code;
-    if (!ExecuteCommandLine(cmd_line, info, MakeSpan((const uint8_t *)nullptr, 0), write, &exit_code))
+    if (!ExecuteCommandLine(cmd_line, info, MakeSpan((const uint8_t *)nullptr, 0), write, &exit_code)) {
+        if (out_output.len) {
+            Span<const char> output = out_output.As<const char>();
+            LogError("Command '%1' failed: %2", cmd_line, output);
+        }
         return -1;
+    }
     if (exit_code) {
-        LogDebug("Command '%1 failed (exit code: %2)", cmd_line, exit_code);
+        LogDebug("Command '%1' failed (exit code: %2)", cmd_line, exit_code);
         return -1;
     }
 
     return total_len;
 }
 
-bool ReadCommandOutput(const char *cmd_line, HeapArray<char> *out_output)
+bool ReadCommandOutput(const char *cmd_line, HeapArray<uint8_t> *out_output)
 {
     static ExecuteInfo::KeyValue variables[] = {
         { "LANG", "C" },
         { "LC_ALL", "C" }
     };
 
+    Size start_len = out_output->len;
+    K_DEFER_N(err_guard) { out_output->RemoveFrom(start_len); };
+
     ExecuteInfo info = {};
     info.env_variables = variables;
 
     int exit_code;
-    if (!ExecuteCommandLine(cmd_line, info, {}, Mebibytes(1), out_output, &exit_code))
+    if (!ExecuteCommandLine(cmd_line, info, {}, Mebibytes(1), out_output, &exit_code)) {
+        if (out_output->len > start_len) {
+            Span<const char> output = out_output->Take(start_len, out_output->len - start_len).As<const char>();
+            LogError("Command '%1' failed: %2", cmd_line, output);
+        }
         return false;
+    }
     if (exit_code) {
-        LogDebug("Command '%1 failed (exit code: %2)", cmd_line, exit_code);
+        LogDebug("Command '%1' failed (exit code: %2)", cmd_line, exit_code);
         return false;
     }
 
+    err_guard.Disable();
     return true;
 }
 
@@ -7405,7 +7453,7 @@ public:
     void AddTask(Async *async, int worker_idx, const std::function<bool()> &func);
 
     void RunWorker(int worker_idx);
-    void SyncOn(Async *async, bool soon);
+    void SyncOn(Async *async, Async *only);
     bool WaitOn(Async *async, int timeout);
 
     void RunTasks(int worker_idx, Async *only);
@@ -7419,7 +7467,7 @@ static thread_local AsyncPool *async_running_pool = nullptr;
 static thread_local int async_running_worker_idx;
 static thread_local bool async_running_task = false;
 
-Async::Async(int threads)
+Async::Async(int threads, unsigned int flags)
 {
     K_ASSERT(threads);
 
@@ -7441,14 +7489,22 @@ Async::Async(int threads)
     }
 
     pool->RegisterAsync();
+
+    if (flags & (int)AsyncFlag::Selfish) {
+        only = this;
+    }
 }
 
-Async::Async(Async *parent)
+Async::Async(Async *parent, unsigned int flags)
 {
     K_ASSERT(parent);
 
     pool = parent->pool;
     pool->RegisterAsync();
+
+    if (flags & (int)AsyncFlag::Selfish) {
+        only = this;
+    }
 }
 
 Async::~Async()
@@ -7471,13 +7527,7 @@ void Async::Run(int worker, const std::function<bool()> &func)
 
 bool Async::Sync()
 {
-    pool->SyncOn(this, false);
-    return success;
-}
-
-bool Async::SyncSoon()
-{
-    pool->SyncOn(this, true);
+    pool->SyncOn(this, only);
     return success;
 }
 
@@ -7613,7 +7663,7 @@ void AsyncPool::AddTask(Async *async, int worker_idx, const std::function<bool()
         int worker_idx = async_running_worker_idx;
 
         do {
-            RunTasks(worker_idx, nullptr);
+            RunTasks(worker_idx, async->only);
         } while (pending_tasks >= K_ASYNC_MAX_PENDING_TASKS);
     } else if (!prev_pending) {
         std::lock_guard<std::mutex> lock_pool(pool_mutex);
@@ -7647,7 +7697,7 @@ void AsyncPool::RunWorker(int worker_idx)
     }
 }
 
-void AsyncPool::SyncOn(Async *async, bool soon)
+void AsyncPool::SyncOn(Async *async, Async *only)
 {
     K_DEFER_C(pool = async_running_pool,
                worker_idx = async_running_worker_idx) {
@@ -7659,7 +7709,7 @@ void AsyncPool::SyncOn(Async *async, bool soon)
     async_running_worker_idx = 0;
 
     while (async->remaining_tasks) {
-        RunTasks(0, soon ? async : nullptr);
+        RunTasks(0, only);
 
         std::unique_lock<std::mutex> lock_sync(pool_mutex);
         sync_cv.wait(lock_sync, [&]() { return pending_tasks || !async->remaining_tasks; });
@@ -7739,12 +7789,12 @@ void AsyncPool::RunTask(Task *task)
 #else
 
 
-Async::Async(int threads)
+Async::Async(int threads, unsigned int)
 {
     K_ASSERT(threads);
 }
 
-Async::Async(Async *parent)
+Async::Async(Async *parent, unsigned int)
 {
     K_ASSERT(parent);
 }
@@ -10728,7 +10778,7 @@ const char *GetMimeType(Span<const char> extension, const char *default_type)
     const char *mimetype = mimetypes.FindValue(lower, nullptr);
 
     if (!mimetype) {
-        LogError("Unknown MIME type for extension '%1'", extension);
+        LogDebug("Unknown MIME type for extension '%1'", extension);
         mimetype = default_type;
     }
 
@@ -10768,8 +10818,10 @@ bool CanCompressFile(const char *filename)
     if (TestStrI(extension, ".db") || TestStrI(extension, ".sqlite3"))
         return false;
 
-    const char *mimetype = GetMimeType(extension);
+    const char *mimetype = GetMimeType(extension, nullptr);
 
+    if (!mimetype)
+        return false;
     if (StartsWith(mimetype, "video/"))
         return false;
     if (StartsWith(mimetype, "audio/"))