c-resources/CPlusPlus20ForProgrammers-m.../examples/ch17/fig17_02/fig17_02.cpp

84 lines
3.6 KiB
C++
Raw Normal View History

2024-04-09 06:45:18 +00:00
// fig17_02.cpp
// Performing transforms with execution policies par and unseq.
#include <algorithm>
#include <chrono> // for timing operations
#include <cmath>
#include <execution> // for execution policies
#include <fmt/format.h>
#include <iostream>
#include <random>
#include <vector>
// time each std::transform call and return its duration in seconds
double timeTransform(auto policy, const std::vector<int>& v) {
// <chrono> library features we'll use for timing
using std::chrono::steady_clock;
using std::chrono::duration_cast;
using std::chrono::milliseconds;
std::vector<double> result(v.size());
auto start{steady_clock::now()}; // get current time
std::transform(policy, v.begin(), v.end(),
result.begin(), [](auto x) {return std::sqrt(x);});
auto end{steady_clock::now()}; // get current time
// calculate and return time in seconds
auto time{duration_cast<milliseconds>(end - start)};
return time.count() / 1000.0;
}
int main() {
// set up random-number generation
std::random_device rd;
std::default_random_engine engine{rd()};
std::uniform_int_distribution ints{0, 1000};
std::cout << "Creating vectors\n";
std::vector<int> v1(100'000'000);
std::vector<int> v2(1'000'000'000);
std::cout << "Filling vectors with random ints\n";
std::generate(std::execution::par, v1.begin(), v1.end(),
[&]() {return ints(engine);});
std::generate(std::execution::par, v2.begin(), v2.end(),
[&]() {return ints(engine);});
std::cout << "\nCalculating square roots:\n";
// time the transforms on 100,000,000 elements
std::cout << fmt::format("{} elements with par\n", v1.size());
double parTime1{timeTransform(std::execution::par, v1)};
std::cout << fmt::format("{} elements with unseq\n", v1.size());
double unseqTime1{timeTransform(std::execution::unseq, v1)};
// time the transforms on 1,000,000,000 elements
std::cout << fmt::format("{} elements with par\n", v2.size());
double parTime2{timeTransform(std::execution::par, v2)};
std::cout << fmt::format("{} elements with unseq\n", v2.size());
double unseqTime2{timeTransform(std::execution::unseq, v2)};
// display table of timing results
std::cout << "\nExecution times (in seconds):\n\n"
<< fmt::format("{:>13}{:>17}{:>21}\n", "# of elements",
"par (parallel)", "unseq (vectorized)")
<< fmt::format("{:>13}{:>17.3f}{:>21.3f}\n",
v1.size(), parTime1, unseqTime1)
<< fmt::format("{:>13}{:>17.3f}{:>21.3f}\n",
v2.size(), parTime2, unseqTime2);
}
/**************************************************************************
* (C) Copyright 1992-2021 by Deitel & Associates, Inc. and *
* Pearson Education, Inc. All Rights Reserved. *
* *
* DISCLAIMER: The authors and publisher of this book have used their *
* best efforts in preparing the book. These efforts include the *
* development, research, and testing of the theories and programs *
* to determine their effectiveness. The authors and publisher make *
* no warranty of any kind, expressed or implied, with regard to these *
* programs or to the documentation contained in these books. The authors *
* and publisher shall not be liable in any event for incidental or *
* consequential damages in connection with, or arising out of, the *
* furnishing, performance, or use of these programs. *
**************************************************************************/