TEST(Mem, random_gaussian_accum)
{
int status = 0;
int seed = 1;
int blocksize = 256;
int rounds = 10240;
oskar_Mem* block = oskar_mem_create(OSKAR_DOUBLE, OSKAR_GPU,
blocksize, &status);
oskar_Mem* total = oskar_mem_create(OSKAR_DOUBLE, OSKAR_GPU,
blocksize * rounds, &status);
for (int i = 0; i < rounds; ++i)
{
oskar_mem_random_gaussian(block, seed, i, 0, 0, 1.0, &status);
oskar_mem_copy_contents(total, block,
i * blocksize, 0, blocksize, &status);
}
ASSERT_EQ(0, status) << oskar_get_error_string(status);
if (save)
{
FILE* fhan = fopen("random_gaussian_accum.txt", "w");
oskar_mem_save_ascii(fhan, 1, blocksize * rounds, &status, total);
fclose(fhan);
}
oskar_mem_free(block, &status);
oskar_mem_free(total, &status);
}
int main(int argc, char** argv)
{
int status = 0;
oskar::OptionParser opt("oskar_convert_geodetic_to_ecef",
oskar_version_string());
opt.set_description("Converts geodetic longitude/latitude/altitude to "
"Cartesian ECEF coordinates. Assumes WGS84 ellipsoid.");
opt.add_required("input file", "Path to file containing input coordinates. "
"Angles must be in degrees.");
if (!opt.check_options(argc, argv))
return OSKAR_FAIL;
const char* filename = opt.get_arg();
// Load the input file.
oskar_Mem *lon = oskar_mem_create(OSKAR_DOUBLE, OSKAR_CPU, 0, &status);
oskar_Mem *lat = oskar_mem_create(OSKAR_DOUBLE, OSKAR_CPU, 0, &status);
oskar_Mem *alt = oskar_mem_create(OSKAR_DOUBLE, OSKAR_CPU, 0, &status);
size_t num_points = oskar_mem_load_ascii(filename, 3, &status,
lon, "", lat, "", alt, "0.0");
oskar_mem_scale_real(lon, M_PI / 180.0, &status);
oskar_mem_scale_real(lat, M_PI / 180.0, &status);
// Convert coordinates.
oskar_Mem *x = oskar_mem_create(OSKAR_DOUBLE, OSKAR_CPU,
num_points, &status);
oskar_Mem *y = oskar_mem_create(OSKAR_DOUBLE, OSKAR_CPU,
num_points, &status);
oskar_Mem *z = oskar_mem_create(OSKAR_DOUBLE, OSKAR_CPU,
num_points, &status);
oskar_convert_geodetic_spherical_to_ecef(num_points,
oskar_mem_double_const(lon, &status),
oskar_mem_double_const(lat, &status),
oskar_mem_double_const(alt, &status),
oskar_mem_double(x, &status),
oskar_mem_double(y, &status),
oskar_mem_double(z, &status));
// Print converted coordinates.
oskar_mem_save_ascii(stdout, 3, num_points, &status, x, y, z);
// Clean up.
oskar_mem_free(lon, &status);
oskar_mem_free(lat, &status);
oskar_mem_free(alt, &status);
oskar_mem_free(x, &status);
oskar_mem_free(y, &status);
oskar_mem_free(z, &status);
if (status)
{
oskar_log_error(0, oskar_get_error_string(status));
return status;
}
return 0;
}
TEST(element_weights_errors, test_evaluate)
{
int num_elements = 10000;
double element_gain = 1.0;
double element_gain_error = 0.0;
double element_phase = 0.0 * M_PI;
double element_phase_error = 0.0 * M_PI;
int error = 0;
unsigned int seed = 1;
oskar_Mem *d_gain, *d_gain_error, *d_phase, *d_phase_error, *d_errors;
d_gain = oskar_mem_create(OSKAR_DOUBLE, OSKAR_GPU,
num_elements, &error);
d_gain_error = oskar_mem_create(OSKAR_DOUBLE, OSKAR_GPU,
num_elements, &error);
d_phase = oskar_mem_create(OSKAR_DOUBLE, OSKAR_GPU,
num_elements, &error);
d_phase_error = oskar_mem_create(OSKAR_DOUBLE, OSKAR_GPU,
num_elements, &error);
d_errors = oskar_mem_create(OSKAR_DOUBLE_COMPLEX, OSKAR_GPU,
num_elements, &error);
ASSERT_EQ(0, error) << oskar_get_error_string(error);
oskar_mem_set_value_real(d_gain, element_gain, 0, 0, &error);
oskar_mem_set_value_real(d_gain_error, element_gain_error, 0, 0, &error);
oskar_mem_set_value_real(d_phase, element_phase, 0, 0, &error);
oskar_mem_set_value_real(d_phase_error, element_phase_error, 0, 0, &error);
oskar_mem_set_value_real(d_errors, 0.0, 0, 0, &error);
ASSERT_EQ(0, error) << oskar_get_error_string(error);
// Evaluate weights errors.
oskar_evaluate_element_weights_errors(num_elements,
d_gain, d_gain_error, d_phase, d_phase_error,
seed, 0, 0, d_errors, &error);
ASSERT_EQ(0, error) << oskar_get_error_string(error);
// Write memory to file for inspection.
const char* fname = "temp_test_element_errors.dat";
FILE* file = fopen(fname, "w");
oskar_mem_save_ascii(file, 5, num_elements, &error,
d_gain, d_gain_error, d_phase, d_phase_error, d_errors);
fclose(file);
remove(fname);
// Free memory.
oskar_mem_free(d_gain, &error);
oskar_mem_free(d_gain_error, &error);
oskar_mem_free(d_phase, &error);
oskar_mem_free(d_phase_error, &error);
oskar_mem_free(d_errors, &error);
ASSERT_EQ(0, error) << oskar_get_error_string(error);
}
TEST(Mem, random_uniform)
{
int seed = 1;
int c1 = 437;
int c2 = 0;
int c3 = 0xDECAFBAD;
int n = 544357;
int status = 0;
double max_err = 0.0, avg_err = 0.0;
oskar_Mem* v_cpu_f = oskar_mem_create(OSKAR_SINGLE, OSKAR_CPU, n, &status);
oskar_Mem* v_gpu_f = oskar_mem_create(OSKAR_SINGLE, OSKAR_GPU, n, &status);
oskar_Mem* v_cpu_d = oskar_mem_create(OSKAR_DOUBLE, OSKAR_CPU, n, &status);
oskar_Mem* v_gpu_d = oskar_mem_create(OSKAR_DOUBLE, OSKAR_GPU, n, &status);
oskar_Timer* tmr = oskar_timer_create(OSKAR_TIMER_CUDA);
// Run in single precision.
oskar_timer_start(tmr);
oskar_mem_random_uniform(v_cpu_f, seed, c1, c2, c3, &status);
report_time(n, "uniform", "single", "CPU", oskar_timer_elapsed(tmr));
ASSERT_EQ(0, status) << oskar_get_error_string(status);
oskar_timer_start(tmr);
oskar_mem_random_uniform(v_gpu_f, seed, c1, c2, c3, &status);
report_time(n, "uniform", "single", "GPU", oskar_timer_elapsed(tmr));
ASSERT_EQ(0, status) << oskar_get_error_string(status);
// Check consistency between CPU and GPU results.
oskar_mem_evaluate_relative_error(v_gpu_f, v_cpu_f, 0,
&max_err, &avg_err, 0, &status);
EXPECT_LT(max_err, 1e-5);
EXPECT_LT(avg_err, 1e-5);
// Run in double precision.
oskar_timer_start(tmr);
oskar_mem_random_uniform(v_cpu_d, seed, c1, c2, c3, &status);
report_time(n, "uniform", "double", "CPU", oskar_timer_elapsed(tmr));
ASSERT_EQ(0, status) << oskar_get_error_string(status);
oskar_timer_start(tmr);
oskar_mem_random_uniform(v_gpu_d, seed, c1, c2, c3, &status);
report_time(n, "uniform", "double", "GPU", oskar_timer_elapsed(tmr));
ASSERT_EQ(0, status) << oskar_get_error_string(status);
// Check consistency between CPU and GPU results.
oskar_mem_evaluate_relative_error(v_gpu_d, v_cpu_d, 0,
&max_err, &avg_err, 0, &status);
EXPECT_LT(max_err, 1e-10);
EXPECT_LT(avg_err, 1e-10);
// Check consistency between single and double precision.
oskar_mem_evaluate_relative_error(v_cpu_f, v_cpu_d, 0,
&max_err, &avg_err, 0, &status);
EXPECT_LT(max_err, 1e-5);
EXPECT_LT(avg_err, 1e-5);
if (save)
{
FILE* fhan = fopen("random_uniform.txt", "w");
oskar_mem_save_ascii(fhan, 4, n, &status,
v_cpu_f, v_gpu_f, v_cpu_d, v_gpu_d);
fclose(fhan);
}
// Free memory.
oskar_mem_free(v_cpu_f, &status);
oskar_mem_free(v_gpu_f, &status);
oskar_mem_free(v_cpu_d, &status);
oskar_mem_free(v_gpu_d, &status);
oskar_timer_free(tmr);
}
TEST(prefix_sum, test)
{
int n = 100000, status = 0, exclusive = 1;
oskar_Mem* in_cpu = oskar_mem_create(OSKAR_INT, OSKAR_CPU, n, &status);
oskar_Mem* out_cpu = oskar_mem_create(OSKAR_INT, OSKAR_CPU, n, &status);
oskar_Timer* tmr = oskar_timer_create(OSKAR_TIMER_NATIVE);
// Fill input with random integers from 0 to 9.
int* t = oskar_mem_int(in_cpu, &status);
srand(1556);
for (int i = 0; i < n; ++i)
t[i] = (int) (10.0 * rand() / ((double) RAND_MAX));
t[0] = 3;
// Run on CPU.
oskar_timer_start(tmr);
oskar_prefix_sum(n, in_cpu, out_cpu, 0, exclusive, &status);
EXPECT_EQ(0, status);
printf("Prefix sum on CPU took %.3f sec\n", oskar_timer_elapsed(tmr));
#ifdef OSKAR_HAVE_CUDA
// Run on GPU with CUDA.
oskar_Mem* in_gpu = oskar_mem_create_copy(in_cpu, OSKAR_GPU, &status);
oskar_Mem* out_gpu = oskar_mem_create(OSKAR_INT, OSKAR_GPU, n, &status);
oskar_timer_start(tmr);
oskar_prefix_sum(n, in_gpu, out_gpu, 0, exclusive, &status);
EXPECT_EQ(0, status);
printf("Prefix sum on GPU took %.3f sec\n", oskar_timer_elapsed(tmr));
// Check consistency between CPU and GPU results.
oskar_Mem* out_cmp_gpu = oskar_mem_create_copy(out_gpu, OSKAR_CPU, &status);
EXPECT_EQ(0, oskar_mem_different(out_cpu, out_cmp_gpu, n, &status));
#endif
#ifdef OSKAR_HAVE_OPENCL
// Run on OpenCL.
oskar_Mem* in_cl = oskar_mem_create_copy(in_cpu, OSKAR_CL, &status);
oskar_Mem* out_cl = oskar_mem_create(OSKAR_INT, OSKAR_CL, n, &status);
oskar_timer_start(tmr);
printf("Using %s\n", oskar_cl_device_name());
oskar_prefix_sum(n, in_cl, out_cl, 0, exclusive, &status);
EXPECT_EQ(0, status);
printf("Prefix sum on OpenCL took %.3f sec\n", oskar_timer_elapsed(tmr));
// Check consistency between CPU and OpenCL results.
oskar_Mem* out_cmp_cl = oskar_mem_create_copy(out_cl, OSKAR_CPU, &status);
EXPECT_EQ(0, oskar_mem_different(out_cpu, out_cmp_cl, n, &status));
#endif
if (save)
{
size_t num_mem = 1;
FILE* fhan = fopen("prefix_sum_test.txt", "w");
#ifdef OSKAR_HAVE_CUDA
num_mem += 1;
#endif
#ifdef OSKAR_HAVE_OPENCL
num_mem += 1;
#endif
oskar_mem_save_ascii(fhan, num_mem, n, &status, out_cpu
#ifdef OSKAR_HAVE_CUDA
, out_cmp_gpu
#endif
#ifdef OSKAR_HAVE_OPENCL
, out_cmp_cl
#endif
);
fclose(fhan);
}
// Clean up.
oskar_timer_free(tmr);
oskar_mem_free(in_cpu, &status);
oskar_mem_free(out_cpu, &status);
#ifdef OSKAR_HAVE_CUDA
oskar_mem_free(in_gpu, &status);
oskar_mem_free(out_gpu, &status);
oskar_mem_free(out_cmp_gpu, &status);
#endif
#ifdef OSKAR_HAVE_OPENCL
oskar_mem_free(in_cl, &status);
oskar_mem_free(out_cl, &status);
oskar_mem_free(out_cmp_cl, &status);
#endif
}
TEST(element_weights_errors, test_apply)
{
int num_elements = 10000;
int status = 0;
double gain = 1.5;
double gain_error = 0.2;
double phase = 0.1 * M_PI;
double phase_error = (5 / 180.0) * M_PI;
double weight_gain = 1.0;
double weight_phase = 0.5 * M_PI;
double2 weight;
weight.x = weight_gain * cos(weight_phase);
weight.y = weight_gain * sin(weight_phase);
oskar_Mem *d_gain, *d_gain_error, *d_phase, *d_phase_error, *d_errors;
oskar_Mem *h_weights, *d_weights;
d_errors = oskar_mem_create(OSKAR_DOUBLE_COMPLEX, OSKAR_GPU,
num_elements, &status);
d_gain = oskar_mem_create(OSKAR_DOUBLE, OSKAR_GPU,
num_elements, &status);
d_gain_error = oskar_mem_create(OSKAR_DOUBLE, OSKAR_GPU,
num_elements, &status);
d_phase = oskar_mem_create(OSKAR_DOUBLE, OSKAR_GPU,
num_elements, &status);
d_phase_error = oskar_mem_create(OSKAR_DOUBLE, OSKAR_GPU,
num_elements, &status);
h_weights = oskar_mem_create(OSKAR_DOUBLE_COMPLEX, OSKAR_CPU,
num_elements, &status);
ASSERT_EQ(0, status) << oskar_get_error_string(status);
oskar_mem_set_value_real(d_gain, gain, 0, 0, &status);
oskar_mem_set_value_real(d_gain_error, gain_error, 0, 0, &status);
oskar_mem_set_value_real(d_phase, phase, 0, 0, &status);
oskar_mem_set_value_real(d_phase_error, phase_error, 0, 0, &status);
ASSERT_EQ(0, status) << oskar_get_error_string(status);
double2* h_weights_ = oskar_mem_double2(h_weights, &status);
for (int i = 0; i < num_elements; ++i)
{
h_weights_[i].x = weight.x;
h_weights_[i].y = weight.y;
}
d_weights = oskar_mem_create_copy(h_weights, OSKAR_GPU, &status);
oskar_evaluate_element_weights_errors(num_elements,
d_gain, d_gain_error, d_phase, d_phase_error,
0, 0, 0, d_errors, &status);
ASSERT_EQ(0, status) << oskar_get_error_string(status);
oskar_mem_element_multiply(NULL, d_weights, d_errors, num_elements, &status);
ASSERT_EQ(0, status) << oskar_get_error_string(status);
// Write memory to file for inspection.
const char* fname = "temp_test_weights.dat";
FILE* file = fopen(fname, "w");
oskar_mem_save_ascii(file, 7, num_elements, &status,
d_gain, d_gain_error, d_phase, d_phase_error, d_errors,
h_weights, d_weights);
fclose(file);
remove(fname);
// Free memory.
oskar_mem_free(d_gain, &status);
oskar_mem_free(d_gain_error, &status);
oskar_mem_free(d_phase, &status);
oskar_mem_free(d_phase_error, &status);
oskar_mem_free(d_errors, &status);
oskar_mem_free(h_weights, &status);
oskar_mem_free(d_weights, &status);
ASSERT_EQ(0, status) << oskar_get_error_string(status);
}