The PMLL

[drQedwards]

https://www.authorea.com/users/856117/articles/1297819-the-persistent-memory-logic-loop-from-proposal-design-to-formal-proof-of-p-np-using-the-pmll-algorithm

[drQedwards]

/* pmll.h — Persistent-Memory Logic Loop (CPU reference)
Copyright (c) 2025 Dr. Josef Kurk Edwards
MIT License (same as llm.c)
-------------------------------------------------------------------- */
#pragma once
#include <stddef.h>

#ifndef MAX_MEM_T
#define MAX_MEM_T 128 /* timesteps stored per head */
#endif

/* Ring-buffer state for one batch element /
typedef struct {
int T; / current length 0 ≤ T ≤ MAX_MEM_T /
int hs; / head-size (channels / num_heads) */
float k; / (NH, MAX_MEM_T, hs) contiguous */
float v; / (NH, MAX_MEM_T, hs) */
} pmll_state;

/* Life-cycle ------------------------------------------------------ */
int pmll_init (pmll_state S, int NH, int hs); / malloc → return 0 = OK */
void pmll_reset(pmll_state S); / T ← 0 (keep buffers) */
void pmll_free (pmll_state S); / free() buffers */

/* Data flow ------------------------------------------------------- /
/ Read stored KV for head h into out_k/out_v (both len = (Tmem+Tctx)*hs).
Fills first Tmem positions with history, then zero-pads the Tctx region. */
void pmll_read(float *out_k, float *out_v,
const pmll_state *S, int h, int Tctx);

/* Write new_k/new_v (len = Tctx*hs) into ring buffer for head h.
gate[t] ∈ [0,1] controls how much to blend new vs. old at slot (Told+t). */
void pmll_write(pmll_state *S, int h,
const float *new_k, const float *new_v,
int Tctx, const float *gate);

[drQedwards]

/* pmll.c — implementation for pmll.h (CPU, single-thread safe) */
#include "pmll.h"
#include <stdlib.h>
#include <string.h>

/* Allocate and zero-init ring buffers. Returns 0 on success, -1 on OOM. /
int pmll_init(pmll_state S, int NH, int hs)
{
S->T = 0;
S->hs = hs;
size_t bytes = (size_t)NH * MAX_MEM_T * hs * sizeof(float);
S->k = (float)calloc(1, bytes);
S->v = (float)calloc(1, bytes);
return (S->k && S->v) ? 0 : -1;
}

void pmll_reset(pmll_state *S) { S->T = 0; }

void pmll_free(pmll_state *S)
{
free(S->k); S->k = NULL;
free(S->v); S->v = NULL;
S->T = S->hs = 0;
}

/* Copy historic KV into the caller’s scratch buffers.
Layout: [Tmem history][Tctx zeros] */
void pmll_read(float *out_k, float *out_v,
const pmll_state *S, int h, int Tctx)
{
const int hs = S->hs;
const int Tmem = S->T;
const float src_k = S->k + (size_t)h * MAX_MEM_T * hs;
const float src_v = S->v + (size_t)h * MAX_MEM_T * hs;
size_t hist_bytes = (size_t)Tmem * hs * sizeof(float);
memcpy(out_k, src_k, hist_bytes);
memcpy(out_v, src_v, hist_bytes);
/ zero-pad the fresh-context part /
size_t pad_bytes = (size_t)Tctx * hs * sizeof(float);
memset(out_k + Tmemhs, 0, pad_bytes);
memset(out_v + Tmemhs, 0, pad_bytes);
}

/* Gate-controlled write (blend-in) new_buf shape = (Tctx,hs) */
void pmll_write(pmll_state *S, int h,
const float *new_k, const float *new_v,
int Tctx, const float *gate)
{
const int hs = S->hs;
float *dst_k = S->k + (size_t)h * MAX_MEM_T * hs;
float *dst_v = S->v + (size_t)h * MAX_MEM_T * hs;

for(int t=0; t<Tctx; ++t){
    float g = gate ? gate[t] : 1.0f;          /* default: keep all */
    int   idx = (S->T + t) % MAX_MEM_T;       /* ring-slot */
    const float *nk = new_k + t*hs;
    const float *nv = new_v + t*hs;
    float       *dk = dst_k + idx*hs;
    float       *dv = dst_v + idx*hs;

    for(int i=0;i<hs;++i){
        dk[i] = g * nk[i] + (1.f - g) * dk[i];
        dv[i] = g * nv[i] + (1.f - g) * dv[i];
    }
}
/* advance length */
S->T += Tctx;
if(S->T > MAX_MEM_T) S->T = MAX_MEM_T;

}