int main(void) {
int *data1 = (int *)malloc(SIZE*sizeof(int));
auto acc = hc::accelerator();
int* data1_d = (int*)hc::am_alloc(SIZE*sizeof(int), acc, 0);
grid_launch_parm lp;
grid_launch_init(&lp);
lp.gridDim.x = GRID_SIZE;
lp.groupDim.x = TILE_SIZE;
hc::completion_future cf;
lp.cf = &cf;
kernel1(lp, data1_d);
lp.cf->wait();
hc::am_copy(data1, data1_d, SIZE*sizeof(int));
bool ret = 0;
for(int i = 0; i < SIZE; ++i) {
if(data1[i] != i) {
ret = 1;
break;
}
}
hc::am_free(data1_d);
free(data1);
return ret;
}
int main(void) {
char c = 1;
int * data1 = (int*)malloc(SIZE*sizeof(int));
auto acc = hc::accelerator();
int * data1_d = (int*)hc::am_alloc(SIZE*sizeof(int), acc, 0);
grid_launch_parm lp;
grid_launch_init(&lp);
lp.grid_dim = gl_dim3(GRID_SIZE, 1);
lp.group_dim = gl_dim3(TILE_SIZE, 1);
hc::completion_future cf;
lp.cf = &cf;
kernel1(lp, data1_d, c);
lp.cf->wait();
static hc::accelerator_view av = acc.get_default_view();
av.copy(data1_d, data1, SIZE*sizeof(int));
bool ret = 0;
for(int i = 0; i < SIZE; ++i) {
if((data1[i] != (int)c)) {
ret = 1;
break;
}
}
hc::am_free(data1);
free(data1);
return ret;
}
int main(void) {
Foo data1(5);
Bar* data2 = (Bar*)malloc(SIZE*sizeof(Bar));
auto acc = hc::accelerator();
Bar* data2_d = (Bar*)hc::am_alloc(SIZE*sizeof(Bar), acc, 0);
grid_launch_parm lp;
grid_launch_init(&lp);
lp.grid_dim = gl_dim3(GRID_SIZE, 1);
lp.group_dim = gl_dim3(TILE_SIZE, 1);
hc::completion_future cf;
lp.cf = &cf;
kernel1(lp, data1, data2_d);
lp.cf->wait();
hc::am_copy(data2, data2_d, SIZE*sizeof(Bar));
bool ret = 0;
for(int i = 0; i < SIZE; ++i) {
if((data2[i].x != i + data1.y)) {
ret = 1;
break;
}
}
hc::am_free(data2_d);
free(data2);
return ret;
}
int main(void) {
Foo* data1 = (Foo*)malloc(SIZE*sizeof(Foo));
Bar* data2 = (Bar*)malloc(SIZE*sizeof(Bar));
constStructconst* data3 = (constStructconst*)malloc(SIZE*sizeof(constStructconst));
for(int i = 0; i < SIZE; ++i) {
data3[i].x = i;
}
auto acc = hc::accelerator();
Foo* data1_d = (Foo*)hc::am_alloc(SIZE*sizeof(Foo), acc, 0);
Bar* data2_d = (Bar*)hc::am_alloc(SIZE*sizeof(Bar), acc, 0);
constStructconst* data3_d = (constStructconst*)hc::am_alloc(SIZE*sizeof(constStructconst), acc, 0);
hc::am_copy(data3_d, data3, SIZE*sizeof(constStructconst));
grid_launch_parm lp;
grid_launch_init(&lp);
lp.gridDim = gl_dim3(GRID_SIZE, 1);
lp.groupDim = gl_dim3(TILE_SIZE, 1);
hc::completion_future cf;
lp.cf = &cf;
kernel1(lp, data1_d, data2_d, data3_d);
lp.cf->wait();
hc::am_copy(data1, data1_d, SIZE*sizeof(Foo));
hc::am_copy(data2, data2_d, SIZE*sizeof(Bar));
bool ret = 0;
for(int i = 0; i < SIZE; ++i) {
if((data1[i].x != i) || (data2[i].x != i + data3[i].x)) {
ret = 1;
break;
}
}
hc::am_free(data1_d);
hc::am_free(data2_d);
hc::am_free(data3_d);
free(data1);
free(data2);
free(data3);
return ret;
}
int main()
{
int width = 320;
int height = 112;
int *a = (int*)malloc(width*height*sizeof(int));
int pitch = sizeof(int)*width;
auto acc = hc::accelerator();
int* a_d = (int*)hc::am_alloc(width*height*sizeof(int), acc, 0);
grid_launch_parm lp;
grid_launch_init(&lp);
lp.grid_dim = gl_dim3(width/TILE_I, height/TILE_J);
lp.group_dim = gl_dim3(TILE_I, TILE_J);
hc::completion_future cf;
lp.cf = &cf;
kernel_call(lp, a_d, pitch);
lp.cf->wait();
static hc::accelerator_view av = acc.get_default_view();
av.copy(a_d, a, width*height*sizeof(int));
int ret = 0;
for(int i = 0; i < width*height; ++i)
{
if(a[i] != i)
ret++;
}
if(ret != 0)
{
printf("errors: %d\n", ret);
return 1;
}
hc::am_free(a_d);
free(a);
return 0;
}
int main(int argc, char* argv[]) {
const char *nullkernel_hsaco = NULL;
int dispatch_count = DISPATCH_COUNT;
if(argc > 1)
dispatch_count = std::stoi(argv[1]);
if(argc > 2) {
nullkernel_hsaco = argv[2];
}
std::chrono::time_point<std::chrono::high_resolution_clock> start, end;
std::vector<std::chrono::duration<double>> elapsed_pfe;
std::vector<std::chrono::duration<double>> elapsed_grid_launch;
std::vector<std::chrono::duration<double>> elapsed_exception;
std::chrono::duration<double> tol_hi(TOL_HI);
std::vector<std::chrono::duration<double>> outliers_pfe;
std::vector<std::chrono::duration<double>> outliers_gl;
std::vector<std::chrono::duration<double>> outliers_gl_ex;
hc::accelerator acc = hc::accelerator();
// Set up extra stuff
static hc::accelerator_view av = acc.get_default_view();
grid_launch_parm lp;
grid_launch_init(&lp);
lp.grid_dim = gl_dim3(GRID_SIZE);
lp.group_dim = gl_dim3(TILE_SIZE);
lp.av = &av;
std::cout << "Iterations per test: " << dispatch_count << "\n";
// launch empty kernel to initialize everything first
// timing for null kernel launch appears later
hc::parallel_for_each(av, hc::extent<3>(lp.grid_dim.x*lp.group_dim.x,1,1).tile(lp.group_dim.x,1,1),
[=](hc::index<3>& idx) __HC__ {
}).wait();
int main()
{
int size = 1000;
int* a = (int*)malloc(sizeof(int)*size);
auto acc = hc::accelerator();
int* a_d = (int*)hc::am_alloc(size*sizeof(int), acc, 0);
grid_launch_parm lp;
grid_launch_init(&lp);
lp.groupDim = gl_dim3(size);
hc::completion_future cf;
lp.cf = &cf;
foo(lp, a_d);
lp.cf->wait();
hc::am_copy(a, a_d, size*sizeof(int));
int ret = 0;
for(int i = 0; i < size; ++i)
{
if(a[i] != i)
{
ret = 1;
if(i < 64)
printf("%d %d\n", a[i], i);
break;
}
}
hc::am_free(a_d);
free(a);
return ret;
}
