Update benchmarks

CMakeLists.txt

@@ -63,6 +63,5 @@ endif()
 
 add_subdirectory(cpp)
 
-
 # Exports Purify so other packages can access it
 include(export_purify)

cmake_files/dependencies.cmake

@@ -65,10 +65,6 @@ if(tests)  # Adds ctest
   include(AddCatchTest)
 endif()
 
-if(examples)
-  find_package(TIFF REQUIRED)
-endif()
-
 if(tests OR examples)
   file(COPY data DESTINATION .)
 endif()

cmake_files/export_purify.cmake

@@ -38,3 +38,4 @@ install(FILES
 )
 
 install(EXPORT PurifyTargets DESTINATION share/cmake/purify COMPONENT dev)
+install(DIRECTORY "${PROJECT_SOURCE_DIR}/data" DESTINATION "${CMAKE_INSTALL_PREFIX}")

cpp/benchmarks/CMakeLists.txt

@@ -25,8 +25,8 @@ if(dompi)
   add_executable(mpi_benchmark_MO_wproj main.cc utilities.cc measurement_operator_wproj.cc)
   target_link_libraries(mpi_benchmark_MO_wproj ${MPI_LIBRARIES} benchmark libpurify)
   #target_include_directories(mpi_benchmark_MO_wproj PUBLIC "${PROJECT_SOURCE_DIR}/cpp" "${CMAKE_CURRENT_BINARY_DIR}/include")
-  add_executable(mpi_benchmark_PADMM main.cc utilities.cc padmm_mpi.cc)
-  target_link_libraries(mpi_benchmark_PADMM ${MPI_LIBRARIES} benchmark libpurify)
+  add_executable(mpi_benchmark_algorithms main.cc utilities.cc algorithms_mpi.cc)
+  target_link_libraries(mpi_benchmark_algorithms ${MPI_LIBRARIES} benchmark libpurify)
   #target_include_directories(mpi_benchmark_PADMM PUBLIC "${PROJECT_SOURCE_DIR}/cpp" "${CMAKE_CURRENT_BINARY_DIR}/include")
   add_executable(mpi_benchmark_WLO main.cc utilities.cc wavelet_operator_mpi.cc)
   target_link_libraries(mpi_benchmark_WLO ${MPI_LIBRARIES} benchmark libpurify)

cpp/benchmarks/algorithms.cc

@@ -0,0 +1,156 @@
+#include "purify/config.h"
+#include "purify/types.h"
+#include <array>
+#include <benchmark/benchmark.h>
+#include "benchmarks/utilities.h"
+#include "purify/algorithm_factory.h"
+#include "purify/directories.h"
+#include "purify/measurement_operator_factory.h"
+#include "purify/operators.h"
+#include "purify/utilities.h"
+#include "purify/wavelet_operator_factory.h"
+#include <sopt/imaging_padmm.h>
+#include <sopt/relative_variation.h>
+#include <sopt/utilities.h>
+#include <sopt/wavelets.h>
+#include <sopt/wavelets/sara.h>
+
+using namespace purify;
+
+class AlgoFixture : public ::benchmark::Fixture {
+ public:
+  void SetUp(const ::benchmark::State &state) {
+    // Reading image from file and update related quantities
+    bool newImage = b_utilities::updateImage(state.range(0), m_image, m_imsizex, m_imsizey);
+
+    // Generating random uv(w) coverage
+    bool newMeasurements =
+        b_utilities::updateMeasurements(state.range(1), m_uv_data, m_epsilon, newImage, m_image);
+
+    bool newKernel = m_kernel != state.range(2);
+
+    m_kernel = state.range(2);
+    // creating the measurement operator
+    const t_real FoV = 1;  // deg
+    const t_real cellsize = FoV / m_imsizex * 60. * 60.;
+    const bool w_term = false;
+    m_measurements_transform = factory::measurement_operator_factory<Vector<t_complex>>(
+        factory::distributed_measurement_operator::serial, m_uv_data, m_imsizey, m_imsizex,
+        cellsize, cellsize, 2, kernels::kernel::kb, m_kernel, m_kernel, w_term);
+
+    t_real const m_sigma = 0.016820222945913496 * std::sqrt(2);  // see test_parameters file
+  }
+
+  void TearDown(const ::benchmark::State &state) {}
+
+  t_real m_epsilon;
+  t_uint m_counter;
+  t_real m_sigma;
+  std::vector<std::tuple<std::string, t_uint>> const m_sara{
+      std::make_tuple("Dirac", 3u), std::make_tuple("DB1", 3u), std::make_tuple("DB2", 3u),
+      std::make_tuple("DB3", 3u),   std::make_tuple("DB4", 3u), std::make_tuple("DB5", 3u),
+      std::make_tuple("DB6", 3u),   std::make_tuple("DB7", 3u), std::make_tuple("DB8", 3u)};
+
+  Image<t_complex> m_image;
+  t_uint m_imsizex;
+  t_uint m_imsizey;
+
+  utilities::vis_params m_uv_data;
+
+  t_uint m_kernel;
+  std::shared_ptr<sopt::LinearTransform<Vector<t_complex>> const> m_measurements_transform;
+  std::shared_ptr<sopt::algorithm::ImagingProximalADMM<t_complex>> m_padmm;
+  std::shared_ptr<sopt::algorithm::ImagingForwardBackward<t_complex>> m_fb;
+};
+
+BENCHMARK_DEFINE_F(AlgoFixture, Padmm)(benchmark::State &state) {
+  // Benchmark the application of the algorithm
+  auto const wavelets = factory::wavelet_operator_factory<Vector<t_complex>>(
+      factory::distributed_wavelet_operator::serial, m_sara, m_imsizey, m_imsizex);
+
+  m_padmm = factory::padmm_factory<sopt::algorithm::ImagingProximalADMM<t_complex>>(
+      factory::algo_distribution::serial, m_measurements_transform, 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,
+      1.0, 1.0);
+
+  while (state.KeepRunning()) {
+    auto start = std::chrono::high_resolution_clock::now();
+    (*m_padmm)();
+    auto end = std::chrono::high_resolution_clock::now();
+    state.SetIterationTime(b_utilities::duration(start, end));
+  }
+}
+
+BENCHMARK_DEFINE_F(AlgoFixture, ForwardBackward)(benchmark::State &state) {
+  // Benchmark the application of the algorithm
+  auto const wavelets = factory::wavelet_operator_factory<Vector<t_complex>>(
+      factory::distributed_wavelet_operator::serial, 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::serial, m_measurements_transform, wavelets, m_uv_data, m_sigma,
+      beta, gamma, m_imsizey, m_imsizex, m_sara.size(), state.range(3) + 1, true, true, false, 1e-3,
+      1e-2, 50, 1.0);
+
+  while (state.KeepRunning()) {
+    auto start = std::chrono::high_resolution_clock::now();
+    (*m_fb)();
+    auto end = std::chrono::high_resolution_clock::now();
+    state.SetIterationTime(b_utilities::duration(start, end));
+  }
+}
+
+#ifdef PURIFY_ONNXRT
+BENCHMARK_DEFINE_F(AlgoFixture, ForwardBackwardOnnx)(benchmark::State &state) {
+  // Benchmark the application of the algorithm
+  auto const wavelets = factory::wavelet_operator_factory<Vector<t_complex>>(
+      factory::distributed_wavelet_operator::serial, m_sara, m_imsizey, m_imsizex);
+
+  t_real const beta = m_sigma * m_sigma;
+  t_real const gamma = 0.0001;
+  std::string tf_model_path = purify::models_directory() + "/snr_15_model_dynamic.onnx";
+
+  m_fb = factory::fb_factory<sopt::algorithm::ImagingForwardBackward<t_complex>>(
+      factory::algo_distribution::serial, m_measurements_transform, wavelets, m_uv_data, m_sigma,
+      beta, gamma, m_imsizey, m_imsizex, m_sara.size(), state.range(3) + 1, true, true, false, 1e-3,
+      1e-2, 50, 1.0, tf_model_path, factory::g_proximal_type::TFGProximal);
+
+  while (state.KeepRunning()) {
+    auto start = std::chrono::high_resolution_clock::now();
+    (*m_fb)();
+    auto end = std::chrono::high_resolution_clock::now();
+    state.SetIterationTime(b_utilities::duration(start, end));
+  }
+}
+
+BENCHMARK_REGISTER_F(AlgoFixture, ForwardBackwardOnnx)
+    //->Apply(b_utilities::Arguments)
+    ->Args({128, 10000, 4, 10})
+    ->UseManualTime()
+    ->MinTime(10.0)
+    ->MinWarmUpTime(5.0)
+    ->Repetitions(3)  //->ReportAggregatesOnly(true)
+    ->Unit(benchmark::kMillisecond);
+#endif
+
+BENCHMARK_REGISTER_F(AlgoFixture, Padmm)
+    //->Apply(b_utilities::Arguments)
+    ->Args({128, 10000, 4, 10})
+    ->UseManualTime()
+    ->MinTime(10.0)
+    ->MinWarmUpTime(5.0)
+    ->Repetitions(3)  //->ReportAggregatesOnly(true)
+    ->Unit(benchmark::kMillisecond);
+
+BENCHMARK_REGISTER_F(AlgoFixture, ForwardBackward)
+    //->Apply(b_utilities::Arguments)
+    ->Args({128, 10000, 4, 10})
+    ->UseManualTime()
+    ->MinTime(10.0)
+    ->MinWarmUpTime(5.0)
+    ->Repetitions(3)  //->ReportAggregatesOnly(true)
+    ->Unit(benchmark::kMillisecond);
+
+BENCHMARK_MAIN();