int main(int argc, char **argv) {
Func source;
source.define_extern("make_data",
std::vector<ExternFuncArgument>(),
Float(32), 2);
Func sink;
Var x, y;
sink(x, y) = source(x, y) - sin(x + y);
Var xi, yi;
sink.tile(x, y, xi, yi, 32, 32);
// Compute the source per tile of sink
source.compute_at(sink, x);
Image<float> output = sink.realize(100, 100);
// Should be all zeroes.
RDom r(output);
float error = evaluate_may_gpu<float>(sum(abs(output(r.x, r.y))));
if (error != 0) {
printf("Something went wrong\n");
return -1;
}
Func multi;
std::vector<Type> types;
types.push_back(Float(32));
types.push_back(Float(32));
multi.define_extern("make_data_multi",
std::vector<ExternFuncArgument>(),
types, 2);
Func sink_multi;
sink_multi(x, y) = multi(x, y)[0] - sin(x + y) +
multi(x, y)[1] - cos(x + y);
sink_multi.tile(x, y, xi, yi, 32, 32);
// Compute the source per tile of sink
multi.compute_at(sink_multi, x);
Image<float> output_multi = sink_multi.realize(100, 100);
// Should be all zeroes.
float error_multi = evaluate<float>(sum(abs(output_multi(r.x, r.y))));
if (error_multi != 0) {
printf("Something went wrong in multi case\n");
return -1;
}
printf("Success!\n");
return 0;
}
int main(int argc, char **argv) {
Func data;
Var x;
data(x) = sin(x);
data.compute_root();
Func sorted;
std::vector<ExternFuncArgument> args;
args.push_back(data);
sorted.define_extern("sort_buffer", args, Float(32), 1);
Buffer<float> output = sorted.realize(100);
// Check the output
Buffer<float> reference = lambda(x, sin(x)).realize(100);
std::sort(&reference(0), &reference(100));
RDom r(reference);
float error = evaluate_may_gpu<float>(sum(abs(reference(r) - output(r))));
if (error != 0) {
printf("Output incorrect\n");
return -1;
}
printf("Success!\n");
return 0;
}
int main(int argc, char **argv) {
Func source;
source.define_extern("make_data",
std::vector<ExternFuncArgument>(),
Float(32), 2);
Func sink;
Var x, y;
sink(x, y) = source(x, y) - sin(x + y);
Var xi, yi;
sink.tile(x, y, xi, yi, 32, 32);
// Compute the source per tile of sink
source.compute_at(sink, x);
Image<float> output = sink.realize(100, 100);
// Should be all zeroes.
RDom r(output);
float error = evaluate<float>(sum(abs(output(r.x, r.y))));
if (error != 0) {
printf("Something went wrong\n");
return -1;
}
printf("Success!\n");
return 0;
}
int main(int argc, char **argv) {
// Define a pipeline that dumps some squares to a file using an
// external consumer stage.
Func source;
Var x;
source(x) = x*x;
Param<int> min, extent;
Param<const char *> filename;
Func sink;
std::vector<ExternFuncArgument> args;
args.push_back(source);
args.push_back(filename);
args.push_back(min);
args.push_back(extent);
sink.define_extern("dump_to_file", args, Int(32), 0);
source.compute_root();
sink.compile_jit();
// Dump the first 10 squares to a file
filename.set("halide_test_extern_consumer.txt");
min.set(0);
extent.set(10);
sink.realize();
if (!check_result())
return -1;
// Test ImageParam ExternFuncArgument via passed in image.
Image<int32_t> buf = source.realize(10);
ImageParam passed_in(Int(32), 1);
passed_in.set(buf);
Func sink2;
std::vector<ExternFuncArgument> args2;
args2.push_back(passed_in);
args2.push_back(filename);
args2.push_back(min);
args2.push_back(extent);
sink2.define_extern("dump_to_file", args2, Int(32), 0);
sink2.realize();
if (!check_result())
return -1;
printf("Success!\n");
return 0;
}
int main(int argc, char **argv) {
std::vector<ExternFuncArgument> args;
args.push_back(user_context_value());
Func f;
f.define_extern("extern_error", args, Float(32), 1);
f.set_error_handler(&my_halide_error);
f.realize(100);
if (!error_occurred || !extern_error_called) {
printf("There was supposed to be an error\n");
return -1;
}
printf("Success!\n");
return 0;
}
