def UnpackResult(result_path: typing.Optional[str]) -> None:
"""Unpack a result proto into its components.
Args:
result_path: The path of the result to unpack.
Raises:
UsageError: In case of error.
"""
result_to_unpack = ResultProtoFromFlag(result_path)
unpack_dir = pathlib.Path(result_path).parent
WriteFile(unpack_dir / "kernel.cl", result_to_unpack.testcase.inputs["src"])
WriteFile(unpack_dir / "stdout.txt", result_to_unpack.outputs["stdout"])
WriteFile(unpack_dir / "stderr.txt", result_to_unpack.outputs["stderr"])
if result_to_unpack.testcase.harness.name == "cldrive":
WriteFile(
unpack_dir / "driver.c",
cldrive.MakeDriver(result_to_unpack.testcase, FLAGS.opencl_opt),
)
elif result_to_unpack.testcase.harness.name == "cl_launcher":
shutil.copyfile(CL_LAUNCHER_SRC, unpack_dir / "driver.c")
else:
raise app.UsageError(
f"Unrecognized harness: '{result.testcase.harness.name}'"
)
def test_MakeDriver_CompileDriver_hello_world():
"""And end-to-end test."""
testcase = deepsmith_pb2.Testcase(
inputs={
"lsize": "1,1,1",
"gsize": "1,1,1",
"src": "kernel void A(global int* a) {a[get_global_id(0)] += 10;}",
})
driver = cldrive.MakeDriver(testcase, True)
with tempfile.TemporaryDirectory() as d:
binary = cldrive.CompileDriver(driver,
pathlib.Path(d) / "exe",
0,
0,
timeout_seconds=60)
proc = oclgrind.Exec([str(binary)])
assert "[cldrive] Platform:" in proc.stderr
assert "[cldrive] Device:" in proc.stderr
assert "[cldrive] OpenCL optimizations: on\n" in proc.stderr
assert '[cldrive] Kernel: "A"\n' in proc.stderr
assert "done.\n" in proc.stderr
assert proc.stdout.split("\n")[-2] == (
"global int * a: 10 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 "
"22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 "
"46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 "
"70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 "
"94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 "
"114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 "
"132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 "
"150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 "
"168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 "
"186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 "
"204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 "
"222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 "
"240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255")
def test_MakeDriver_ValueError_no_src():
"""Test that ValueError is raised if src input not set."""
testcase = deepsmith_pb2.Testcase(inputs={
"lsize": "1,1,1",
"gsize": "1,1,1",
})
with test.Raises(ValueError) as e_ctx:
cldrive.MakeDriver(testcase, True)
assert "Field not set: 'Testcase.inputs[\"src\"]'" == str(e_ctx.value)
def test_MakeDriver_ValueError_no_lsize():
"""Test that ValueError is raised if lsize input not set."""
testcase = deepsmith_pb2.Testcase(inputs={
"gsize": "1,1,1",
"src": "kernel void A() {}"
})
with test.Raises(ValueError) as e_ctx:
cldrive.MakeDriver(testcase, True)
assert "Field not set: 'Testcase.inputs[\"lsize\"]'" == str(e_ctx.value)
def test_MakeDriver_optimizations_on():
"""Test that OpenCL optimizations are enabled when requested."""
testcase = deepsmith_pb2.Testcase(inputs={
"lsize": "1,1,1",
"gsize": "1,1,1",
"src": "kernel void A() {}"
})
src = cldrive.MakeDriver(testcase, True)
assert "[cldrive] OpenCL optimizations: on" in src
assert "clBuildProgram(program, 0, NULL, NULL, NULL, NULL);" in src
def test_MakeDriver_ValueError_invalid_gsize():
"""Test that ValueError is raised if gsize is not an NDRange."""
testcase = deepsmith_pb2.Testcase(inputs={
"lsize": "1,1,1",
"gsize": "abc",
"src": "kernel void A() {}"
})
with test.Raises(ValueError) as e_ctx:
cldrive.MakeDriver(testcase, True)
assert "invalid literal for int() with base 10: 'abc'" == str(e_ctx.value)
def test_MakeDriver_optimizations_on():
"""Test that OpenCL optimizations are enabled when requested."""
testcase = deepsmith_pb2.Testcase(inputs={
'lsize': "1,1,1",
'gsize': "1,1,1",
'src': 'kernel void A() {}'
})
src = cldrive.MakeDriver(testcase, True)
assert '[cldrive] OpenCL optimizations: on' in src
assert 'clBuildProgram(program, 0, NULL, NULL, NULL, NULL);' in src
def test_MakeDriver_optimizations_off():
"""Test that OpenCL optimizations are disabled when requested."""
testcase = deepsmith_pb2.Testcase(inputs={
"lsize": "1,1,1",
"gsize": "1,1,1",
"src": "kernel void A() {}"
})
src = cldrive.MakeDriver(testcase, False)
print(src)
assert "[cldrive] OpenCL optimizations: off" in src
assert ('clBuildProgram(program, 0, NULL, "-cl-opt-disable", NULL, NULL);'
in src)
def MakeDriverSrc(data_generator: str) -> str:
testcase = deepsmith_pb2.Testcase(
inputs={
"gsize": f"{gsize_x},1,1",
"lsize": f"{lsize_x},1,1",
"data_generator": data_generator,
"src": opencl_kernel,
}
)
src = cldrive_harness.MakeDriver(testcase, optimizations=True)
if testcase.invariant_opts["driver_type"] != "compile_and_run":
raise DriverConstructionFailed(
"Expected compile-and-run driver, found "
+ testcase.invariant_opts["driver_type"]
)
return src
def test_GenerateDeadcodeMutations_fuzz_test_batch(i: int):
"""Fuzz test the mutation generator.
For each round of testing:
Generate a batch of mutated kernels.
For each mutated kernel:
Create a DeepSmith testcase to compile and run the kernel.
Drive the testcase using oclgrind.
Ensure that the testcase completes.
"""
del i # unused
# Select random parameters for test.
kernels = [random.choice(KERNELS)] + [
k for k in KERNELS if random.random() < 0.5
]
seed = random.randint(0, 1e9)
num_permutations_of_kernel = random.randint(1, 5)
num_mutations_per_kernel_min = random.randint(1, 5)
num_mutations_per_kernel_max = num_mutations_per_kernel_min + random.randint(
1, 5
)
num_mutations_per_kernel = (
num_mutations_per_kernel_min,
num_mutations_per_kernel_max,
)
app.Log(
1,
"num_kernels=%d, seed=%d, num_permutations_of_kernel=%d, "
"num_mutations_per_kernel=%s",
len(kernels),
seed,
num_permutations_of_kernel,
num_mutations_per_kernel,
)
# Generate a batch of mutations.
generator = dci.GenerateDeadcodeMutations(
kernels=kernels,
rand=np.random.RandomState(seed),
num_permutations_of_kernel=num_permutations_of_kernel,
num_mutations_per_kernel=num_mutations_per_kernel,
)
for i, mutated_kernel in enumerate(generator):
app.Log(1, "Testing mutated kernel: %s", mutated_kernel)
# Create a DeepSmith testcase for the mutated kernel.
testcase = deepsmith_pb2.Testcase(
inputs={"lsize": "1,1,1", "gsize": "1,1,1", "src": mutated_kernel,}
)
# Make a driver for the testcase.
driver = cldrive.MakeDriver(testcase, optimizations=True)
with tempfile.TemporaryDirectory(prefix="phd_") as d:
# Compile the driver.
binary = cldrive.CompileDriver(
driver, pathlib.Path(d) / "exe", 0, 0, timeout_seconds=60
)
# Execute the driver.
proc = oclgrind.Exec([str(binary)])
app.Log(1, "Testcase driver output: '%s'", proc.stderr.rstrip())
assert not proc.returncode
assert "[cldrive] Platform:" in proc.stderr
assert "[cldrive] Device:" in proc.stderr
assert "[cldrive] OpenCL optimizations: on\n" in proc.stderr
assert '[cldrive] Kernel: "' in proc.stderr
assert "done.\n" in proc.stderr
# Sanity check that the correct number of kernels have been generated.
app.Log(1, "Generated %d mutations", i + 1)
assert i + 1 == len(kernels) * num_permutations_of_kernel
