based

Opinionated utility library
git clone git://git.dimitrijedobrota.com/based.git
Log | Files | Refs | README | HACKING | CONTRIBUTING | CODE_OF_CONDUCT | BUILDING
commitf8f8eae22a0c8e4ea765fa752715b84373a73bc7
parent0e84dc494cc423caf5f8c5ee0145bcf75ae97e29
authorDimitrije Dobrota <mail@dimitrijedobrota.com>
dateMon, 17 Mar 2025 22:03:18 +0100

Count_operations helper, with normalization

Diffstat:
Mexample/empty_example.cpp|+++++---------------
Minclude/based/instrumentation.hpp|+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

2 files changed, 72 insertions(+), 15 deletions(-)

diff --git a/example/empty_example.cpp b/example/empty_example.cpp

@@ -1,24 +1,14 @@

#include <algorithm>
#include <format>
#include <iostream>
#include <vector>
#include "based/instrumentation.hpp"
int main()
{
using instrumented = based::instrumented<int>;
std::vector<int> base = {12, 5, 52, 5, 62, 46, 53, 73, 8, 83, 6};
std::vector<instrumented> vec(std::begin(base), std::end(base));
instrumented::initialize(vec.size());
std::sort(std::begin(vec), std::end(vec));
for (std::size_t i = 0; i < instrumented::op_num; i++) {
std::cout << std::format(
"{:15}: {}\n", instrumented::name(i), instrumented::count(i));
}
based::count_operations(
16UL,
16UL * 1024 * 1024,
[](const auto& a, const auto& b) { std::sort(a, b); },
based::normalize_nlogn);
return 0;
}

diff --git a/include/based/instrumentation.hpp b/include/based/instrumentation.hpp

@@ -6,12 +6,38 @@

#include <concepts>
#include <cstddef>
#include <cstdint>
#include <format>
#include <iostream>
#include <numbers>
#include <numeric>
#include <random>
#include <vector>
#include "based/enum.hpp"
namespace based
{
inline auto dont_normalize(double x, double /* n */)
{
return x;
}
inline auto normalize_n(double x, double n)
{
return x / n;
}
inline auto normalize_nlogn(double x, double n)
{
return x / (n * (std::log(n) / std::numbers::ln2));
}
inline auto normalize_nlogn1(double x, double n)
{
return x / (n * std::log(n) - n);
}
struct instrumented_base
{
protected:

@@ -142,4 +168,45 @@ struct instrumented : instrumented_base

}
};
template<typename Function>
void count_operations(size_t i,
size_t j,
Function fun,
double (*norm)(double, double) = dont_normalize)
{
using instrumented = based::instrumented<double>;
constexpr size_t cols = instrumented::op_num;
const size_t normalized((norm == dont_normalize) ? 0 : 2);
std::array<size_t, cols> decimals = {0};
std::fill(std::next(std::begin(decimals)), std::end(decimals), normalized);
for (size_t k = 0; k < cols; ++k) {
std::cout << std::format("{:^12} | ", instrumented::name(k));
}
std::cout << '\n';
std::mt19937 rng(0); // NOLINT cert-msc32-c cert-msc51-cpp
while (i <= j) {
std::vector<instrumented> vec(i);
std::iota(std::begin(vec), std::end(vec), 0.0);
std::shuffle(std::begin(vec), std::end(vec), rng);
instrumented::initialize(i);
fun(std::begin(vec), std::end(vec));
std::cout << std::format("{:12} | ", instrumented::count(0));
for (size_t k = 1; k < cols; ++k) {
std::cout << std::format(
"{:12.{}f} | ",
norm(instrumented::count(k), static_cast<double>(i)),
decimals[k]);
}
std::cout << '\n' << std::flush;
i <<= 1U;
}
}
} // namespace based