Beispiel #1
0
def test_default_verify_function_scalar():

    answer = [np.zeros(4).astype(np.float32), None, np.int64(42)]

    instance = core.KernelInstance("name", None, "kernel_string", [],
                                   (256, 1, 1), (1, 1, 1), {}, answer)

    answer_type_error1 = [np.zeros(4).astype(np.float32), None, np.float64(42)]
    answer_type_error2 = [np.zeros(4).astype(np.float32), None, np.float32(42)]

    result_host = [
        np.array([0, 0, 0, 0]).astype(np.float32), None,
        np.int64(42)
    ]

    for ans in [answer_type_error1, answer_type_error2]:
        try:
            core._default_verify_function(instance, ans, result_host, 0, False)
            print("_default_verify_function failed to throw an exception")
            assert False
        except TypeError:
            assert True

    assert core._default_verify_function(instance, answer, result_host, 0.1,
                                         False)
def test_default_verify_function_scalar():

    answer = [numpy.zeros(4).astype(numpy.float32), None, numpy.int64(42)]

    instance = core.KernelInstance("name", "kernel_string", [], (256,1,1), (1,1,1), {}, answer)

    answer_type_error1 = [numpy.zeros(4).astype(numpy.float32), None, numpy.float64(42)]
    answer_type_error2 = [numpy.zeros(4).astype(numpy.float32), None, numpy.float32(42)]

    result_host = [numpy.array([0,0,0,0]).astype(numpy.float32), None, numpy.int64(42)]

    for ans in [answer_type_error1, answer_type_error2]:
        try:
            core._default_verify_function(instance, ans, result_host, 0, False)
            print("check_kernel_output failed to throw an exception")
            assert False
        except TypeError:
            assert True

    assert core._default_verify_function(instance, answer, result_host, 0.1, False)
Beispiel #3
0
def test_default_verify_function(env):

    #gpu_args = dev.ready_argument_list(args)
    #func = dev.compile_kernel(instance, verbose)

    dev, instance = env
    args = instance.arguments
    verbose = True

    #1st case, correct answer but not enough items in the list
    answer = [args[1] + args[2]]
    try:
        core._default_verify_function(instance, answer, args, 1e-6, verbose)
        #dev.check_kernel_output(func, gpu_args, instance, answer, 1e-6, None, verbose)
        print("Expected a TypeError to be raised")
        assert False
    except TypeError as expected_error:
        print(str(expected_error))
        assert "The length of argument list and provided results do not match." == str(
            expected_error)
    except Exception:
        print("Expected a TypeError to be raised")
        assert False

    #2nd case, answer is of wrong type
    answer = [np.ubyte([12]), None, None, None]
    try:
        core._default_verify_function(instance, answer, args, 1e-6, verbose)
        #dev.check_kernel_output(func, gpu_args, instance, answer, 1e-6, None, verbose)
        print("Expected a TypeError to be raised")
        assert False
    except TypeError as expected_error:
        print(str(expected_error))
        assert "Element 0" in str(expected_error)
    except Exception:
        print("Expected a TypeError to be raised")
        assert False

    instance.delete_temp_files()
    assert True
Beispiel #4
0
def test_default_verify_function_arrays():

    answer = [np.zeros(4).astype(np.float32), None, np.ones(5).astype(np.int32)]

    answer_type_error1 = [np.zeros(4).astype(np.float32)]
    answer_type_error2 = [np.zeros(4).astype(np.float32), None, np.int32(1)]
    answer_type_error3 = [np.zeros(4).astype(np.float32), None, np.ones(4).astype(np.int32)]

    result_host = [np.zeros(4).astype(np.float32), None, np.ones(5).astype(np.int32)]
    result_host2 = [np.array([0, 0, 0, 0]).reshape((2, 2)).astype(np.float32), None, np.ones(5).astype(np.int32)]

    instance = core.KernelInstance("name", None, "kernel_string", [], (256, 1, 1), (1, 1, 1), {}, answer)

    for ans in [answer_type_error1, answer_type_error2, answer_type_error3]:
        try:
            core._default_verify_function(instance, ans, result_host, 0, False)
            print("_default_verify_function failed to throw an exception")
            assert False
        except TypeError:
            assert True

    for result_host in [result_host, result_host2]:
        assert core._default_verify_function(instance, answer, result_host, 0.1, False)