thread.hpp

Go to the documentation of this file.

#pragma once
#include "barretenberg/common/compiler_hints.hpp"
#include <atomic>
#include <barretenberg/env/hardware_concurrency.hpp>
#include <barretenberg/numeric/bitop/get_msb.hpp>
#include <functional>
#include <iostream>
#include <vector>
 
namespace bb {
 
inline size_t get_num_cpus()
{
    return env_hardware_concurrency();
}
 
// For algorithms that need to be divided amongst power of 2 threads.
inline size_t get_num_cpus_pow2()
{
    return static_cast<size_t>(1ULL << numeric::get_msb(get_num_cpus()));
}
 
void parallel_for(size_t num_iterations, const std::function<void(size_t)>& func);
void parallel_for_range(size_t num_points,
                        const std::function<void(size_t, size_t)>& func,
                        size_t no_multhreading_if_less_or_equal = 0);
 
void parallel_for_heuristic(size_t num_points,
                            const std::function<void(size_t, size_t, size_t)>& func,
                            size_t heuristic_cost);
 
template <typename Func>
    requires std::invocable<Func, std::size_t>
void parallel_for_heuristic(size_t num_points, const Func& func, size_t heuristic_cost)
{
    parallel_for_heuristic(
        num_points,
        [&](size_t start_idx, size_t end_idx, BB_UNUSED size_t chunk_index) {
            for (size_t i = start_idx; i < end_idx; i++) {
                func(i);
            }
        },
        heuristic_cost);
}
 
template <typename Func, typename Accum>
    requires std::invocable<Func, std::size_t, Accum&>
std::vector<Accum> parallel_for_heuristic(size_t num_points,
                                          const Accum& initial_accum,
                                          const Func& func,
                                          size_t heuristic_cost)
{
    // thread-safe accumulators
    std::vector<Accum> accumulators(get_num_cpus(), initial_accum);
    parallel_for_heuristic(
        num_points,
        [&](size_t start_idx, size_t end_idx, size_t chunk_index) {
            for (size_t i = start_idx; i < end_idx; i++) {
                func(i, accumulators[chunk_index]);
            }
        },
        heuristic_cost);
    return accumulators;
}
 
const size_t DEFAULT_MIN_ITERS_PER_THREAD = 1 << 4;
 
struct MultithreadData {
    size_t num_threads;
    // index bounds for each thread
    std::vector<size_t> start;
    std::vector<size_t> end;
};
 
MultithreadData calculate_thread_data(size_t num_iterations,
                                      size_t min_iterations_per_thread = DEFAULT_MIN_ITERS_PER_THREAD);
 
size_t calculate_num_threads(size_t num_iterations, size_t min_iterations_per_thread = DEFAULT_MIN_ITERS_PER_THREAD);
 
size_t calculate_num_threads_pow2(size_t num_iterations,
                                  size_t min_iterations_per_thread = DEFAULT_MIN_ITERS_PER_THREAD);
 
namespace thread_heuristics {
// Rough cost of operations (the operation costs are derives in basics_bench and the units are nanoseconds)
// Field element (16 byte) addition cost
constexpr size_t FF_ADDITION_COST = 4;
// Field element (16 byte) multiplication cost
constexpr size_t FF_MULTIPLICATION_COST = 21;
// Field element (16 byte) inversion cost
constexpr size_t FF_INVERSION_COST = 7000;
// Group element projective addition number
constexpr size_t GE_ADDITION_COST = 350;
// Group element projective doubling number
constexpr size_t GE_DOUBLING_COST = 194;
// Group element scalar multiplication cost
constexpr size_t SM_COST = 50000;
// Field element (16 byte) sequential copy number
constexpr size_t FF_COPY_COST = 3;
// Fine default if something looks 'chunky enough that I don't want to calculate'
constexpr size_t ALWAYS_MULTITHREAD = 100000;
} // namespace thread_heuristics
 
} // namespace bb