scripts/lab_env.py

# Copyright 2025 Yingwei Zheng
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# 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.

import llvm_helper
import json
import os
import dateparser
import time
import datetime
import re
from typing import Tuple, Sequence, Union


class TimeCompensationGuard:
    def __init__(self, environment):
        self.environment = environment

    def __enter__(self):
        self.start_time = time.time()
        self.environment.interaction_time_compensation_enter += 1

    def __exit__(self, exception_type, exception_value, exception_traceback):
        self.environment.interaction_time_compensation_enter -= 1
        if self.environment.interaction_time_compensation_enter == 0:
            self.environment.interaction_time_compensation += (
                time.time() - self.start_time
            )


class Environment:
    def __init__(
        self,
        issue_id,
        base_model_knowledge_cutoff: str,
        *,
        max_build_jobs=None,
        max_test_jobs=None,
    ):
        with open(os.path.join(llvm_helper.dataset_dir, f"{issue_id}.json")) as f:
            self.data = json.load(f)
        self.base_commit = self.data["base_commit"]
        self.knowledge_cutoff = dateparser.parse(self.data["knowledge_cutoff"])
        self.bug_type = self.data["bug_type"]
        self.test_commit = self.data.get(
            "test_commit", self.data["hints"]["fix_commit"]
        )
        self.used_knowledge = dict()
        self.use_knowledge("base_model", base_model_knowledge_cutoff)
        self.interaction_time_compensation = 0.0
        self.interaction_time_compensation_enter = 0
        self.build_count = 0
        self.build_failure_count = 0
        self.fast_check_count = 0
        self.full_check_count = 0
        self.fast_check_pass = False
        self.full_check_pass = False
        if max_build_jobs is None:
            self.max_build_jobs = os.cpu_count()
        else:
            self.max_build_jobs = max_build_jobs
        if max_test_jobs is None:
            self.max_test_jobs = max_build_jobs
        else:
            self.max_test_jobs = max_test_jobs
        self.start_time = time.time()

    def use_knowledge(self, url: str, date: Union[str, datetime.datetime]):
        if isinstance(date, str):
            date = dateparser.parse(date)
        if date <= self.knowledge_cutoff:
            self.used_knowledge[url] = min(self.used_knowledge.get(url, date), date)
        else:
            raise ValueError("Knowledge is newer than the cutoff date")

    def reset(self):
        with TimeCompensationGuard(self):
            llvm_helper.reset(self.base_commit)

    def verify_head(self):
        head = llvm_helper.git_execute(["rev-parse", "HEAD"]).strip()
        if head != self.base_commit:
            raise RuntimeError("invalid HEAD")

    def build(self):
        with TimeCompensationGuard(self):
            self.build_count += 1
            self.verify_head()
            res, log = llvm_helper.build(self.max_build_jobs)
            if not res:
                self.build_failure_count += 1
            return res, log

    def dump(self, log=None):
        wall_time = time.time() - self.start_time - self.interaction_time_compensation
        self.verify_head()
        patch = llvm_helper.git_execute(["diff", "--", "llvm/lib/*", "llvm/include/*"])
        used_knowledge = []
        for url, t in self.used_knowledge.items():
            used_knowledge.append((url, t.strftime("%Y-%m-%d%z")))
        return {
            "wall_time": wall_time,
            "knowledge": used_knowledge,
            "build_count": self.build_count,
            "build_failure_count": self.build_failure_count,
            "fast_check_count": self.fast_check_count,
            "full_check_count": self.full_check_count,
            "fast_check_pass": self.fast_check_pass,
            "full_check_pass": self.full_check_pass,
            "patch": patch,
            "log": log,
        }

    def check_fast(self):
        with TimeCompensationGuard(self):
            self.fast_check_count += 1
            res, reason = self.build()
            if not res:
                return (False, reason)
            res, log = llvm_helper.verify_test_group(
                repro=False, input=self.data["tests"], type=self.bug_type
            )
            if not res:
                return (False, log)
            self.fast_check_pass = True
            return (True, log)

    def check_full(self):
        with TimeCompensationGuard(self):
            self.full_check_count += 1
            res, reason = self.build()
            if not res:
                return (False, reason)
            res, log = llvm_helper.verify_test_group(
                repro=False, input=self.data["tests"], type=self.bug_type
            )
            if not res:
                return (False, log)
            self.fast_check_pass = True
            res, log = llvm_helper.verify_lit(
                test_commit=self.test_commit,
                dirs=self.data["lit_test_dir"],
                max_test_jobs=self.max_build_jobs,
            )
            if not res:
                return (False, log)
            self.full_check_pass = True
            return (True, log)

    def get_bug_type(self):
        return self.bug_type

    def get_base_commit(self):
        return self.base_commit

    def get_tests(self):
        return self.data["tests"]

    def get_hint_fix_commit(self):
        self.use_knowledge("hint:fix_commit", self.knowledge_cutoff)
        return self.data["hints"].get("fix_commit")

    def get_hint_components(self):
        self.use_knowledge("hint:components", self.knowledge_cutoff)
        return self.data["hints"].get("components")

    def get_hint_files(self):
        self.use_knowledge("hint:files", self.knowledge_cutoff)
        lineno = self.data["hints"].get("bug_location_lineno")
        if lineno is None:
            return None
        return sorted(lineno.keys())

    def get_hint_bug_functions(self):
        self.use_knowledge("hint:bug_functions", self.knowledge_cutoff)
        return self.data["hints"].get("bug_location_funcname")

    def get_hint_line_level_bug_locations(self):
        self.use_knowledge("hint:line_level_bug_locations", self.knowledge_cutoff)
        return self.data["hints"].get("bug_location_lineno")

    def get_hint_issue(self):
        self.use_knowledge("hint:issue", self.knowledge_cutoff)
        return self.data.get("issue")

    def get_ir_keywords(self, ir: str):
        keywords = set()
        # instructions
        instruction_pattern = re.compile(r"%.+ = (\w+) ")
        for match in re.findall(instruction_pattern, ir):
            keywords.add(match)
        # intrinsics
        intrinsic_pattern = re.compile(r"@(llvm.\w+)\(")
        for match in re.findall(intrinsic_pattern, ir):
            keywords.add(match)
        keywords.discard("call")
        return keywords

    def get_langref_desc(self, keywords):
        self.use_knowledge("llvm/docs/LangRef.rst", self.knowledge_cutoff)
        return llvm_helper.get_langref_desc(keywords, self.base_commit)