code wiki / _hdl_build / nx_eco_graph_arch.nx
`nx_eco_graph_arch.nx` source

↩ module page · 234 lines · 9574 B
1// nx_eco_graph_arch.nx -- SOVEREIGN ARCHITECTURE REVIEW of the ecosystem's dependency design, computed
2// from the eco_graph store with the field's own instruments (operator 2026-07-16: "is syscalls supposed
3// to have this design? give the ecosystem design a SOTA review"):
4//   1. SCCs (iterative Kosaraju)   -> cycles = Acyclic-Dependencies-Principle violations, NAMED; the
5//                                     largest SCC = the "core" in MacCormack's core-periphery method
6//   2. PROPAGATION COST            -> avg % of the codebase a change can reach (MacCormack et al.,
7//                                     "Exploring the Structure of Complex Software Designs" -- Linux/
8//                                     Mozilla were measured with exactly this)
9//   3. Fan-in concentration        -> the god-node question: direct-import share of the top hubs
10//                                     (libc-pattern universal base vs unhealthy coupling)
11//   4. Depth histogram             -> generations from roots: deep layered composition vs base-hugging flat
12// Usage: nx_eco_graph_arch <store-prefix>   license_tier: ORIGINAL  expect_exit:0
13import "nx_syscalls.nx"
14import "nx_eco_graph.nx"
15const K_MAGIC_10000: i64 = 10000
16
17func aw(s: *u8) -> i64 { var n:i64=0; while s[n]!=(0 as u8){n=n+1} sys_write(1,s,n); return 0 }
18func an(v: i64) -> i64 { let b:*u8=sys_mmap(24); var m:i64=v; if m<0{sys_write(1,"-" as *u8,1);m=0-m} let t:*u8=sys_mmap(24); var k:i64=0; if m==0{t[0]=48 as u8;k=1} while m>0{t[k]=(48+(m%10)) as u8;m=m/10;k=k+1} var j:i64=0; while j<k{b[j]=t[k-1-j];j=j+1} sys_write(1,b,k); return 0 }
19func aname(g: *EcoGraph, idx: i64) -> i64 {
  let off: i64 = g.node_off[idx]
  var n: i64 = 0
  while g.arena[off+n] != (0 as u8) { n = n + 1 }
  sys_write(1, ((g.arena as i64)+off) as *u8, n)
  return 0
25}
26
27func main(argc: i64, argv: *i64) -> i64 {
  if argc < 2 { aw("usage: nx_eco_graph_arch <store-prefix>\n" as *u8); return 2 }
  let g: *EcoGraph = eg_load(argv[1] as *u8)
  if (g as i64) == 0 { aw("ERROR store not found\n" as *u8); return 3 }
  let n: i64 = g.node_count
  let E: i64 = g.out_head[n]
  aw("=== NX-ECO-ARCH: sovereign architecture review of the dependency design ===\n" as *u8)
  aw("nodes=" as *u8); an(n); aw("  edges=" as *u8); an(E); aw("\n\n" as *u8)
35
  // ---------- 1. SCCs: iterative Kosaraju ----------
  let color: *u8 = sys_mmap(n + 2)
  let order: *i64 = sys_mmap((n+2)*8) as *i64
  let stv: *i64 = sys_mmap((n+2)*8) as *i64
  let stp: *i64 = sys_mmap((n+2)*8) as *i64
  var i: i64 = 0
  while i < n { color[i] = 0 as u8; i = i + 1 }
  var ordn: i64 = 0
  var s: i64 = 0
  while s < n {
      if color[s] == (0 as u8) {
          var sp: i64 = 0
          stv[0] = s
          stp[0] = g.out_head[s]
          color[s] = 1 as u8
          while sp >= 0 {
              let v: i64 = stv[sp]
              if stp[sp] < g.out_head[v+1] {
                  let w: i64 = g.out_list[stp[sp]]
                  stp[sp] = stp[sp] + 1
                  if color[w] == (0 as u8) {
                      color[w] = 1 as u8
                      sp = sp + 1
                      stv[sp] = w
                      stp[sp] = g.out_head[w]
                  }
              } else {
                  order[ordn] = v
                  ordn = ordn + 1
                  sp = sp - 1
              }
          }
      }
      s = s + 1
  }
  // pass 2 on transpose (in-edges), reverse finish order
  let comp: *i64 = sys_mmap((n+2)*8) as *i64
  i = 0
  while i < n { comp[i] = 0 - 1; i = i + 1 }
  var nc: i64 = 0
  var oi: i64 = ordn - 1
  while oi >= 0 {
      let s2: i64 = order[oi]
      if comp[s2] < 0 {
          var sp2: i64 = 0
          stv[0] = s2
          comp[s2] = nc
          while sp2 >= 0 {
              let v2: i64 = stv[sp2]
              sp2 = sp2 - 1
              var p: i64 = g.in_head[v2]
              while p < g.in_head[v2+1] {
                  let w2: i64 = g.in_list[p]
                  if comp[w2] < 0 {
                      comp[w2] = nc
                      sp2 = sp2 + 1
                      stv[sp2] = w2
                  }
                  p = p + 1
              }
          }
          nc = nc + 1
      }
      oi = oi - 1
  }
  // component sizes
  let csz: *i64 = sys_mmap((n+2)*8) as *i64
  i = 0; while i < nc { csz[i] = 0; i = i + 1 }
  i = 0; while i < n { csz[comp[i]] = csz[comp[i]] + 1; i = i + 1 }
  var ncyc: i64 = 0
  var incyc: i64 = 0
  var big: i64 = 0
  i = 0
  while i < nc {
      if csz[i] > 1 { ncyc = ncyc + 1; incyc = incyc + incyc*0 + csz[i] }
      if csz[i] > csz[big] { big = i }
      i = i + 1
  }
  aw("[1] CYCLES (Acyclic-Dependencies-Principle):\n" as *u8)
  aw("  nontrivial SCCs=" as *u8); an(ncyc); aw("  organs-inside-cycles=" as *u8); an(incyc)
  aw("  largest-SCC(core)=" as *u8); an(csz[big]); aw("\n" as *u8)
  // print members of up to 5 nontrivial SCCs (cap 20 names each)
  var printed: i64 = 0
  var ci: i64 = 0
  while ci < nc {
      if csz[ci] > 1 { if printed < 5 {
          aw("  CYCLE size=" as *u8); an(csz[ci]); aw(":" as *u8)
          var m: i64 = 0
          i = 0
          while i < n {
              if comp[i] == ci { if m < 20 { aw(" " as *u8); aname(g, i) } m = m + 1 }
              i = i + 1
          }
          if m > 20 { aw(" ...+" as *u8); an(m-20) }
          aw("\n" as *u8)
          printed = printed + 1
      } }
      ci = ci + 1
  }
  aw("\n" as *u8)
136
  // ---------- 2. PROPAGATION COST (MacCormack): avg transitive reach of a change ----------
  // For each v: how many organs TRANSITIVELY depend on v (BFS over in-edges). Stamp array, no memset.
  let stamp: *i64 = sys_mmap((n+2)*8) as *i64
  i = 0; while i < n { stamp[i] = 0 - 1; i = i + 1 }
  var total: i64 = 0
  var mxreach: i64 = 0
  var mxv: i64 = 0
  s = 0
  while s < n {
      var reach: i64 = 0
      var sp3: i64 = 0
      stv[0] = s
      stamp[s] = s
      while sp3 >= 0 {
          let v3: i64 = stv[sp3]
          sp3 = sp3 - 1
          var p3: i64 = g.in_head[v3]
          while p3 < g.in_head[v3+1] {
              let w3: i64 = g.in_list[p3]
              if stamp[w3] != s {
                  stamp[w3] = s
                  reach = reach + 1
                  sp3 = sp3 + 1
                  stv[sp3] = w3
              }
              p3 = p3 + 1
          }
      }
      total = total + reach
      if reach > mxreach { mxreach = reach; mxv = s }
      s = s + 1
  }
  // PC as basis points (x/10000) to keep integer precision: total / (n*n)
  let pc_bp: i64 = total * K_MAGIC_10000 / (n * n)
  aw("[2] PROPAGATION COST (MacCormack core-periphery instrument):\n" as *u8)
  aw("  avg transitive dependents per organ=" as *u8); an(total / n)
  aw("  propagation-cost=" as *u8); an(pc_bp / 100); aw("." as *u8); an(pc_bp % 100); aw("% (published Linux ~5-18%, Mozilla pre-redesign ~17%)\n" as *u8)
  aw("  max blast-radius organ=" as *u8); aname(g, mxv); aw(" reaches " as *u8); an(mxreach); aw(" (" as *u8); an(mxreach * 100 / n); aw("% of ecosystem)\n\n" as *u8)
175
  // ---------- 3. FAN-IN CONCENTRATION (the god-node question) ----------
  aw("[3] FAN-IN CONCENTRATION (direct imports; libc-pattern vs coupling):\n" as *u8)
  let bi: *i64 = sys_mmap(14*8) as *i64
  let bc: *i64 = sys_mmap(14*8) as *i64
  var bn: i64 = 0
  i = 0
  while i < n {
      let fin: i64 = g.in_head[i+1] - g.in_head[i]
      if bn < 12 { bi[bn] = i; bc[bn] = fin; bn = bn + 1 } else {
          var mn: i64 = 0
          var k: i64 = 1
          while k < bn { if bc[k] < bc[mn] { mn = k } k = k + 1 }
          if fin > bc[mn] { bi[mn] = i; bc[mn] = fin }
      }
      i = i + 1
  }
  var em: i64 = 0
  while em < bn {
      var bb: i64 = 0
      var k2: i64 = 1
      while k2 < bn { if bc[k2] > bc[bb] { bb = k2 } k2 = k2 + 1 }
      if bc[bb] >= 0 {
          aw("  " as *u8); aname(g, bi[bb]); aw("  direct-importers=" as *u8); an(bc[bb]); aw(" (" as *u8); an(bc[bb] * 100 / n); aw("% of all organs)\n" as *u8)
          bc[bb] = 0 - 1
      }
      em = em + 1
  }
  aw("\n" as *u8)
204
  // ---------- 4. DEPTH: BFS generations from roots ----------
  let gen: *i64 = sys_mmap((n+2)*8) as *i64
  i = 0; while i < n { gen[i] = 0 - 1; i = i + 1 }
  var wt: i64 = 0
  i = 0
  while i < n { if g.out_head[i] == g.out_head[i+1] { gen[i] = 0; order[wt] = i; wt = wt + 1 } i = i + 1 }
  var wh: i64 = 0
  while wh < wt {
      let v4: i64 = order[wh]
      var p4: i64 = g.in_head[v4]
      while p4 < g.in_head[v4+1] {
          let u: i64 = g.in_list[p4]
          if gen[u] < 0 { gen[u] = gen[v4] + 1; order[wt] = u; wt = wt + 1 }
          p4 = p4 + 1
      }
      wh = wh + 1
  }
  var mxg: i64 = 0
  i = 0; while i < n { if gen[i] > mxg { mxg = gen[i] } i = i + 1 }
  aw("[4] DEPTH (shortest import-hops from roots; deep layering vs base-hugging):\n" as *u8)
  var l: i64 = 0
  while l <= mxg {
      var cnt: i64 = 0
      i = 0; while i < n { if gen[i] == l { cnt = cnt + 1 } i = i + 1 }
      aw("  gen " as *u8); an(l); aw(": " as *u8); an(cnt); aw(" organs (" as *u8); an(cnt * 100 / n); aw("%)\n" as *u8)
      l = l + 1
  }
  aw("\nNX-ECO-ARCH done -- feed cycles to the janitor, numbers to /compare/ecosysdesign.\n" as *u8)
  return 0
234}
nx_eco_graph_arch.nx source

`nx_eco_graph_arch.nx` source
