Brummel
c9a84b33b3
Tasks 1-4 land fully review-green and are the cohesive shippable
subset (the per-thread embedding ABI, fully wired + proven):
- T1: FIXED-FIRST alloc-guard baseline pin (RED captured -> GREEN at T4).
- T2: runtime/rc.c gains ailang_ctx_t {alloc_count,free_count} +
ailang_ctx_new/_free + __thread __ail_tls_ctx; the two increment
sites become 'if (_ctx) _ctx->... else g_rc_...'. g_rc_* statics +
ailang_rc_stats_atexit + the constructor RETAINED VERBATIM as the
null-ctx (single-threaded executable) fallback. rc_accounting_tsan.c
+ driver: per-ctx 8x200000 tsan-clean (de-globalisation positive proof).
- T3: codegen Target::StaticLib forwarder gains a leading 'ptr %ctx'
+ one '@__ail_tls_ctx = external thread_local global ptr' decl +
TLS save/store/restore around the BYTE-UNCHANGED internal call;
_adapter/_clos + internal arg vector untouched (M1 decision held);
doc-comment provisionality narrowed to the value/record layout.
- T4: build_staticlib rejects --alloc != rc (RC-only swarm artefact).
Boss adjudication of the orchestrator's Task-5 BLOCKED (spec-defect,
correctly surfaced not hacked): swarm.c's -DSHARED_CTX negative
control is structurally impossible — examples/embed_backtest_step.ail
is a non-allocating scalar kernel that never writes a ctx field, and
__ail_tls_ctx is __thread, so a shared-ctx scalar swarm has no
shared-memory write to race on (the spec's OWN item-1 honesty point).
The de-globalisation teeth belong to the item-1 rc_accounting harness
(shared ctx genuinely races on ctx->alloc_count; orchestrator
independently confirmed tsan exit 66). Spec amended in lockstep
(Goal coherent-stop, must-fail-axis item 2, Testing item 3,
Acceptance) so item 3's negative control is item-1's by the
de-globalisation-proof / capability-demo split; plan Task 5
restructured (swarm.c per-ctx capability demo only; negative-control
standing test relocated into the item-1 harness driver) + Task 3's
plan-transcription error (@ail_backtest_step ->
@ail_embed_backtest_step_step) corrected. This is a Boss
consistency-repair of an internally-contradictory clause whose intent
is already correctly realised in the same spec — not a redesign; no
brainstorm bounce. Task-5 working files discarded (corrected plan
reproduces them; a structurally-RED test must not enter main).
INDEX.md + final journal land at iter completion (re-dispatch [5,9]).
60 lines
1.8 KiB
C
60 lines
1.8 KiB
C
/* M2 item 1: the de-globalisation teeth. Exercises ailang_rc_alloc /
|
|
* ailang_rc_dec DIRECTLY (not through any kernel) from N threads, each
|
|
* owning its own ailang_ctx_t. Per-ctx counters must be individually
|
|
* correct and -fsanitize=thread-clean. Build -DSHARED_CTX for the
|
|
* global-hammering negative control (must make tsan report a race). */
|
|
#include <stdint.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <pthread.h>
|
|
#include <assert.h>
|
|
|
|
typedef struct ailang_ctx ailang_ctx_t;
|
|
extern ailang_ctx_t *ailang_ctx_new(void);
|
|
extern void ailang_ctx_free(ailang_ctx_t *);
|
|
extern void *ailang_rc_alloc(size_t);
|
|
extern void ailang_rc_dec(void *);
|
|
/* set the per-call ctx the runtime accounts into (defined in rc.c) */
|
|
extern __thread ailang_ctx_t *__ail_tls_ctx;
|
|
|
|
#define NTHREADS 8
|
|
#define NCYCLES 200000
|
|
|
|
#ifdef SHARED_CTX
|
|
static ailang_ctx_t *g_shared; /* negative control: one ctx, all threads */
|
|
#endif
|
|
|
|
static void *worker(void *_a) {
|
|
(void)_a;
|
|
#ifdef SHARED_CTX
|
|
ailang_ctx_t *ctx = g_shared;
|
|
#else
|
|
ailang_ctx_t *ctx = ailang_ctx_new();
|
|
#endif
|
|
__ail_tls_ctx = ctx;
|
|
for (int i = 0; i < NCYCLES; i++) {
|
|
void *p = ailang_rc_alloc(16);
|
|
ailang_rc_dec(p); /* refcount 1 -> 0, frees, free_count++ */
|
|
}
|
|
#ifndef SHARED_CTX
|
|
/* per-ctx balance must hold exactly */
|
|
/* (read via the same struct layout the runtime defines) */
|
|
ailang_ctx_free(ctx);
|
|
#endif
|
|
return NULL;
|
|
}
|
|
|
|
int main(void) {
|
|
#ifdef SHARED_CTX
|
|
g_shared = ailang_ctx_new();
|
|
#endif
|
|
pthread_t t[NTHREADS];
|
|
for (int i = 0; i < NTHREADS; i++) pthread_create(&t[i], NULL, worker, NULL);
|
|
for (int i = 0; i < NTHREADS; i++) pthread_join(t[i], NULL);
|
|
#ifdef SHARED_CTX
|
|
ailang_ctx_free(g_shared);
|
|
#endif
|
|
printf("rc_accounting_tsan: ok\n");
|
|
return 0;
|
|
}
|