JANA/Utils/JBenchUtils.cc

0001
0002 // Copyright 2020, Jefferson Science Associates, LLC.
0003 // Subject to the terms in the LICENSE file found in the top-level directory.
0004
0005
0006 #include "JBenchUtils.h"
0007 #include <chrono>
0008
0009
0010 void JBenchUtils::set_seed(size_t event_number, std::string caller_name)
0011 {
0012     std::hash<std::string> hasher;
0013     long seed = event_number ^ hasher(caller_name);
0014     m_generator = std::mt19937(seed);
0015 }
0016
0017
0018 size_t JBenchUtils::rand_size(size_t avg, double spread) {
0019     auto delta = static_cast<size_t>(avg*spread);
0020     std::uniform_int_distribution<size_t> distribution(avg-delta, avg+delta);
0021     return distribution(m_generator);
0022 }
0023
0024
0025 int JBenchUtils::randint(int min, int max) {
0026     std::uniform_int_distribution<int> distribution(min, max);
0027     return distribution(m_generator);
0028 }
0029
0030 double JBenchUtils::randdouble(double min, double max) {
0031     std::uniform_real_distribution<double> dist(min, max);
0032     return dist(m_generator);
0033 }
0034
0035 float JBenchUtils::randfloat(float min, float max) {
0036     std::uniform_real_distribution<float> dist(min, max);
0037     return dist(m_generator);
0038 }
0039
0040 uint64_t JBenchUtils::consume_cpu_ms(uint64_t millisecs, double spread) {
0041
0042     uint64_t sampled = rand_size(millisecs, spread);
0043     uint64_t result = 0;
0044
0045     // Perform a variable amount of work in a fixed time
0046     auto duration = std::chrono::milliseconds(sampled);
0047     auto start_time = std::chrono::steady_clock::now();
0048     while ((std::chrono::steady_clock::now() - start_time) < duration) {
0049
0050         double a = (m_generator)();
0051         double b = sqrt(a * pow(1.23, -a)) / a;
0052         result += long(b);
0053     }
0054     return result;
0055 }
0056
0057 uint64_t JBenchUtils::read_memory(const std::vector<char>& buffer) {
0058
0059     auto length = buffer.size();
0060     uint64_t sum = 0;
0061     for (unsigned i=0; i<length; ++i) {
0062         sum += buffer[i];
0063     }
0064     return sum;
0065 }
0066
0067 uint64_t JBenchUtils::write_memory(std::vector<char>& buffer, uint64_t bytes, double spread) {
0068
0069     uint64_t sampled = rand_size(bytes, spread);
0070     for (unsigned i=0; i<sampled; ++i) {
0071         buffer.push_back(2);
0072     }
0073     return sampled*2;
0074 }
0075
0076
0077
0078
0079