int benchmark(int num_stations, int num_sources, int type,
int jones_type, int loc, int use_extended, int use_time_ave, int niter,
std::vector<double>& times)
{
int status = 0;
oskar_Timer* timer;
timer = oskar_timer_create(loc == OSKAR_GPU ?
OSKAR_TIMER_CUDA : OSKAR_TIMER_OMP);
// Set up a test sky model, telescope model and Jones matrices.
oskar_Telescope* tel = oskar_telescope_create(type, loc,
num_stations, &status);
oskar_Sky* sky = oskar_sky_create(type, loc, num_sources, &status);
oskar_Jones* J = oskar_jones_create(jones_type, loc, num_stations,
num_sources, &status);
oskar_telescope_set_channel_bandwidth(tel, 1e6);
oskar_telescope_set_time_average(tel, (double) use_time_ave);
oskar_sky_set_use_extended(sky, use_extended);
// Memory for visibility coordinates and output visibility slice.
oskar_Mem *vis, *u, *v, *w;
vis = oskar_mem_create(jones_type, loc, oskar_telescope_num_baselines(tel),
&status);
u = oskar_mem_create(type, loc, num_stations, &status);
v = oskar_mem_create(type, loc, num_stations, &status);
w = oskar_mem_create(type, loc, num_stations, &status);
// Run benchmark.
times.resize(niter);
for (int i = 0; i < niter; ++i)
{
oskar_timer_start(timer);
oskar_cross_correlate(vis, oskar_sky_num_sources(sky), J, sky, tel, u, v, w,
0.0, 100e6, &status);
times[i] = oskar_timer_elapsed(timer);
}
// Free memory.
oskar_mem_free(u, &status);
oskar_mem_free(v, &status);
oskar_mem_free(w, &status);
oskar_mem_free(vis, &status);
oskar_jones_free(J, &status);
oskar_telescope_free(tel, &status);
oskar_sky_free(sky, &status);
oskar_timer_free(timer);
return status;
}
void createTestData(int precision, int location, int matrix)
{
int status = 0, type;
// Allocate memory for data structures.
type = precision | OSKAR_COMPLEX;
if (matrix) type |= OSKAR_MATRIX;
jones = oskar_jones_create(type, location, num_stations, num_sources,
&status);
u_ = oskar_mem_create(precision, location, num_stations, &status);
v_ = oskar_mem_create(precision, location, num_stations, &status);
w_ = oskar_mem_create(precision, location, num_stations, &status);
sky = oskar_sky_create(precision, location, num_sources, &status);
tel = oskar_telescope_create(precision, location,
num_stations, &status);
ASSERT_EQ(0, status) << oskar_get_error_string(status);
// Fill data structures with random data in sensible ranges.
srand(2);
oskar_mem_random_range(oskar_jones_mem(jones), 1.0, 5.0, &status);
oskar_mem_random_range(u_, 1.0, 5.0, &status);
oskar_mem_random_range(v_, 1.0, 5.0, &status);
oskar_mem_random_range(w_, 1.0, 5.0, &status);
oskar_mem_random_range(
oskar_telescope_station_true_x_offset_ecef_metres(tel),
0.1, 1000.0, &status);
oskar_mem_random_range(
oskar_telescope_station_true_y_offset_ecef_metres(tel),
0.1, 1000.0, &status);
oskar_mem_random_range(
oskar_telescope_station_true_z_offset_ecef_metres(tel),
0.1, 1000.0, &status);
oskar_mem_random_range(oskar_sky_I(sky), 1.0, 2.0, &status);
oskar_mem_random_range(oskar_sky_Q(sky), 0.1, 1.0, &status);
oskar_mem_random_range(oskar_sky_U(sky), 0.1, 0.5, &status);
oskar_mem_random_range(oskar_sky_V(sky), 0.1, 0.2, &status);
oskar_mem_random_range(oskar_sky_l(sky), 0.1, 0.9, &status);
oskar_mem_random_range(oskar_sky_m(sky), 0.1, 0.9, &status);
oskar_mem_random_range(oskar_sky_n(sky), 0.1, 0.9, &status);
oskar_mem_random_range(oskar_sky_gaussian_a(sky), 0.1e-6, 0.2e-6,
&status);
oskar_mem_random_range(oskar_sky_gaussian_b(sky), 0.1e-6, 0.2e-6,
&status);
oskar_mem_random_range(oskar_sky_gaussian_c(sky), 0.1e-6, 0.2e-6,
&status);
ASSERT_EQ(0, status) << oskar_get_error_string(status);
}
static void set_up_device_data(oskar_Simulator* h, int* status)
{
int i, dev_loc, complx, vistype, num_stations, num_src;
if (*status) return;
/* Get local variables. */
num_stations = oskar_telescope_num_stations(h->tel);
num_src = h->max_sources_per_chunk;
complx = (h->prec) | OSKAR_COMPLEX;
vistype = complx;
if (oskar_telescope_pol_mode(h->tel) == OSKAR_POL_MODE_FULL)
vistype |= OSKAR_MATRIX;
/* Expand the number of devices to the number of selected GPUs,
* if required. */
if (h->num_devices < h->num_gpus)
oskar_simulator_set_num_devices(h, h->num_gpus);
for (i = 0; i < h->num_devices; ++i)
{
DeviceData* d = &h->d[i];
d->previous_chunk_index = -1;
/* Select the device. */
if (i < h->num_gpus)
{
oskar_device_set(h->gpu_ids[i], status);
dev_loc = OSKAR_GPU;
}
else
{
dev_loc = OSKAR_CPU;
}
/* Timers. */
if (!d->tmr_compute)
{
d->tmr_compute = oskar_timer_create(OSKAR_TIMER_NATIVE);
d->tmr_copy = oskar_timer_create(OSKAR_TIMER_NATIVE);
d->tmr_clip = oskar_timer_create(OSKAR_TIMER_NATIVE);
d->tmr_E = oskar_timer_create(OSKAR_TIMER_NATIVE);
d->tmr_K = oskar_timer_create(OSKAR_TIMER_NATIVE);
d->tmr_join = oskar_timer_create(OSKAR_TIMER_NATIVE);
d->tmr_correlate = oskar_timer_create(OSKAR_TIMER_NATIVE);
}
/* Visibility blocks. */
if (!d->vis_block)
{
d->vis_block = oskar_vis_block_create_from_header(dev_loc,
h->header, status);
d->vis_block_cpu[0] = oskar_vis_block_create_from_header(OSKAR_CPU,
h->header, status);
d->vis_block_cpu[1] = oskar_vis_block_create_from_header(OSKAR_CPU,
h->header, status);
}
oskar_vis_block_clear(d->vis_block, status);
oskar_vis_block_clear(d->vis_block_cpu[0], status);
oskar_vis_block_clear(d->vis_block_cpu[1], status);
/* Device scratch memory. */
if (!d->tel)
{
d->u = oskar_mem_create(h->prec, dev_loc, num_stations, status);
d->v = oskar_mem_create(h->prec, dev_loc, num_stations, status);
d->w = oskar_mem_create(h->prec, dev_loc, num_stations, status);
d->chunk = oskar_sky_create(h->prec, dev_loc, num_src, status);
d->chunk_clip = oskar_sky_create(h->prec, dev_loc, num_src, status);
d->tel = oskar_telescope_create_copy(h->tel, dev_loc, status);
d->J = oskar_jones_create(vistype, dev_loc, num_stations, num_src,
status);
d->R = oskar_type_is_matrix(vistype) ? oskar_jones_create(vistype,
dev_loc, num_stations, num_src, status) : 0;
d->E = oskar_jones_create(vistype, dev_loc, num_stations, num_src,
status);
d->K = oskar_jones_create(complx, dev_loc, num_stations, num_src,
status);
d->Z = 0;
d->station_work = oskar_station_work_create(h->prec, dev_loc,
status);
}
}
}
