def main() -> None: # pylint: disable=too-many-statements, too-many-locals, too-many-branches;
parser = argparse.ArgumentParser(
description="Runs AmberScript files on Android devices."
)
parser.add_argument(
"amber_script_file", help="AmberScript tests to run.", nargs="+",
)
parser.add_argument(
"--output", help="Output directory.", default="output",
)
parser.add_argument(
"--settings",
help="Path to a settings JSON file for this instance. "
"Unlike with gfauto_fuzz, the default value is an empty string, which is ignored. ",
default="",
)
parser.add_argument(
"--serial",
help="Android device serial. If left unspecified, the tests will be run on all Android devices.",
action="append",
)
parsed_args = parser.parse_args(sys.argv[1:])
amber_script_files: List[Path] = [Path(a) for a in parsed_args.amber_script_file]
output_path: Path = Path(parsed_args.output)
serials: Optional[List[str]] = parsed_args.serial
settings_str: str = parsed_args.settings
settings = Settings()
if settings_str:
settings = settings_util.read_or_create(Path(settings_str))
binary_manager = binaries_util.get_default_binary_manager(settings)
if not serials:
android_devices = android_device.get_all_android_devices(
binary_manager, include_device_details=False
)
serials = []
for device in android_devices:
serials.append(device.android.serial)
for amber_script_file in amber_script_files:
for serial in serials:
android_device.run_amber_on_device(
amber_script_file,
output_path / serial,
dump_image=False,
dump_buffer=False,
serial=serial,
)
def run_shader_job( # pylint: disable=too-many-return-statements,too-many-branches, too-many-locals, too-many-statements;
source_dir: Path,
output_dir: Path,
binary_manager: binaries_util.BinaryManager,
test: Optional[Test] = None,
device: Optional[Device] = None,
ignore_test_and_device_binaries: bool = False,
shader_job_overrides: Iterable[tool.NameAndShaderJob] = (),
shader_job_shader_overrides: Optional[
tool.ShaderJobNameToShaderOverridesMap] = None,
) -> Path:
if not shader_job_shader_overrides:
shader_job_shader_overrides = {}
with util.file_open_text(output_dir / "log.txt", "w") as log_file:
try:
gflogging.push_stream_for_logging(log_file)
# TODO: Find amber path. NDK or host.
# TODO: If Amber is going to be used, check if Amber can use Vulkan debug layers now, and if not, pass that
# info down via a bool.
if not test:
test = test_util.metadata_read_from_path(
source_dir / test_util.TEST_METADATA)
if not device:
device = test.device
log(f"Running test on device:\n{device.name}")
# We will create a binary_manager child with a restricted set of binaries so that we only use the binaries
# specified in the test and by the device; if some required binaries are not specified by the test nor the
# device, there will be an error instead of falling back to our default binaries. But we keep a reference to
# the parent so we can still access certain "test-independent" binaries like Amber.
binary_manager_parent = binary_manager
if not ignore_test_and_device_binaries:
binary_manager = binary_manager.get_child_binary_manager(
list(device.binaries) + list(test.binaries))
spirv_opt_hash: Optional[str] = None
spirv_opt_args: Optional[List[str]] = None
if test.glsl.spirv_opt_args or test.spirv_fuzz.spirv_opt_args:
spirv_opt_hash = binary_manager.get_binary_by_name(
binaries_util.SPIRV_OPT_NAME).version
spirv_opt_args = (list(test.glsl.spirv_opt_args)
if test.glsl.spirv_opt_args else list(
test.spirv_fuzz.spirv_opt_args))
shader_jobs = tool.get_shader_jobs(source_dir,
overrides=shader_job_overrides)
combined_spirv_shader_jobs: List[tool.SpirvCombinedShaderJob] = []
for shader_job in shader_jobs:
try:
shader_overrides = shader_job_shader_overrides.get(
shader_job.name, None)
combined_spirv_shader_jobs.append(
tool.compile_shader_job(
name=shader_job.name,
input_json=shader_job.shader_job,
work_dir=output_dir / shader_job.name,
binary_paths=binary_manager,
spirv_opt_args=spirv_opt_args,
shader_overrides=shader_overrides,
))
except subprocess.CalledProcessError:
result_util.write_status(output_dir,
fuzz.STATUS_TOOL_CRASH,
shader_job.name)
return output_dir
except subprocess.TimeoutExpired:
result_util.write_status(output_dir,
fuzz.STATUS_TOOL_TIMEOUT,
shader_job.name)
return output_dir
# Device types: |preprocess| and |shader_compiler| don't need an AmberScript file.
# noinspection PyTypeChecker
if device.HasField("preprocess"):
# The "preprocess" device type just needs to get this far, so this is a success.
result_util.write_status(output_dir, fuzz.STATUS_SUCCESS)
return output_dir
# noinspection PyTypeChecker
if device.HasField("shader_compiler"):
for combined_spirv_shader_job in combined_spirv_shader_jobs:
try:
shader_compiler_util.run_shader_job(
device.shader_compiler,
combined_spirv_shader_job.spirv_shader_job,
output_dir,
binary_manager=binary_manager,
)
except subprocess.CalledProcessError:
result_util.write_status(
output_dir,
fuzz.STATUS_CRASH,
combined_spirv_shader_job.name,
)
return output_dir
except subprocess.TimeoutExpired:
result_util.write_status(
output_dir,
fuzz.STATUS_TIMEOUT,
combined_spirv_shader_job.name,
)
return output_dir
# The shader compiler succeeded on all files; this is a success.
result_util.write_status(output_dir, fuzz.STATUS_SUCCESS)
return output_dir
# Other device types need an AmberScript file.
amber_converter_shader_job_files = [
amber_converter.ShaderJobFile(
name_prefix=combined_spirv_shader_job.name,
asm_spirv_shader_job_json=combined_spirv_shader_job.
spirv_asm_shader_job,
glsl_source_json=combined_spirv_shader_job.
glsl_source_shader_job,
processing_info="",
) for combined_spirv_shader_job in combined_spirv_shader_jobs
]
# Check if the first is the reference shader; if so, pull it out into its own variable.
reference: Optional[amber_converter.ShaderJobFile] = None
variants = amber_converter_shader_job_files
if (amber_converter_shader_job_files[0].name_prefix ==
test_util.REFERENCE_DIR):
reference = amber_converter_shader_job_files[0]
variants = variants[1:]
elif len(variants) > 1:
raise AssertionError(
"More than one variant, but no reference. This is unexpected."
)
amber_script_file = amber_converter.spirv_asm_shader_job_to_amber_script(
shader_job_file_amber_test=amber_converter.
ShaderJobFileBasedAmberTest(reference_asm_spirv_job=reference,
variants_asm_spirv_job=variants),
output_amber_script_file_path=output_dir / "test.amber",
amberfy_settings=amber_converter.AmberfySettings(
spirv_opt_args=spirv_opt_args,
spirv_opt_hash=spirv_opt_hash),
)
is_compute = bool(
shader_job_util.get_related_files(
combined_spirv_shader_jobs[0].spirv_shader_job,
[shader_job_util.EXT_COMP],
))
# noinspection PyTypeChecker
if device.HasField("host") or device.HasField("swift_shader"):
icd: Optional[Path] = None
# noinspection PyTypeChecker
if device.HasField("swift_shader"):
icd = binary_manager.get_binary_path_by_name(
binaries_util.SWIFT_SHADER_NAME).path
# Run the test on the host using Amber.
host_device_util.run_amber(
amber_script_file,
output_dir,
amber_path=binary_manager_parent.get_binary_path_by_name(
binaries_util.AMBER_NAME).path,
dump_image=(not is_compute),
dump_buffer=is_compute,
icd=icd,
)
return output_dir
# noinspection PyTypeChecker
if device.HasField("android"):
android_device.run_amber_on_device(
amber_script_file,
output_dir,
dump_image=(not is_compute),
dump_buffer=is_compute,
serial=device.android.serial,
)
return output_dir
# TODO: For a remote device (which we will probably need to support), use log_a_file to output the
# "amber_log.txt" file.
raise AssertionError(f"Unhandled device type:\n{str(device)}")
finally:
gflogging.pop_stream_for_logging()
def main_helper( # pylint: disable=too-many-locals,too-many-branches,too-many-statements;
tests_dir: Path,
work_dir: Path,
binaries: binaries_util.BinaryManager,
settings: Settings,
active_devices: List[Device],
results_out_handle: Optional[TextIO],
updated_settings_output_path: Optional[Path],
) -> None:
util.mkdirs_p(work_dir)
def write_entry(entry: str) -> None:
if not results_out_handle:
return
results_out_handle.write(entry)
results_out_handle.write(", ")
results_out_handle.flush()
def write_newline() -> None:
if not results_out_handle:
return
results_out_handle.write("\n")
results_out_handle.flush()
spirv_opt_path: Optional[Path] = None
swift_shader_path: Optional[Path] = None
amber_path: Optional[Path] = None
# Small hack to ensure we have three devices for spirv-opt, each with a different name.
main_spirv_opt_device: Optional[Device] = None
if active_devices and active_devices[0].name == "host_preprocessor":
main_spirv_opt_device = active_devices[0]
main_spirv_opt_device.name = SPIRV_OPT_O
spirv_opt_custom = Device()
spirv_opt_custom.CopyFrom(main_spirv_opt_device)
spirv_opt_custom.name = SPIRV_OPT_CUSTOM
active_devices.insert(1, spirv_opt_custom)
spirv_opt_os = Device()
spirv_opt_os.CopyFrom(main_spirv_opt_device)
spirv_opt_os.name = SPIRV_OPT_OS
active_devices.insert(1, spirv_opt_os)
# Enumerate active devices, writing their name and storing binary paths if needed.
write_entry("test")
for device in active_devices:
write_entry(device.name)
if device.HasField("preprocess"):
spirv_opt_path = binaries.get_binary_path_by_name(
binaries_util.SPIRV_OPT_NAME).path
if device.HasField("swift_shader"):
swift_shader_path = binaries.get_binary_path_by_name(
binaries_util.SWIFT_SHADER_NAME).path
if device.HasField("swift_shader") or device.HasField("host"):
amber_path = binaries.get_binary_path_by_name(
binaries_util.AMBER_NAME).path
write_newline()
# Enumerate tests and devices, writing the results.
for test in sorted(tests_dir.glob("*.amber")):
test_name = util.remove_end(test.name, ".amber")
write_entry(test_name)
spirv_shaders = sorted(
tests_dir.glob(util.remove_end(test.name, "amber") + "*.spv"))
for device in active_devices:
test_run_dir = work_dir / f"{test_name}_{device.name}"
util.mkdirs_p(test_run_dir)
ignored_signatures_set: Set[str] = set(
device.ignored_crash_signatures)
with util.file_open_text(test_run_dir / "log.txt",
"w") as log_stream:
try:
gflogging.push_stream_for_logging(log_stream)
if device.HasField("preprocess"):
# This just means spirv-opt for now.
assert spirv_opt_path # noqa
assert main_spirv_opt_device # noqa
# Pick spirv-opt arguments based on device name.
if device.name == SPIRV_OPT_O:
spirv_opt_args = ["-O"]
elif device.name == SPIRV_OPT_OS:
spirv_opt_args = ["-Os"]
elif device.name == SPIRV_OPT_CUSTOM:
spirv_opt_args = (spirv_opt_util.
OPT_INTERESTING_SUBSET_OF_PASSES)
else:
raise AssertionError(
f"Can't tell how to run device {device.name}; "
f"must be named host_preprocessor and be the first active device."
)
# Reset device and ignored_crash_signatures.
device = main_spirv_opt_device
ignored_signatures_set = set(
device.ignored_crash_signatures)
try:
for spirv_shader in spirv_shaders:
spirv_opt_util.run_spirv_opt_on_spirv_shader(
spirv_shader,
test_run_dir,
spirv_opt_args,
spirv_opt_path,
)
result_util.write_status(
test_run_dir,
fuzz.STATUS_SUCCESS,
)
except subprocess.CalledProcessError:
result_util.write_status(
test_run_dir,
fuzz.STATUS_TOOL_CRASH,
)
except subprocess.TimeoutExpired:
result_util.write_status(
test_run_dir,
fuzz.STATUS_TOOL_TIMEOUT,
)
elif device.HasField("shader_compiler"):
try:
for spirv_shader in spirv_shaders:
shader_compiler_util.run_shader(
shader_compiler_device=device.
shader_compiler,
shader_path=spirv_shader,
output_dir=test_run_dir,
compiler_path=binaries.
get_binary_path_by_name(
device.shader_compiler.binary).path,
timeout=DEFAULT_TIMEOUT,
)
result_util.write_status(
test_run_dir,
fuzz.STATUS_SUCCESS,
)
except subprocess.CalledProcessError:
result_util.write_status(
test_run_dir,
fuzz.STATUS_CRASH,
)
except subprocess.TimeoutExpired:
result_util.write_status(
test_run_dir,
fuzz.STATUS_TIMEOUT,
)
elif device.HasField("swift_shader"):
assert swift_shader_path # noqa
assert amber_path # noqa
host_device_util.run_amber(
test,
test_run_dir,
amber_path=amber_path,
dump_image=False,
dump_buffer=False,
icd=swift_shader_path,
)
elif device.HasField("host"):
assert amber_path # noqa
host_device_util.run_amber(
test,
test_run_dir,
amber_path=amber_path,
dump_image=False,
dump_buffer=False,
custom_launcher=list(device.host.custom_launcher),
)
elif device.HasField("android"):
android_device.run_amber_on_device(
test,
test_run_dir,
dump_image=False,
dump_buffer=False,
serial=device.android.serial,
)
else:
raise AssertionError(
f"Unsupported device {device.name}")
finally:
gflogging.pop_stream_for_logging()
status = result_util.get_status(test_run_dir)
if status == fuzz.STATUS_SUCCESS:
write_entry("P")
elif status in (fuzz.STATUS_TIMEOUT, fuzz.STATUS_TOOL_TIMEOUT):
write_entry("T")
else:
write_entry("F")
# Update ignored signatures.
if (status in (
fuzz.STATUS_TOOL_CRASH,
fuzz.STATUS_CRASH,
fuzz.STATUS_UNRESPONSIVE,
) and updated_settings_output_path):
log_contents = util.file_read_text(
result_util.get_log_path(test_run_dir))
signature = signature_util.get_signature_from_log_contents(
log_contents)
if signature == signature_util.NO_SIGNATURE:
log(f"NOT updating ignored signatures to include {signature}"
)
elif signature in ignored_signatures_set:
log(f"Signature is already ignored: {signature}")
else:
log(f"Adding ignored signature: {signature}")
device.ignored_crash_signatures.append(signature)
write_newline()
if updated_settings_output_path:
# Reset main_spirv_opt_device name before writing it back out.
if main_spirv_opt_device:
main_spirv_opt_device.name = "host_preprocessor"
settings_util.write(settings, updated_settings_output_path)
def main() -> None: # pylint: disable=too-many-locals,too-many-branches,too-many-statements;
parser = argparse.ArgumentParser(
description="Runs GraphicsFuzz AmberScript tests on the active devices listed in "
"the settings.json file.",
formatter_class=argparse.ArgumentDefaultsHelpFormatter,
)
parser.add_argument(
"--settings",
help="Path to the settings JSON file for this instance.",
default=str(settings_util.DEFAULT_SETTINGS_FILE_PATH),
)
parser.add_argument(
"--tests",
help="Path to the directory of AmberScript tests with shaders extracted.",
default="graphicsfuzz",
)
parser.add_argument(
"--update_ignored_signatures",
help="As the tests are run for each device, add any crash signatures to the device's ignored_crash_signatures "
"property and write out the updated settings.json file.",
action="store_true",
)
parser.add_argument(
"--results_out",
help="Output file path for the CSV results table.",
default="results.csv",
)
parsed_args = parser.parse_args(sys.argv[1:])
# Args.
tests_dir: Path = Path(parsed_args.tests)
settings_path: Path = Path(parsed_args.settings)
update_ignored_signatures: bool = parsed_args.update_ignored_signatures
results_out_path: Path = Path(parsed_args.results_out)
# Settings and devices.
settings = settings_util.read_or_create(settings_path)
active_devices = devices_util.get_active_devices(settings.device_list)
# Binaries.
binaries = binaries_util.get_default_binary_manager(settings=settings)
work_dir = Path() / "temp" / f"cts_run_{fuzz.get_random_name()[:8]}"
util.mkdirs_p(work_dir)
with util.file_open_text(results_out_path, "w") as results_handle:
def write_entry(entry: str) -> None:
results_handle.write(entry)
results_handle.write(", ")
results_handle.flush()
def write_newline() -> None:
results_handle.write("\n")
results_handle.flush()
spirv_opt_path: Optional[Path] = None
swift_shader_path: Optional[Path] = None
amber_path: Optional[Path] = None
# Small hack to ensure we have three devices for spirv-opt, each with a different name.
main_spirv_opt_device: Optional[Device] = None
if active_devices and active_devices[0].name == "host_preprocessor":
main_spirv_opt_device = active_devices[0]
main_spirv_opt_device.name = SPIRV_OPT_O
spirv_opt_custom = Device()
spirv_opt_custom.CopyFrom(main_spirv_opt_device)
spirv_opt_custom.name = SPIRV_OPT_CUSTOM
active_devices.insert(1, spirv_opt_custom)
spirv_opt_os = Device()
spirv_opt_os.CopyFrom(main_spirv_opt_device)
spirv_opt_os.name = SPIRV_OPT_OS
active_devices.insert(1, spirv_opt_os)
# Enumerate active devices, writing their name and storing binary paths if needed.
write_entry("test")
for device in active_devices:
write_entry(device.name)
if device.HasField("preprocess"):
spirv_opt_path = binaries.get_binary_path_by_name(
binaries_util.SPIRV_OPT_NAME
).path
if device.HasField("swift_shader"):
swift_shader_path = binaries.get_binary_path_by_name(
binaries_util.SWIFT_SHADER_NAME
).path
if device.HasField("swift_shader") or device.HasField("host"):
amber_path = binaries.get_binary_path_by_name(
binaries_util.AMBER_NAME
).path
write_newline()
# Enumerate tests and devices, writing the results.
for test in sorted(tests_dir.glob("*.amber")):
test_name = util.remove_end(test.name, ".amber")
write_entry(test_name)
spirv_shaders = sorted(
tests_dir.glob(util.remove_end(test.name, "amber") + "*.spv")
)
for device in active_devices:
test_run_dir = work_dir / f"{test_name}_{device.name}"
util.mkdirs_p(test_run_dir)
ignored_signatures_set: Set[str] = set(device.ignored_crash_signatures)
with util.file_open_text(test_run_dir / "log.txt", "w") as log_stream:
try:
gflogging.push_stream_for_logging(log_stream)
if device.HasField("preprocess"):
# This just means spirv-opt for now.
assert spirv_opt_path # noqa
assert main_spirv_opt_device # noqa
# Pick spirv-opt arguments based on device name.
if device.name == SPIRV_OPT_O:
spirv_opt_args = ["-O"]
elif device.name == SPIRV_OPT_OS:
spirv_opt_args = ["-Os"]
elif device.name == SPIRV_OPT_CUSTOM:
spirv_opt_args = (
spirv_opt_util.OPT_INTERESTING_SUBSET_OF_PASSES
)
else:
raise AssertionError(
f"Can't tell how to run device {device.name}; "
f"must be named host_preprocessor and be the first active device."
)
# Reset device and ignored_crash_signatures.
device = main_spirv_opt_device
ignored_signatures_set = set(
device.ignored_crash_signatures
)
try:
for spirv_shader in spirv_shaders:
spirv_opt_util.run_spirv_opt_on_spirv_shader(
spirv_shader,
test_run_dir,
spirv_opt_args,
spirv_opt_path,
)
result_util.write_status(
test_run_dir, fuzz.STATUS_SUCCESS,
)
except subprocess.CalledProcessError:
result_util.write_status(
test_run_dir, fuzz.STATUS_TOOL_CRASH,
)
except subprocess.TimeoutExpired:
result_util.write_status(
test_run_dir, fuzz.STATUS_TOOL_TIMEOUT,
)
elif device.HasField("shader_compiler"):
try:
for spirv_shader in spirv_shaders:
shader_compiler_util.run_shader(
shader_compiler_device=device.shader_compiler,
shader_path=spirv_shader,
output_dir=test_run_dir,
compiler_path=binaries.get_binary_path_by_name(
device.shader_compiler.binary
).path,
timeout=DEFAULT_TIMEOUT,
)
result_util.write_status(
test_run_dir, fuzz.STATUS_SUCCESS,
)
except subprocess.CalledProcessError:
result_util.write_status(
test_run_dir, fuzz.STATUS_CRASH,
)
except subprocess.TimeoutExpired:
result_util.write_status(
test_run_dir, fuzz.STATUS_TIMEOUT,
)
elif device.HasField("swift_shader"):
assert swift_shader_path # noqa
assert amber_path # noqa
host_device_util.run_amber(
test,
test_run_dir,
amber_path=amber_path,
dump_image=False,
dump_buffer=False,
icd=swift_shader_path,
)
elif device.HasField("host"):
assert amber_path # noqa
host_device_util.run_amber(
test,
test_run_dir,
amber_path=amber_path,
dump_image=False,
dump_buffer=False,
custom_launcher=list(device.host.custom_launcher),
)
elif device.HasField("android"):
android_device.run_amber_on_device(
test,
test_run_dir,
dump_image=False,
dump_buffer=False,
serial=device.android.serial,
)
else:
raise AssertionError(f"Unsupported device {device.name}")
finally:
gflogging.pop_stream_for_logging()
status = result_util.get_status(test_run_dir)
if status == fuzz.STATUS_SUCCESS:
write_entry("P")
elif status in (fuzz.STATUS_TIMEOUT, fuzz.STATUS_TOOL_TIMEOUT):
write_entry("T")
else:
write_entry("F")
# Update ignored signatures.
if (
status
in (
fuzz.STATUS_TOOL_CRASH,
fuzz.STATUS_CRASH,
fuzz.STATUS_UNRESPONSIVE,
)
and update_ignored_signatures
):
log_contents = util.file_read_text(
result_util.get_log_path(test_run_dir)
)
signature = signature_util.get_signature_from_log_contents(
log_contents
)
if signature == signature_util.NO_SIGNATURE:
log(f"NOT updating ignored signatures to include {signature}")
elif signature in ignored_signatures_set:
log(f"Signature is already ignored: {signature}")
else:
log(f"Adding ignored signature: {signature}")
device.ignored_crash_signatures.append(signature)
write_newline()
if update_ignored_signatures:
# Reset main_spirv_opt_device name before writing it back out.
if main_spirv_opt_device:
main_spirv_opt_device.name = "host_preprocessor"
settings_util.write(settings, settings_path)
def main() -> None: # pylint: disable=too-many-locals,too-many-branches,too-many-statements;
parser = argparse.ArgumentParser(
description="Runs GraphicsFuzz AmberScript tests on the active devices listed in "
"the settings.json file."
)
parser.add_argument(
"--settings",
help="Path to the settings JSON file for this instance.",
default=str(settings_util.DEFAULT_SETTINGS_FILE_PATH),
)
parser.add_argument(
"--tests",
help="Path to the directory of AmberScript tests with shaders extracted.",
default=str("graphicsfuzz"),
)
parsed_args = parser.parse_args(sys.argv[1:])
# Args.
tests_dir: Path = Path(parsed_args.tests)
settings_path: Path = Path(parsed_args.settings)
# Settings and devices.
settings = settings_util.read_or_create(settings_path)
active_devices = devices_util.get_active_devices(settings.device_list)
# Binaries.
binaries = binaries_util.get_default_binary_manager(settings=settings)
work_dir = Path() / "temp" / f"cts_run_{fuzz.get_random_name()[:8]}"
util.mkdirs_p(work_dir)
with util.file_open_text(Path("results.txt"), "w") as log_handle:
def write_entry(entry: str) -> None:
log_handle.write(entry)
log_handle.write(", ")
log_handle.flush()
def write_newline() -> None:
log_handle.write("\n")
log_handle.flush()
spirv_opt_path: Optional[Path] = None
swift_shader_path: Optional[Path] = None
amber_path: Optional[Path] = None
# Enumerate active devices, writing their name and storing binary paths if needed.
write_entry("test")
for device in active_devices:
if device.name == "host_preprocessor":
# We are actually just running spirv-opt on the SPIR-V shaders.
write_entry("spirv-opt")
else:
write_entry(device.name)
if device.HasField("preprocess"):
spirv_opt_path = binaries.get_binary_path_by_name(
binaries_util.SPIRV_OPT_NAME
).path
if device.HasField("swift_shader"):
swift_shader_path = binaries.get_binary_path_by_name(
binaries_util.SWIFT_SHADER_NAME
).path
if device.HasField("swift_shader") or device.HasField("host"):
amber_path = binaries.get_binary_path_by_name(
binaries_util.AMBER_NAME
).path
write_newline()
# Enumerate tests and devices, writing the results.
for test in sorted(tests_dir.glob("*.amber")):
test_name = util.remove_end(test.name, ".amber")
write_entry(test_name)
spirv_shaders = sorted(
tests_dir.glob(util.remove_end(test.name, "amber") + "*.spv")
)
for device in active_devices:
test_run_dir = work_dir / f"{test_name}_{device.name}"
util.mkdirs_p(test_run_dir)
try:
# Confusingly, some functions below will raise on an error; others will write e.g. CRASH to the
# STATUS file in the output directory. In the latter case, we update |status|. We check |status| at
# the end of this if-else chain and raise fake exceptions if appropriate.
status = fuzz.STATUS_SUCCESS
if device.HasField("preprocess"):
# This just means spirv-op for now.
assert spirv_opt_path # noqa
for spirv_shader in spirv_shaders:
spirv_opt_util.run_spirv_opt_on_spirv_shader(
spirv_shader, test_run_dir, ["-O"], spirv_opt_path
)
elif device.HasField("shader_compiler"):
for spirv_shader in spirv_shaders:
shader_compiler_util.run_shader(
shader_compiler_device=device.shader_compiler,
shader_path=spirv_shader,
output_dir=test_run_dir,
compiler_path=binaries.get_binary_path_by_name(
device.shader_compiler.binary
).path,
timeout=DEFAULT_TIMEOUT,
)
elif device.HasField("swift_shader"):
assert swift_shader_path # noqa
assert amber_path # noqa
host_device_util.run_amber(
test,
test_run_dir,
amber_path=amber_path,
dump_image=False,
dump_buffer=False,
icd=swift_shader_path,
)
status = result_util.get_status(test_run_dir)
elif device.HasField("host"):
assert amber_path # noqa
host_device_util.run_amber(
test,
test_run_dir,
amber_path=amber_path,
dump_image=False,
dump_buffer=False,
)
status = result_util.get_status(test_run_dir)
elif device.HasField("android"):
android_device.run_amber_on_device(
test,
test_run_dir,
dump_image=False,
dump_buffer=False,
serial=device.android.serial,
)
status = result_util.get_status(test_run_dir)
else:
raise AssertionError(f"Unsupported device {device.name}")
if status in (fuzz.STATUS_CRASH, fuzz.STATUS_TOOL_CRASH):
raise CalledProcessError(1, "??")
if status != fuzz.STATUS_SUCCESS:
raise TimeoutExpired("??", fuzz.AMBER_RUN_TIME_LIMIT)
write_entry("P")
except CalledProcessError:
write_entry("F")
except TimeoutExpired:
write_entry("T")
write_newline()
