lifecycle.c File Reference

Go to the source code of this file.

Functions
bool	lifecycle_init (lifecycle_t *lc, const char *name)
bool	lifecycle_init_once (lifecycle_t *lc)
void	lifecycle_init_commit (lifecycle_t *lc)
void	lifecycle_init_abort (lifecycle_t *lc)
bool	lifecycle_shutdown (lifecycle_t *lc)
bool	lifecycle_shutdown_forever (lifecycle_t *lc)
bool	lifecycle_is_initialized (const lifecycle_t *lc)

Function Documentation

lifecycle_init()

bool lifecycle_init	(	lifecycle_t *	lc,
		const char *	name
	)

CAS-based initialization: UNINIT → INITIALIZED.

Parameters

lc	lifecycle state (may include sync_type and sync pointer)
name	name tag for any sync primitive (for debugging), or NULL if no sync

Returns

true if THIS caller won the race and should do init work

false if already INITIALIZED, INITIALIZING, or DEAD

Suitable for single-threaded startup or contexts where the caller guarantees serialization. If lc->sync_type != SYNC_NONE, initializes the sync primitive.

Definition at line 14 of file platform/wasm/lifecycle.c.

                                                       {
  (void)name;
  if (!lc)
    return false;
 
  // Only initialize if not already initialized (matches native CAS behavior)
  int expected = LIFECYCLE_UNINITIALIZED;
  return atomic_cas_int(&lc->state, &expected, LIFECYCLE_INITIALIZED);
}

References atomic_cas_int(), LIFECYCLE_INITIALIZED, LIFECYCLE_UNINITIALIZED, and lifecycle_t::state.

lifecycle_init_abort()

void lifecycle_init_abort

(

lifecycle_t *

lc

)

Abort failed initialization: INITIALIZING → UNINITIALIZED. Call this if lifecycle_init_once() returns true but init work fails.

Parameters

lc	lifecycle state

Allows the next caller to retry initialization. Wakes spinners.

Definition at line 39 of file platform/wasm/lifecycle.c.

                                           {
  if (!lc)
    return;
  atomic_store_int(&lc->state, LIFECYCLE_UNINITIALIZED);
}

References atomic_store_int(), LIFECYCLE_UNINITIALIZED, and lifecycle_t::state.

lifecycle_init_commit()

void lifecycle_init_commit

(

lifecycle_t *

lc

)

Commit successful initialization: INITIALIZING → INITIALIZED. Call this after lifecycle_init_once() returns true and init work succeeds.

Parameters

lc	lifecycle state

Wakes all spinners waiting in lifecycle_init_once(). Must be called by the lifecycle_init_once() winner after successful init work.

Definition at line 33 of file platform/wasm/lifecycle.c.

                                            {
  if (!lc)
    return;
  atomic_store_int(&lc->state, LIFECYCLE_INITIALIZED);
}

References atomic_store_int(), LIFECYCLE_INITIALIZED, and lifecycle_t::state.

lifecycle_init_once()

bool lifecycle_init_once

(

lifecycle_t *

lc

)

Lock-free concurrent initialization: CAS UNINIT → INITIALIZING.

Winner receives true and must complete the two-phase sequence:

1. Do actual init work
2. Call lifecycle_init_commit() on success or lifecycle_init_abort() on failure

Losing callers spin on the transient INITIALIZING state until the winner commits, then return false without doing work.

Parameters

lc	lifecycle state

Returns

true if THIS caller won the init race and should do work

false if init already happened (or is in progress) or module is DEAD

Safe for concurrent callers. Exactly one caller gets true (the CAS winner). Other concurrent callers spin until the winner moves to INITIALIZED or DEAD.

Definition at line 24 of file platform/wasm/lifecycle.c.

                                          {
  if (!lc)
    return false;
 
  // Try to transition from UNINITIALIZED to INITIALIZING
  int expected = LIFECYCLE_UNINITIALIZED;
  return atomic_cas_int(&lc->state, &expected, LIFECYCLE_INITIALIZING);
}

References atomic_cas_int(), LIFECYCLE_INITIALIZING, LIFECYCLE_UNINITIALIZED, and lifecycle_t::state.

lifecycle_is_initialized()

bool lifecycle_is_initialized

(

const lifecycle_t *

lc

)

Query: is module in INITIALIZED state?

Parameters

lc	lifecycle state

Returns

true if state == LIFECYCLE_INITIALIZED

Load-only, no side effects. Safe to call from any thread.

Definition at line 56 of file platform/wasm/lifecycle.c.

                                                     {
  if (!lc) {
    return false;
  }
 
  // WASM: Use non-tracking atomic load to avoid time_get_ns() which can block
  // Simply read the state value without the atomic_on_load callback
  int state = (int)(int32_t)atomic_load((const _Atomic(uint64_t) *)&lc->state);
  bool result = state == LIFECYCLE_INITIALIZED;
 
  return result;
}

References LIFECYCLE_INITIALIZED, and lifecycle_t::state.

lifecycle_shutdown()

bool lifecycle_shutdown

(

lifecycle_t *

lc

)

Regular shutdown: INITIALIZED → UNINITIALIZED.

Parameters

lc	lifecycle state (may include sync_type and sync pointer)

Returns

true if THIS caller should do shutdown work

false if already UNINITIALIZED or DEAD

Allows re-initialization after shutdown (unlike shutdown_forever). If lc->sync_type != SYNC_NONE, destroys the sync primitive.

Definition at line 45 of file platform/wasm/lifecycle.c.

                                         {
  if (!lc)
    return false;
  atomic_store_int(&lc->state, LIFECYCLE_UNINITIALIZED);
  return true;
}

References atomic_store_int(), LIFECYCLE_UNINITIALIZED, and lifecycle_t::state.

Referenced by lifecycle_shutdown_forever().

lifecycle_shutdown_forever()

bool lifecycle_shutdown_forever

(

lifecycle_t *

lc

)

Permanent shutdown: any non-DEAD → DEAD.

Parameters

lc	lifecycle state

Returns

true if module was INITIALIZED and caller should do shutdown work

false if already DEAD

Once DEAD, future init/init_once calls always return false. Spins if called while init_once is in progress (INITIALIZING state). Used for modules that must never be re-initialized.

Definition at line 52 of file platform/wasm/lifecycle.c.

                                                 {
  return lifecycle_shutdown(lc);
}

References lifecycle_shutdown().