239 lines
8.2 KiB
C
239 lines
8.2 KiB
C
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <stdint.h>
|
|
#include <string.h>
|
|
#include <time.h>
|
|
#include <unistd.h>
|
|
#include <sys/mman.h>
|
|
#include <errno.h>
|
|
#include <pthread.h>
|
|
#include <ctype.h>
|
|
#include <getopt.h>
|
|
|
|
#define DEBUG 0
|
|
#define jemalloc 0
|
|
|
|
#if defined(DEBUG) && DEBUG > 1
|
|
#define DEBUG_PRINT(fmt, args...) fprintf(stderr, "DEBUG: %s:%d:%s(): " fmt, \
|
|
__FILE__, __LINE__, __func__, ##args)
|
|
#elif DEBUG == 1
|
|
#define DEBUG_PRINT(fmt, args...) fprintf(stderr, "DEBUG: %d:%s(): " fmt, \
|
|
__LINE__, __func__, ##args)
|
|
#else
|
|
#define DEBUG_PRINT(fmt, args...) /* Don't do anything in release builds */
|
|
#endif
|
|
|
|
#define BLOCK_SIZE (1024ULL*1024ULL*1024ULL*8)
|
|
|
|
uint32_t test_patterns[] = {0x00000000, 0xFFFFFFFF, 0xAAAAAAAA, 0x55555555};
|
|
int test_list[] = {2,3,4};
|
|
#define bool unsigned char
|
|
|
|
struct tred_pizdec{
|
|
uint32_t* mem;
|
|
size_t words_stop;
|
|
int id;
|
|
size_t words_start;
|
|
int return_error;
|
|
bool test_tip;
|
|
};
|
|
|
|
#include "multi_tred.h"
|
|
#include "single_tred.h"
|
|
|
|
// Получить доступную память из /proc/meminfo
|
|
unsigned long int get_mem_available_mb() {
|
|
FILE* f = fopen("/proc/meminfo", "r");
|
|
if (!f) return 0;
|
|
char line[256];
|
|
unsigned long int available = 0;
|
|
while (fgets(line, sizeof(line), f)) {
|
|
if (sscanf(line, "MemAvailable: %lu kB", &available) == 1) break;
|
|
}
|
|
fclose(f);
|
|
printf("mem Gb: %lu\n",(available-available/100*10)/1024/1024);
|
|
printf("mem MB: %lu\n",(available-available/100*10)/1024);
|
|
return (available - available/100*10)*1024;
|
|
}
|
|
|
|
|
|
void test_patern(struct tred_pizdec** meta,unsigned long* thread, int tred, size_t words, uint32_t * mem, int* err, int p, int test_tipe){
|
|
if (test_tipe == 1){
|
|
printf("\rЗапушен патерн 0x%08X", test_patterns[p]);
|
|
fflush(stdout);
|
|
}
|
|
else if (test_tipe == 2){
|
|
printf("\rЗапушен патерн инкрементации");
|
|
fflush(stdout);
|
|
}
|
|
else if (test_tipe == 3){
|
|
printf("\rЗапушен патерн ones test");
|
|
fflush(stdout);
|
|
}
|
|
else if (test_tipe == 4){
|
|
printf("\rЗапушен патерн zeros test");
|
|
fflush(stdout);
|
|
}
|
|
for (bool i = 0;(i != tred); i++){
|
|
meta[i] = malloc(sizeof(struct tred_pizdec));
|
|
meta[i]->id = p;
|
|
meta[i]->mem = mem;
|
|
meta[i]->words_stop = words/tred*(i+1);
|
|
meta[i]->words_start = i * words/tred;
|
|
meta[i]->test_tip = test_tipe;
|
|
DEBUG_PRINT("words_stop: %zu\n",meta[i]->words_stop);
|
|
DEBUG_PRINT("words_start:%zu\n",meta[i]->words_start);
|
|
pthread_create(&thread[i], NULL, fill_pattern_multi_tred, (void*)meta[i]);
|
|
//pthread_join(thread[i], NULL);
|
|
}
|
|
for (bool i = 0;(i != tred); i++)
|
|
pthread_join(thread[i], NULL);
|
|
//fill_pattern(mem, words, test_patterns[p]);
|
|
//printf("Жду\n");
|
|
//usleep(10000000);
|
|
printf("\r-- Проверяю ");
|
|
fflush(stdout);
|
|
//int err = check_pattern(mem, words, test_patterns[p]);
|
|
|
|
for (bool i = 0;(i != tred); i++){
|
|
meta[i] = malloc(sizeof(struct tred_pizdec));
|
|
meta[i]->id = p;
|
|
meta[i]->mem = mem;
|
|
meta[i]->words_stop = words/tred*(i+1);
|
|
meta[i]->words_start = i * words/tred;
|
|
meta[i]->test_tip = test_tipe;
|
|
DEBUG_PRINT("words_stop: %zu\n",meta[i]->words_stop);
|
|
DEBUG_PRINT("words_start:%zu\n",meta[i]->words_start);
|
|
pthread_create(&thread[i], NULL, check_pattern_multi_tred, (void*)meta[i]);
|
|
//pthread_join(thread[i], NULL);
|
|
}
|
|
for (bool i = 0;(i != tred); i++){
|
|
pthread_join(thread[i], NULL);
|
|
*err += meta[i]->return_error;
|
|
free(meta[i]);
|
|
}
|
|
if (*err == 0){
|
|
printf("\rOK\n");
|
|
fflush(stdout);
|
|
}
|
|
else printf("Errors: %d\n", *err);
|
|
}
|
|
void print_help(const char *progname) {
|
|
printf("Использование: %s [опции]\n", progname);
|
|
printf(" -h, --help показать это сообщение\n");
|
|
printf(" -t, --threads N указать число потоков\n");
|
|
printf(" -i, --iterations N указать число повторения тестов\n");
|
|
printf(" -j, --json вывод в виде json\n");
|
|
}
|
|
|
|
int main(int argc, char *argv[]){
|
|
if (mlockall(MCL_CURRENT | MCL_FUTURE) != 0) {
|
|
perror("mlockall ошибка!\nВозможно недостаточно прав!\n");
|
|
return 1;
|
|
}
|
|
int tred = -1, iterations = 1;
|
|
|
|
const struct option long_options[] = {
|
|
{"help", no_argument, 0, 'h'},
|
|
{"threads", required_argument, 0, 't'},
|
|
{"verbose", no_argument, 0, 'v'},
|
|
{"iterations", required_argument, 0, 'i'},
|
|
{"json", no_argument, 0, 'j'},
|
|
{0, 0, 0, 0}
|
|
};
|
|
|
|
int opt;
|
|
while ((opt = getopt_long(argc, argv, "ht:i:j", long_options, NULL)) != -1) {
|
|
switch (opt) {
|
|
case 'h':
|
|
print_help(argv[0]);
|
|
exit(0);
|
|
case 't':
|
|
tred = atoi(optarg);
|
|
break;
|
|
case 'i':
|
|
iterations = atoi(optarg);
|
|
break;
|
|
default:
|
|
print_help(argv[0]);
|
|
exit(1);
|
|
}
|
|
}
|
|
|
|
printf("threads: %d\n", tred);
|
|
|
|
unsigned long int mem_size = get_mem_available_mb();
|
|
size_t words = mem_size / sizeof(uint32_t);
|
|
uint32_t *mem = malloc(mem_size);
|
|
if (!mem) {
|
|
perror("Память выделена!");
|
|
return 1;
|
|
}
|
|
//struct tred_pizdec* meta[];
|
|
//pthread_t thread[];
|
|
int err = 0;
|
|
struct tred_pizdec** meta = malloc(sizeof(struct tred_pizdec) * tred);
|
|
pthread_t *thread = malloc(sizeof(pthread_t) * tred);
|
|
printf("iterations: %i\n", iterations);
|
|
for (;iterations != 0; iterations--){
|
|
if (tred != -1){
|
|
for (size_t p = 0; p < sizeof(test_patterns)/sizeof(test_patterns[0]); ++p)
|
|
test_patern(meta, thread, tred, words, mem, &err, p, 1);// Основные паттерны 0x00000000, 0xFFFFFFFF, 0xAAAAAAAA, 0x55555555
|
|
for (int test_list_id = 0; test_list_id < sizeof(test_list)/sizeof(test_list[0]); ++test_list_id){
|
|
test_patern(meta, thread, tred, words, mem, &err, 0, test_list[test_list_id]);
|
|
}
|
|
}
|
|
else{
|
|
// Основные паттерны 0x00000000, 0xFFFFFFFF, 0xAAAAAAAA, 0x55555555
|
|
for (size_t p = 0; p < sizeof(test_patterns)/sizeof(test_patterns[0]); ++p){
|
|
printf("\rЗапушен патерн 0x%08X", test_patterns[p]);
|
|
fflush(stdout);
|
|
fill_pattern(mem, words, test_patterns[p]);
|
|
printf("\r-- Проверяю ");
|
|
fflush(stdout);
|
|
err += check_pattern(mem, words, test_patterns[p]);
|
|
if (err == 0){
|
|
printf("\rOK");
|
|
fflush(stdout);
|
|
}
|
|
else printf("\nErrors: %d\n", err);
|
|
}
|
|
// Инкремент
|
|
printf("\rЗапушен патерн инкрементации");
|
|
fflush(stdout);
|
|
fill_increment(mem, words);
|
|
//usleep(10000000);
|
|
for (size_t i = 0; i < words; i++) {
|
|
if (mem[i] != (uint32_t)i) {
|
|
printf("\nОшибка в тесте %zu: должен быть: 0x%08X, фактический: 0x%08X\n", i, (uint32_t)i, mem[i]);
|
|
err++;
|
|
if (err > 10) break;
|
|
}
|
|
}
|
|
printf("\rЗапушен патерн Walking Ones");
|
|
fflush(stdout);
|
|
fill_walking_ones(mem, words);
|
|
if (0 == fill_walking_ones_test(mem, words)){
|
|
printf("\rOK");
|
|
fflush(stdout);
|
|
}
|
|
printf("\rЗапушен патерн Walking Zeros");
|
|
fflush(stdout);
|
|
fill_walking_zeros(mem, words);
|
|
if (0 == fill_walking_zeros_test(mem, words)){
|
|
printf("\rOK");
|
|
fflush(stdout);
|
|
}
|
|
if (err == 0){
|
|
printf("\rOK");
|
|
fflush(stdout);
|
|
}
|
|
else printf("\nErrors: %d\n", err);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
free(mem);
|
|
return 0;
|
|
}
|