Datasets:

ruthvikanne
/

kernel-mcu-c-pool

#!/usr/bin/env python3
"""Stage 0 - build the kernel / MCU-OS C corpus. CPU only (spends no GPU quota).
Mix (by estimated tokens, configurable):
  40% mcu          RTOS / microcontroller OS / firmware / bootloader code
  20% linux_gpu    drivers/gpu, video, accel
  15% linux_cpu    arch/*, cpufreq, cpuidle, irqchip, clocksource, perf, firmware
  25% linux_core   kernel, mm, fs, net, block, pci, usb, dma, include/linux, ...
Outputs (in $WORK/corpus): train.jsonl, heldout.jsonl, stats.json
Known gaps: no near-duplicate removal (exact dedup only); token counts are
byte-based estimates until the real tokenizer is applied in the next stage.
"""
import hashlib, json, os, random, re, shutil, subprocess, sys, time
from collections import Counter, defaultdict
from pathlib import Path

WORK = Path(os.environ.get("WORK", "/kaggle/working"))
SRC, OUT = WORK / "src", WORK / "corpus"
TOKEN_BUDGET = int(os.environ.get("TOKEN_BUDGET", 40_000_000))
BYTES_PER_TOKEN = float(os.environ.get("BYTES_PER_TOKEN", 3.6))  # rough, C code
ONLY = set(filter(None, os.environ.get("ONLY_REPOS", "").split(",")))  # for tests
SEED = 1234
MAX_FILE_BYTES, MIN_FILE_BYTES = 120_000, 300
HELDOUT_MOD = 50  # ~2% of directories held out entirely
SHARE_CAP = 0.35  # no single source may exceed this share of its bucket

WEIGHTS = {"mcu": 0.40, "linux_gpu": 0.20, "linux_cpu": 0.15, "linux_core": 0.25}

# name: (url, license_hint, include_prefixes or None for all)
MCU_REPOS = {
    "freertos": ("https://github.com/FreeRTOS/FreeRTOS-Kernel", "MIT", None),
    "zephyr": ("https://github.com/zephyrproject-rtos/zephyr", "Apache-2.0",
               ["kernel/", "arch/", "drivers/", "soc/", "lib/", "include/", "subsys/"]),
    "nuttx": ("https://github.com/apache/nuttx", "Apache-2.0",
              ["sched/", "arch/", "drivers/", "mm/", "fs/", "libs/", "include/"]),
    "riot": ("https://github.com/RIOT-OS/RIOT", "LGPL-2.1", ["core/", "cpu/", "drivers/", "sys/"]),
    "cmsis": ("https://github.com/ARM-software/CMSIS_6", "Apache-2.0", None),
    "xv6": ("https://github.com/mit-pdos/xv6-public", "MIT", None),
    "contiki-ng": ("https://github.com/contiki-ng/contiki-ng", "BSD-3-Clause", ["os/", "arch/"]),
    "rt-thread": ("https://github.com/RT-Thread/rt-thread", "Apache-2.0",
                  ["src/", "libcpu/", "components/drivers/"]),
    "u-boot": ("https://github.com/u-boot/u-boot", "GPL-2.0", ["arch/", "drivers/", "common/", "lib/", "cmd/"]),
    "opensbi": ("https://github.com/riscv-software-src/opensbi", "BSD-2-Clause", None),
    "sel4": ("https://github.com/seL4/seL4", "GPL-2.0", ["src/", "include/", "libsel4/"]),
    "libopencm3": ("https://github.com/libopencm3/libopencm3", "LGPL-3.0", None),
}
LINUX = ("https://github.com/torvalds/linux", "GPL-2.0")
LINUX_BUCKETS = {
    "linux_gpu": ["drivers/gpu/", "drivers/video/", "drivers/accel/"],
    "linux_cpu": ["arch/x86/", "arch/arm64/", "arch/riscv/", "arch/arm/", "drivers/cpufreq/",
                  "drivers/cpuidle/", "drivers/irqchip/", "drivers/clocksource/", "drivers/perf/",
                  "drivers/firmware/"],
    "linux_core": ["kernel/", "mm/", "fs/", "net/", "block/", "ipc/", "lib/", "security/", "crypto/",
                   "init/", "include/linux/", "drivers/pci/", "drivers/usb/", "drivers/nvme/",
                   "drivers/base/", "drivers/dma/", "drivers/iommu/", "drivers/virtio/",
                   "drivers/tty/", "drivers/char/", "drivers/md/", "drivers/scsi/"],
}
EXTS = {".c", ".h", ".S", ".s"}
SKIP_PATH = re.compile(
    r"(_sh_mask\.h$|_offset\.h$|/asic_reg/|/firmware/.*\.(c|h)$|/(test|tests|selftests|Documentation|"
    r"samples|tools|scripts|third_party|ThirdParty|examples)/|\.dtsi?$|/bsp/|/boards/|/dts/)")
GENERATED = re.compile(r"(auto-?generated|do not edit|generated by|this file is generated)", re.I)
HEXROW = re.compile(r"^\s*(0x[0-9a-fA-F]+\s*,?\s*)+$")
SPDX = re.compile(r"SPDX-License-Identifier:\s*([^\n*]+?)\s*(?:\*/)?\s*$", re.M)


def sh(cmd, cwd=None, tries=3):
    for i in range(tries):
        r = subprocess.run(cmd, cwd=cwd, shell=True, capture_output=True, text=True)
        if r.returncode == 0:
            return r.stdout.strip()
        print(f"  retry {i+1}: {r.stderr.strip()[:200]}", flush=True)
        time.sleep(3)
    return None


def clone(name, url):
    dst = SRC / name
    if not dst.exists():
        print(f"cloning {name}", flush=True)
        if sh(f"git clone --depth 1 --quiet {url} {dst}") is None:
            return None, None
    return dst, sh("git rev-parse HEAD", cwd=dst)


def define_ratio(text):
    lines = [l for l in text.splitlines() if l.strip()]
    return sum(l.lstrip().startswith("#define") for l in lines) / max(1, len(lines))


def accept(rel, text):
    if SKIP_PATH.search("/" + rel):
        return False
    n = len(text.encode("utf-8", "ignore"))
    if not (MIN_FILE_BYTES <= n <= MAX_FILE_BYTES):
        return False
    if GENERATED.search(text[:1500]):
        return False
    lines = text.splitlines()
    if not lines or max(len(l) for l in lines) > 2000:
        return False
    if sum(bool(HEXROW.match(l)) for l in lines) / len(lines) > 0.4:
        return False
    if sum(ord(c) > 127 for c in text) / len(text) > 0.05:
        return False
    return True


def scan(root, prefixes, bucket, source, lic_hint, sha, out):
    for p in root.rglob("*"):
        if p.suffix not in EXTS or not p.is_file() or ".git" in p.parts:
            continue
        rel = p.relative_to(root).as_posix()
        if prefixes and not any(rel.startswith(x) for x in prefixes):
            continue
        try:
            text = p.read_text("utf-8")
        except (UnicodeDecodeError, OSError):
            continue
        if not accept(rel, text):
            continue
        m = SPDX.search(text[:600])
        out.append({"text": text, "path": f"{source}/{rel}", "bucket": bucket, "source": source,
                    "spdx": (m.group(1) if m else lic_hint), "commit": sha,
                    "def_heavy": define_ratio(text) > 0.6})


def main():
    random.seed(SEED)
    SRC.mkdir(parents=True, exist_ok=True)
    OUT.mkdir(parents=True, exist_ok=True)
    cands, failed = [], []
    for name, (url, lic, prefixes) in MCU_REPOS.items():
        if ONLY and name not in ONLY:
            continue
        d, sha = clone(name, url)
        if d is None:
            failed.append(name); continue
        scan(d, prefixes, "mcu", name, lic, sha, cands)
    if not ONLY or "linux" in ONLY:
        d, sha = clone("linux", LINUX[0])
        if d is None:
            failed.append("linux")
        else:
            for bucket, prefixes in LINUX_BUCKETS.items():
                # source = first two path components so GPU/arch/etc. are balanced
                tmp = []
                scan(d, prefixes, bucket, "linux", LINUX[1], sha, tmp)
                for r in tmp:
                    parts = r["path"].split("/")
                    r["source"] = "/".join(parts[:3])
                cands.extend(tmp)
    print(f"candidates before dedup: {len(cands)}", flush=True)

    seen, uniq = set(), []
    for r in cands:
        h = hashlib.sha1(re.sub(r"\s+", " ", r["text"]).encode()).hexdigest()
        if h not in seen:
            seen.add(h); uniq.append(r)
    print(f"after exact dedup: {len(uniq)}", flush=True)

    train, held = [], []
    by_bucket = defaultdict(lambda: defaultdict(list))
    for r in uniq:
        d = "/".join(r["path"].split("/")[:5])
        if int(hashlib.md5(d.encode()).hexdigest(), 16) % HELDOUT_MOD == 0:
            held.append(r)
        else:
            by_bucket[r["bucket"]][r["source"]].append(r)

    for bucket, srcs in by_bucket.items():
        budget = TOKEN_BUDGET * WEIGHTS[bucket] * BYTES_PER_TOKEN
        # #define-heavy register headers: keep only ~15% so they don't dominate
        for k in srcs:
            srcs[k] = [r for r in srcs[k] if not r["def_heavy"] or random.random() < 0.15]
            random.shuffle(srcs[k])
        used, per = 0, Counter()
        queues = {k: v for k, v in srcs.items() if v}
        while queues and used < budget:
            for k in list(queues):
                if per[k] > SHARE_CAP * budget:
                    del queues[k]; continue
                r = queues[k].pop()
                b = len(r["text"].encode())
                train.append(r); used += b; per[k] += b
                if not queues[k]:
                    del queues[k]
                if used >= budget:
                    break
        print(f"{bucket}: {used/BYTES_PER_TOKEN/1e6:.1f}M est. tokens "
              f"(target {TOKEN_BUDGET*WEIGHTS[bucket]/1e6:.1f}M)", flush=True)

    random.shuffle(train)
    for name, rows in (("train", train), ("heldout", held)):
        with open(OUT / f"{name}.jsonl", "w") as f:
            for r in rows:
                r = {k: v for k, v in r.items() if k != "def_heavy"}
                f.write(json.dumps(r) + "\n")
    stats = {"failed_repos": failed, "budget_tokens": TOKEN_BUDGET, "bytes_per_token_assumed": BYTES_PER_TOKEN}
    for name, rows in (("train", train), ("heldout", held)):
        tot = Counter(); n = Counter(); lic = Counter()
        for r in rows:
            tot[r["bucket"]] += len(r["text"].encode()); n[r["bucket"]] += 1; lic[r["spdx"]] += 1
        s = sum(tot.values()) or 1
        stats[name] = {"files": dict(n), "est_tokens_M": {k: round(v / BYTES_PER_TOKEN / 1e6, 2) for k, v in tot.items()},
                       "share": {k: round(v / s, 3) for k, v in tot.items()},
                       "top_licenses": lic.most_common(12)}
    (OUT / "stats.json").write_text(json.dumps(stats, indent=2))
    print(json.dumps(stats, indent=2))
    if os.environ.get("CLEAN_SRC", "1") == "1":
        shutil.rmtree(SRC, ignore_errors=True)  # keep notebook output small


if __name__ == "__main__":
    main()

	#!/usr/bin/env python3
	"""Stage 0 - build the kernel / MCU-OS C corpus. CPU only (spends no GPU quota).

	Mix (by estimated tokens, configurable):
	40% mcu RTOS / microcontroller OS / firmware / bootloader code
	20% linux_gpu drivers/gpu, video, accel
	15% linux_cpu arch/*, cpufreq, cpuidle, irqchip, clocksource, perf, firmware
	25% linux_core kernel, mm, fs, net, block, pci, usb, dma, include/linux, ...
	Outputs (in $WORK/corpus): train.jsonl, heldout.jsonl, stats.json
	Known gaps: no near-duplicate removal (exact dedup only); token counts are
	byte-based estimates until the real tokenizer is applied in the next stage.
	"""
	import hashlib, json, os, random, re, shutil, subprocess, sys, time
	from collections import Counter, defaultdict
	from pathlib import Path

	WORK = Path(os.environ.get("WORK", "/kaggle/working"))
	SRC, OUT = WORK / "src", WORK / "corpus"
	TOKEN_BUDGET = int(os.environ.get("TOKEN_BUDGET", 40_000_000))
	BYTES_PER_TOKEN = float(os.environ.get("BYTES_PER_TOKEN", 3.6)) # rough, C code
	ONLY = set(filter(None, os.environ.get("ONLY_REPOS", "").split(","))) # for tests
	SEED = 1234
	MAX_FILE_BYTES, MIN_FILE_BYTES = 120_000, 300
	HELDOUT_MOD = 50 # ~2% of directories held out entirely
	SHARE_CAP = 0.35 # no single source may exceed this share of its bucket

	WEIGHTS = {"mcu": 0.40, "linux_gpu": 0.20, "linux_cpu": 0.15, "linux_core": 0.25}

	# name: (url, license_hint, include_prefixes or None for all)
	MCU_REPOS = {
	"freertos": ("https://github.com/FreeRTOS/FreeRTOS-Kernel", "MIT", None),
	"zephyr": ("https://github.com/zephyrproject-rtos/zephyr", "Apache-2.0",
	["kernel/", "arch/", "drivers/", "soc/", "lib/", "include/", "subsys/"]),
	"nuttx": ("https://github.com/apache/nuttx", "Apache-2.0",
	["sched/", "arch/", "drivers/", "mm/", "fs/", "libs/", "include/"]),
	"riot": ("https://github.com/RIOT-OS/RIOT", "LGPL-2.1", ["core/", "cpu/", "drivers/", "sys/"]),
	"cmsis": ("https://github.com/ARM-software/CMSIS_6", "Apache-2.0", None),
	"xv6": ("https://github.com/mit-pdos/xv6-public", "MIT", None),
	"contiki-ng": ("https://github.com/contiki-ng/contiki-ng", "BSD-3-Clause", ["os/", "arch/"]),
	"rt-thread": ("https://github.com/RT-Thread/rt-thread", "Apache-2.0",
	["src/", "libcpu/", "components/drivers/"]),
	"u-boot": ("https://github.com/u-boot/u-boot", "GPL-2.0", ["arch/", "drivers/", "common/", "lib/", "cmd/"]),
	"opensbi": ("https://github.com/riscv-software-src/opensbi", "BSD-2-Clause", None),
	"sel4": ("https://github.com/seL4/seL4", "GPL-2.0", ["src/", "include/", "libsel4/"]),
	"libopencm3": ("https://github.com/libopencm3/libopencm3", "LGPL-3.0", None),
	}
	LINUX = ("https://github.com/torvalds/linux", "GPL-2.0")
	LINUX_BUCKETS = {
	"linux_gpu": ["drivers/gpu/", "drivers/video/", "drivers/accel/"],
	"linux_cpu": ["arch/x86/", "arch/arm64/", "arch/riscv/", "arch/arm/", "drivers/cpufreq/",
	"drivers/cpuidle/", "drivers/irqchip/", "drivers/clocksource/", "drivers/perf/",
	"drivers/firmware/"],
	"linux_core": ["kernel/", "mm/", "fs/", "net/", "block/", "ipc/", "lib/", "security/", "crypto/",
	"init/", "include/linux/", "drivers/pci/", "drivers/usb/", "drivers/nvme/",
	"drivers/base/", "drivers/dma/", "drivers/iommu/", "drivers/virtio/",
	"drivers/tty/", "drivers/char/", "drivers/md/", "drivers/scsi/"],
	}
	EXTS = {".c", ".h", ".S", ".s"}
	SKIP_PATH = re.compile(
	r"(_sh_mask\.h$\|_offset\.h$\|/asic_reg/\|/firmware/.*\.(c\|h)$\|/(test\|tests\|selftests\|Documentation\|"
	r"samples\|tools\|scripts\|third_party\|ThirdParty\|examples)/\|\.dtsi?$\|/bsp/\|/boards/\|/dts/)")
	GENERATED = re.compile(r"(auto-?generated\|do not edit\|generated by\|this file is generated)", re.I)
	HEXROW = re.compile(r"^\s(0x[0-9a-fA-F]+\s,?\s*)+$")
	SPDX = re.compile(r"SPDX-License-Identifier:\s([^\n]+?)\s(?:\/)?\s*$", re.M)


	def sh(cmd, cwd=None, tries=3):
	for i in range(tries):
	r = subprocess.run(cmd, cwd=cwd, shell=True, capture_output=True, text=True)
	if r.returncode == 0:
	return r.stdout.strip()
	print(f" retry {i+1}: {r.stderr.strip()[:200]}", flush=True)
	time.sleep(3)
	return None


	def clone(name, url):
	dst = SRC / name
	if not dst.exists():
	print(f"cloning {name}", flush=True)
	if sh(f"git clone --depth 1 --quiet {url} {dst}") is None:
	return None, None
	return dst, sh("git rev-parse HEAD", cwd=dst)


	def define_ratio(text):
	lines = [l for l in text.splitlines() if l.strip()]
	return sum(l.lstrip().startswith("#define") for l in lines) / max(1, len(lines))


	def accept(rel, text):
	if SKIP_PATH.search("/" + rel):
	return False
	n = len(text.encode("utf-8", "ignore"))
	if not (MIN_FILE_BYTES <= n <= MAX_FILE_BYTES):
	return False
	if GENERATED.search(text[:1500]):
	return False
	lines = text.splitlines()
	if not lines or max(len(l) for l in lines) > 2000:
	return False
	if sum(bool(HEXROW.match(l)) for l in lines) / len(lines) > 0.4:
	return False
	if sum(ord(c) > 127 for c in text) / len(text) > 0.05:
	return False
	return True


	def scan(root, prefixes, bucket, source, lic_hint, sha, out):
	for p in root.rglob("*"):
	if p.suffix not in EXTS or not p.is_file() or ".git" in p.parts:
	continue
	rel = p.relative_to(root).as_posix()
	if prefixes and not any(rel.startswith(x) for x in prefixes):
	continue
	try:
	text = p.read_text("utf-8")
	except (UnicodeDecodeError, OSError):
	continue
	if not accept(rel, text):
	continue
	m = SPDX.search(text[:600])
	out.append({"text": text, "path": f"{source}/{rel}", "bucket": bucket, "source": source,
	"spdx": (m.group(1) if m else lic_hint), "commit": sha,
	"def_heavy": define_ratio(text) > 0.6})


	def main():
	random.seed(SEED)
	SRC.mkdir(parents=True, exist_ok=True)
	OUT.mkdir(parents=True, exist_ok=True)
	cands, failed = [], []
	for name, (url, lic, prefixes) in MCU_REPOS.items():
	if ONLY and name not in ONLY:
	continue
	d, sha = clone(name, url)
	if d is None:
	failed.append(name); continue
	scan(d, prefixes, "mcu", name, lic, sha, cands)
	if not ONLY or "linux" in ONLY:
	d, sha = clone("linux", LINUX[0])
	if d is None:
	failed.append("linux")
	else:
	for bucket, prefixes in LINUX_BUCKETS.items():
	# source = first two path components so GPU/arch/etc. are balanced
	tmp = []
	scan(d, prefixes, bucket, "linux", LINUX[1], sha, tmp)
	for r in tmp:
	parts = r["path"].split("/")
	r["source"] = "/".join(parts[:3])
	cands.extend(tmp)
	print(f"candidates before dedup: {len(cands)}", flush=True)

	seen, uniq = set(), []
	for r in cands:
	h = hashlib.sha1(re.sub(r"\s+", " ", r["text"]).encode()).hexdigest()
	if h not in seen:
	seen.add(h); uniq.append(r)
	print(f"after exact dedup: {len(uniq)}", flush=True)

	train, held = [], []
	by_bucket = defaultdict(lambda: defaultdict(list))
	for r in uniq:
	d = "/".join(r["path"].split("/")[:5])
	if int(hashlib.md5(d.encode()).hexdigest(), 16) % HELDOUT_MOD == 0:
	held.append(r)
	else:
	by_bucket[r["bucket"]][r["source"]].append(r)

	for bucket, srcs in by_bucket.items():
	budget = TOKEN_BUDGET * WEIGHTS[bucket] * BYTES_PER_TOKEN
	# #define-heavy register headers: keep only ~15% so they don't dominate
	for k in srcs:
	srcs[k] = [r for r in srcs[k] if not r["def_heavy"] or random.random() < 0.15]
	random.shuffle(srcs[k])
	used, per = 0, Counter()
	queues = {k: v for k, v in srcs.items() if v}
	while queues and used < budget:
	for k in list(queues):
	if per[k] > SHARE_CAP * budget:
	del queues[k]; continue
	r = queues[k].pop()
	b = len(r["text"].encode())
	train.append(r); used += b; per[k] += b
	if not queues[k]:
	del queues[k]
	if used >= budget:
	break
	print(f"{bucket}: {used/BYTES_PER_TOKEN/1e6:.1f}M est. tokens "
	f"(target {TOKEN_BUDGET*WEIGHTS[bucket]/1e6:.1f}M)", flush=True)

	random.shuffle(train)
	for name, rows in (("train", train), ("heldout", held)):
	with open(OUT / f"{name}.jsonl", "w") as f:
	for r in rows:
	r = {k: v for k, v in r.items() if k != "def_heavy"}
	f.write(json.dumps(r) + "\n")
	stats = {"failed_repos": failed, "budget_tokens": TOKEN_BUDGET, "bytes_per_token_assumed": BYTES_PER_TOKEN}
	for name, rows in (("train", train), ("heldout", held)):
	tot = Counter(); n = Counter(); lic = Counter()
	for r in rows:
	tot[r["bucket"]] += len(r["text"].encode()); n[r["bucket"]] += 1; lic[r["spdx"]] += 1
	s = sum(tot.values()) or 1
	stats[name] = {"files": dict(n), "est_tokens_M": {k: round(v / BYTES_PER_TOKEN / 1e6, 2) for k, v in tot.items()},
	"share": {k: round(v / s, 3) for k, v in tot.items()},
	"top_licenses": lic.most_common(12)}
	(OUT / "stats.json").write_text(json.dumps(stats, indent=2))
	print(json.dumps(stats, indent=2))
	if os.environ.get("CLEAN_SRC", "1") == "1":
	shutil.rmtree(SRC, ignore_errors=True) # keep notebook output small


	if __name__ == "__main__":
	main()