400文字だけ残したはずのツール出力が、1MB を握り続けていた

// exp2b.mjs — 平坦化の効き目を1手法ずつ別プロセスで測る
const F = {
  'slice':        s => s.slice(0, KEEP),
  'substring':    s => s.substring(0, KEEP),
  'template':     s => `${s.slice(0, KEEP)}`,
  'String()':     s => String(s.slice(0, KEEP)),
  'concat-empty': s => '' + s.slice(0, KEEP),
  'space-slice1': s => (' ' + s.slice(0, KEEP)).slice(1),
  'split-join':   s => s.slice(0, KEEP).split('').join(''),
  'buffer':       s => Buffer.from(s.slice(0, KEEP), 'utf8').toString('utf8'),
  'json':         s => JSON.parse(JSON.stringify(s.slice(0, KEEP))),
  'array-join':   s => Array.from(s.slice(0, KEEP)).join(''),
  'repeat1':      s => s.slice(0, KEEP).repeat(1),
  'padEnd':       s => s.slice(0, KEEP).padEnd(KEEP),
  'normalize':    s => s.slice(0, KEEP).normalize(),
};

// exp10.mjs — node --expose-gc exp10.mjs [naive|flatten]
const FLATTEN = process.argv[2] === 'flatten';
const CALLS = 200;
const OUT = 1024 * 1024;
const KEEP = 400;
 
function truncatePreview(s, keep) {
  if (s.length <= keep) return s;
  const head = s.slice(0, keep);
  // head は親の全文への参照を握っている。Buffer 往復で切り離す。
  return FLATTEN ? Buffer.from(head, 'utf8').toString('utf8') : head;
}
 
async function callTool(i) {
  return 'L'.repeat(OUT) + '\n#' + i;   // 大きなログを返すツールを模擬
}
 
const history = [];
global.gc();
const t0 = Date.now();
 
for (let i = 0; i < CALLS; i++) {
  const out = await callTool(i);
  history.push({ tool: 'read_log', preview: truncatePreview(out, KEEP), fullBytes: out.length });
}
 
global.gc();
const m = process.memoryUsage();
console.log(FLATTEN ? 'flatten' : 'naive  ',
            'heapUsed =', (m.heapUsed / 1048576).toFixed(1), 'MB',
            '/ rss =', (m.rss / 1048576).toFixed(1), 'MB',
            '/ elapsed =', Date.now() - t0, 'ms');

#!/usr/bin/env node
// sliced_audit.mjs
// ヒープスナップショット中の sliced string と、それが握り続けている親文字列を集計する。
// 使い方: node sliced_audit.mjs <snapshot> [親と見なす下限バイト] [許容合計MB]
import fs from 'node:fs';
 
const file = process.argv[2];
const PARENT_MIN_BYTES = Number(process.argv[3] || 262_144); // 256KB 以上の親だけ数える
const BUDGET_MB = Number(process.argv[4] || 8);
 
const snap = JSON.parse(fs.readFileSync(file, 'utf8'));
const { node_fields: nf, node_types: nt, edge_fields: ef, edge_types: et } = snap.snapshot.meta;
const NS = nf.length, ES = ef.length;
const TYPE = nf.indexOf('type'), NAME = nf.indexOf('name'),
      SIZE = nf.indexOf('self_size'), ECOUNT = nf.indexOf('edge_count');
const ETYPE = ef.indexOf('type'), ETO = ef.indexOf('to_node');
const nodeTypes = nt[0], edgeTypes = et[0];
 
// ノード index → 先頭エッジ index を先に作る。毎回頭から数えると O(n^2) になる。
const edgeStart = new Uint32Array(snap.nodes.length / NS);
for (let i = 0, o = 0, e = 0; o < snap.nodes.length; o += NS, i++) {
  edgeStart[i] = e;
  e += snap.nodes[o + ECOUNT];
}
 
// 同じ親を複数の slice が指す場合の二重計上を Map で防ぐ
const parents = new Map();
let sliced = 0;
 
for (let i = 0, o = 0; o < snap.nodes.length; o += NS, i++) {
  if (nodeTypes[snap.nodes[o + TYPE]] !== 'sliced string') continue;
  sliced++;
  const base = edgeStart[i] * ES;
  for (let k = 0; k < snap.nodes[o + ECOUNT]; k++) {
    const eo = base + k * ES;
    if (edgeTypes[snap.edges[eo + ETYPE]] !== 'internal') continue;
    const po = snap.edges[eo + ETO];
    const bytes = snap.nodes[po + SIZE];
    if (bytes >= PARENT_MIN_BYTES) parents.set(po, bytes);
  }
}
 
let retained = 0;
const samples = [];
for (const [po, bytes] of parents) {
  retained += bytes;
  if (samples.length < 3) {
    samples.push({
      parentMB: +(bytes / 1048576).toFixed(2),
      head: (snap.strings[snap.nodes[po + NAME]] || '').slice(0, 32),
    });
  }
}
 
const retainedMB = +(retained / 1048576).toFixed(2);
console.log(JSON.stringify({
  slicedStrings: sliced, retainedParents: parents.size, retainedMB, budgetMB: BUDGET_MB, samples,
}));
 
process.exit(retainedMB > BUDGET_MB ? 1 : 0);

import tracemalloc
SIZE, N, KEEP = 4 * 1024 * 1024, 20, 200
tracemalloc.start()
base = tracemalloc.get_traced_memory()[0]
kept = [( 'x' * SIZE + '#' + str(i))[:KEEP] for i in range(N)]
cur = tracemalloc.get_traced_memory()[0]
print(f"retained = {(cur - base) / 1048576:.2f} MB")

kept.append(memoryview(full)[:KEEP])   # full は bytes