272 lines
8.4 KiB
C++
272 lines
8.4 KiB
C++
// CPUSpeed v1.20
|
||
// 17/11/2021
|
||
// https://t.me/ssleg © 2020 – 2021
|
||
|
||
#include <iostream>
|
||
#include <random>
|
||
#include <thread>
|
||
#include <sys/sysinfo.h>
|
||
#include <mutex>
|
||
|
||
using namespace std;
|
||
|
||
const int max_gen_value = 2147483647;
|
||
const int MB = 1048576;
|
||
mutex print_lock;
|
||
|
||
double cpu_time() {
|
||
clockid_t id = CLOCK_THREAD_CPUTIME_ID;
|
||
struct timespec ts{};
|
||
|
||
clock_gettime(id, &ts);
|
||
return (double) ts.tv_sec + (double) ts.tv_nsec / 1000000000.0;
|
||
}
|
||
|
||
void rnd_generator(int th_num, int start, int end, float *array, double *times) {
|
||
print_lock.lock();
|
||
cout << "поток #" << th_num << " " << start << " " << end << endl;
|
||
print_lock.unlock();
|
||
|
||
random_device rd;
|
||
mt19937 gen(rd());
|
||
uniform_int_distribution<> dist(0, max_gen_value);
|
||
|
||
double start_time = cpu_time();
|
||
int interval = (end - start) / 5;
|
||
double cycle_time;
|
||
double old_cycle_time = start_time;
|
||
|
||
int i;
|
||
for (i = start; i < end; i++) {
|
||
array[i] = dist(gen);
|
||
if (i % interval == 0 and i > 0) {
|
||
cycle_time = cpu_time();
|
||
|
||
print_lock.lock();
|
||
printf("поток #%u, %uМб. время %3.5f сек.\n", th_num, i / MB * 16, cycle_time - old_cycle_time);
|
||
print_lock.unlock();
|
||
|
||
old_cycle_time = cycle_time;
|
||
}
|
||
}
|
||
|
||
double end_time = cpu_time();
|
||
double th_time = end_time - start_time;
|
||
|
||
print_lock.lock();
|
||
printf("поток #%u, всего времени генератора %3.5f сек.\n", th_num, th_time);
|
||
print_lock.unlock();
|
||
|
||
times[th_num] = th_time;
|
||
}
|
||
|
||
void zero_fill(int th_num, int arr_size, double *array, double *times) {
|
||
print_lock.lock();
|
||
cout << "поток #" << th_num << ", zero_fill." << endl;
|
||
print_lock.unlock();
|
||
|
||
double start_time = cpu_time();
|
||
int interval = arr_size / 5;
|
||
double cycle_time;
|
||
double old_cycle_time = start_time;
|
||
|
||
int i;
|
||
for (i = 0; i < arr_size; i++) {
|
||
array[i] = 0;
|
||
if (i % interval == 0 and i > 0) {
|
||
cycle_time = cpu_time();
|
||
|
||
print_lock.lock();
|
||
printf("поток #%u, %uМб. время %3.5f сек.\n", th_num, i / MB * 16, cycle_time - old_cycle_time);
|
||
print_lock.unlock();
|
||
|
||
old_cycle_time = cycle_time;
|
||
}
|
||
}
|
||
|
||
double end_time = cpu_time();
|
||
double th_time = end_time - start_time;
|
||
|
||
print_lock.lock();
|
||
printf("поток #%u, всего времени стирания %3.5f сек.\n", th_num, th_time);
|
||
print_lock.unlock();
|
||
|
||
times[th_num] = th_time;
|
||
}
|
||
|
||
void compute(int th_num, int start, int end, const float *a, const float *b, double *rez, double *times) {
|
||
int i;
|
||
double r1, r2, r3, r4, r5, r6, r7, r8;
|
||
double start_time = cpu_time();
|
||
double end_time;
|
||
for (i = start; i < end - 7; i++) {
|
||
r1 = a[i] * b[i];
|
||
r2 = a[i] * b[i + 1];
|
||
r3 = a[i] * b[i + 2];
|
||
r4 = a[i] * b[i + 3];
|
||
r5 = a[i] * b[i + 4];
|
||
r6 = a[i] * b[i + 5];
|
||
r7 = a[i] * b[i + 6];
|
||
r8 = a[i] * b[i + 7];
|
||
rez[i] = (r1 + r2 + r3 + r4 + r5 + r6 + r7 + r8) / 8;
|
||
}
|
||
end_time = cpu_time();
|
||
times[th_num] = end_time - start_time;
|
||
}
|
||
|
||
void thread_starter(int start_num, int th_number, int arr_size, float *array, thread *threads, double *times) {
|
||
int i;
|
||
int start, end, block;
|
||
block = arr_size / th_number;
|
||
|
||
for (i = 0; i < th_number; i++) {
|
||
start = i * block;
|
||
if (i + 1 != th_number) {
|
||
end = (i + 1) * block;
|
||
} else {
|
||
end = arr_size;
|
||
}
|
||
|
||
threads[start_num + i] = thread(rnd_generator, start_num + i, start, end, array, times);
|
||
}
|
||
|
||
}
|
||
|
||
int input_integer(int low, int high) {
|
||
bool flag = false;
|
||
int input;
|
||
|
||
do {
|
||
cin >> input;
|
||
if (input > low and input <= high) {
|
||
flag = true;
|
||
} else {
|
||
cin.clear();
|
||
cin.ignore(32767, '\n');
|
||
cout << "неверный ввод, попробуйте снова:";
|
||
}
|
||
} while (!flag);
|
||
cin.ignore(32767, '\n');
|
||
|
||
return input;
|
||
}
|
||
|
||
|
||
int main() {
|
||
struct sysinfo info{};
|
||
sysinfo(&info);
|
||
long total_ram = info.totalram;
|
||
long free_ram = info.freeram;
|
||
int max_array_size = int(double(free_ram) / 16 / MB);
|
||
cout << "-----------------------------------------------" << endl;
|
||
cout << "CPUSpeed v1.20" << endl;
|
||
cout << "-----------------------------------------------" << endl;
|
||
printf("оперативной памяти всего - %3.1f Gb\n", float(total_ram) / 1024 / MB);
|
||
printf("свободно - %3.2f Gb\n", float(free_ram) / 1024 / MB);
|
||
|
||
int cores_count = int(thread::hardware_concurrency());
|
||
|
||
printf("введите количество потоков [1-%u]:", cores_count);
|
||
int threads = input_integer(0, cores_count);
|
||
|
||
printf("введите размер массива данных [8-%u]:", max_array_size);
|
||
int arr = input_integer(7, max_array_size);
|
||
|
||
cout << "введите количество тестов [1-1000]:";
|
||
int test_count = input_integer(0, 1000);
|
||
|
||
const int arr_size = arr * MB;
|
||
const float real_mem_size = float(arr_size) * 16 / 1024 / MB;
|
||
auto *a = new float[arr_size];
|
||
auto *b = new float[arr_size];
|
||
auto *rez = new double[arr_size];
|
||
|
||
printf("запуск бенчмарка. реальный необходимый обьем RAM - %3.1f Gb\n", real_mem_size);
|
||
|
||
int i;
|
||
auto *thr = new thread[threads];
|
||
auto *times = new double[threads];
|
||
auto *sum_times = new double[threads];
|
||
auto *sum_flops = new double[threads];
|
||
|
||
if (threads == 1) {
|
||
thread_starter(0, threads, arr_size, a, thr, times);
|
||
thr[0].join();
|
||
thread_starter(0, threads, arr_size, b, thr, times);
|
||
thr[0].join();
|
||
thr[0] = thread(zero_fill, 0, arr_size, rez, times);
|
||
thr[0].join();
|
||
}
|
||
if (threads == 2) {
|
||
thread_starter(0, 1, arr_size, a, thr, times);
|
||
thread_starter(1, 1, arr_size, b, thr, times);
|
||
thr[0].join();
|
||
thr[1].join();
|
||
thr[0] = thread(zero_fill, 0, arr_size, rez, times);
|
||
thr[0].join();
|
||
}
|
||
if (threads > 2) {
|
||
int a_threads = (threads - 1) / 2;
|
||
int b_threads = threads - 1 - a_threads;
|
||
thread_starter(0, a_threads, arr_size, a, thr, times);
|
||
thread_starter(a_threads, b_threads, arr_size, b, thr, times);
|
||
thr[threads - 1] = thread(zero_fill, threads - 1, arr_size, rez, times);
|
||
for (i = 0; i < threads; i++) {
|
||
thr[i].join();
|
||
}
|
||
}
|
||
|
||
for (i = 0; i < threads; i++) {
|
||
printf("поток %u, время - %3.5f сек.\n", i, times[i]);
|
||
}
|
||
|
||
|
||
int k, start, end, block;
|
||
int64_t operations;
|
||
double flops;
|
||
block = arr_size / threads;
|
||
for (k = 0; k < test_count; k++) {
|
||
cout << "запуск теста #" << k + 1 << endl;
|
||
for (i = 0; i < threads; i++) {
|
||
start = i * block;
|
||
if (i + 1 != threads) {
|
||
end = (i + 1) * block;
|
||
} else {
|
||
end = arr_size;
|
||
}
|
||
|
||
thr[i] = thread(compute, i, start, end, a, b, rez, times);
|
||
}
|
||
for (i = 0; i < threads; i++) {
|
||
thr[i].join();
|
||
}
|
||
for (i = 0; i < threads; i++) {
|
||
sum_times[i] += times[i];
|
||
operations = (int64_t(end) - int64_t(start) - 7) * 16;
|
||
flops = (operations / times[i]) / 1000000;
|
||
sum_flops[i] += flops;
|
||
printf("поток %u, время - %3.5f сек. (%3.2f MFlops)\n", i, times[i], flops);
|
||
}
|
||
}
|
||
cout << "-----------------------------------------------" << endl;
|
||
cout << "Итоговая производительность." << endl;
|
||
cout << "потоков - " << threads << ", размер массива - " << arr << ", тестов - " << test_count << endl;
|
||
cout << "-----------------------------------------------" << endl;
|
||
double medium_speed, medium_flops, sys_flops;
|
||
sys_flops = 0;
|
||
for (i = 0; i < threads; i++) {
|
||
medium_speed = sum_times[i] / test_count;
|
||
medium_flops = sum_flops[i] / test_count;
|
||
sys_flops += medium_flops;
|
||
printf("поток %u, время - %3.5f сек. (%3.2f MFlops)\n", i, medium_speed, medium_flops);
|
||
}
|
||
cout << "-----------------------------------------------" << endl;
|
||
printf("Система всего - %3.2f MFlops\n", sys_flops);
|
||
cout << "-----------------------------------------------" << endl;
|
||
|
||
free(a);
|
||
free(b);
|
||
free(rez);
|
||
|
||
return 0;
|
||
} |