int main(int argc, char** argv)
{
// create some random vectors and storage on the stack
int N = 1 << 23; // about 8 million
int* v = (int*) malloc(N*sizeof(int));
int* w = (int*) malloc(N*sizeof(int));
int* out_serial = (int*) malloc(N*sizeof(int));
int* out_parallel = (int*) malloc(N*sizeof(int));
// seed the random number generator
srand(0);
for (int i=0; i<N; ++i)
{
v[i] = ((int)rand() % 11) - 10; // random numbers between -10 and 10
w[i] = ((int)rand() % 11) - 10;
}
double start, end;
double serial_time, parallel_time, chunked_time;
// time serial vecadd
start = omp_get_wtime();
vec_add_serial(out_serial, v, w, N);
end = omp_get_wtime();
serial_time = end - start;
printf("serial time: %f sec\n", serial_time);
// time parallel vecadd
start = omp_get_wtime();
vec_add_parallel(out_parallel, v, w, N);
end = omp_get_wtime();
parallel_time = end - start;
printf("parallel time: %f sec\n", parallel_time);
// time chunked vecadd (overwrite out_parallel to save space)
start = omp_get_wtime();
vec_add_chunked(out_parallel, v, w, N);
end = omp_get_wtime();
chunked_time = end - start;
printf("chunked time: %f sec\n", chunked_time);
printf("\nparallel speed up = %f\n", serial_time / parallel_time);
printf("chunked speed up = %f\n", serial_time / chunked_time);
// will throw a runtime error if the arrays are not equal.
// (a very harsh way to quit the program)
printf("\nTesting if vectors are equal...");
int are_equal = arrays_equal(out_serial, out_parallel, N);
if (are_equal)
printf("true.\n");
else
printf("false.\n");
free(v);
free(w);
free(out_serial);
free(out_parallel);
return 0;
}
int main(void)
{
int letter_counts1[SIZE] = {0};
int letter_counts2[SIZE] = {0};
printf("Enter the first word: ");
read_word(letter_counts1);
printf("Enter the second word: ");
read_word(letter_counts2);
if (arrays_equal(letter_counts1, letter_counts2))
printf("The words are anagrams\n");
else
printf("The words are not anagrams\n");
return 0;
}
TEST_F(ClassifyTest, FlatSurfaceTest)
{
const int dimLen = 128;
const int sliceSize = dimLen * dimLen;
const int gridSize = dimLen * dimLen * dimLen;
const int gridDataSliceSize = (dimLen + 1) * (dimLen + 1);
const int gridDataSize = (dimLen + 1) * (dimLen + 1) * (dimLen + 1);
uint3 gridDim{dimLen};
float3 voxelSize{1.0f};
float3 startPos{0.0f};
cl::CommandQueue queue = ctx->getQueues()[0];
Grid grid{gridDim, voxelSize, startPos, ctx->getClContext(), queue, ctx->getMemsetKernel()};
float4 *values = grid.getValues();
//Set first slice to all -1's
for(int i=0; i<gridDataSliceSize; i++) {
values[i] = {-1.0f};
}
for(int i=gridDataSliceSize; i<gridDataSize; i++) {
values[i] = {1.0f};
}
grid.copyToDevice();
size_t bufferSize = sizeof(uint) * gridSize;
cl::Buffer voxelVerts(
ctx->getClContext(),
CL_MEM_READ_WRITE,
bufferSize
);
cl::Buffer voxelOccupied(
ctx->getClContext(),
CL_MEM_READ_WRITE,
bufferSize
);
ctx->getMcProgram()->launchClassifyVoxel(grid, voxelVerts, voxelOccupied, 0.0f);
std::unique_ptr<uint[]> voxelVertsResult{new uint[gridSize]};
std::unique_ptr<uint[]> voxelOccupiedResult{new uint[gridSize]};
queue.enqueueReadBuffer(voxelVerts, CL_TRUE, 0, bufferSize, voxelVertsResult.get());
queue.enqueueReadBuffer(voxelOccupied, CL_TRUE, 0, bufferSize, voxelOccupiedResult.get());
std::unique_ptr<uint[]> voxelVertsRef{new uint[gridSize]};
std::unique_ptr<uint[]> voxelOccupiedRef{new uint[gridSize]};
for(int i=0; i<sliceSize; i++) {
voxelVertsRef[i] = 6;
voxelOccupiedRef[i] = 1;
}
for(int i=sliceSize; i<gridSize; i++) {
voxelVertsRef[i] = 0;
voxelOccupiedRef[i] = 0;
}
bool voxelVertsTestResult = arrays_equal(voxelVertsResult.get(), voxelVertsRef.get(), gridSize);
bool voxelOccupiedTestResult = arrays_equal(voxelOccupiedResult.get(), voxelOccupiedRef.get(), gridSize);
EXPECT_TRUE(voxelVertsTestResult && voxelOccupiedTestResult);
}
