# Shared

---

## Object Definition

```c
typedef struct _kpl_shared {
    KPL_POOL_HEADER(_kpl_shared);
    _Atomic bool mutating;
    bool mark;
    kpl_class class;
    kpl_task *queue_head, queue_tail;
    pthread_mutex_t queue_mutex;
} kpl_shared;

static _Atomic int32_t shared_threads_marked;

static kpl_shared *shared_pool_sweep, *shared_pool;

static pthread_mutex_t shared_pool_mutex;
```

## Tracing

1. Once triggered add a init task to the async queue
2. This task moves the `shared_pool` to the `shared_pool_sweep` and sets the `shared_wait` to off for each thread
3. Each thread will run down its queue queue marking found shared objects
3. Once all have run and `shared_threads_marked == available_threads` add a mark and sweep task to the async queue
4. The async queue is moved to a temp queue and as each item on the tmep queue is marked it is moved back to the async queue
5. A sweep on the `shared_pool_sweep` is done
6. What remains on the `shared_pool_sweep` is added to `shared_pool`

## Mutating

1. Check if state of `mutating`
    1. If false, set to true and add the task to the `async_queue_pool`
    2. Once complete lock `queue_mutex` and check the `queue_pool`
    3. If empty set the state of `mutating` to false
    4. Else queue the next task
2. If the state of `mutating` is true add, lock `queue_mutex` the task to `queue_tail`