exampleHyperRectDomainParallelScan.cpp File Reference

Example of parallelization of an HyperRectDomain scan and ImageContainerBySTL initialization. More...

#include <numeric>
#include <iterator>
#include <chrono>
#include <string>
#include <iostream>
#include <iomanip>
#include <omp.h>
#include "DGtal/base/Common.h"
#include "DGtal/kernel/SpaceND.h"
#include "DGtal/kernel/PointVector.h"
#include "DGtal/kernel/domains/HyperRectDomain.h"
#include "DGtal/images/ImageContainerBySTLVector.h"
#include "DGtal/base/SimpleConstRange.h"

Include dependency graph for exampleHyperRectDomainParallelScan.cpp:

Go to the source code of this file.

Functions
void	tic ()
double	toc ()
template<typename TIterator >
SimpleConstRange< TIterator >	split_range (TIterator it_begin, TIterator it_end, std::size_t idx, std::size_t count)
	[split_range]
template<typename TIterable >
auto	split_range (TIterable &iterable, std::size_t idx, std::size_t count) -> decltype(split_range(iterable.begin(), iterable.end(), idx, count))
template<typename Image >
Image::Value	calc_image_checksum (Image const &image)
	[split_range]
template<typename Domain , typename Function >
auto	sum_fn_on_domain (Domain const &domain, Function const &fn) -> decltype(fn(domain.lowerBound()))
template<typename Image , typename Function >
void	init_image_getset (Image &image, Function const &fn)
template<typename Image , typename Function >
void	init_image_iter (Image &image, Function const &fn)
int	main (int argc, char *argv[])

Variables
auto	tic_timer = std::chrono::high_resolution_clock::now()

Detailed Description

Example of parallelization of an HyperRectDomain scan and ImageContainerBySTL initialization.

This program is free software: you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with this program. If not, see http://www.gnu.org/licenses/.

Author

Roland Denis (denis.nosp@m.@mat.nosp@m.h.uni.nosp@m.v-ly.nosp@m.on1.f.nosp@m.r ) CNRS, Institut Camille Jordan (UMR 5208), Université Lyon 1, France

Date

2019/10/16

This file is part of the DGtal library.

Definition in file exampleHyperRectDomainParallelScan.cpp.

Function Documentation

calc_image_checksum()

template<typename Image >

Image::Value calc_image_checksum

(

Image const &

image

)

[split_range]

Definition at line 93 of file exampleHyperRectDomainParallelScan.cpp.

{
  typename Image::Value sum = 0;
 
  #pragma omp parallel reduction(+:sum)
    {
      std::size_t thread_idx = omp_get_thread_num();
      std::size_t thread_cnt = omp_get_max_threads();
      auto const range = split_range(image, thread_idx, thread_cnt);
      sum = std::accumulate(range.begin(), range.end(), sum);
    }
 
  return sum;
}

References split_range().

Referenced by main().

init_image_getset()

template<typename Image , typename Function >

void init_image_getset	(	Image &	image,
		Function const &	fn )

[image_init_getset]

[image_init_getset]

Definition at line 132 of file exampleHyperRectDomainParallelScan.cpp.

{
  #pragma omp parallel
    {
      std::size_t thread_idx = omp_get_thread_num();
      std::size_t thread_cnt = omp_get_num_threads();
 
      for (auto const& pt : split_range(image.domain(), thread_idx, thread_cnt))
        image.setValue(pt, fn(pt, image(pt)));
    }
}

References split_range().

Referenced by main().

init_image_iter()

template<typename Image , typename Function >

void init_image_iter	(	Image &	image,
		Function const &	fn )

[image_init_iter]

[image_init_iter]

Definition at line 148 of file exampleHyperRectDomainParallelScan.cpp.

{
  #pragma omp parallel
    {
      std::size_t thread_idx = omp_get_thread_num();
      std::size_t thread_cnt = omp_get_num_threads();
 
      auto domain_it = split_range(image.domain(), thread_idx, thread_cnt).begin();
      for (auto & v : split_range(image, thread_idx, thread_cnt))
        {
          v = fn(*domain_it, v);
          ++domain_it;
        }
    }
}

References split_range().

Referenced by main().

main()

int main	(	int	argc,
		char *	argv[] )

Definition at line 166 of file exampleHyperRectDomainParallelScan.cpp.

{
  using Space   = SpaceND<3>;
  using Point   = Space::Point;
  using Domain  = HyperRectDomain<Space>;
  using Value   = double;
  using Image   = ImageContainerBySTLVector<Domain, Value>;
 
  if (argc < 2)
    {
      std::cerr << "Usage: " << argv[0] << " <domain_size>" << std::endl;
      return 1;
    }
 
  trace.info() << "Initialization..." << std::endl;
  std::size_t domain_size = std::stoll(argv[1]);
  Domain domain(Point::diagonal(0), Point::diagonal(domain_size-1));
  Image image(domain);
 
  double ref_duration = 0;
  std::size_t max_threads = omp_get_max_threads();
  trace.info() << std::fixed << std::setprecision(6);
 
  // Choose here the function you want to use
 
  //auto const fn = [&domain] (Point const& pt) { return 25 * ( std::cos( (pt - domain.upperBound()).norm() ) + 1 ); }; // CPU intensive
  auto const fn = [&domain] (Point const& pt) { return (pt - domain.upperBound()).norm(); }; // Mixed
  //auto const fn = [] (Point const& pt) { return Value(pt[0]); }; // Memory bound
 
 
  // Scanning a domain in parallel
 
  trace.info() << std::endl;
  trace.info() << "Scanning a domain in parallel..." << std::endl;
  for (std::size_t thread_cnt = 1; thread_cnt <= max_threads; ++thread_cnt)
    {
      omp_set_num_threads(thread_cnt);
      Value sum = sum_fn_on_domain(domain, fn);
      tic();
      sum += sum_fn_on_domain(domain, fn);
      const double duration = toc();
 
      if (thread_cnt == 1)
        ref_duration = duration;
 
      trace.info() << "\tthreads: " << thread_cnt
                   << "\tduration: " << duration << "s"
                   << "\tspeed: " << 1e-6 * domain.size() / duration << "Mpt/s"
                   << "\tspeedup: " << ref_duration/duration
                   << "\tchecksum: " << sum
                   << std::endl;
    }
 
 
  // Initializing an image in parallel using getter and setter
 
  trace.info() << std::endl;
  trace.info() << "Initializing an image in parallel using getter and setter..." << std::endl;
  for (std::size_t thread_cnt = 1; thread_cnt <= max_threads; ++thread_cnt)
    {
      omp_set_num_threads(thread_cnt);
      init_image_getset(image, [&fn] (Point const& pt, Value) { return fn(pt); });
      tic();
      init_image_getset(image, [&fn] (Point const& pt, Value v) { return v + fn(pt); });
      const double duration = toc();
 
      if (thread_cnt == 1)
        ref_duration = duration;
 
      trace.info() << "\tthreads: " << thread_cnt
                   << "\tduration: " << duration << "s"
                   << "\tspeed: " << 1e-6 * domain.size() / duration << "Mpt/s"
                   << "\tspeedup: " << ref_duration/duration
                   << "\tchecksum: " << calc_image_checksum(image)
                   << std::endl;
    }
 
 
  // Initializing an image in parallel using iterators
 
  trace.info() << std::endl;
  trace.info() << "Initializing an image in parallel using iterators..." << std::endl;
  for (std::size_t thread_cnt = 1; thread_cnt <= max_threads; ++thread_cnt)
    {
      omp_set_num_threads(thread_cnt);
      init_image_iter(image, [&fn] (Point const& pt, Value) { return fn(pt); });
      tic();
      init_image_iter(image, [&fn] (Point const& pt, Value v) { return v + fn(pt); });
      const double duration = toc();
 
      if (thread_cnt == 1)
        ref_duration = duration;
 
      trace.info() << "\tthreads: " << thread_cnt
                   << "\tduration: " << duration << "s"
                   << "\tspeed: " << 1e-6 * domain.size() / duration << "Mpt/s"
                   << "\tspeedup: " << ref_duration/duration
                   << "\tchecksum: " << calc_image_checksum(image)
                   << std::endl;
    }
 
  return 0;
}

References calc_image_checksum(), domain, DGtal::Trace::info(), init_image_getset(), init_image_iter(), DGtal::HyperRectDomain< TSpace >::size(), sum_fn_on_domain(), tic(), toc(), DGtal::trace, and DGtal::HyperRectDomain< TSpace >::upperBound().

split_range() [1/2]

template<typename TIterable >

auto split_range	(	TIterable &	iterable,
		std::size_t	idx,
		std::size_t	count ) -> decltype(split_range(iterable.begin(), iterable.end(), idx, count))

Definition at line 84 of file exampleHyperRectDomainParallelScan.cpp.

{
  return split_range(iterable.begin(), iterable.end(), idx, count);
}

References split_range().

split_range() [2/2]

template<typename TIterator >

SimpleConstRange< TIterator > split_range	(	TIterator	it_begin,
		TIterator	it_end,
		std::size_t	idx,
		std::size_t	count )

[split_range]

Definition at line 73 of file exampleHyperRectDomainParallelScan.cpp.

{
  auto range_size  = std::distance(it_begin, it_end);
  auto begin_shift = (range_size*idx) / count;
  auto end_shift   = (range_size*(idx+1)) / count;
  return { it_begin + begin_shift, it_begin + end_shift };
}

Referenced by calc_image_checksum(), init_image_getset(), init_image_iter(), split_range(), and sum_fn_on_domain().

sum_fn_on_domain()

template<typename Domain , typename Function >

auto sum_fn_on_domain	(	Domain const &	domain,
		Function const &	fn ) -> decltype(fn(domain.lowerBound()))

[domain_scan]

[domain_scan]

Definition at line 110 of file exampleHyperRectDomainParallelScan.cpp.

{
  auto sum = 0 * fn(domain.lowerBound()); // To initialize the sum depending on the function return type
 
  #pragma omp parallel reduction(+:sum)
    {
      // OpenMP context
      std::size_t thread_idx = omp_get_thread_num();
      std::size_t thread_cnt = omp_get_num_threads();
 
      for (auto const& pt : split_range(domain, thread_idx, thread_cnt))
        sum += fn(pt);
    }
 
  return sum;
}

References domain, DGtal::HyperRectDomain< TSpace >::lowerBound(), and split_range().

Referenced by main().

tic()

void tic

(

)

Definition at line 56 of file exampleHyperRectDomainParallelScan.cpp.

{
  tic_timer = std::chrono::high_resolution_clock::now();
}

References tic_timer.

Referenced by main().

toc()

double toc

(

)

Definition at line 62 of file exampleHyperRectDomainParallelScan.cpp.

{
  const auto toc_timer = std::chrono::high_resolution_clock::now();
  const std::chrono::duration<double> time_span = toc_timer - tic_timer;
  return time_span.count();
}

References tic_timer.

Referenced by main().

Variable Documentation

tic_timer

auto tic_timer = std::chrono::high_resolution_clock::now()

Definition at line 53 of file exampleHyperRectDomainParallelScan.cpp.

Referenced by tic(), and toc().