static int run_test(void *uc, int channels, Implementation imp, Layout layout) {
std::string name = "Example_";
name += std::to_string(channels);
name += (imp == kGLSL) ? "_GLSL" : "_CPU";
name += (layout == kChunky) ? "_Chunky" : "_Planar";
halide_printf(uc, "\n---------------------------\n%s\n", name.c_str());
Image<uint8_t> input(kWidth, kHeight, channels, 0, (layout == kChunky));
Image<uint8_t> output(kWidth, kHeight, channels, 0, (layout == kChunky));
(void) halide_smooth_buffer_host<uint8_t>(uc, kSeed, input);
if (imp == kGLSL) {
// Call once to ensure OpenGL is inited (we want to time the
// cost of copy-to-device alone)
halide_copy_to_device(uc, input, halide_opengl_device_interface());
// Mark as dirty so the next call won't be a no-op
input.set_host_dirty();
{
ScopedTimer timer(uc, name + " halide_copy_to_device input");
halide_copy_to_device(uc, input, halide_opengl_device_interface());
}
{
ScopedTimer timer(uc, name + " halide_copy_to_device output");
halide_copy_to_device(uc, output, halide_opengl_device_interface());
}
}
// Call once to compile shader, warm up, etc.
ExampleFunc example = exampleFuncs[channels-1][imp];
(void) example(input, output);
{
ScopedTimer timer(uc, name, kIter);
for (int i = 0; i < kIter; ++i) {
(void) example(input, output);
}
}
if (imp == kGLSL) {
ScopedTimer timer(uc, name + " halide_copy_to_host");
halide_copy_to_host(uc, output);
}
// halide_buffer_display(input);
// halide_buffer_print(input);
// halide_buffer_display(output);
// halide_buffer_print(output);
int errors = check<uint8_t>(input, output);
if (errors) {
halide_errorf(uc, "Test %s had %d errors!\n\n", name.c_str(), errors);
} else {
halide_printf(uc, "Test %s had no errors.\n\n", name.c_str());
}
return errors;
}
WEAK int halide_copy_to_device_legacy(void *user_context, struct buffer_t *old_buf,
const struct halide_device_interface_t *device_interface) {
halide_buffer_t new_buf = {0};
halide_dimension_t shape[4];
new_buf.dim = shape;
int err = guess_type_and_dimensionality(user_context, old_buf, &new_buf);
err = err || halide_upgrade_buffer_t(user_context, "", old_buf, &new_buf, /*bounds_query_only*/ 0);
err = err || halide_copy_to_device(user_context, &new_buf, device_interface);
err = err || halide_downgrade_buffer_t_device_fields(user_context, "", &new_buf, old_buf);
return err;
}
int main(int argc, char const *argv[])
{
LibRaw rawProcessor;
rawProcessor.open_file(argv[argc-1]);
rawProcessor.unpack();
// Use 16-bit input.
buffer_t input_buf = {0};
input_buf.host = (uint8_t *)rawProcessor.imgdata.rawdata.raw_image;
input_buf.stride[0] = 1;
input_buf.stride[1] = rawProcessor.imgdata.sizes.width;
input_buf.extent[0] = rawProcessor.imgdata.sizes.width;
input_buf.extent[1] = rawProcessor.imgdata.sizes.height;
input_buf.elem_size = sizeof(*rawProcessor.imgdata.rawdata.raw_image);
// Allocate WxH 16-bit, 3 channel output buffer.
buffer_t output_buf = {0};
output_buf.stride[0] = 1;
output_buf.stride[1] = rawProcessor.imgdata.sizes.width;
output_buf.stride[2] = rawProcessor.imgdata.sizes.width * rawProcessor.imgdata.sizes.height;
output_buf.stride[3] = rawProcessor.imgdata.sizes.width * rawProcessor.imgdata.sizes.height * 3;
output_buf.extent[0] = rawProcessor.imgdata.sizes.width;
output_buf.extent[1] = rawProcessor.imgdata.sizes.height;
output_buf.extent[2] = 3;
output_buf.elem_size = 2;
uint8_t *output_data = new uint8_t[sizeof(uint16_t) * rawProcessor.imgdata.sizes.width * rawProcessor.imgdata.sizes.height * 3];
output_buf.host = output_data;
output_buf.host_dirty = false;
output_buf.dev_dirty = false;
output_buf.dev = 0;
for (int i = 0; i<20; i++) {
auto start = std::chrono::system_clock::now();
input_buf.host_dirty = true;
halide_copy_to_device(NULL, &input_buf, halide_opencl_device_interface());
std::cout << "Input: " << std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now()-start).count() << std::endl;
buffer_t input_no_host = *(&input_buf);
input_no_host.host = NULL;
buffer_t output_no_host = *(&output_buf);
output_no_host.host = (uint8_t *)1;
igd_demosaic(&input_no_host, 0, &output_no_host);
std::cout << "Halide: " << std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now()-start).count() << std::endl;
output_no_host.host = output_data;
halide_copy_to_host(NULL, &output_no_host);
std::cout << "Output: " << std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now()-start).count() << std::endl << std::endl;
}
//Halide::Tools::Image<uint16_t> output_image = Image<uint16_t>(&output_buf, "output");
//output_image.copy_to_host();
//Tools::save_image(output_image, "test.png");
return 0;
}
int Buffer::copy_to_device() {
return halide_copy_to_device(NULL, raw_buffer(), NULL);
}
