```cpp
#include <iostream>
#include <vector>
#include <random>
#include <chrono>
int main() {
// время работы бенчмарка по умолчанию
long long milliseconds = 6000;
// размер буфера чисел для бенчмарке в тесте (нужен, чтобы избежать работы L1/L2/L3-кэша процессора)
int randomBufferSize = 20000;
// заполнение буфера 32-битных чисел для участия в бенчмарке
std::vector<int> mem1;
std::mt19937 rnd1(777);
for (int n = 0; n < randomBufferSize; n++) {
int a = static_cast<int>(rnd1() % INT_MAX) << 17;
int b = static_cast<int>(rnd1() % INT_MAX);
int r = a + b;
mem1.push_back(r == 0 ? 1 : r);
}
// заполнение буфера 64-битных чисел для участия в бенчмарке
std::vector<long long> mem2;
std::mt19937 rnd2(777);
for (int n = 0; n < randomBufferSize; n++) {
long long a = static_cast<long long>(rnd2() % INT_MAX) << 15;
long long b = (a + static_cast<long long>(rnd2() % INT_MAX)) << 15;
long long c = (b + static_cast<long long>(rnd2() % INT_MAX)) << 15;
long long d = static_cast<long long>(rnd2() % INT_MAX);
long long r = c + d;
mem2.push_back(r == 0 ? 1 : r);
}
// числа, участвующие в бенчмарке вынесены из цикла, чтобы избежать затрат ресурсов на выделение памяти на каждой итерации
int mem_index = 0;
long long v27 = 0;
const int addSubOpsCount = 1000;
const int mulDivOpsCount = 500;
int v11, v17, v4, v10, v12, v13, v18;
long long v15, v16, v14, v8, v9, v31, i;
// таймер для подсчета прошедшего времени
auto start_time = std::chrono::high_resolution_clock::now();
// основной цикл бенчмарка длительностью в 6 секунд
while (true)
{
// значения для 32-битного эксперимента
v4 = mem1[mem_index + 1];
v10 = mem1[mem_index + 0];
v11 = mem1[mem_index + 2];
v12 = mem1[mem_index + 3];
v13 = mem1[mem_index + 4];
v17 = mem1[mem_index + 5];
v18 = v4;
// значения для 64-битного эксперимента
v14 = mem2[mem_index + 0];
v8 = mem2[mem_index + 1];
v15 = mem2[mem_index + 2];
v31 = mem2[mem_index + 3];
i = v31;
v9 = mem2[mem_index + 4];
v16 = mem2[mem_index + 5];
mem_index = (mem_index + 6) % (randomBufferSize - 6);
int v19 = addSubOpsCount;
// 32-битный эксперимент: сложение/вычитание (66 операций)
do {
v10 = (~(v11 + (v18 ^ ((v11 & (v11 + ((v11 - v18 + v10) << 8))) - v18))) - v18) | 0x337;
v12 = (~(v17 + (v13 ^ ((v17 & (v17 + ((v17 - v13 + v12) << 8))) - v13))) - v13) | 0x337;
v18 = (~(v11 + (v10 ^ ((v11 & (v11 + ((v11 - v10 + v18) << 8))) - v10))) - v10) | 0x1C9;
v13 = (~(v17 + (v12 ^ ((v17 & (v17 + ((v17 - v12 + v13) << 8))) - v12))) - v12) | 0x1C9;
v11 = (~(v10 + (v18 ^ ((v10 & (v10 + ((v10 + v11 - v18) << 8))) - v18))) - v18) | 0x2A1;
v17 = (~(v12 + (v13 ^ ((v12 & (v12 + ((v12 + v17 - v13) << 8))) - v13))) - v13) | 0x2A1;
--v19;
} while (v19 > 0);
long long v20 = addSubOpsCount;
long long i = v31;
// 64-битный эксперимент: сложение/вычитание (66 операций)
for (; v20 > 0; --v20) {
v14 = (~(v15 + (v8 ^ ((v15 & (v15 + ((v15 - v8 + v14) << 8))) - v8))) - v8) | 0x337;
i = (~(v16 + (v9 ^ ((v16 & (v16 + ((v16 - v9 + i) << 8))) - v9))) - v9) | 0x337;
v8 = (~(v15 + (v14 ^ ((v15 & (v15 + ((v15 - v14 + v8) << 8))) - v14))) - v14) | 0x1C9;
v9 = (~(v16 + (i ^ ((v16 & (v16 + ((v16 - i + v9) << 8))) - i))) - i) | 0x1C9;
v15 = (~(v14 + (v8 ^ ((v14 & (v14 + ((v14 + v15 - v8) << 8))) - v8))) - v8) | 0x2A1;
v16 = (~(i + (v9 ^ ((i & (i + ((i + v16 - v9) << 8))) - v9))) - v9) | 0x2A1;
}
int v22 = mulDivOpsCount;
// 32-битный эксперимент: умножение/деление (10 операций)
do {
v11 = v18 | (v18 * v10 * v11 * v10 * v11 / v10);
v17 = v13 | (v13 * v12 * v17 * v12 * v17 / v12);
--v22;
} while (v22 > 0);
// 64-битный эксперимент: умножение/деление (10 операций)
for (int j = mulDivOpsCount; j > 0; --j) {
v15 = v8 | (v8 * v14 * v15 * v14 * v15 / v14);
v16 = v9 | (v9 * i * v16 * i * v16 / i);
}
// суммирование всех операций за итерацию (66 - сложение/вычитание, 10 - умножение/деление)
v27 += 66 * (addSubOpsCount + addSubOpsCount) + 10 * (mulDivOpsCount + mulDivOpsCount);
// если время бенчмарка подошло к концу, выйти из цикла
auto elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::high_resolution_clock::now() - start_time).count();
if (elapsed >= milliseconds) {
break;
}
}
auto end_time = std::chrono::high_resolution_clock::now();
auto elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(end_time - start_time).count();
// итоговый результат = число операций в микросекунду
double result = (static_cast<double>(v27) / elapsed) / 1000.0;
// выводим все значения, чтобы компилятор не срезал вычисления в ходе оптимизации
std::cout << "IntegerMath Test: " << result << " | "
<< v11 + v17 + v4 + v10 + v12 + v13 + v18 +
v15 + v16 + v14 + v8 + v9 + v31 + i << std::endl;
std::cin.get();
return 0;
}
```