xref: /aosp_15_r20/external/deqp/scripts/check_build_sanity.py (revision 35238bce31c2a825756842865a792f8cf7f89930)

# -*- coding: utf-8 -*-

#-------------------------------------------------------------------------
# drawElements Quality Program utilities
# --------------------------------------
#
# Copyright 2016 The Android Open Source Project
#
# 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 itertools
import os
import argparse
import tempfile
import sys

from ctsbuild.common import *
from ctsbuild.build import *

pythonExecutable = sys.executable or "python"

class Environment:
    def __init__ (self, srcDir, tmpDir, verbose):
        self.srcDir = srcDir
        self.tmpDir = tmpDir
        self.verbose = verbose

class BuildTestStep:
    def getName (self):
        return "<unknown>"

    def isAvailable (self, env):
        return True

    def run (self, env):
        raise Exception("Not implemented")

class RunScript(BuildTestStep):
    def __init__ (self, scriptPath, getExtraArgs = None):
        self.scriptPath = scriptPath
        self.getExtraArgs = getExtraArgs

    def getName (self):
        return self.scriptPath

    def run (self, env):
        args = [pythonExecutable, os.path.join(env.srcDir, self.scriptPath)]

        if self.getExtraArgs != None:
            args += self.getExtraArgs(env)

        execute(args)

    def __repr__(self):
        return "RunScript:%s" % (self.scriptPath)

def makeCflagsArgs (cflags):
    cflagsStr = " ".join(cflags)
    return ["-DCMAKE_C_FLAGS=%s" % cflagsStr, "-DCMAKE_CXX_FLAGS=%s" % cflagsStr]

def makeBuildArgs (target, cc, cpp, cflags):
    return ["-DDEQP_TARGET=%s" % target, "-DCMAKE_C_COMPILER=%s" % cc, "-DCMAKE_CXX_COMPILER=%s" % cpp] + makeCflagsArgs(cflags)

class BuildConfigGen:
    def isAvailable (self, env):
        return True

class UnixConfig(BuildConfigGen):
    def __init__ (self, target, buildType, cc, cpp, cflags):
        self.target = target
        self.buildType = buildType
        self.cc = cc
        self.cpp = cpp
        self.cflags = cflags

    def isAvailable (self, env):
        return which(self.cc) != None and which(self.cpp) != None

    def getBuildConfig (self, env, buildDir):
        args = makeBuildArgs(self.target, self.cc, self.cpp, self.cflags)
        return BuildConfig(buildDir, self.buildType, args, env.srcDir)

class VSConfig(BuildConfigGen):
    def __init__ (self, buildType):
        self.buildType = buildType

    def getBuildConfig (self, env, buildDir):
        args = ["-DCMAKE_C_FLAGS=/WX -DCMAKE_CXX_FLAGS=/WX"]
        return BuildConfig(buildDir, self.buildType, args, env.srcDir)

class Build(BuildTestStep):
    def __init__ (self, buildDir, configGen, generator):
        self.buildDir = buildDir
        self.configGen = configGen
        self.generator = generator

    def getName (self):
        return self.buildDir

    def isAvailable (self, env):
        return self.configGen.isAvailable(env) and self.generator != None and self.generator.isAvailable()

    def run (self, env):
        # specialize config for env
        buildDir = os.path.join(env.tmpDir, self.buildDir)
        curConfig = self.configGen.getBuildConfig(env, buildDir)

        build(curConfig, self.generator)

class CheckSrcChanges(BuildTestStep):
    def getName (self):
        return "check for changes"

    def run (self, env):
        pushWorkingDir(env.srcDir)
        execute(["git", "diff", "--exit-code"])
        popWorkingDir()

def getClangVersion ():
    knownVersions = ["4.0", "3.9", "3.8", "3.7", "3.6", "3.5"]
    for version in knownVersions:
        if which("clang-" + version) != None:
            return "-" + version
    return ""

def runSteps (steps):
    for step in steps:
        if step.isAvailable(env):
            print("Run: %s" % step.getName())
            step.run(env)
        else:
            print("Skip: %s" % step.getName())

COMMON_CFLAGS = ["-Werror", "-Wno-error=unused-function"]
COMMON_GCC_CFLAGS = COMMON_CFLAGS + ["-Wno-error=array-bounds", "-Wno-error=address", "-Wno-error=nonnull"]
COMMON_CLANG_CFLAGS = COMMON_CFLAGS + ["-Wno-error=unused-command-line-argument"]
GCC_32BIT_CFLAGS = COMMON_GCC_CFLAGS + ["-m32"]
CLANG_32BIT_CFLAGS = COMMON_CLANG_CFLAGS + ["-m32"]
GCC_64BIT_CFLAGS = COMMON_GCC_CFLAGS + ["-m64"]
CLANG_64BIT_CFLAGS = COMMON_CLANG_CFLAGS + ["-m64"]
CLANG_VERSION = getClangVersion()

# Always ran before any receipe
PREREQUISITES = [
    RunScript(os.path.join("external", "fetch_sources.py"), lambda env: ["--force"] + (["--verbose"] if env.verbose else []))
]

# Always ran after any receipe
POST_CHECKS = [
    CheckSrcChanges()
]

# Optional step to clean up external resources after finishing receipe
POST_CLEANUP = [
    RunScript(os.path.join("external", "fetch_sources.py"), lambda env: ["--clean"])
]

BUILD_TARGETS = [
    Build("clang-64-debug",
          UnixConfig("null",
                     "Debug",
                     "clang" + CLANG_VERSION,
                     "clang++" + CLANG_VERSION,
                     CLANG_64BIT_CFLAGS),
          ANY_UNIX_GENERATOR),
    Build("gcc-32-debug",
          UnixConfig("null",
                     "Debug",
                     "gcc",
                     "g++",
                     GCC_32BIT_CFLAGS),
          ANY_UNIX_GENERATOR),
    Build("gcc-64-release",
          UnixConfig("null",
                     "Release",
                     "gcc",
                     "g++",
                     GCC_64BIT_CFLAGS),
          ANY_UNIX_GENERATOR),
    Build("vs-64-debug",
          VSConfig("Debug"),
          ANY_VS_X64_GENERATOR),
]

EARLY_SPECIAL_RECIPES = [
    ('gen-inl-files', [
            RunScript(os.path.join("scripts", "gen_egl.py")),
            RunScript(os.path.join("scripts", "opengl", "gen_all.py")),
            RunScript(os.path.join("external", "vulkancts", "scripts", "gen_framework.py"), lambda env: (["--verbose"] if env.verbose else []) ),
            RunScript(os.path.join("external", "vulkancts", "scripts", "gen_framework_c.py"), lambda env: (["--verbose"] if env.verbose else []) ),
            RunScript(os.path.join("external", "vulkancts", "scripts", "gen_framework.py"), lambda env: ["--api", "SC"] ),
            RunScript(os.path.join("external", "vulkancts", "scripts", "gen_framework_c.py"), lambda env: ["--api", "SC"] ),
            RunScript(os.path.join("scripts", "gen_android_bp.py")),
            RunScript(os.path.join("scripts", "gen_khronos_cts_bp.py"))
        ]),
]

LATE_SPECIAL_RECIPES = [
    ('android-mustpass', [
            RunScript(os.path.join("scripts", "build_android_mustpass.py"),
                      lambda env: ["--build-dir", os.path.join(env.tmpDir, "android-mustpass")] + (["--verbose"] if env.verbose else [])),
        ]),
    ('vulkan-mustpass', [
            RunScript(os.path.join("external", "vulkancts", "scripts", "build_mustpass.py"),
                      lambda env: ["--build-dir", os.path.join(env.tmpDir, "vulkan-mustpass")] + (["--verbose"] if env.verbose else [])),
        ]),
    ('spirv-binaries', [
            RunScript(os.path.join("external", "vulkancts", "scripts", "build_spirv_binaries.py"),
                      lambda env: ["--build-type", "Release",
                                    "--build-dir", os.path.join(env.tmpDir, "spirv-binaries"),
                                    "--dst-path", os.path.join(env.tmpDir, "spirv-binaries")]),
        ]),
    ('amber-verify', [
            RunScript(os.path.join("external", "vulkancts", "scripts", "amber_verify.py"),
                      lambda env: ["--build-type", "Release",
                                    "--build-dir", os.path.join(env.tmpDir, "amber-verify"),
                                    "--dst-path", os.path.join(env.tmpDir, "amber-verify")]),
        ]),
    ('check-all', [
            RunScript(os.path.join("scripts", "src_util", "check_all.py")),
        ])
]

def getBuildRecipes ():
    return [(b.getName(), [b]) for b in BUILD_TARGETS]

def getAllRecipe (recipes):
    allSteps = {}
    for name, steps in recipes:
        allSteps[name] = steps
    return allSteps

def getRecipes ():
    recipes = EARLY_SPECIAL_RECIPES + getBuildRecipes() + LATE_SPECIAL_RECIPES
    return recipes

def getRecipesByName (recipes, recipeNames):
    selectedRecipes = {}
    for recipeName in recipeNames:
        for curName, steps in recipes:
            logging.debug("Evaluating %s against %s" % (recipeName, curName))
            if curName == recipeName:
                selectedRecipes[curName] = steps
    return selectedRecipes

RECIPES = getRecipes()

def parseArgs ():
    parser = argparse.ArgumentParser(description = "Build and test source",
                                     formatter_class=argparse.ArgumentDefaultsHelpFormatter)
    parser.add_argument("-s",
                        "--src-dir",
                        dest="srcDir",
                        default=DEQP_DIR,
                        help="Source directory")
    parser.add_argument("-t",
                        "--tmp-dir",
                        dest="tmpDir",
                        default=os.path.join(tempfile.gettempdir(), "deqp-build-test"),
                        help="Temporary directory")
    parser.add_argument("-r",
                        "--recipe",
                        dest="recipes",
                        nargs='+',
                        choices=[n for n, s in RECIPES] + ["all"],
                        default="all",
                        help="Build / test recipe")
    parser.add_argument("-d",
                        "--dump-recipes",
                        dest="dumpRecipes",
                        action="store_true",
                        help="Print out recipes that have any available actions")
    parser.add_argument("--skip-prerequisites",
                        dest="skipPrerequisites",
                        action="store_true",
                        help="Skip external dependency fetch")
    parser.add_argument("--skip-post-checks",
                        dest="skipPostCheck",
                        action="store_true",
                        help="Skip post recipe checks")
    parser.add_argument("--apply-post-external-cleanup",
                        dest="applyPostExternalDependencyCleanup",
                        action="store_true",
                        help="skip external dependency clean up")
    parser.add_argument("-v", "--verbose",
                        dest="verbose",
                        action="store_true",
                        help="Enable verbose logging")

    return parser.parse_args()

if __name__ == "__main__":
    args = parseArgs()
    env = Environment(args.srcDir, args.tmpDir, args.verbose)
    initializeLogger(args.verbose)

    if args.dumpRecipes:
        for name, steps in RECIPES:
            for step in steps:
                if step.isAvailable(env):
                    print(name)
                    break
    else:
        selectedRecipes = getAllRecipe(RECIPES) if args.recipes == "all" \
                        else getRecipesByName(RECIPES, args.recipes)

        print("Running %s" % ','.join(selectedRecipes.keys()))
        selectedSteps = list(itertools.chain.from_iterable(selectedRecipes.values()))
        allSteps = (PREREQUISITES if (args.skipPrerequisites == False) else []) + selectedSteps + (POST_CHECKS if (args.skipPostCheck == False) else []) + (POST_CLEANUP if (args.applyPostExternalDependencyCleanup == True) else [])
        runSteps(allSteps)

        print("All steps completed successfully")