measurement_operator_af.cc File Reference

#include <chrono>
#include <benchmark/benchmark.h>
#include "benchmarks/utilities.h"
#include "purify/operators_gpu.h"

Include dependency graph for measurement_operator_af.cc:

Go to the source code of this file.

Classes
class	DegridOperatorFixture
class	DegridOperatorDirectFixture
class	DegridOperatorAdjointFixture

Functions
void	degrid_operator_ctor (benchmark::State &state)
	BENCHMARK_DEFINE_F (DegridOperatorDirectFixture, Apply)(benchmark
	BENCHMARK_DEFINE_F (DegridOperatorAdjointFixture, Apply)(benchmark
	Args ({256, 500000, 4}) -> Args({512, 500000, 4}) ->Args({1024, 500000, 4}) ->Args({2048, 500000, 4}) ->UseManualTime() ->Repetitions(10) ->ReportAggregatesOnly(true) ->Unit(benchmark::kMillisecond)
	BENCHMARK_MAIN ()

Function Documentation

Args()

Args

(

{256, 500000, 4}

)

-> Args({512, 500000, 4}) ->Args({1024, 500000, 4}) ->Args({2048, 500000, 4}) ->UseManualTime() ->Repetitions(10) ->ReportAggregatesOnly(true) ->Unit(benchmark::kMillisecond)

BENCHMARK_DEFINE_F() [1/2]

BENCHMARK_DEFINE_F	(	DegridOperatorAdjointFixture	,
		Apply
	)

Definition at line 135 of file measurement_operator_af.cc.

                                                                               {
  // Benchmark the application of the adjoint operator
  if ((m_counter % 10) == 1) {
    m_image = m_degridOperator->adjoint() * m_uv_data.vis;
  }
  while (state.KeepRunning()) {
    auto start = std::chrono::high_resolution_clock::now();
    m_image = m_degridOperator->adjoint() * m_uv_data.vis;
    auto end = std::chrono::high_resolution_clock::now();
    state.SetIterationTime(b_utilities::duration(start, end));
  }
 
  state.SetBytesProcessed(int64_t(state.iterations()) * (state.range(1) + m_imsizey * m_imsizex) *
                          sizeof(t_complex));
}

References b_utilities::duration().

BENCHMARK_DEFINE_F() [2/2]

BENCHMARK_DEFINE_F	(	DegridOperatorDirectFixture	,
		Apply
	)

Definition at line 119 of file measurement_operator_af.cc.

                                                                              {
  // Benchmark the application of the operator
  if ((m_counter % 10) == 1) {
    m_uv_data.vis = (*m_degridOperator) * Image<t_complex>::Map(m_image.data(), m_image.size(), 1);
  }
  while (state.KeepRunning()) {
    auto start = std::chrono::high_resolution_clock::now();
    m_uv_data.vis = (*m_degridOperator) * Image<t_complex>::Map(m_image.data(), m_image.size(), 1);
    auto end = std::chrono::high_resolution_clock::now();
    state.SetIterationTime(b_utilities::duration(start, end));
  }
 
  state.SetBytesProcessed(int64_t(state.iterations()) * (state.range(1) + m_imsizey * m_imsizex) *
                          sizeof(t_complex));
}

References b_utilities::duration().

BENCHMARK_MAIN()

BENCHMARK_MAIN

(

)

degrid_operator_ctor()

void degrid_operator_ctor

(

benchmark::State &

state

)

Definition at line 10 of file measurement_operator_af.cc.

                                                 {
  // Generating random uv(w) coverage
  t_int const rows = state.range(0);
  t_int const cols = state.range(0);
  t_int const number_of_vis = state.range(1);
  auto uv_data = b_utilities::random_measurements(number_of_vis);
 
  const t_real FoV = 1;  // deg
  const t_real cellsize = FoV / cols * 60. * 60.;
  const bool w_term = false;
  // benchmark the creation of measurement operator
  while (state.KeepRunning()) {
    auto start = std::chrono::high_resolution_clock::now();
#ifdef PURIFY_CPU
    auto sky_measurements = measurementoperator::init_degrid_operator_2d<Vector<t_complex>>(
        uv_data, rows, cols, cellsize, cellsize, 2, kernels::kernel::kb, state.range(2),
        state.range(2), w_term);
#else
    auto sky_measurements = gpu::measurementoperator::init_degrid_operator_2d(
        uv_data, rows, cols, cellsize, cellsize, 2, kernels::kernel::kb, state.range(2),
        state.range(2), w_term);
 
#endif
    auto end = std::chrono::high_resolution_clock::now();
 
    state.SetIterationTime(b_utilities::duration(start, end));
  }
 
  state.SetBytesProcessed(int64_t(state.iterations()) * (number_of_vis + rows * cols) *
                          sizeof(t_complex));
}

References b_utilities::duration(), purify::measurementoperator::init_degrid_operator_2d(), purify::kernels::kb, and b_utilities::random_measurements().