koffi 2.6.3 → 2.6.5

package/src/core/libcc/libcc.cc

@@ -1426,7 +1426,7 @@ static inline void ProcessArg(const FmtArg &arg, AppendFunc append)
                 RG_ASSERT(arg.u.random.len <= RG_SIZE(out_buf.data));
 
                 for (Size j = 0; j < arg.u.random.len; j++) {
-                    int rnd = GetRandomIntSafe(0, (int)chars.len);
+                    int rnd = GetRandomIntFast(0, (int)chars.len);
                     out_buf.Append(chars[rnd]);
                 }
 
@@ -2146,37 +2146,6 @@ fail:
     return str_buf;
 }
 
-void SetEnvironmentVar(const char *name, const char *value)
-{
-    RG_ASSERT(name && name[0] && !strchr(name, '='));
-    RG_ASSERT(value);
-
-    if (win32_utf8) {
-        RG_CRITICAL(SetEnvironmentVariableA(name, value), "Failed to set environment variable '%1' to '%2': %3", name, value, GetWin32ErrorString());
-    } else {
-        wchar_t name_w[256];
-        wchar_t value_w[4096];
-
-        RG_CRITICAL(ConvertUtf8ToWin32Wide(name, name_w) >= 0, "Failed to set environment variable '%1' to '%2'", name, value);
-        RG_CRITICAL(ConvertUtf8ToWin32Wide(value, value_w) >= 0, "Failed to set environment variable '%1' to '%2'", name, value);
-        RG_CRITICAL(SetEnvironmentVariableW(name_w, value_w), "Failed to set environment variable '%1' to '%2': %3", name, value, GetWin32ErrorString());
-    }
-}
-
-void DeleteEnvironmentVar(const char *name)
-{
-    RG_ASSERT(name && name[0] && !strchr(name, '='));
-
-    if (win32_utf8) {
-        RG_CRITICAL(SetEnvironmentVariableA(name, nullptr), "Failed to clear environment variable '%1': %2", name, GetWin32ErrorString());
-    } else {
-        wchar_t name_w[256];
-
-        RG_CRITICAL(ConvertUtf8ToWin32Wide(name, name_w) >= 0, "Failed to clear environment variable '%1'", name);
-        RG_CRITICAL(SetEnvironmentVariableW(name_w, nullptr), "Failed to clear environment variable '%1': %2", name, GetWin32ErrorString());
-    }
-}
-
 static FileType FileAttributesToType(uint32_t attr)
 {
     if (attr & FILE_ATTRIBUTE_DIRECTORY) {
@@ -2360,20 +2329,6 @@ EnumResult EnumerateDirectory(const char *dirname, const char *filter, Size max_
 
 #else
 
-void SetEnvironmentVar(const char *name, const char *value)
-{
-    RG_ASSERT(name && name[0] && !strchr(name, '='));
-    RG_ASSERT(value);
-
-    RG_CRITICAL(!setenv(name, value, 1), "Failed to set environment variable '%1' to '%2': %3", name, value, strerror(errno));
-}
-
-void DeleteEnvironmentVar(const char *name)
-{
-    RG_ASSERT(name && name[0] && !strchr(name, '='));
-    RG_CRITICAL(!unsetenv(name), "Failed to clear environment variable '%1': %2", name, strerror(errno));
-}
-
 static FileType FileModeToType(mode_t mode)
 {
     if (S_ISDIR(mode)) {
@@ -2473,11 +2428,15 @@ StatResult StatFile(const char *filename, unsigned int flags, FileInfo *out_info
                       (int64_t)sb.st_mtim.tv_nsec / 1000000;
     out_info->btime = (int64_t)sb.__st_birthtim.tv_sec * 1000 +
                       (int64_t)sb.__st_birthtim.tv_nsec / 1000000;
-#else
+#elif defined(__FreeBSD__)
     out_info->mtime = (int64_t)sb.st_mtim.tv_sec * 1000 +
                       (int64_t)sb.st_mtim.tv_nsec / 1000000;
     out_info->btime = (int64_t)sb.st_birthtim.tv_sec * 1000 +
                       (int64_t)sb.st_birthtim.tv_nsec / 1000000;
+#else
+    out_info->mtime = (int64_t)sb.st_mtim.tv_sec * 1000 +
+                      (int64_t)sb.st_mtim.tv_nsec / 1000000;
+    out_info->btime = out_info->mtime;
 #endif
     out_info->mode = (unsigned int)sb.st_mode;
     out_info->uid = (uint32_t)sb.st_uid;
@@ -3919,7 +3878,7 @@ struct PendingIO {
     }
 };
 
-bool ExecuteCommandLine(const char *cmd_line, const char *work_dir,
+bool ExecuteCommandLine(const char *cmd_line, const ExecuteInfo &info,
                         FunctionRef<Span<const uint8_t>()> in_func,
                         FunctionRef<void(Span<uint8_t> buf)> out_func, int *out_code)
 {
@@ -3934,9 +3893,9 @@ bool ExecuteCommandLine(const char *cmd_line, const char *work_dir,
 
     // Convert work directory
     Span<wchar_t> work_dir_w;
-    if (work_dir) {
-        work_dir_w = AllocateSpan<wchar_t>(&temp_alloc, 2 * strlen(work_dir) + 1);
-        if (ConvertUtf8ToWin32Wide(work_dir, work_dir_w) < 0)
+    if (info.work_dir) {
+        work_dir_w = AllocateSpan<wchar_t>(&temp_alloc, 2 * strlen(info.work_dir) + 1);
+        if (ConvertUtf8ToWin32Wide(info.work_dir, work_dir_w) < 0)
             return false;
     } else {
         work_dir_w = {};
@@ -3988,6 +3947,45 @@ bool ExecuteCommandLine(const char *cmd_line, const char *work_dir,
     if (out_func.IsValid() && !CreateOverlappedPipe(true, false, PipeMode::Byte, out_pipe))
         return false;
 
+    // Prepare environment (if needed)
+    HeapArray<wchar_t> new_env_w;
+    if (info.reset_env || info.env_variables.len) {
+        if (!info.reset_env) {
+            Span<wchar_t> current_env = MakeSpan(GetEnvironmentStringsW(), 0);
+
+            do {
+                Size len = (Size)wcslen(current_env.end());
+                current_env.len += len + 1;
+            } while (current_env.ptr[current_env.len]);
+
+            new_env_w.Append(current_env);
+        }
+
+        for (const ExecuteInfo::KeyValue &kv: info.env_variables) {
+            Span<const char> key = kv.key;
+            Span<const char> value = kv.value;
+
+            Size len = 2 * (key.len + value.len + 1) + 1;
+            new_env_w.Reserve(len);
+
+            len = ConvertUtf8ToWin32Wide(key, new_env_w.TakeAvailable());
+            if (len < 0) [[unlikely]]
+                return false;
+            new_env_w.len += len;
+
+            new_env_w.Append(L'=');
+
+            len = ConvertUtf8ToWin32Wide(value, new_env_w.TakeAvailable());
+            if (len < 0) [[unlikely]]
+                return false;
+            new_env_w.len += len;
+
+            new_env_w.Append(0);
+        }
+
+        new_env_w.Append(0);
+    }
+
     // Start process
     HANDLE process_handle;
     {
@@ -4012,9 +4010,11 @@ bool ExecuteCommandLine(const char *cmd_line, const char *work_dir,
             si.dwFlags |= STARTF_USESTDHANDLES;
         }
 
+        int flags = CREATE_NEW_PROCESS_GROUP | CREATE_UNICODE_ENVIRONMENT;
+
         PROCESS_INFORMATION pi = {};
-        if (!CreateProcessW(nullptr, cmd_line_w.ptr, nullptr, nullptr, TRUE, CREATE_NEW_PROCESS_GROUP,
-                            nullptr, work_dir_w.ptr, &si, &pi)) {
+        if (!CreateProcessW(nullptr, cmd_line_w.ptr, nullptr, nullptr, TRUE, flags,
+                            new_env_w.ptr, work_dir_w.ptr, &si, &pi)) {
             LogError("Failed to start process: %1", GetWin32ErrorString());
             return false;
         }
@@ -4223,10 +4223,12 @@ void CloseDescriptorSafe(int *fd_ptr)
     *fd_ptr = -1;
 }
 
-bool ExecuteCommandLine(const char *cmd_line, const char *work_dir,
+bool ExecuteCommandLine(const char *cmd_line, const ExecuteInfo &info,
                         FunctionRef<Span<const uint8_t>()> in_func,
                         FunctionRef<void(Span<uint8_t> buf)> out_func, int *out_code)
 {
+    BlockAllocator temp_alloc;
+
     // Create read pipes
     int in_pfd[2] = {-1, -1};
     RG_DEFER {
@@ -4277,6 +4279,26 @@ bool ExecuteCommandLine(const char *cmd_line, const char *work_dir,
         }
     }
 
+    // Prepare new environment (if needed)
+    HeapArray<char *> new_env;
+    if (info.reset_env || info.env_variables.len) {
+        if (!info.reset_env) {
+            char **ptr = environ;
+
+            while (*ptr) {
+                new_env.Append(*ptr);
+                ptr++;
+            }
+        }
+
+        for (const ExecuteInfo::KeyValue &kv: info.env_variables) {
+            const char *var = Fmt(&temp_alloc, "%1=%2", kv.key, kv.value).ptr;
+            new_env.Append((char *)var);
+        }
+
+        new_env.Append(nullptr);
+    }
+
     // Start process
     pid_t pid;
     {
@@ -4297,12 +4319,12 @@ bool ExecuteCommandLine(const char *cmd_line, const char *work_dir,
             return false;
         }
 
-        if (work_dir) {
-            const char *argv[] = {"env", "-C", work_dir, "sh", "-c", cmd_line, nullptr };
-            errno = posix_spawn(&pid, "/bin/env", &file_actions, nullptr, const_cast<char **>(argv), environ);
+        if (info.work_dir) {
+            const char *argv[] = {"env", "-C", info.work_dir, "sh", "-c", cmd_line, nullptr };
+            errno = posix_spawn(&pid, "/bin/env", &file_actions, nullptr, const_cast<char **>(argv), new_env.ptr ? new_env.ptr : environ);
         } else {
             const char *argv[] = {"sh", "-c", cmd_line, nullptr};
-            errno = posix_spawn(&pid, "/bin/sh", &file_actions, nullptr, const_cast<char **>(argv), environ);
+            errno = posix_spawn(&pid, "/bin/sh", &file_actions, nullptr, const_cast<char **>(argv), new_env.ptr ? new_env.ptr : environ);
         }
         if (errno) {
             LogError("Failed to start process: %1", strerror(errno));
@@ -4444,7 +4466,7 @@ bool ExecuteCommandLine(const char *cmd_line, const char *work_dir,
 
 #endif
 
-bool ExecuteCommandLine(const char *cmd_line, const char *work_dir,
+bool ExecuteCommandLine(const char *cmd_line, const ExecuteInfo &info,
                         Span<const uint8_t> in_buf, Size max_len,
                         HeapArray<uint8_t> *out_buf, int *out_code)
 {
@@ -4467,8 +4489,8 @@ bool ExecuteCommandLine(const char *cmd_line, const char *work_dir,
     // Don't f*ck up the log
     bool warned = false;
 
-    bool success = ExecuteCommandLine(cmd_line, work_dir, [&]() { return in_buf; },
-                                                          [&](Span<uint8_t> buf) {
+    bool success = ExecuteCommandLine(cmd_line, info, [&]() { return in_buf; },
+                                                      [&](Span<uint8_t> buf) {
         if (out_buf->len - start_len <= max_len - buf.len) {
             out_buf->Append(buf);
         } else if (!warned) {
@@ -4494,7 +4516,7 @@ Size ReadCommandOutput(const char *cmd_line, Span<char> out_output)
     };
 
     int exit_code;
-    if (!ExecuteCommandLine(cmd_line, nullptr, MakeSpan((const uint8_t *)nullptr, 0), write, &exit_code))
+    if (!ExecuteCommandLine(cmd_line, {}, MakeSpan((const uint8_t *)nullptr, 0), write, &exit_code))
         return -1;
     if (exit_code) {
         LogDebug("Command '%1 failed (exit code: %2)", cmd_line, exit_code);
@@ -4507,7 +4529,7 @@ Size ReadCommandOutput(const char *cmd_line, Span<char> out_output)
 bool ReadCommandOutput(const char *cmd_line, HeapArray<char> *out_output)
 {
     int exit_code;
-    if (!ExecuteCommandLine(cmd_line, nullptr, {}, Mebibytes(1), out_output, &exit_code))
+    if (!ExecuteCommandLine(cmd_line, {}, {}, Mebibytes(1), out_output, &exit_code))
         return false;
     if (exit_code) {
         LogDebug("Command '%1 failed (exit code: %2)", cmd_line, exit_code);
@@ -4759,7 +4781,7 @@ bool NotifySystemd()
         return false;
     }
 
-    DeleteEnvironmentVar("NOTIFY_SOCKET");
+    unsetenv("NOTIFY_SOCKET");
     return true;
 }
 #endif
@@ -5063,79 +5085,6 @@ const char *CreateUniqueDirectory(Span<const char> directory, const char *prefix
 // Random
 // ------------------------------------------------------------------------
 
-static inline uint32_t ROTL32(uint32_t v, int n)
-{
-    return (v << n) | (v >> (32 - n));
-}
-
-static inline uint64_t ROTL64(uint64_t v, int n) {
-    return (v << n) | (v >> (64 - n));
-}
-
-FastRandom::FastRandom()
-{
-    do {
-        FillRandomSafe(state, RG_SIZE(state));
-    } while (std::all_of(std::begin(state), std::end(state), [](uint64_t v) { return !v; }));
-}
-
-FastRandom::FastRandom(uint64_t seed)
-{
-    // splitmix64 generator to seed xoshiro256++, as recommended
-
-    seed += 0x9e3779b97f4a7c15;
-
-    for (int i = 0; i < 4; i++) {
-        seed = (seed ^ (seed >> 30)) * 0xbf58476d1ce4e5b9;
-        seed = (seed ^ (seed >> 27)) * 0x94d049bb133111eb;
-        state[i] = seed ^ (seed >> 31);
-    }
-}
-
-void FastRandom::Fill(void *out_buf, Size len)
-{
-    for (Size i = 0; i < len; i += 8) {
-        uint64_t rnd = Next();
-
-        Size copy_len = std::min(RG_SIZE(rnd), len - i);
-        memcpy((uint8_t *)out_buf + i, &rnd, copy_len);
-    }
-}
-
-int FastRandom::GetInt(int min, int max)
-{
-    int range = max - min;
-    RG_ASSERT(range >= 2);
-
-    unsigned int treshold = (UINT_MAX - UINT_MAX % range);
-
-    unsigned int x;
-    do {
-        Fill(&x, RG_SIZE(x));
-    } while (x >= treshold);
-    x %= range;
-
-    return min + (int)x;
-}
-
-uint64_t FastRandom::Next()
-{
-    // xoshiro256++ by David Blackman and Sebastiano Vigna (vigna@acm.org)
-    // Hopefully I did not screw it up :)
-
-    uint64_t result = ROTL64(state[0] + state[3], 23) + state[0];
-    uint64_t t = state[1] << 17;
-
-    state[2] ^= state[0];
-    state[3] ^= state[1];
-    state[1] ^= state[2];
-    state[0] ^= state[3];
-    state[2] ^= t;
-    state[3] = ROTL64(state[3], 45);
-
-    return result;
-}
-
 static RG_THREAD_LOCAL Size rnd_remain;
 static RG_THREAD_LOCAL int64_t rnd_time;
 #ifndef _WIN32
@@ -5145,6 +5094,17 @@ static RG_THREAD_LOCAL uint32_t rnd_state[16];
 static RG_THREAD_LOCAL uint8_t rnd_buf[64];
 static RG_THREAD_LOCAL Size rnd_offset;
 
+static thread_local FastRandom rng_fast;
+
+static inline uint32_t ROTL32(uint32_t v, int n)
+{
+    return (v << n) | (v >> (32 - n));
+}
+
+static inline uint64_t ROTL64(uint64_t v, int n) {
+    return (v << n) | (v >> (64 - n));
+}
+
 static void InitChaCha20(uint32_t state[16], uint32_t key[8], uint32_t iv[2])
 {
     alignas(uint32_t) static char str[] = "expand 32-byte k";
@@ -5251,18 +5211,18 @@ void FillRandomSafe(void *out_buf, Size len)
 
         memset(rnd_state, 0, RG_SIZE(rnd_state));
 #if defined(_WIN32)
-        RG_CRITICAL(RtlGenRandom(&buf, RG_SIZE(buf)), "RtlGenRandom() failed: %s", GetWin32ErrorString());
+        RG_CRITICAL(RtlGenRandom(&buf, RG_SIZE(buf)), "RtlGenRandom() failed: %1", GetWin32ErrorString());
 #elif defined(__linux__)
         {
 restart:
             int ret = syscall(SYS_getrandom, &buf, RG_SIZE(buf), 0);
-            RG_CRITICAL(ret >= 0, "getentropy() failed: %s", strerror(errno));
+            RG_CRITICAL(ret >= 0, "getentropy() failed: %1", strerror(errno));
 
             if (ret < RG_SIZE(buf))
                 goto restart;
         }
 #else
-        RG_CRITICAL(getentropy(&buf, RG_SIZE(buf)) == 0, "getentropy() failed: %s", strerror(errno));
+        RG_CRITICAL(getentropy(&buf, RG_SIZE(buf)) == 0, "getentropy() failed: %1", strerror(errno));
 #endif
 
         InitChaCha20(rnd_state, buf.key, buf.iv);
@@ -5312,6 +5272,75 @@ int GetRandomIntSafe(int min, int max)
     return min + (int)x;
 }
 
+FastRandom::FastRandom()
+{
+    do {
+        FillRandomSafe(state, RG_SIZE(state));
+    } while (std::all_of(std::begin(state), std::end(state), [](uint64_t v) { return !v; }));
+}
+
+FastRandom::FastRandom(uint64_t seed)
+{
+    // splitmix64 generator to seed xoshiro256++, as recommended
+
+    seed += 0x9e3779b97f4a7c15;
+
+    for (int i = 0; i < 4; i++) {
+        seed = (seed ^ (seed >> 30)) * 0xbf58476d1ce4e5b9;
+        seed = (seed ^ (seed >> 27)) * 0x94d049bb133111eb;
+        state[i] = seed ^ (seed >> 31);
+    }
+}
+
+void FastRandom::Fill(void *out_buf, Size len)
+{
+    for (Size i = 0; i < len; i += 8) {
+        uint64_t rnd = Next();
+
+        Size copy_len = std::min(RG_SIZE(rnd), len - i);
+        memcpy((uint8_t *)out_buf + i, &rnd, copy_len);
+    }
+}
+
+int FastRandom::GetInt(int min, int max)
+{
+    int range = max - min;
+    RG_ASSERT(range >= 2);
+
+    unsigned int treshold = (UINT_MAX - UINT_MAX % range);
+
+    unsigned int x;
+    do {
+        x = (unsigned int)Next();
+    } while (x >= treshold);
+    x %= range;
+
+    return min + (int)x;
+}
+
+uint64_t FastRandom::Next()
+{
+    // xoshiro256++ by David Blackman and Sebastiano Vigna (vigna@acm.org)
+    // Hopefully I did not screw it up :)
+
+    uint64_t result = ROTL64(state[0] + state[3], 23) + state[0];
+    uint64_t t = state[1] << 17;
+
+    state[2] ^= state[0];
+    state[3] ^= state[1];
+    state[1] ^= state[2];
+    state[0] ^= state[3];
+    state[2] ^= t;
+    state[3] = ROTL64(state[3], 45);
+
+    return result;
+}
+
+int GetRandomIntFast(int min, int max)
+{
+    return rng_fast.GetInt(min, max);
+}
+
 // ------------------------------------------------------------------------
 // Sockets
 // ------------------------------------------------------------------------
@@ -5517,7 +5546,10 @@ struct Task {
     std::function<bool()> func;
 };
 
-struct TaskQueue {
+struct WorkerData {
+    AsyncPool *pool = nullptr;
+    int idx;
+
     std::mutex queue_mutex;
     BucketArray<Task> tasks;
 };
@@ -5533,15 +5565,13 @@ class AsyncPool {
     int refcount = 0;
 
     int async_count = 0;
-    HeapArray<bool> workers_state;
-
-    HeapArray<TaskQueue> queues;
+    HeapArray<WorkerData> workers;
     std::atomic_int pending_tasks { 0 };
 
 public:
     AsyncPool(int threads, bool leak);
 
-    int GetWorkerCount() const { return (int)queues.len; }
+    int GetWorkerCount() const { return (int)workers.len; }
     int CountPendingTasks() const { return pending_tasks; }
 
     void RegisterAsync();
@@ -5552,7 +5582,7 @@ public:
     void RunWorker(int worker_idx);
     void SyncOn(Async *async);
 
-    void RunTasks(int queue_idx);
+    void RunTasks(int worker_idx);
     void RunTask(Task *task);
 };
 
@@ -5643,25 +5673,72 @@ AsyncPool::AsyncPool(int threads, bool leak)
         threads = RG_ASYNC_MAX_THREADS;
     }
 
-    // The first queue is for the main thread, whereas workers_state[0] is
-    // not used but it's easier to index it the same way.
-    workers_state.AppendDefault(threads);
-    queues.AppendDefault(threads);
+    // The first queue is for the main thread
+    workers.AppendDefault(threads);
 
     refcount = leak;
 }
 
+#ifdef _WIN32
+
+static DWORD WINAPI RunWorkerWin32(void *udata)
+{
+    WorkerData *worker = (WorkerData *)udata;
+    worker->pool->RunWorker(worker->idx);
+    return 0;
+}
+
+#else
+
+static void *RunWorkerPthread(void *udata)
+{
+    WorkerData *worker = (WorkerData *)udata;
+    worker->pool->RunWorker(worker->idx);
+    return nullptr;
+}
+
+#endif
+
 void AsyncPool::RegisterAsync()
 {
     std::lock_guard<std::mutex> lock_pool(pool_mutex);
 
     if (!async_count++) {
-        for (int i = 1; i < workers_state.len; i++) {
-            if (!workers_state[i]) {
-                std::thread(&AsyncPool::RunWorker, this, i).detach();
+        for (int i = 1; i < workers.len; i++) {
+            WorkerData *worker = &workers[i];
+
+            if (!worker->pool) {
+                worker->pool = this;
+                worker->idx = i;
+
+#ifdef _WIN32
+                // Our worker threads may exit after main() has returned (or exit has been called),
+                // which can trigger crashes in _Cnd_do_broadcast_at_thread_exit() because it
+                // tries to dereference destroyed stuff. It turns out that std::thread calls this
+                // function, and we don't want that, so avoid std::thread on Windows.
+                HANDLE h = CreateThread(nullptr, 0, RunWorkerWin32, worker, 0, nullptr);
+                if (!h) [[unlikely]] {
+                    LogError("Failed to create worker thread: %1", GetWin32ErrorString());
+
+                    worker->pool = nullptr;
+                    return;
+                }
+
+                CloseHandle(h);
+#else
+                pthread_t thread;
+                int ret = pthread_create(&thread, nullptr, RunWorkerPthread, worker);
+                if (ret) [[unlikely]] {
+                    LogError("Failed to create worker thread: %1", strerror(ret));
+
+                    worker->pool = nullptr;
+                    return;
+                }
+
+                pthread_detach(thread);
+#endif
 
                 refcount++;
-                workers_state[i] = true;
             }
         }
     }
@@ -5677,20 +5754,20 @@ void AsyncPool::AddTask(Async *async, const std::function<bool()> &func)
 {
     if (async_running_pool != async->pool) {
         for (;;) {
-            int idx = GetRandomIntSafe(0, queues.len);
-            TaskQueue *queue = &queues[idx];
+            int idx = GetRandomIntFast(0, (int)workers.len);
+            WorkerData *worker = &workers[idx];
 
-            std::unique_lock<std::mutex> lock_queue(queue->queue_mutex, std::try_to_lock);
+            std::unique_lock<std::mutex> lock_queue(worker->queue_mutex, std::try_to_lock);
             if (lock_queue.owns_lock()) {
-                queue->tasks.Append({ async, func });
+                worker->tasks.Append({ async, func });
                 break;
             }
         }
     } else {
-        TaskQueue *queue = &queues[async_running_worker_idx];
+        WorkerData *worker = &workers[async_running_worker_idx];
 
-        std::lock_guard<std::mutex> lock_queue(queue->queue_mutex);
-        queue->tasks.Append({ async, func });
+        std::lock_guard<std::mutex> lock_queue(worker->queue_mutex);
+        worker->tasks.Append({ async, func });
     }
 
     async->remaining_tasks++;
@@ -5720,7 +5797,8 @@ void AsyncPool::RunWorker(int worker_idx)
         pending_cv.wait_for(lock_pool, duration, [&]() { return !!pending_tasks; });
     }
 
-    workers_state[worker_idx] = false;
+    workers[worker_idx].pool = nullptr;
+
     if (!--refcount) {
         lock_pool.unlock();
         delete this;
@@ -5739,31 +5817,31 @@ void AsyncPool::SyncOn(Async *async)
     async_running_worker_idx = 0;
 
     while (async->remaining_tasks) {
-        RunTasks(async_running_worker_idx);
+        RunTasks(0);
 
         std::unique_lock<std::mutex> lock_sync(pool_mutex);
         sync_cv.wait(lock_sync, [&]() { return pending_tasks || !async->remaining_tasks; });
     }
 }
 
-void AsyncPool::RunTasks(int queue_idx)
+void AsyncPool::RunTasks(int worker_idx)
 {
     // The '12' factor is pretty arbitrary, don't try to find meaning there
-    for (int i = 0; i < workers_state.len * 12; i++) {
-        TaskQueue *queue = &queues[queue_idx];
-        std::unique_lock<std::mutex> lock_queue(queue->queue_mutex, std::try_to_lock);
+    for (int i = 0; i < workers.len * 12; i++) {
+        WorkerData *worker = &workers[worker_idx];
+        std::unique_lock<std::mutex> lock_queue(worker->queue_mutex, std::try_to_lock);
 
-        if (lock_queue.owns_lock() && queue->tasks.len) {
-            Task task = std::move(queue->tasks[0]);
+        if (lock_queue.owns_lock() && worker->tasks.len) {
+            Task task = std::move(worker->tasks[0]);
 
-            queue->tasks.RemoveFirst();
-            queue->tasks.Trim();
+            worker->tasks.RemoveFirst();
+            worker->tasks.Trim();
 
             lock_queue.unlock();
 
             RunTask(&task);
         } else {
-            queue_idx = (++queue_idx < queues.len) ? queue_idx : 0;
+            worker_idx = (++worker_idx < workers.len) ? worker_idx : 0;
         }
     }
 }
@@ -5982,10 +6060,16 @@ void Fiber::FiberCallback(unsigned int high, unsigned int low)
 static RG_THREAD_LOCAL std::unique_lock<std::mutex> *fib_lock;
 static RG_THREAD_LOCAL Fiber *fib_self;
 
-Fiber::Fiber(const std::function<bool()> &f, Size stack_size)
+Fiber::Fiber(const std::function<bool()> &f, Size)
     : f(f)
 {
-    thread = std::thread(ThreadCallback, this);
+    int ret = pthread_create(&thread, nullptr, ThreadCallback, this);
+    if (ret) {
+        LogError("Failed to create thread: %1", strerror(ret));
+        return;
+    }
+    joinable = true;
+
     done = false;
 
     while (toggle == 1) {
@@ -5998,8 +6082,8 @@ Fiber::~Fiber()
     // We are forced to execute it until the end
     Finalize();
 
-    if (thread.joinable()) {
-        thread.join();
+    if (joinable) {
+        pthread_join(thread, nullptr);
     }
 }
 
@@ -6030,7 +6114,7 @@ bool Fiber::SwitchBack()
     }
 }
 
-void Fiber::ThreadCallback(void *udata)
+void *Fiber::ThreadCallback(void *udata)
 {
     Fiber *self = (Fiber *)udata;
 
@@ -6047,6 +6131,8 @@ void Fiber::ThreadCallback(void *udata)
 
     self->toggle = 0;
     self->cv.notify_one();
+
+    return nullptr;
 }
 
 void Fiber::Toggle(int to, std::unique_lock<std::mutex> *lock)