utils/hct/hcttest-samples.py

# Copyright (C) Microsoft Corporation. All rights reserved.
# This file is distributed under the University of Illinois Open Source License. See LICENSE.TXT for details.
import argparse
import glob
import shutil
import os
import subprocess
import re

try:
    import xml.etree.cElementTree as ET
except ImportError:
    import xml.etree.ElementTree as ET


# Comment namespace to make working with ElementTree easier:
def ReadXmlString(text):
    global xmlheader
    text = text.replace("xmlns=", "xmlns_commented=")
    xmlheader = text[: text.find("\n") + 1]
    # TODO: read xml and return xml root
    return ET.fromstring(text)


def WriteXmlString(root):
    global xmlheader
    text = ET.tostring(root, encoding="utf-8")
    return xmlheader + text.replace("xmlns_commented=", "xmlns=")


def DeepCopyElement(e):
    cpy = ET.Element(e.tag, e.attrib)
    cpy.text = e.text
    cpy.tail = e.tail
    for child in e:
        cpy.append(DeepCopyElement(child))
    return cpy


sample_names = [
    "D3D1211On12",
    "D3D12Bundles",
    "D3D12DynamicIndexing",
    "D3D12ExecuteIndirect",
    "D3D12Fullscreen",
    #    "D3D12HelloWorld",
    "D3D12HelloWorld\\src\\HelloBundles",
    "D3D12HelloWorld\\src\\HelloConstBuffers",
    "D3D12HelloWorld\\src\\HelloFrameBuffering",
    "D3D12HelloWorld\\src\\HelloTexture",
    "D3D12HelloWorld\\src\\HelloTriangle",
    "D3D12HelloWorld\\src\\HelloWindow",
    "D3D12HeterogeneousMultiadapter",
    # WarpAssert in ReadPointerOperand: pInfoSrc->getName().startswith("dx.var.x").
    # Fix tested - incorrect rendered result produced.
    # Worked around in sample shaders for now by moving to non-static locals.
    "D3D12Multithreading",  # works and is visually impressive!
    "D3D12nBodyGravity",  # expected empty cbuffer culling due to static members causes this to fail!  FIXED!
    "D3D12PipelineStateCache",  # Requires workaround for static globals
    "D3D12PredicationQueries",
    "D3D12ReservedResources",
    "D3D12Residency",  # has problems on x86 due to mem limitations. The following seems to help:
    # change NumTextures to 1024 * 1, and add min with 1GB here:
    # UINT64 memoryToUse = UINT64 (float(min(memoryInfo.Budget, UINT64(1 << 30))) * 0.95f);
    # Still produces a bunch of these errors:
    # D3D12 ERROR: ID3D12CommandAllocator::Reset: A command allocator is being reset before previous executions associated with the allocator have completed. [ EXECUTION ERROR #552: COMMAND_ALLOCATOR_SYNC]
    # but at least it no longer crashes
    "D3D12SmallResources",
]


class Sample(object):
    def __init__(self, name):
        self.name = name
        self.preBuild = []
        self.postBuild = []


samples = dict([(name, Sample(name)) for name in sample_names])


def SetSampleActions():
    # Actions called with (name, args, dxil)
    # Actions for all projects:
    for name, sample in samples.items():
        sample.postBuild.append(ActionCopyD3DBins)
        sample.postBuild.append(ActionCopySDKLayers)
        sample.postBuild.append(ActionCopyWarp12)
        sample.postBuild.append(
            ActionCopyCompilerBins
        )  # Do this for all projects for now
    # TODO: limit ActionCopyCompilerBins action to ones that do run-time compilation.
    # # Runtime HLSL compilation:
    # for name in [   "D3D1211On12",
    #                 "D3D12HelloWorld\\src\\HelloTriangle",
    #                 "D3D12ExecuteIndirect",
    #             ]:
    #     samples[name].postBuild.append(ActionCopyCompilerBins)


def CopyFiles(source_path, dest_path, filenames, symbols=False):
    for filename in filenames:
        renamed = filename
        try:
            filename, renamed = filename.split(";")
            print("Copying %s from %s to %s" % (filename, source_path, dest_path))
            print(".. with new name: %s" % (renamed))
        except:
            print("Copying %s from %s to %s" % (filename, source_path, dest_path))
        try:
            shutil.copy2(
                os.path.join(source_path, filename), os.path.join(dest_path, renamed)
            )
        except:
            print(
                'Error copying "%s" from "%s" to "%s"'
                % (filename, source_path, dest_path)
            )
            # sys.excepthook(*sys.exc_info())
            continue
        if symbols and (filename.endswith(".exe") or filename.endswith(".dll")):
            symbol_filename = filename[:-4] + ".pdb"
            try:
                shutil.copy2(
                    os.path.join(source_path, symbol_filename),
                    os.path.join(dest_path, symbol_filename),
                )
            except:
                print(
                    'Error copying symbols "%s" from "%s" to "%s"'
                    % (symbol_filename, source_path, dest_path)
                )


def CopyBins(args, name, dxil, filenames, symbols=False):
    samples_path = args.samples
    config = dxil and "DxilDebug" or "Debug"
    CopyFiles(
        args.bins,
        os.path.join(PathToSampleSrc(samples_path, name), "bin", args.arch, config),
        filenames,
        symbols,
    )


def ActionCopyCompilerBins(args, name, dxil):
    if dxil:
        CopyBins(
            args,
            name,
            dxil,
            [
                "dxcompiler.dll",
                "dxil.dll",
                "d3dcompiler_dxc_bridge.dll;d3dcompiler_47.dll",  # Wrapper version that calls into dxcompiler.dll
            ],
            args.symbols,
        )


def ActionCopyD3DBins(args, name, dxil):
    if dxil:
        CopyBins(
            args,
            name,
            dxil,
            [
                "d3d12.dll",
            ],
            args.symbols,
        )


def ActionCopySDKLayers(args, name, dxil):
    CopyBins(
        args,
        name,
        dxil,
        [
            "D3D11_3SDKLayers.dll",
            "D3D12SDKLayers.dll",
            "DXGIDebug.dll",
        ],
        args.symbols,
    )


def ActionCopyWarp12(args, name, dxil):
    CopyBins(
        args,
        name,
        dxil,
        [
            "d3d12warp.dll",
        ],
        args.symbols,
    )


def MakeD3D12WarpCopy(bin_path):
    # Copy d3d10warp.dll to d3d12warp.dll
    shutil.copy2(
        os.path.join(bin_path, "d3d10warp.dll"), os.path.join(bin_path, "d3d12warp.dll")
    )


def PathSplitAll(p):
    s = filter(None, os.path.split(p))
    if len(s) > 1:
        return PathSplitAll(s[0]) + (s[1],)
    else:
        return (s[0],)


def GetBinPath(args, name):
    return os.path.join(args.bins, name)


def GetProjectBinFilePath(args, samples_path, sample_name, file_name):
    src = PathToSampleSrc(samples_path, sample_name)
    return os.path.join(src, "bin", args.arch, file_name)


def ListRuntimeCompilePaths(args):
    return [
        os.path.join(args.bins, name)
        for name in [
            "fxc.exe",
            "dxc.exe",
            "dxcompiler.dll",
            "dxil.dll",
            "d3dcompiler_47.dll",
            "d3d12.dll",
            "D3D11_3SDKLayers.dll",
            "D3D12SDKLayers.dll",
            "DXGIDebug.dll",
            "d3d12warp.dll",
        ]
    ]


def CheckEnvironment(args):
    if not args.bins:
        print("The -bins argument is needed to populate tool binaries.")
        exit(1)
    if not os.path.exists(args.bins):
        print("The -bins argument '" + args.bins + "' does not exist.")
        exit(1)
    for fn in ListRuntimeCompilePaths(args):
        if not os.path.exists(fn):
            print("Expected file '" + fn + "' not found.")
            exit(1)
    if os.path.getmtime(GetBinPath(args, "fxc.exe")) != os.path.getmtime(
        GetBinPath(args, "dxc.exe")
    ):
        print("fxc.exe should be a copy of dxc.exe.")
        print(
            "Please copy "
            + GetBinPath(args, "dxc.exe")
            + " "
            + GetBinPath(args, "fxc.exe")
        )
        exit(1)
    try:
        msbuild_version = subprocess.check_output(["msbuild", "-nologo", "-ver"])
        print("msbuild version: " + msbuild_version)
    except Exception as E:
        print("Unable to get the version from msbuild: " + str(E))
        print("This command should be run from a Developer Command Prompt")
        exit(1)


def SampleIsNested(name):
    return "\\src\\" in name


def PathToSampleSrc(basePath, sampleName):
    if SampleIsNested(sampleName):
        return os.path.join(basePath, "Samples", "Desktop", sampleName)
    return os.path.join(basePath, "Samples", "Desktop", sampleName, "src")


reConfig = r"(Debug|Release|DxilDebug|DxilRelease)\|(Win32|x64)"


def AddProjectConfigs(root, args):
    rxConfig = re.compile(reConfig)
    changed = False
    for e in root.findall(".//WindowsTargetPlatformVersion"):
        if e.text == "10.0.10240.0":
            e.text = "10.0.10586.0"
            changed = True
    # Override fxc path for Dxil configs:
    for config in ["DxilDebug", "DxilRelease"]:
        for arch in ["Win32", "x64"]:
            if not root.find(
                """./PropertyGroup[@Condition="'$(Configuration)|$(Platform)'=='%s|%s'"]/FXCToolPath"""
                % (config, arch)
            ):
                e = ET.Element(
                    "PropertyGroup",
                    {
                        "Condition": "'$(Configuration)|$(Platform)'=='%s|%s'"
                        % (config, arch)
                    },
                )
                e.text = "\n    "
                e.tail = "\n  "
                root.insert(0, e)
                e = ET.SubElement(e, "FXCToolPath")
                e.text = "$(DXC_BIN_PATH)"  # args.bins
                e.tail = "\n  "
    # Extend ProjectConfiguration for Win32 and Dxil configs
    ig = root.find('./ItemGroup[@Label="ProjectConfigurations"]') or []
    debug_config = release_config = None  # ProjectConfiguration
    configs = {}
    for e in ig:
        try:
            m = rxConfig.match(e.attrib["Include"])
            if m:
                key = m.groups()
                configs[key] = e
                if m.group(1) == "Debug":
                    debug_config = key, e
                elif m.group(1) == "Release":
                    release_config = key, e
        except:
            continue
    parents = root.findall(
        """.//*[@Condition="'$(Configuration)|$(Platform)'=='%s|%s'"]/.."""
        % ("Debug", "x64")
    )
    if not configs or not debug_config or not release_config:
        print("No ProjectConfigurations found")
        return False
    for arch in ["Win32", "x64"]:
        for config in ["Debug", "DxilDebug", "Release", "DxilRelease"]:
            if config in ("Debug", "DxilDebug"):
                t_config = "Debug", "x64"
            else:
                t_config = "Release", "x64"
            config_condition = "'$(Configuration)|$(Platform)'=='%s|%s'" % t_config
            if not configs.get((config, arch), None):
                changed = True
                if config in ("Debug", "DxilDebug"):
                    e = DeepCopyElement(debug_config[1])
                else:
                    e = DeepCopyElement(release_config[1])
                e.set("Include", "%s|%s" % (config, arch))
                e.find("./Configuration").text = config
                e.find("./Platform").text = arch
                ig.append(e)
                for parent in reversed(parents):
                    for n, e in reversed(list(enumerate(parent))):
                        try:
                            cond = e.attrib["Condition"]
                        except KeyError:
                            continue
                        if cond == config_condition:
                            e = DeepCopyElement(e)
                            # Override DisableOptimizations for DxilDebug since this flag is problematic right now
                            if e.tag == "ItemDefinitionGroup" and config == "DxilDebug":
                                FxCompile = e.find("./FxCompile") or ET.SubElement(
                                    e, "FxCompile"
                                )
                                DisableOptimizations = FxCompile.find(
                                    "./DisableOptimizations"
                                ) or ET.SubElement(FxCompile, "DisableOptimizations")
                                DisableOptimizations.text = "false"
                            e.attrib[
                                "Condition"
                            ] = "'$(Configuration)|$(Platform)'=='%s|%s'" % (
                                config,
                                arch,
                            )
                            parent.insert(n + 1, e)
    return changed


def AddSlnConfigs(sln_text):
    # sln: GlobalSection(SolutionConfigurationPlatforms)
    rxSlnConfig = re.compile(r"^\s+%s = \1\|\2$" % reConfig)
    # sln: GlobalSection(ProjectConfigurationPlatforms)
    rxActiveCfg = re.compile(r"^\s+\{[0-9A-Z-]+\}\.%s\.ActiveCfg = \1\|\2$" % reConfig)
    rxBuild = re.compile(r"^\s+\{[0-9A-Z-]+\}\.%s\.Build\.0 = \1\|\2$" % reConfig)
    sln_changed = []
    line_set = set(sln_text.splitlines())

    def add_line(lst, line):
        "Prevent duplicates from being added"
        if line not in line_set:
            lst.append(line)

    for line in sln_text.splitlines():
        if line == "VisualStudioVersion = 14.0.23107.0":
            sln_changed.append("VisualStudioVersion = 14.0.25123.0")
            continue
        m = rxSlnConfig.match(line)
        if not m:
            m = rxActiveCfg.match(line)
        if not m:
            m = rxBuild.match(line)
        if m:
            sln_changed.append(line)
            config = m.group(1)
            if config in ("Debug", "Release") and m.group(2) == "x64":
                add_line(sln_changed, line.replace("x64", "Win32"))
                add_line(sln_changed, line.replace(config, "Dxil" + config))
                add_line(
                    sln_changed,
                    line.replace(config, "Dxil" + config).replace("x64", "Win32"),
                )
            continue
        sln_changed.append(line)
    return "\n".join(sln_changed)


def PatchProjects(args):
    for name in sample_names + ["D3D12HelloWorld"]:
        sample_path = PathToSampleSrc(args.samples, name)
        print("Patching " + name + " in " + sample_path)
        for proj_path in glob.glob(os.path.join(sample_path, "*.vcxproj")):
            # Consider looking for msbuild and other tool paths in registry, etg:
            # reg query HKLM\Software\Microsoft\MSBuild\ToolsVersions\14.0
            with open(proj_path, "r") as proj_file:
                proj_text = proj_file.read()
            root = ReadXmlString(proj_text)
            if AddProjectConfigs(root, args):
                changed_text = WriteXmlString(root)
                print("Patching the Windows SDK version in " + proj_path)
                with open(proj_path, "w") as proj_file:
                    proj_file.write(changed_text)

        # Extend project configs in solution file
        for sln_path in glob.glob(os.path.join(sample_path, "*.sln")):
            with open(sln_path, "r") as sln_file:
                sln_text = sln_file.read()
            changed_text = AddSlnConfigs(sln_text)
            if changed_text != sln_text:
                print("Adding additional configurations to " + sln_path)
                with open(sln_path, "w") as sln_file:
                    sln_file.write(changed_text)


def BuildSample(samples_path, name, x86, dxil):
    sample_path = PathToSampleSrc(samples_path, name)
    if not SampleIsNested(name):
        print("Building " + name + " in " + sample_path)
        Platform = x86 and "Win32" or "x64"
        Configuration = dxil and "DxilDebug" or "Debug"
        subprocess.check_call(
            [
                "msbuild",
                "-nologo",
                "/p:Configuration=%s;Platform=%s" % (Configuration, Platform),
                "/t:Rebuild",
            ],
            cwd=sample_path,
        )


def BuildSamples(args, dxil):
    samples_path = args.samples
    rxSample = args.sample and re.compile(args.sample, re.I)
    buildHelloWorld = False
    os.environ["DXC_BIN_PATH"] = args.bins
    for sample_name in sample_names:
        if rxSample and not rxSample.match(sample_name):
            continue
        if SampleIsNested(sample_name):
            buildHelloWorld = True
            continue
        BuildSample(samples_path, sample_name, args.x86, dxil)
    if buildHelloWorld:
        # HelloWorld containts sub-samples that must be built from the solution file.
        BuildSample(samples_path, "D3D12HelloWorld", args.x86, dxil)


def PatchSample(args, name, dxil, afterBuild):
    if args.sample and not re.match(args.sample, name, re.I):
        return
    try:
        sample = samples[name]
    except:
        print("Error: selected sample missing from sample map '" + name + "'.")
        return
    if afterBuild:
        actions = sample.postBuild
    else:
        actions = sample.preBuild
    for action in actions:
        action(args, name, dxil)


def PatchSamplesAfterBuild(args, dxil):
    for sample_name in sample_names:
        PatchSample(args, sample_name, dxil, True)


def PatchSamplesBeforeBuild(args, dxil):
    for sample_name in sample_names:
        PatchSample(args, sample_name, dxil, False)


def RunSampleTests(args):
    CheckEnvironment(args)
    print("Building Debug config ...")
    BuildSamples(args, False)

    print("Building DxilDebug config ...")
    BuildSamples(args, True)

    print("Applying patch to post-build binaries to enable dxc ...")
    PatchSamplesAfterBuild(args, False)
    PatchSamplesAfterBuild(args, True)

    print(
        "TODO - run Debug config vs. DxilDebug config and verify results are the same"
    )


if __name__ == "__main__":
    parser = argparse.ArgumentParser(description="Run D3D sample tests...")
    parser.add_argument("-x86", action="store_true", help="add x86 targets")
    parser.add_argument("-samples", help="path to root of D3D12 samples")
    parser.add_argument("-bins", help="path to dxcompiler.dll and related binaries")
    parser.add_argument(
        "-sample", help="choose a single sample to build/test (* wildcard supported)"
    )
    parser.add_argument(
        "-postbuild", action="store_true", help="only perform post-build operations"
    )
    parser.add_argument("-patch", action="store_true", help="patch projects")
    parser.add_argument(
        "-symbols",
        action="store_true",
        help="try to copy symbols for various dependencies",
    )
    args = parser.parse_args()

    SetSampleActions()

    if args.x86:
        args.arch = "Win32"
    else:
        args.arch = "x64"

    if not args.samples:
        print("The -samples option must be used to indicate the root of D3D12 Samples.")
        print("Samples are available at this URL.")
        print("https://github.com/Microsoft/DirectX-Graphics-Samples")
        exit(1)

    if args.sample:
        print("Applying sample filter: %s" % args.sample)
        args.sample = re.escape(args.sample).replace("\\*", ".*")
        rxSample = re.compile(args.sample, re.I)
        for name in samples:
            if rxSample.match(name):
                print("  %s" % name)

    if args.postbuild:
        print("Applying patch to post-build binaries to enable dxc ...")
        PatchSamplesAfterBuild(args, False)
        PatchSamplesAfterBuild(args, True)
    elif args.patch:
        print("Patching projects ...")
        PatchProjects(args)
    else:
        RunSampleTests(args)