exebench.py

# coding=utf-8
# Copyright 2022 ExeBench authors
# The code required to produce and load this dataset is licensed under MIT License.
# The code samples included in this dataset keep their own licenses, which can be retrieved via their metadata.
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

# Please note that the dataset release is still work in progress.

"""The ExeBench dataset."""

import json

import datasets

from pathlib import Path


_CITATION = """\
@inproceedings{10.1145/3520312.3534867,
author = {Armengol-Estap\'{e}, Jordi and Woodruff, Jackson and Brauckmann, Alexander and Magalh\~{a}es, Jos\'{e} Wesley de Souza and O'Boyle, Michael F. P.},
title = {ExeBench: An ML-Scale Dataset of Executable C Functions},
year = {2022},
isbn = {9781450392730},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/3520312.3534867},
doi = {10.1145/3520312.3534867},
abstract = {Machine-learning promises to transform compilation and software engineering, yet is frequently limited by the scope of available datasets. In particular, there is a lack of runnable, real-world datasets required for a range of tasks ranging from neural program synthesis to machine learning-guided program optimization. We introduce a new dataset, ExeBench, which attempts to address this. It tackles two key issues with real-world code: references to external types and functions and scalable generation of IO examples. ExeBench is the first publicly available dataset that pairs real-world C code taken from GitHub with IO examples that allow these programs to be run. We develop a toolchain that scrapes GitHub, analyzes the code, and generates runnable snippets of code. We analyze our benchmark suite using several metrics, and show it is representative of real-world code. ExeBench contains 4.5M compilable and 700k executable C functions. This scale of executable, real functions will enable the next generation of machine learning-based programming tasks.},
booktitle = {Proceedings of the 6th ACM SIGPLAN International Symposium on Machine Programming},
pages = {50–59},
numpages = {10},
keywords = {Code Dataset, Program Synthesis, Mining Software Repositories, C, Machine Learning for Code, Compilers},
location = {San Diego, CA, USA},
series = {MAPS 2022}
}
"""

_DESCRIPTION = """\
An ML-scale dataset of executable C functions
"""  # TODO: expand

_HOMEPAGE = "https://github.com/jordiae/exebench"

_LICENSE = "Multiple: see each function license (fields 'ref' and 'path')"

_URL = ""  # "https://huggingface.co/datasets/jordiae/exebench-test/resolve/main/"

_REMOVED_FEATURES = ["doc", "angha_error", "real_error", "angha_io_error", "real_io_error",
                     "angha_io_pairs_are_trivial", "real_io_pairs_are_trivial"]

_RENAMED_FEATURES = {"angha_deps": "synth_deps", "angha_io_pairs": "synth_io_pairs",
                     "angha_exe_wrapper": "synth_exe_wrapper", "angha_iospec": "synth_iospec"}

_FEATURES = datasets.Features(
    {
        "path": datasets.Value("string"),
        "func_def": datasets.Value("string"),
        "func_head": datasets.Value("string"),
        "func_head_types": datasets.Value("string"),
        "fname": datasets.Value("string"),
        "signature": datasets.Sequence(datasets.Value("string")),
        # "doc": datasets.Value("string"),
        # "angha_error": datasets.Value("string"),
        # "real_error": datasets.Value("string"),
        "asm": datasets.Sequence({'target': datasets.Value("string"), 'code': datasets.Value("string")}),  # unflat dict#Optional[Dict[str, Optional[FuncAsm]]] = None
        "synth_deps": datasets.Value("string"),
        "real_deps": datasets.Value("string"),
        "synth_io_pairs": datasets.Sequence({
            "input": datasets.Sequence({'var': datasets.Value("string"), 'value': datasets.Value("string")}),
            "output": datasets.Sequence({'var': datasets.Value("string"), 'value': datasets.Value("string")}),
            "dummy_funcs": datasets.Value("string"),
            "dummy_funcs_seed": datasets.Value("int64")
        }),
        "real_io_pairs": datasets.Sequence({
            "input": datasets.Sequence({'var': datasets.Value("string"), 'value': datasets.Value("string")}),
            "output": datasets.Sequence({'var': datasets.Value("string"), 'value': datasets.Value("string")}),
            "dummy_funcs": datasets.Value("string"),
            "dummy_funcs_seed": datasets.Value("int64")
        }),
        # "angha_io_error": datasets.Value("string"),
        # "real_io_error": datasets.Value("string"),
        "synth_exe_wrapper": datasets.Value("string"),
        "real_exe_wrapper": datasets.Value("string"),
        # "angha_io_pairs_are_trivial": datasets.Value("bool"),
        # "real_io_pairs_are_trivial": datasets.Value("bool"),
        "ref": datasets.Value("string"),
        "synth_iospec": datasets.Value("string"), # serialized, TODO: improve
        "real_iospec": datasets.Value("string")
    }
)


class ExeBenchConfig(datasets.BuilderConfig):
    """BuilderConfig for ExeBench."""

    def __init__(self, *args, **kwargs):
        """BuilderConfig for The Pile.
        Args:
            **kwargs: keyword arguments forwarded to super.
        """
        super().__init__(
            *args,
            **kwargs,
        )


class ExeBench(datasets.GeneratorBasedBuilder):
    """ExeBench dataset"""

    BUILDER_CONFIGS = [
        ExeBenchConfig(
            name="ExeBench",
            version=datasets.Version("1.0.4"),
            description="Executable C dataset"
        ),
    ]

    def _info(self):
        """Give information and typings for the dataset."""
        return datasets.DatasetInfo(
            # This is the description that will appear on the datasets page.
            description=_DESCRIPTION,
            # This defines the different columns of the dataset and their types
            features=_FEATURES,
            # If there's a common (input, target) tuple from the features,
            # specify them here. They'll be used if as_supervised=True in
            # builder.as_dataset.
            supervised_keys=None,
            # Homepage of the dataset for documentation
            homepage=_HOMEPAGE,
            # License for the dataset if available
            license=_LICENSE,
            # Citation for the dataset
            citation=_CITATION,
        )

    def _split_generators(self, dl_manager):
        """Returns SplitGenerators."""
        urls_to_download = {
                "train_not_compilable": f"{_URL}train_no_compilable.tar.gz",
                "train_synth_compilable": f"{_URL}train_synth_compilable.tar.gz",
                "train_real_compilable": f"{_URL}train_real_compilable.tar.gz",
                "train_synth_simple_io": f"{_URL}train_synth_simple_io.tar.gz",
                "train_real_simple_io": f"{_URL}train_real_simple_io.tar.gz",
                "train_synth_rich_io": f"{_URL}train_synth_rich_io.tar.gz",
                "valid_synth": f"{_URL}valid_synth.tar.gz",
                "valid_real": f"{_URL}valid_real.tar.gz",
                "test_synth": f"{_URL}test_synth.tar.gz",
                "test_real": f"{_URL}test_real.tar.gz",
             }
        downloaded_files = dl_manager.download_and_extract(urls_to_download)

        return [
            datasets.SplitGenerator(name='train_not_compilable',
                                    gen_kwargs={"files": downloaded_files["train_not_compilable"]}),
            datasets.SplitGenerator(name='train_synth_compilable',
                                   gen_kwargs={"files": downloaded_files["train_synth_compilable"]}),
            datasets.SplitGenerator(name='train_real_compilable',
                                    gen_kwargs={"files": downloaded_files["train_real_compilable"]}),
            datasets.SplitGenerator(name='train_synth_simple_io',
                                    gen_kwargs={"files": downloaded_files["train_synth_simple_io"]}),
            datasets.SplitGenerator(name='train_real_simple_io',
                                    gen_kwargs={"files": downloaded_files["train_real_simple_io"]}),
            datasets.SplitGenerator(name='train_synth_rich_io',
                                    gen_kwargs={"files": downloaded_files["train_synth_rich_io"]}),
            datasets.SplitGenerator(name='valid_synth',
                                   gen_kwargs={"files": downloaded_files["valid_synth"]}),
            datasets.SplitGenerator(name='valid_real',
                                    gen_kwargs={"files": downloaded_files["valid_real"]}),
            datasets.SplitGenerator(name='test_synth',
                                    gen_kwargs={"files": downloaded_files["test_synth"]}),
            datasets.SplitGenerator(name='test_real',
                                    gen_kwargs={"files": downloaded_files["test_real"]}),
        ]

    def _generate_examples(self, files):
        """Yield examples as (key, example) tuples."""
        key = 0
        import zstandard as zstd

        for path in Path(files).rglob('*.jsonl.zst'):
            with zstd.open(open(path, "rb"), "rt", encoding="utf-8") as f:
                for row in f:
                    data = json.loads(row)
                    data = data['text']
                    data = self._fixes(data)
                    for io_pairs_kind in ('synth_io_pairs', 'real_io_pairs'):
                        if data[io_pairs_kind]:
                            new_io_pairs = []
                            for e in data[io_pairs_kind]:
                                new_e = {}
                                new_e['input'] = [{'var': var, 'value': json.dumps(value)} for (var, value) in e['input'].items()] if e['input'] else []
                                new_e['output'] = [{'var': var, 'value': json.dumps(value)} for (var, value) in e['output'].items()] if e['output'] else []
                                new_e['dummy_funcs'] = e['dummy_funcs']
                                new_e['dummy_funcs_seed'] = e['dummy_funcs_seed']
                                new_io_pairs.append(new_e)
                            data[io_pairs_kind] = new_io_pairs
                    data['synth_iospec'] = json.dumps(data['synth_iospec'])
                    data['real_iospec'] = json.dumps(data['real_iospec'])
                    yield key, data
                    key += 1

    def _fixes(self, row):
        if 'angha_iospec' not in row:
            row['angha_iospec'] = None
        if 'real_iospec' not in row:
            row['real_iospec'] = None
        if 'func_head_types' not in row:
            row['func_head_types'] = ''
        row['asm'] = [{'target': target, 'code': code['func_asm'] if code else None} for (target, code) in
                       row['asm'].items()]  # TODO: pre_asm etc
        for removed_key in _REMOVED_FEATURES:
            if removed_key in row:
                del row[removed_key]
        for original_key, new_key in _RENAMED_FEATURES.items():
            row[new_key] = row[original_key]
            del row[original_key]
        return row