measurement_operator_mpi.cc File Reference

#include <chrono>
#include <sstream>
#include <benchmark/benchmark.h>
#include "benchmarks/utilities.h"
#include "purify/directories.h"
#include "purify/operators.h"
#include <sopt/imaging_padmm.h>
#include <sopt/mpi/communicator.h>
#include <sopt/mpi/session.h>
#include <sopt/wavelets.h>

Include dependency graph for measurement_operator_mpi.cc:

Go to the source code of this file.

Classes
class	DegridOperatorCtorFixturePar
class	DegridOperatorFixturePar
class	DegridOperatorDirectFixturePar
class	DegridOperatorAdjointFixturePar
class	DegridOperatorDirectFixtureDistr
class	DegridOperatorDirectFixtureMPI
class	DegridOperatorAdjointFixtureDistr
class	DegridOperatorAdjointFixtureMPI

Functions
	BENCHMARK_DEFINE_F (DegridOperatorCtorFixturePar, Distr)(benchmark
	BENCHMARK_DEFINE_F (DegridOperatorCtorFixturePar, MPI)(benchmark
	BENCHMARK_DEFINE_F (DegridOperatorDirectFixtureDistr, Apply)(benchmark
	BENCHMARK_DEFINE_F (DegridOperatorAdjointFixtureDistr, Apply)(benchmark
	BENCHMARK_DEFINE_F (DegridOperatorDirectFixtureMPI, Apply)(benchmark
	BENCHMARK_DEFINE_F (DegridOperatorAdjointFixtureMPI, Apply)(benchmark
	Args ({1024, static_cast< t_int >(1e6), 4}) -> Args({1024, static_cast< t_int >(1e7), 4}) ->UseManualTime() ->MinTime(10.0) ->MinWarmUpTime(5.0) ->Repetitions(3) ->Unit(benchmark::kMillisecond)

Function Documentation

Args()

Args

(

{1024, static_cast< t_int >(1e6), 4}

)

-> Args({1024, static_cast< t_int >(1e7), 4}) ->UseManualTime() ->MinTime(10.0) ->MinWarmUpTime(5.0) ->Repetitions(3) ->Unit(benchmark::kMillisecond)

BENCHMARK_DEFINE_F() [1/6]

BENCHMARK_DEFINE_F	(	DegridOperatorAdjointFixtureDistr	,
		Apply
	)

Definition at line 201 of file measurement_operator_mpi.cc.

                                                                                    {
  // Benchmark the application of the adjoint distributed operator
  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, m_world));
  }
 
  state.SetBytesProcessed(int64_t(state.iterations()) * (state.range(1) + m_imsizey * m_imsizex) *
                          sizeof(t_complex));
}

References b_utilities::duration().

BENCHMARK_DEFINE_F() [2/6]

BENCHMARK_DEFINE_F	(	DegridOperatorAdjointFixtureMPI	,
		Apply
	)

Definition at line 227 of file measurement_operator_mpi.cc.

                                                                                  {
  // Benchmark the application of the adjoint distributed MPI operator
  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, m_world));
  }
 
  state.SetBytesProcessed(int64_t(state.iterations()) * (state.range(1) + m_imsizey * m_imsizex) *
                          sizeof(t_complex));
}

References b_utilities::duration().

BENCHMARK_DEFINE_F() [3/6]

BENCHMARK_DEFINE_F	(	DegridOperatorCtorFixturePar	,
		Distr
	)

Definition at line 48 of file measurement_operator_mpi.cc.

                                                                               {
  // benchmark the creation of the distributed measurement operator
  if ((m_counter % 10) == 1) {
    auto sky_measurements = measurementoperator::init_degrid_operator_2d<Vector<t_complex>>(
        m_world, m_uv_data, m_imsizey, m_imsizex, m_cellsize, m_cellsize, 2, kernels::kernel::kb,
        state.range(2), state.range(2), m_w_term);
  }
  while (state.KeepRunning()) {
    auto start = std::chrono::high_resolution_clock::now();
    auto sky_measurements = measurementoperator::init_degrid_operator_2d<Vector<t_complex>>(
        m_world, m_uv_data, m_imsizey, m_imsizex, m_cellsize, m_cellsize, 2, kernels::kernel::kb,
        state.range(2), state.range(2), m_w_term);
    auto end = std::chrono::high_resolution_clock::now();
    state.SetIterationTime(b_utilities::duration(start, end, m_world));
  }
 
  state.SetBytesProcessed(int64_t(state.iterations()) * (state.range(1) + m_imsizex * m_imsizey) *
                          sizeof(t_complex));
}

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

BENCHMARK_DEFINE_F() [4/6]

BENCHMARK_DEFINE_F	(	DegridOperatorCtorFixturePar	,
		MPI
	)

Definition at line 68 of file measurement_operator_mpi.cc.

                                                                             {
  // benchmark the creation of the distributed MPI measurement operator
  if ((m_counter % 10) == 1) {
    auto sky_measurements = measurementoperator::init_degrid_operator_2d_mpi<Vector<t_complex>>(
        m_world, m_uv_data, m_imsizey, m_imsizex, m_cellsize, m_cellsize, 2, kernels::kernel::kb,
        state.range(2), state.range(2), m_w_term);
  }
  while (state.KeepRunning()) {
    auto start = std::chrono::high_resolution_clock::now();
    auto sky_measurements = measurementoperator::init_degrid_operator_2d_mpi<Vector<t_complex>>(
        m_world, m_uv_data, m_imsizey, m_imsizex, m_cellsize, m_cellsize, 2, kernels::kernel::kb,
        state.range(2), state.range(2), m_w_term);
    auto end = std::chrono::high_resolution_clock::now();
    state.SetIterationTime(b_utilities::duration(start, end, m_world));
  }
 
  state.SetBytesProcessed(int64_t(state.iterations()) * (state.range(1) + m_imsizex * m_imsizey) *
                          sizeof(t_complex));
}

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

BENCHMARK_DEFINE_F() [5/6]

BENCHMARK_DEFINE_F	(	DegridOperatorDirectFixtureDistr	,
		Apply
	)

Definition at line 188 of file measurement_operator_mpi.cc.

                                                                                   {
  // Benchmark the application of the distributed operator
  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, m_world));
  }
 
  state.SetBytesProcessed(int64_t(state.iterations()) * (state.range(1) + m_imsizey * m_imsizex) *
                          sizeof(t_complex));
}

References b_utilities::duration().

BENCHMARK_DEFINE_F() [6/6]

BENCHMARK_DEFINE_F	(	DegridOperatorDirectFixtureMPI	,
		Apply
	)

Definition at line 214 of file measurement_operator_mpi.cc.

                                                                                 {
  // Benchmark the application of the distributed MPI operator
  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, m_world));
  }
 
  state.SetBytesProcessed(int64_t(state.iterations()) * (state.range(1) + m_imsizey * m_imsizex) *
                          sizeof(t_complex));
}

References b_utilities::duration().