algorithms_mpi.cc File Reference

#include "purify/types.h"
#include <array>
#include <random>
#include "benchmarks/utilities.h"
#include "purify/algorithm_factory.h"
#include "purify/convergence_factory.h"
#include "purify/directories.h"
#include "purify/distribute.h"
#include "purify/logging.h"
#include "purify/measurement_operator_factory.h"
#include "purify/mpi_utilities.h"
#include "purify/operators.h"
#include "purify/utilities.h"
#include "purify/wavelet_operator_factory.h"
#include <sopt/imaging_padmm.h>
#include <sopt/mpi/communicator.h>
#include <sopt/mpi/session.h>
#include <sopt/relative_variation.h>
#include <sopt/utilities.h>
#include <sopt/wavelets.h>
#include <sopt/wavelets/sara.h>

Include dependency graph for algorithms_mpi.cc:

Go to the source code of this file.

Classes
class	AlgoFixtureMPI

Functions
	BENCHMARK_DEFINE_F (AlgoFixtureMPI, PadmmDistributeImage)(benchmark
	BENCHMARK_DEFINE_F (AlgoFixtureMPI, PadmmDistributeGrid)(benchmark
	BENCHMARK_DEFINE_F (AlgoFixtureMPI, FbDistributeImage)(benchmark
	BENCHMARK_DEFINE_F (AlgoFixtureMPI, FbDistributeGrid)(benchmark
	Args ({128, 10000, 4, 10, 1}) -> Args({1024, static_cast< t_int >(1e6), 4, 10, 1}) ->Args({1024, static_cast< t_int >(1e7), 4, 10, 1}) ->Args({2048, static_cast< t_int >(1e6), 4, 10, 1}) ->Args({2048, static_cast< t_int >(1e7), 4, 10, 1}) ->Args({4096, static_cast< t_int >(1e6), 4, 10, 1}) ->Args({4096, static_cast< t_int >(1e7), 4, 10, 1}) ->UseManualTime() ->MinTime(60.0) ->MinWarmUpTime(10.0) ->Repetitions(3) ->Unit(benchmark::kMillisecond)
	Args ({128, 10000, 4, 10, 2}) -> Args({1024, static_cast< t_int >(1e6), 4, 10, 2}) ->Args({1024, static_cast< t_int >(1e7), 4, 10, 2}) ->Args({2048, static_cast< t_int >(1e6), 4, 10, 2}) ->Args({2048, static_cast< t_int >(1e7), 4, 10, 2}) ->Args({4096, static_cast< t_int >(1e6), 4, 10, 2}) ->Args({4096, static_cast< t_int >(1e7), 4, 10, 2}) ->UseManualTime() ->MinTime(60.0) ->MinWarmUpTime(10.0) ->Repetitions(3) ->Unit(benchmark::kMillisecond)

Function Documentation

Args() [1/2]

Args

(

{128, 10000, 4, 10, 1}

)

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

Args() [2/2]

Args

(

{128, 10000, 4, 10, 2}

)

-> Args({1024, static_cast< t_int >(1e6), 4, 10, 2}) ->Args({1024, static_cast< t_int >(1e7), 4, 10, 2}) ->Args({2048, static_cast< t_int >(1e6), 4, 10, 2}) ->Args({2048, static_cast< t_int >(1e7), 4, 10, 2}) ->Args({4096, static_cast< t_int >(1e6), 4, 10, 2}) ->Args({4096, static_cast< t_int >(1e7), 4, 10, 2}) ->UseManualTime() ->MinTime(60.0) ->MinWarmUpTime(10.0) ->Repetitions(3) ->Unit(benchmark::kMillisecond)

BENCHMARK_DEFINE_F() [1/4]

BENCHMARK_DEFINE_F	(	AlgoFixtureMPI	,
		FbDistributeGrid
	)

Definition at line 150 of file algorithms_mpi.cc.

                                                                            {
  // Create the algorithm - has to be done there to reset the internal state.
  // If done in the fixture repeats would start at the solution and converge immediately.
  auto const wavelets = factory::wavelet_operator_factory<Vector<t_complex>>(
      factory::distributed_wavelet_operator::mpi_sara, m_sara, m_imsizey, m_imsizex);
 
  t_real const beta = m_sigma * m_sigma;
  t_real const gamma = 0.0001;
 
  m_fb = factory::fb_factory<sopt::algorithm::ImagingForwardBackward<t_complex>>(
      factory::algo_distribution::mpi_serial, m_measurements_distribute_grid, wavelets, m_uv_data,
      m_sigma, beta, gamma, m_imsizey, m_imsizex, m_sara.size(), state.range(3), true, true, false,
      1e-3, 1e-2, 50);
 
  // Benchmark the application of the algorithm
  while (state.KeepRunning()) {
    auto start = std::chrono::high_resolution_clock::now();
    auto result = (*m_fb)();
    auto end = std::chrono::high_resolution_clock::now();
    std::cout << "Converged? " << result.good << " , niters = " << result.niters << std::endl;
    state.SetIterationTime(b_utilities::duration(start, end, m_world));
  }
}

References b_utilities::duration(), purify::factory::mpi_sara, and purify::factory::mpi_serial.

BENCHMARK_DEFINE_F() [2/4]

BENCHMARK_DEFINE_F	(	AlgoFixtureMPI	,
		FbDistributeImage
	)

Definition at line 126 of file algorithms_mpi.cc.

                                                                             {
  // Create the algorithm - has to be done there to reset the internal state.
  // If done in the fixture repeats would start at the solution and converge immediately.
  auto const wavelets = factory::wavelet_operator_factory<Vector<t_complex>>(
      factory::distributed_wavelet_operator::mpi_sara, m_sara, m_imsizey, m_imsizex);
 
  t_real const beta = m_sigma * m_sigma;
  t_real const gamma = 0.0001;
 
  m_fb = factory::fb_factory<sopt::algorithm::ImagingForwardBackward<t_complex>>(
      factory::algo_distribution::mpi_serial, m_measurements_distribute_image, wavelets, m_uv_data,
      m_sigma, beta, gamma, m_imsizey, m_imsizex, m_sara.size(), state.range(3), true, true, false,
      1e-3, 1e-2, 50);
 
  // Benchmark the application of the algorithm
  while (state.KeepRunning()) {
    auto start = std::chrono::high_resolution_clock::now();
    auto result = (*m_fb)();
    auto end = std::chrono::high_resolution_clock::now();
    std::cout << "Converged? " << result.good << " , niters = " << result.niters << std::endl;
    state.SetIterationTime(b_utilities::duration(start, end, m_world));
  }
}

References b_utilities::duration(), purify::factory::mpi_sara, and purify::factory::mpi_serial.

BENCHMARK_DEFINE_F() [3/4]

BENCHMARK_DEFINE_F	(	AlgoFixtureMPI	,
		PadmmDistributeGrid
	)

Definition at line 105 of file algorithms_mpi.cc.

                                                                               {
  // Create the algorithm - has to be done there to reset the internal state.
  // If done in the fixture repeats would start at the solution and converge immediately.
  auto const wavelets = factory::wavelet_operator_factory<Vector<t_complex>>(
      factory::distributed_wavelet_operator::mpi_sara, m_sara, m_imsizey, m_imsizex);
 
  m_padmm = factory::padmm_factory<sopt::algorithm::ImagingProximalADMM<t_complex>>(
      factory::algo_distribution::mpi_distributed, m_measurements_distribute_grid, wavelets,
      m_uv_data, m_sigma, m_imsizey, m_imsizex, m_sara.size(), state.range(3) + 1, true, true,
      false, 1e-3, 1e-2, 50);
 
  // Benchmark the application of the algorithm
  while (state.KeepRunning()) {
    auto start = std::chrono::high_resolution_clock::now();
    auto result = (*m_padmm)();
    auto end = std::chrono::high_resolution_clock::now();
    std::cout << "Converged? " << result.good << " , niters = " << result.niters << std::endl;
    state.SetIterationTime(b_utilities::duration(start, end, m_world));
  }
}

References b_utilities::duration(), purify::factory::mpi_distributed, and purify::factory::mpi_sara.

BENCHMARK_DEFINE_F() [4/4]

BENCHMARK_DEFINE_F	(	AlgoFixtureMPI	,
		PadmmDistributeImage
	)

Definition at line 84 of file algorithms_mpi.cc.

                                                                                {
  // Create the algorithm - has to be done there to reset the internal state.
  // If done in the fixture repeats would start at the solution and converge immediately.
  auto const wavelets = factory::wavelet_operator_factory<Vector<t_complex>>(
      factory::distributed_wavelet_operator::mpi_sara, m_sara, m_imsizey, m_imsizex);
 
  m_padmm = factory::padmm_factory<sopt::algorithm::ImagingProximalADMM<t_complex>>(
      factory::algo_distribution::mpi_distributed, m_measurements_distribute_image, wavelets,
      m_uv_data, m_sigma, m_imsizey, m_imsizex, m_sara.size(), state.range(3) + 1, true, true,
      false, 1e-3, 1e-2, 50);
 
  // Benchmark the application of the algorithm
  while (state.KeepRunning()) {
    auto start = std::chrono::high_resolution_clock::now();
    auto result = (*m_padmm)();
    auto end = std::chrono::high_resolution_clock::now();
    std::cout << "Converged? " << result.good << " , niters = " << result.niters << std::endl;
    state.SetIterationTime(b_utilities::duration(start, end, m_world));
  }
}

References b_utilities::duration(), purify::factory::mpi_distributed, and purify::factory::mpi_sara.