Пятнадцать байтов на стек от конца

Я вижу, машина Тьюринга на OCaml не произвела впечатления. Слишком незнакомый язык. Давайте для сравнения перепишем её на что-нибудь традиционное, скажем C++17.

#include <deque>
#include <iostream>
#include <optional>
#include <string>
#include <tuple>
#include <unordered_map>

// Types for Turing machine
enum class Symbol { One, Blank };
enum class Direction { Left, Right };
using State           = std::string;
using TransitionKey   = std::tuple<State, Symbol>;
using TransitionValue = std::tuple<State, Symbol, Direction>;
using Transitions     = std::unordered_map<TransitionKey, TransitionValue, std::hash<TransitionKey>>;

struct Tape {
    std::deque<Symbol> data;
    size_t head_pos;
};

// Hash function for TransitionKey
namespace std {
template <>
struct hash<TransitionKey> {
    size_t operator()(const TransitionKey &key) const
    {
        auto [state, sym] = key;
        return hash<string>()(state) ^ (hash<size_t>()(static_cast<size_t>(sym)) << 1);
    }
};
} // namespace std

// Convert symbol to string for printing
std::string symbol_to_string(Symbol sym)
{
    return sym == Symbol::One ? "1" : "_";
}

// Print the current tape and head position
void print_tape(const Tape &tape, const State &state)
{
    std::string left_str, right_str;
    size_t i = 0;
    for (const auto &sym : tape.data) {
        if (i < tape.head_pos) {
            left_str += symbol_to_string(sym);
        } else if (i > tape.head_pos) {
            right_str += symbol_to_string(sym);
        }
        ++i;
    }
    std::cout << "[" << left_str << "] " << symbol_to_string(tape.data[tape.head_pos]) << " ("
              << state << ") " << right_str << "\n";
}

// Move the tape head
void move_head(Tape &tape, Direction dir)
{
    if (dir == Direction::Right) {
        if (tape.head_pos + 1 >= tape.data.size()) {
            tape.data.push_back(Symbol::Blank);
        }
        ++tape.head_pos;
    } else { // Left
        if (tape.head_pos == 0) {
            tape.data.push_front(Symbol::Blank);
        } else {
            --tape.head_pos;
        }
    }
}

// Step the Turing machine
std::optional<State> step(Tape &tape, const State &state, const Transitions &transitions)
{
    TransitionKey current = { state, tape.data[tape.head_pos] };
    auto it               = transitions.find(current);
    if (it == transitions.end()) {
        return std::nullopt; // No transition: halt
    }
    const auto &[new_state, new_symbol, dir] = it->second;
    tape.data[tape.head_pos]                 = new_symbol;
    move_head(tape, dir);
    return new_state;
}

// Run the Turing machine
void run_turing_machine(Tape tape, const State &start_state, const Transitions &transitions,
                        const State &accept_state, const State &reject_state)
{
    State current_state = start_state;
    while (true) {
        print_tape(tape, current_state);
        if (current_state == accept_state) {
            std::cout << "Accepted\n";
            break;
        }
        if (current_state == reject_state) {
            std::cout << "Rejected\n";
            break;
        }
        auto next_state = step(tape, current_state, transitions);
        if (!next_state) {
            std::cout << "Halted (no transition)\n";
            break;
        }
        current_state = *next_state;
    }
}

// Turing machine to add two unary numbers
void example_add()
{
    Transitions transitions = {
        // q0: Move right to find blank
        { { "q0", Symbol::One }, { "q0", Symbol::One, Direction::Right } },
        { { "q0", Symbol::Blank }, { "q1", Symbol::One, Direction::Left } },
        // q1: Move left to start
        { { "q1", Symbol::One }, { "q1", Symbol::One, Direction::Left } },
        { { "q1", Symbol::Blank }, { "qaccept", Symbol::Blank, Direction::Right } }
    };
    // Tape represents 2 + 3: 11_111
    Tape tape = {
        { Symbol::One, Symbol::One, Symbol::Blank, Symbol::One, Symbol::One, Symbol::One }, 0
    };
    run_turing_machine(tape, "q0", transitions, "qaccept", "qreject");
}

int main()
{
    example_add();
}

Кода вышло в два раза больше. Стало ли яснее? Запустим для проверки.

$ c++ -std=c++17 turing-add.cpp -o turing-add
$ ./turing-add
[] 1 (q0) 1_111
[1] 1 (q0) _111
[11] _ (q0) 111
[1] 1 (q1) 1111
[] 1 (q1) 11111
[] _ (q1) 111111
[_] 1 (qaccept) 11111
Accepted

Для C++ появилась и развивается реализация универсального парсера. Это вместо YACC, Bison и прочих PEGTL.

Проект: github.com/jwtowner/lug

Пример реализации Бейсика на Си++. Меньше пятисот строк кода: github.com/jwtowner/lug/blob/master/samples/basic/basic.cpp

Простой калькулятор:

using namespace lug::language;

int i;
double e, l, n, r, s;
double v[26];

extern rule Expr;

implicit_space_rule BLANK = lexeme[ *"[ \t]"_rx ];

rule EOL    = lexeme[ "[\n\r;]"_rx ];
rule ID     = lexeme[ "[a-zA-Z]"_rx  <[](syntax m) -> int { return static_cast<int>(lug::unicode::tolower(static_cast<char32_t>(m.str().at(0))) - U'a'); } ];
rule NUMBER = lexeme[ ( ~"[-+]"_rx > +"[0-9]"_rx > ~('.' > +"[0-9]"_rx) )
                                     <[](syntax m) -> double { return std::stod(std::string{m}); } ];
rule Value  = n%NUMBER               <[]{ return n; }
            | i%ID > !"="_sx         <[]{ return v[i]; }
            | '(' > e%Expr > ')'     <[]{ return e; };
rule Prod   = l%Value > *(
                  '*' > r%Value      <[]{ l *= r; }
                | '/' > r%Value      <[]{ l /= r; }
            )                        <[]{ return l; };
rule Sum    = l%Prod > *(
                  '+' > r%Prod       <[]{ l += r; }
                | '-' > r%Prod       <[]{ l -= r; }
            )                        <[]{ return l; };
rule Expr   = i%ID > '=' > s%Sum     <[]{ return v[i] = s; }
            | s%Sum                  <[]{ return s; };
rule Stmt   = ( (   "exit"_isx
                  | "quit"_isx )     <[]{ std::exit(EXIT_SUCCESS); }
                | e%Expr             <[]{ std::cout << e << "\n"; }
            ) > EOL
            | *( !EOL > any ) > EOL  <[]{ std::cout << "SYNTAX ERROR\n"; };

grammar Grammar = start(Stmt > eoi);

Тип Mutex<T> хорош, но разрешает доступ нескольким потокам только по очереди. Что если нам чаще требуется только читать объект, а изменять только изредка? Через RwLock<T> можно получить множественный доступ на чтение.

Question: Please show a meaningful C++ implementation of type RwLock<T>.

I'll create a C++ implementation of RwLock<T> similar to Rust's RwLock, which provides a reader-writer lock allowing multiple readers or one writer. We'll use C++'s std::shared_mutex (available since C++17) as the underlying synchronization primitive.

Here's the implementation: rwlock.cpp.

#include <shared_mutex>
#include <memory>

template<typename T>
class RwLock {
private:
    T data;
    mutable std::shared_mutex mtx;  // mutable to allow locking in const methods

public:
    // Constructor
    explicit RwLock(T value) : data(std::move(value)) {}

    // Read guard class (multiple readers allowed)
    class ReadGuard {
    private:
        const T& data_ref;
        std::shared_lock<std::shared_mutex> lock;

    public:
        ReadGuard(const T& d, std::shared_mutex& m)
            : data_ref(d), lock(m) {}

        const T& operator*() const { return data_ref; }
        const T* operator->() const { return &data_ref; }
    };

    // Write guard class (exclusive writer)
    class WriteGuard {
    private:
        T& data_ref;
        std::unique_lock<std::shared_mutex> lock;

    public:
        WriteGuard(T& d, std::shared_mutex& m)
            : data_ref(d), lock(m) {}

        T& operator*() { return data_ref; }
        T* operator->() { return &data_ref; }
    };

    // Lock methods
    ReadGuard read_lock() const {
        return ReadGuard(data, mtx);
    }

    WriteGuard write_lock() {
        return WriteGuard(data, mtx);
    }

    // Prevent copying
    RwLock(const RwLock&) = delete;
    RwLock& operator=(const RwLock&) = delete;

    // Allow move construction
    RwLock(RwLock&&) = default;
    RwLock& operator=(RwLock&&) = default;
};

( объяснения )

Устав от сложных концепций, глянем что-нибудь простое, скажем тип Option<T>. Это контейнер на одно значение произвольного типа, которое может отсутствовать. В Си++17 появился практически идентичный класс std::optional. Но мы попросим Грок состряпать нам решение, максимально близкое к Rust.

Question: Please implement type Option in C++, making it as close to Rust as possible, but still convenient for C++.

Let's create a C++ implementation of Rust's Option type. In Rust, Option is an enum that represents either Some(value) or None, used for handling cases where a value might be absent. Here's a C++ version that mimics this behavior while adapting to C++ idioms:

#include <utility>
#include <stdexcept>

template <typename T>
class Option {
private:
    bool has_value;
    union {
        T value;
    };

public:
    // Constructors
    Option() : has_value(false) {}

    explicit Option(const T& val) : has_value(true), value(val) {}

    explicit Option(T&& val) : has_value(true), value(std::move(val)) {}

    // Copy constructor
    Option(const Option& other) : has_value(other.has_value) {
        if (has_value) {
            new(&value) T(other.value);
        }
    }

    // Move constructor
    Option(Option&& other) noexcept : has_value(other.has_value) {
        if (has_value) {
            new(&value) T(std::move(other.value));
            other.has_value = false;
        }
    }

    // Destructor
    ~Option() {
        if (has_value) {
            value.~T();
        }
    }

    // Assignment operators
    Option& operator=(const Option& other) {
        if (this != &other) {
            if (has_value) {
                value.~T();
            }
            has_value = other.has_value;
            if (has_value) {
                new(&value) T(other.value);
            }
        }
        return *this;
    }

    Option& operator=(Option&& other) noexcept {
        if (this != &other) {
            if (has_value) {
                value.~T();
            }
            has_value = other.has_value;
            if (has_value) {
                new(&value) T(std::move(other.value));
                other.has_value = false;
            }
        }
        return *this;
    }

    // Static methods to create Some and None
    static Option Some(const T& val) { return Option(val); }
    static Option None() { return Option(); }

    // Check if contains value
    bool is_some() const { return has_value; }
    bool is_none() const { return !has_value; }

    // Access value (unsafe - throws if None)
    T& unwrap() {
        if (!has_value) {
            throw std::runtime_error("Called unwrap on None");
        }
        return value;
    }

    const T& unwrap() const {
        if (!has_value) {
            throw std::runtime_error("Called unwrap on None");
        }
        return value;
    }

    // Access with default value
    T unwrap_or(const T& default_value) const {
        return has_value ? value : default_value;
    }

    // Get value or compute default
    template <typename F>
    T unwrap_or_else(F&& func) const {
        return has_value ? value : func();
    }
};

// Helper function to make creation more convenient
template <typename T>
Option<T> some(const T& value) {
    return Option<T>::Some(value);
}

template <typename T>
Option<T> none() {
    return Option<T>::None();
}

Продолжаю двигаться по списку: изучаю базовые примитивы языка Rust. Сегодня рассмотрим Cell<T>, RefCell<T> и, на десерт, Option<T>.

Cell это простой контейнер на одно значение произвольного типа. С одной хитрой фичей: если значение неизменяемое (то есть имеет атрибут const), Cell позволяет обходить это ограничение и всё-таки изменять его. Аналогично ключевому слову "mutable" в Си++. Спросим у grok.com.

Question: Please show me how type Cell<T> can be implemented in C++.

Let’s dive into how we might implement Rust’s Cell<T> in C++. Rust’s Cell<T> is a fascinating type - it provides interior mutability, allowing you to mutate its contents even when you only have a shared reference, all while being safe in a single-threaded context. It’s lightweight, with no runtime overhead beyond the mutation itself, and it doesn’t involve locks since it’s not thread-safe (that’s what RefCell or atomics are for in Rust). In C++, we don’t have the exact same ownership and borrowing rules, so we’ll need to adapt the concept while preserving its spirit.

The core idea of Cell<T> is simple: it wraps a value of type T and provides methods to get and set that value, bypassing C++’s usual const-correctness restrictions in a controlled way. Rust uses it to allow mutation through shared references, so in C++, we’ll aim for something that lets us modify a value even when we might otherwise be constrained, like through a const reference, while keeping the implementation straightforward.

Here’s a basic implementation in C++: cell.cpp.

#include <utility>
#include <iostream>

template <typename T>
class Cell {
private:
    mutable T value; // Mutable to allow mutation even when Cell is const

public:
    // Constructor
    explicit Cell(T initial) : value(std::move(initial)) {}

    // Get a copy of the value
    T get() const {
        return value;
    }

    // Set a new value
    void set(T new_value) const {
        value = std::move(new_value);
    }

    // Replace the value and return the old one
    T replace(T new_value) const {
        T old_value = std::move(value);
        value = std::move(new_value);
        return old_value;
    }
};

Продолжим разбираться с умными указателями в Rust. Вчера я показывал Rc и Arc. Они похожи на shared_ptr. Теперь глянем типы Weak для них. Начнём с Weak для Rc.

Фишка указателя Weak в том, что он не мешает удалить объект. От указателя Rc<T> можно вызвать метод create_weak(), и он вернёт "слабый" указатель типа Weak<T> на тот же объект. Со слабым указателем мало что можно делать, кроме как вызовом метода upgrade() снова получить сильный указатель. Или не получить - если объект уже к этому времени пропал. 

Question: Let's talk about Weak for Rc for now. Please show me how it can be implemented in C++.

Let’s dive into implementing a Weak pointer analogous to Rust’s Weak for Rc in C++. In Rust, Rc (Reference Counting) provides shared ownership of data, and Weak is a non-owning reference that prevents reference cycles and allows access to the data only if it still exists (i.e., if the strong reference count hasn’t dropped to zero). We’ll replicate this behavior in C++ using a combination of smart pointers and manual reference counting.

In C++, the closest equivalent to Rc is std::shared_ptr, which manages a strong reference count. For Weak, we’ll mimic Rust’s Weak by using std::weak_ptr, which is designed to work with std::shared_ptr and provides a non-owning reference. However, to make this a clear learning exercise and align it closely with Rust’s semantics, I’ll first show a simplified manual implementation before tying it to the standard library.

Manual Implementation Concept

Rust’s Rc and Weak rely on two counters:

• Strong count: Number of owning Rc references.
• Weak count: Number of non-owning Weak references.

The data is deallocated when the strong count reaches zero, and the control block (holding the counters) is deallocated when both strong and weak counts reach zero. Let’s implement this in C++.

C++ Implementation

Here’s a basic implementation weak-rc.cpp:

( исходный код на Си++ )

Explanation

1. RcControlBlock: Manages the strong and weak reference counts.
2. Rc<T>:

• Owns the data and increments the strong count on copy.
• Deletes the data when the strong count hits zero.
• Provides a method to create a Weak pointer.

3. Weak<T>:

• Non-owning reference; increments the weak count on creation.
• Provides upgrade(), which returns an Rc if the strong count is greater than zero, or std::nullopt if the data is gone.
• Cleans up the control block when both counts reach zero.

Key Differences

• Rust’s Weak returns an Option<Rc<T>> on upgrade(), while std::weak_ptr::lock() returns a std::shared_ptr or null.
• The manual C++ version uses std::optional to mimic Rust’s Option.
• Rust enforces thread-safety with Arc separately, while std::shared_ptr is not thread-safe for modification without synchronization (akin to Rc).

Продолжим разбираться с умными указателями в Rust. Глянем на тип Rc<T>. Название расшифровывается как Reference Counted, что намекает. Спросим grok.com. Выходит почти тот же shared_ptr, с двумя отличиями: он не может оказаться NULL, и счетчик простой, а не std::atomic. Сгенерённый ним исходник смотрите в файле: rc.cpp 

Question: How Rc<T> would look if implemented in C++?

Let’s re-implement Rust’s Rc<T> in C++ - a fascinating exercise since Rc<T> introduces reference-counted shared ownership, contrasting with the unique ownership of Box<T>. In Rust, Rc<T> (short for "Reference Counted") allows multiple owners of a heap-allocated T, tracking the number of references via a counter. When the last Rc is dropped, the T is deallocated. This is akin to C++’s std::shared_ptr<T>, but we’ll craft a custom version to mirror Rust’s Rc<T> behavior, focusing on its single-threaded nature (unlike Arc<T> for multi-threading).

What Rc<T> Does in Rust

• Allocation: Places a T on the heap with a reference count.
• Shared Ownership: Multiple Rc<T> instances can point to the same T, incrementing the count.
• Cloning: Rc::clone creates a new reference, bumping the count.
• Deallocation: When the last Rc is dropped (count hits 0), T is destroyed and memory freed.
• No Mutability: Rc<T> alone doesn’t allow mutation (use RefCell<T> or Cell<T> for that).
• Non-Atomic: Single-threaded, unlike Arc<T>.

C++ Implementation

We’ll create an Rc<T> class in C++ that:

• Uses a control block to store the reference count and T together.
• Supports copying (to increment the count) and RAII cleanup.
• Mimics Rust’s immutability by providing const access (mutation would need a separate mechanism).
• Avoids atomic operations, matching Rc’s single-threaded design.

Here’s the code:

#include <cassert>
#include <utility>
#include <iostream>

// Control block to hold the reference count and the value
template <typename T>
struct RcControlBlock {
    size_t count;
    T value;

    template <typename... Args>
    RcControlBlock(Args&&... args) : count(1), value(std::forward<Args>(args)...) {}
};

template <typename T>
class Rc {
private:
    RcControlBlock<T>* block;

    // Private constructor from raw block (for internal use)
    explicit Rc(RcControlBlock<T>* b) : block(b) {}

    void increment() {
        if (block) {
            ++block->count;
        }
    }

    void decrement() {
        if (block && --block->count == 0) {
            delete block;
            block = nullptr;
        }
    }

public:
    // Constructor: Allocate and construct T
    template <typename... Args>
    explicit Rc(Args&&... args) : block(new RcControlBlock<T>(std::forward<Args>(args)...)) {}

    // Destructor: Decrease count, cleanup if last reference
    ~Rc() {
        decrement();
    }

    // Copy constructor: Share ownership
    Rc(const Rc& other) : block(other.block) {
        increment();
    }

    // Copy assignment: Share ownership
    Rc& operator=(const Rc& other) {
        if (this != &other) {
            decrement();           // Drop old reference
            block = other.block;   // Take new reference
            increment();
        }
        return *this;
    }

    // Move constructor: Transfer pointer, no count change
    Rc(Rc&& other) noexcept : block(other.block) {
        other.block = nullptr; // Leave moved-from empty
    }

    // Move assignment: Transfer pointer, no count change
    Rc& operator=(Rc&& other) noexcept {
        if (this != &other) {
            decrement();           // Drop old reference
            block = other.block;   // Take new reference
            other.block = nullptr; // Leave moved-from empty
        }
        return *this;
    }

    // Accessors (const only, mimicking Rust's immutability)
    const T& operator*() const {
        assert(block != nullptr);
        return block->value;
    }

    const T* operator->() const {
        assert(block != nullptr);
        return &block->value;
    }

    // Clone method (like Rc::clone)
    Rc clone() const {
        return Rc(*this); // Uses copy constructor
    }

    // Get reference count (for debugging)
    size_t use_count() const {
        return block ? block->count : 0;
    }
};

// Factory function (like Rc::new)
template <typename T, typename... Args>
Rc<T> make_rc(Args&&... args) {
    return Rc<T>(std::forward<Args>(args)...);
}

This Rc<T> captures Rust’s essence - shared, immutable, single-threaded ownership.

Нет лучше способа понять язык программирования, чем глянуть на реализацию. В языке Rust многое напоминает Си++, но всё ж таки "трошечки не так". Разберёмся с конструкцией Box<T> для начала. Спросим grok.com. Результат смотрите в файле box.cpp.

Question: Imagine I need to re-implement Box<T> in C++. How would it look like?

Re-implementing Rust’s Box<T> in C++ is a fun challenge that lets us peek into Rust’s memory management internals and translate them into C++’s world. In Rust, Box<T> is a smart pointer that provides heap-allocated ownership with automatic cleanup, backed by the global allocator (usually malloc/free via Rust’s alloc crate). It’s simple but powerful: it allocates memory for a T, moves the value onto the heap, and deallocates it when the Box goes out of scope via Drop. In C++, we don’t have Rust’s ownership model or Drop trait, so we’ll use RAII and a custom class to mimic it.

Let’s design a C++ equivalent, breaking down the essentials of Box<T> and handling the nuances of C++’s memory model.

What Box<T> Does in Rust

• Allocation: Allocates memory on the heap for a T using the global allocator.
• Ownership: Sole owner of the heap memory; no sharing or borrowing by default.
• Move Semantics: Transfers ownership when assigned or passed (no copying unless T: Clone).
• Deallocation: Automatically frees the memory when dropped, calling T’s destructor if it has one.
• Dereferencing: Provides access to T via * or . (through Deref).

C++ Implementation

We’ll create a Box class in C++ that:

• Uses new and delete for allocation/deallocation (mirroring malloc/free).
• Implements RAII for automatic cleanup.
• Supports move semantics (C++11 and later) to mimic Rust’s ownership transfer.
• Prevents copying to enforce single ownership (like Rust).
• Provides dereference operators (* and ->).

Here’s the code: box.cpp.

template <typename T>
class Box {
private:
    T *ptr; // Raw pointer to heap-allocated memory

    // Private helper to deallocate
    void deallocate()
    {
        if (ptr) {
            delete ptr; // Calls T's destructor, then frees memory
            ptr = nullptr;
        }
    }

public:
    // Constructor: Allocate and construct T in-place
    template <typename... Args>
    explicit Box(Args &&...args) : ptr(new T(std::forward<Args>(args)...))
    {
    }

    // Destructor: Automatically clean up
    ~Box() { deallocate(); }

    // Disable copying (Rust Box doesn't allow this)
    Box(const Box &) = delete;
    Box &operator=(const Box &) = delete;

    // Move constructor: Transfer ownership
    Box(Box &&other) noexcept : ptr(other.ptr)
    {
        other.ptr = nullptr; // Leave other in a valid, empty state
    }

    // Move assignment: Transfer ownership
    Box &operator=(Box &&other) noexcept
    {
        if (this != &other) {
            deallocate();        // Free current memory
            ptr = other.ptr;     // Take ownership
            other.ptr = nullptr; // Leave other empty
        }
        return *this;
    }

    // Dereference operators
    T &operator*() { return *ptr; }
    const T &operator*() const { return *ptr; }

    T *operator->() { return ptr; }
    const T *operator->() const { return ptr; }

    // Optional: Raw pointer access (like Box::into_raw in Rust)
    T *as_raw() { return ptr; }

    // Optional: Take ownership back (like Box::from_raw, but consumes self)
    T into_inner()
    {
        T value = std::move(*ptr);
        deallocate();
        return value;
    }
};

// Factory function to simplify creation (like Box::new in Rust)
template <typename T, typename... Args>
Box<T> make_box(Args &&...args)
{
    return Box<T>(std::forward<Args>(args)...);
}

Оказывается, народ перевоплотил на Си++ одну из самых ранних досовских игрушек: аркадный волейбол. На маке ставится командой "sudo port install gav".

Исходники здесь: github.com/ctrl-z-bg/gav

Прикидываю, не затащить ли эту игрушку под FP/M на микроконтроллер с экранчиком 240x135.

Задумался я соорудить простой тест для сравнения скорости процессоров. Чтобы чуть более практичный, чем Dhrystone. И сдаётся мне, что красно-черные деревья ровно то, что надо. Многие системные программы, скажем компиляторы, занимаются примерно тем же: выполняют разные манипуляции над графами. В языке Си++ на сбалансированных деревьях построены стандартные классы std::set и std::map. Cкорость их работы и будем замерять. А в качестве генератора данных приспособим лоренцов аттрактор.

Сделал я такие тестики: set.cpp и map.cpp. Тесты создают 2 миллиона записей, а затем эти записи по одной удаляют. Общий размер данных выходит порядка 100 мегабайт. Процесс однопоточный, то есть задействуется только одно ядро процессора. Тест выдаёт две величины: скорость (количество записей в миллисекунду) и занятую память (в байтах на одну запись).

Прогнал я эти тесты на имевшихся под рукой компьютерах:

• макбук на процессоре Apple M2 - MacOS, clang
• мак мини на процессоре Apple M1 - MacOS, clang
• iMac на процессоре Intel i9 - MacOS, clang
• ноутбук Lenovo на процессоре Intel i7 - Ubuntu, gcc
• Raspberry Py 5 - Ubuntu, gcc
• Raspberry Py 4 - FreeBSD, clang
• олинуксино на процессоре ARM32 - Debian, gcc

Результаты собраны в таблицу.

                                            --------Rate--------    -------Memory-------
Processor, Computer                         std::set    std::map    std::set    std::map
----------------------------------------------------------------------------------------
Apple M2 Max (12) @ 3.70 GHz                3856.1      2997.5      32.7        48.7
MacBook Pro (16-inch, 2023)
----------------------------------------------------------------------------------------
Apple M1 (8) @ 3.20 GHz                     2608.3      2091.6      32.7        48.7
Mac mini (M1, 2020)
----------------------------------------------------------------------------------------
Intel Core i9-9900K (16) @ 3.60 GHz         2302.4      1953.3      32.4        48.5
iMac (Retina 5K, 27-inch, 2019)
----------------------------------------------------------------------------------------
Intel Core i7-8750H (12) @ 4.10 GHz         1656.6      1654.2      49.8        49.8
Lenovo ThinkPad P1
----------------------------------------------------------------------------------------
Cortex-A76 (4) @ 2.40 GHz                   775.7       788.1       49.6        49.6
Raspberry Pi 5 Model B Rev 1.0
----------------------------------------------------------------------------------------
ARM Cortex-A72 r0p3 (4) @ 1.5 GHz           527.7       490.3       34.7        50.3
Raspberry Pi 4 Model B Rev 1.2
----------------------------------------------------------------------------------------
Allwinner sun7i (A20) Family (2) @ 960MHz   149.7       141.3       25.2        33.1
Olimex A20-OLinuXino-LIME2