Upload 6 files

dataset_analysis/process.py

@@ -0,0 +1,134 @@
+#!/usr/bin/env python3
+import os
+import json
+import multiprocessing as mp
+from functools import partial
+from pathlib import Path
+
+from core.analysis import (
+    get_module_statistics,
+    get_function_statistics,
+    add_dict_to_corpus,
+)
+
+# --------------------------------------------------------------------------- #
+# Worker runs in a separate process
+# --------------------------------------------------------------------------- #
+def analyse_file(filename: str, wasm_dir: str, max_bytes: int):
+    """
+    Return (module_stats, [function_stats, …]) for one .wasm file,
+    or None if the file should be skipped.
+    """
+    if not filename.endswith(".wat"):
+        return None
+
+    path = Path(wasm_dir) / filename
+    try:
+        if path.stat().st_size > max_bytes:
+            print(f"[worker] Skipping {filename}: larger than {max_bytes} bytes")
+            return None
+
+        with path.open("r") as fh:
+            wasm_code = fh.read()
+
+        module_stats   = get_module_statistics(wasm_code)
+        function_stats = get_function_statistics(wasm_code)
+        return module_stats, function_stats
+
+    except Exception as exc:
+        # Keep worker silent except for diagnostics; never crash the pool
+        print(f"[worker] Error in {filename}: {exc!r}")
+        return None
+
+
+# --------------------------------------------------------------------------- #
+# Main —runs in the parent process
+# --------------------------------------------------------------------------- #
+def main():
+    wasm_directory     = "1_stack_effect_samples"
+    max_file_size_bytes = 100 * 1024        # 100 KB
+
+    file_list        = os.listdir(wasm_directory)
+    total_file_count = len(file_list)
+
+    module_corpus   = []
+    module_corpus_relative_opcodes = []
+    module_corpus_structural_counts = []
+    function_corpus = []
+    function_corpus_relative_opcodes = []
+    function_corpus_structural_counts = []
+
+    # Create a process pool; default size = #CPU cores
+    with mp.Pool() as pool:
+        worker_fn = partial(
+            analyse_file,
+            wasm_dir=wasm_directory,
+            max_bytes=max_file_size_bytes,
+        )
+
+        # imap_unordered streams results back as soon as each worker finishes
+        for idx, result in enumerate(
+            pool.imap_unordered(worker_fn, file_list), start=1
+        ):
+            print(f"[main] Processed {idx}/{total_file_count}")
+
+            if result is None:
+                continue
+
+            module_stats, function_stats = result
+            add_dict_to_corpus(module_corpus, module_stats)
+
+            module_relative_opcodes = {}
+            module_structural_counts = {}
+            for key, value in module_stats.items():
+                if key.startswith("[") and key.endswith("]"):
+                    continue
+                module_relative_opcodes[key] = value
+
+            add_dict_to_corpus(module_corpus_relative_opcodes, module_relative_opcodes)
+            for key, value in module_stats.items():
+                if key.startswith("[") and key.endswith("]"):
+                    module_structural_counts[key] = value
+                else:
+                    continue
+
+            add_dict_to_corpus(module_corpus_structural_counts, module_structural_counts)
+            # Process function statistics
+
+            for fn_stats in function_stats:
+                add_dict_to_corpus(function_corpus, fn_stats)
+                function_relative_opcodes = {}
+                function_structural_counts = {}
+                for key, value in fn_stats.items():
+                    if key.startswith("[") and key.endswith("]"):
+                        continue
+                    function_relative_opcodes[key] = value
+                add_dict_to_corpus(function_corpus_relative_opcodes, function_relative_opcodes)
+                for key, value in fn_stats.items():
+                    if key.startswith("[") and key.endswith("]"):
+                        function_structural_counts[key] = value
+                    else:
+                        continue
+                add_dict_to_corpus(function_corpus_structural_counts, function_structural_counts)
+
+    # ------------------------------------------------------------------- #
+    # Persist the corpora as JSON for later analysis
+    # ------------------------------------------------------------------- #
+    out_dir = Path("1_stack_effect_samples_meta")
+    out_dir.mkdir(exist_ok=True)
+
+    (out_dir / "module_corpus.json").write_text(json.dumps(module_corpus))
+    (out_dir / "function_corpus.json").write_text(json.dumps(function_corpus))
+    (out_dir / "module_corpus_opcodes.json").write_text(json.dumps(module_corpus_relative_opcodes))
+    (out_dir / "function_corpus_opcodes.json").write_text(json.dumps(function_corpus_relative_opcodes))
+    (out_dir / "module_corpus_structural_counts.json").write_text(json.dumps(module_corpus_structural_counts))
+    (out_dir / "function_corpus_structural_counts.json").write_text(json.dumps(function_corpus_structural_counts))
+
+    print("[main] Saved corpora:",
+          f"modules={len(module_corpus)}, functions={len(function_corpus)}")
+
+
+if __name__ == "__main__":
+    # On Windows the "spawn" start‑method is mandatory for pools.
+    mp.freeze_support()
+    main()

dataset_analysis/visualization.py

@@ -0,0 +1,122 @@
+import json
+import os
+
+import matplotlib.pyplot as plt
+import numpy as np
+
+meta_dir = "1_stack_effect_samples_meta"
+#Make dir visualization if not exists
+if not os.path.exists(f"{meta_dir}/visualization"):
+    os.makedirs(f"{meta_dir}/visualization")
+def plot_module_total_byte_distribution():
+    module_corpus = json.load(open(f"{meta_dir}/module_corpus.json"))
+    print(module_corpus[0].keys())
+
+    plt.figure(figsize=(5, 4))
+    plt.hist([module["[binary-bytes]"] for module in module_corpus], bins=100, color='blue', alpha=0.7)
+    plt.title("Distribution of Total Bytes in Modules")
+    plt.xlabel("Total Bytes")
+    plt.ylabel("Frequency")
+    plt.grid(axis='y', alpha=0.75)
+    plt.savefig(f"{meta_dir}/visualization/module_total_byte_distribution.png")
+    plt.show()
+
+def plot_functions_total_byte_distribution():
+    function_corpus = json.load(open(f"{meta_dir}/function_corpus.json"))
+    print(function_corpus[0].keys())
+
+    plt.figure(figsize=(5, 4))
+    #Only plot 99th percentile
+    plt.hist([function["[binary-bytes]"] for function in function_corpus if function["[total]"] < 500], bins=100, color='blue', alpha=0.7)
+    plt.title("Distribution of Total Bytes in Functions")
+    plt.xlabel("Total Bytes")
+    plt.ylabel("Frequency")
+    plt.grid(axis='y', alpha=0.75)
+    plt.savefig(f"{meta_dir}/visualization/functions_total_byte_distribution.png")
+    plt.show()
+
+def plot_module_byte_code_distribution():
+    byte_code_classes = {}
+    total_byte_counts = []
+    module_corpus = json.load(open(f"{meta_dir}/module_corpus.json"))
+    for module in module_corpus:
+        total_byte_count = 0
+        for key, value in module.items():
+            if key.startswith("[") and key.endswith("]"):
+                continue
+            if key not in byte_code_classes:
+                byte_code_classes[key] = []
+            byte_code_classes[key].append(value)
+            total_byte_count += value
+        total_byte_counts.append(total_byte_count)
+    print("Byte code classes:", byte_code_classes)
+
+    #Plot in percentage, descending order
+    for i in range(len(total_byte_counts)):
+        for key, value in byte_code_classes.items():
+            byte_code_classes[key][i] = (value[i] / total_byte_counts[i]) * 100
+
+    #Sort by median
+    byte_code_classes = dict(sorted(byte_code_classes.items(), key=lambda item: (np.median(item[1])), reverse=True))
+    #Sort by median
+
+    plt.figure(figsize=(5, 4))
+    #Use box plots
+    plt.boxplot(list(byte_code_classes.values()), labels=list(byte_code_classes.keys()), showfliers=False)
+    plt.title("Distribution of Byte Code Classes")
+    plt.xlabel("Byte Code Classes")
+    plt.ylabel("Percentage")
+    plt.xticks(rotation=90)
+    plt.grid(axis='y', alpha=0.75)
+    plt.tight_layout()
+    plt.savefig(f"{meta_dir}/visualization/module_byte_code_distribution.png")
+    plt.show()
+
+def plot_functions_byte_code_distribution():
+    byte_code_classes = {}
+    total_byte_counts = []
+    function_corpus = json.load(open(f"{meta_dir}/function_corpus.json"))
+    for function in function_corpus:
+        total_byte_count = 0
+        for key, value in function.items():
+            if key.startswith("[") and key.endswith("]"):
+                continue
+            if key not in byte_code_classes:
+                byte_code_classes[key] = []
+            byte_code_classes[key].append(value)
+            total_byte_count += value
+        total_byte_counts.append(total_byte_count)
+    print("Byte code classes:", byte_code_classes)
+
+    #Plot in percentage, descending order
+    for i in range(len(total_byte_counts)):
+        for key, value in byte_code_classes.items():
+            byte_code_classes[key][i] = (value[i] / total_byte_counts[i]) * 100
+
+    #Sort by median
+    byte_code_classes = dict(sorted(byte_code_classes.items(), key=lambda item: (np.median(item[1])), reverse=True))
+    #Sort by median
+
+    plt.figure(figsize=(5, 4))
+    #Use box plots
+    plt.boxplot(list(byte_code_classes.values()), labels=list(byte_code_classes.keys()), showfliers=False)
+    plt.title("Distribution of Byte Code Classes")
+    plt.xlabel("Byte Code Classes")
+    plt.ylabel("Percentage")
+    plt.xticks(rotation=90)
+    plt.grid(axis='y', alpha=0.75)
+    plt.tight_layout()
+    plt.savefig(f"{meta_dir}/visualization/functions_byte_code_distribution.png")
+    plt.show()
+
+
+def main():
+    #plot_module_total_byte_distribution()
+    #plot_functions_total_byte_distribution()
+    plot_module_byte_code_distribution()
+    plot_functions_byte_code_distribution()
+
+
+
+if __name__ == "__main__":
+    main()

dataset_flags/croissant_metadata.jsonld

@@ -0,0 +1,38 @@
+{
+  "@context": {
+    "@version": 1.1,
+    "schema": "https://schema.org/",
+    "mlc": "https://mlcommons.org/croissant/schema/v0.9/",
+    "@vocab": "https://mlcommons.org/croissant/schema/v0.9/",
+    "name": "schema:name",
+    "description": "schema:description",
+    "license": "schema:license",
+    "url": "schema:url",
+    "authors": { "@id": "schema:author", "@container": "@list" },
+    "data": { "@id": "mlc:data", "@container": "@list" },
+    "features": { "@id": "mlc:features", "@container": "@list" },
+    "encodingFormat": "schema:encodingFormat",
+    "dataType": "mlc:dataType"
+  },
+  "@type": [ "schema:Dataset" ],
+  "name": "wasm-weaver-reachability-reasoning",
+  "description": "This dataset targets control-flow reasoning. Programs contain flags labelled ';;FLAG_1' … ';;FLAG_N'. The model must infer which flags are reachable given the program’s logic (branches, loops, dead code). Each record supplies the program, flag placements, and ground-truth reachability for every flag.",
+  "license": "https://creativecommons.org/licenses/by/4.0/",
+  "url": "https://huggingface.co/datasets/Morxos/WasmWeaver",
+  "authors": [
+    { "name": "Anonymous" }
+  ],
+  "data": [
+    {
+      "@type": "FileObject",
+      "name": "data.jsonl",
+      "encodingFormat": "application/jsonlines",
+      "features": [
+        { "name": "code", "dataType": "string" },
+        { "name": "flag_states", "dataType": "object" },
+        { "name": "return_values", "dataType": "array" },
+        { "name": "stack_values", "dataType": "array" }
+      ]
+    }
+  ]
+}

dataset_results/croissant_metadata.jsonld

@@ -0,0 +1,38 @@
+{
+  "@context": {
+    "@version": 1.1,
+    "schema": "https://schema.org/",
+    "mlc": "https://mlcommons.org/croissant/schema/v0.9/",
+    "@vocab": "https://mlcommons.org/croissant/schema/v0.9/",
+    "name": "schema:name",
+    "description": "schema:description",
+    "license": "schema:license",
+    "url": "schema:url",
+    "authors": { "@id": "schema:author", "@container": "@list" },
+    "data": { "@id": "mlc:data", "@container": "@list" },
+    "features": { "@id": "mlc:features", "@container": "@list" },
+    "encodingFormat": "schema:encodingFormat",
+    "dataType": "mlc:dataType"
+  },
+  "@type": [ "schema:Dataset" ],
+  "name": "wasm-weaver-result-reasoning",
+  "description": "This dataset evaluates a model’s ability to predict the final outputs of WebAssembly programs. Samples range from straight-line code to code with nested branches and loops. Each record contains the program text, any diagnostic flags, and the exact values the program returns when executed.",
+  "license": "https://creativecommons.org/licenses/by/4.0/",
+  "url": "https://huggingface.co/datasets/Morxos/WasmWeaver",
+  "authors": [
+    { "name": "Anonymous" }
+  ],
+  "data": [
+    {
+      "@type": "FileObject",
+      "name": "data.jsonl",
+      "encodingFormat": "application/jsonlines",
+      "features": [
+        { "name": "code", "dataType": "string" },
+        { "name": "flag_states", "dataType": "object" },
+        { "name": "return_values", "dataType": "array" },
+        { "name": "stack_values", "dataType": "array" }
+      ]
+    }
+  ]
+}