98 thread pool

CHANGELOG.md

@@ -5,6 +5,24 @@ All notable changes to the Async extension for PHP will be documented in this fi
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.7.0] -
+
+### Added
+- **`Async\ThreadPool`** (new class): pool of OS threads for executing PHP closures. `submit($callable, ...$args): Future`, `map(array $items, $callable): array`, `close()` (graceful), `cancel()` (rejects backlog with `Async\CancellationException`, running tasks still finish), `isClosed()`, `getWorkerCount()`, `getPendingCount()`, `getRunningCount()`. Implements `Countable`. Constructor `new ThreadPool(int $workers, int $queue_size = 0)`; queue is a thread-safe channel that suspends the submitting coroutine when full (backpressure).
+- **`Async\ThreadPoolException`** (new class): thrown from `submit()` / `map()` when the pool is closed.
+- **`Async\ThreadChannel`** (new class): thread-safe channel for transferring zvals between threads via deep-copy snapshot. `send()` / `receive()` suspend the calling coroutine instead of blocking the OS thread. Closures, including those with bound variables, transfer correctly through the snapshot machinery.
+- **`Async\ThreadChannelException`** (new class).
+- **Coverage phase 2** — targeted tests for `future.c`, `async.c`, `task_group.c`, `channel.c`, `thread.c`, `thread_pool.c`, `context.c`, `pool.c`. Aggregate ext/async coverage went from 77.45% to 78.34% lines (+104 lines) and from 88% to 89.1% functions (+10 functions). New tests cover Future status/cancel/getAwaitingInfo methods, FutureState double-resolve errors, finally() exception-chain propagation, non-callable argument rejection on map/catch/finally, TaskGroup synchronous-settled paths for `all()`/`race()`/`any()`, Channel unbuffered-iterator and foreach-by-ref branches, `Async\timeout(0)` ValueError, `Async\delay(0)` fast path, `Async\current_coroutine()` out-of-coroutine error, and `Context::get()` missing-key fallback. See `COVERAGE_PROGRESS.md` for the per-target breakdown.
+
+### Fixed
+- **`Async\Timeout::cancel()` double-released the backing object**: Calling `$t->cancel()` disposed the backing timer event, whose `async_timeout_event_dispose()` unconditionally ran `OBJ_RELEASE(object)` assuming the event held a counted reference. In the current architecture the event only stores a raw pointer (`async_timeout_ext_t::std`) without a matching `GC_ADDREF` at creation time, so the release actually decremented the caller's live refcount. The backing object was freed while the userland `$t` variable still pointed to it, and shutdown tripped `IS_OBJ_VALID(object_buckets[handle])` in `zend_objects_store_del()`. Fixed by mirroring `async_timeout_destroy_object()`: `cancel()` now clears `timeout_ext->std` before dispatching the dispose so `async_timeout_event_dispose()` sees a NULL `std` and skips the stray release.
+- **`pool_strategy_report_failure()` captured a dangling exception pointer**: When no caller-provided error was available, the helper created a fresh `Exception` via `zend_throw_exception(NULL, "Resource validation failed", 0)` followed immediately by `zend_clear_exception()`. The throw set `EG(exception)` to a refcount-1 object; `clear_exception()` dropped that reference, freeing the exception. The subsequent `ZVAL_OBJ(&error_zval, ex)` captured a dangling pointer that was then handed to the userland `reportFailure()` handler, producing `zend_mm_heap corrupted` and SIGSEGV at shutdown on ZTS DEBUG. Fixed by constructing the exception directly via `object_init_ex(zend_ce_exception)` + `zend_update_property_ex(MESSAGE)`, which never touches `EG(exception)`, and managing the zval lifetime with an `owns_error` flag and an explicit `zval_ptr_dtor()` after the `reportFailure()` call.
+- **`Async\Scope::disposeAfterTimeout()` leaked the scope refcount**: The timer callback bumped `callback->scope->scope.event.ref_count` once but nothing in `scope_timeout_callback()` or `scope_timeout_coroutine_entry()` ever released it, so the scope was always held above its natural lifetime — 4 `zend_mm` leaks per invocation in DEBUG. The raw `ref_count++` was replaced with `ZEND_ASYNC_EVENT_ADD_REF` and a custom `scope_timeout_callback_dispose` handler now releases the ref when the callback is freed without firing. On the fire path, `scope_timeout_callback()` transfers ownership to the spawned cancellation coroutine (via `extended_data`); `scope_timeout_coroutine_entry()` calls `ZEND_ASYNC_EVENT_RELEASE` after `SCOPE_CANCEL`. The previously-silent `add_callback` failure path also now releases the ref and frees the unclaimed callback.
+- **`Async\CompositeException` wrote to hard-coded `properties_table[7]`**: `async_composite_exception_add_exception()` assumed the `private array $exceptions` typed property lived at slot 7 of the typed-property layout. The real offset for `CompositeException extends \Exception` did not match, so the helper was clobbering an unrelated typed slot: `getExceptions()` on an empty composite hit the "Typed property must not be accessed before initialization" fatal because it was reading the actual (uninitialized) `$exceptions` slot via `zend_read_property`; multiple `addException()` calls produced `var_dump` output with garbage pointer fields and implausible string lengths. Fixed by reading and writing `$exceptions` through `zend_read_property` / `zend_update_property` with the property name, so the engine resolves the correct typed-property slot regardless of inherited layout. `getExceptions()` switched from `silent=0` to `silent=1` (`BP_VAR_IS`) so an empty composite reads back as `[]` rather than triggering the typed-uninit fatal. A second latent bug surfaced while verifying: the PHP method `addException` was passing `transfer=true` to the C helper even though `Z_PARAM_OBJECT_OF_CLASS` only lends a borrowed reference, which caused the stored zval refcount to be one short and made repeated adds alias to the last-inserted object once the slot-7 corruption stopped masking it. Fixed by switching the method call site to `transfer=false` so the helper performs the `GC_ADDREF`.
+- **`Async\Timeout::cancel()` assertion at shutdown (`IS_OBJ_VALID`)**: See the first entry above — this is the same bug; leaving it listed because `tests/common/timeout_class_methods.phpt` from coverage phase 2 is the test that exposed it.
+- **`TaskGroup::all()`/`race()`/`any()` use-after-free in synchronous-settled path**: The synchronous fast paths created a waiter via `task_group_waiter_future_new()` (which pushes it into `group->waiter_events[]`), resolved it synchronously, wrapped it in a Future wrapper and returned — but never removed it from the `waiter_events[]` vector. The drain path in `task_group_try_complete()` always calls `task_group_waiter_event_remove()` after resolving; the sync path forgot to mirror that. At shutdown, `task_group_free_object()` force-disposed everything still in `waiter_events[]`, which `efree`'d the waiter. When the Future wrapper was then destroyed and released the waiter it had wrapped, it touched freed memory — "Future was never used" warning from a stale `zend_future_t` followed by a segfault whenever user code kept an intermediate `$future = $group->all()` variable across a `try`/`catch`. Fixed by calling `task_group_waiter_event_remove(waiter)` at the end of each synchronous-resolve branch, matching what `task_group_try_complete()` does.
+- **`Thread::finally()` on a still-running thread NULL-scope crash**: `thread_object_dtor()` dispatches registered finally handlers via `async_call_finally_handlers()`, which unconditionally dereferences `context->scope` through `ZEND_ASYNC_NEW_SCOPE(context->scope)` and `ZEND_ASYNC_EVENT_ADD_REF(&context->scope->event)`. `thread.c` was passing `context->scope = NULL` because the Thread object had no PHP-side scope of its own, and registering a finally handler on a still-running thread then destroying the thread would segfault at dtor time. Fixed by capturing `ZEND_ASYNC_CURRENT_SCOPE` at spawn time (`async_thread_object_t::parent_scope`) and holding a refcount on the scope event so it outlives the Thread. `thread_object_dtor()` now passes `thread->parent_scope` to the finally dispatcher, so handlers inherit the caller's async context hierarchy (exception handlers, context values) just like `coroutine`/`task_group`/`scope` finally do. Released in `thread_object_free()`. Added `thread_finally_handlers_dtor()` to pair the `GC_ADDREF` that keeps the Thread alive during handler execution with an `OBJ_RELEASE` — previously `context->dtor` was `NULL` and the Thread object leaked 72 bytes every time dtor-time finally ran. A `ZEND_ASYNC_IS_OFF` safety net is kept for the edge case where a Thread object outlives the async subsystem (late `zend_call_destructors` after RSHUTDOWN).
+
 ## [0.6.7] - 2026-04-13
 
 ### Added