365 lines
14 KiB
C
365 lines
14 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>
|
|
|
|
|
|
struct args_struct{
|
|
int tred;
|
|
int iterations;
|
|
int json;
|
|
size_t words;
|
|
};
|
|
struct args_struct args;
|
|
#include "cJSON/cJSON.h"
|
|
#include "args_parser.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};
|
|
|
|
char* test_name[] = {"increment", "ones test", "zeros test"};
|
|
int pretest_delay = 0;
|
|
int test_list[] = {2,3,4};
|
|
#define bool unsigned char
|
|
|
|
|
|
|
|
struct test_info{
|
|
int error;
|
|
int number_addresses;
|
|
};
|
|
struct error_info{
|
|
uint32_t error_adres;
|
|
uint32_t expected;
|
|
uint32_t actual;
|
|
struct error_info* error_info_next;
|
|
};
|
|
struct test_local_stats{
|
|
int error_int;
|
|
struct error_info* error_info;
|
|
struct error_info* error_info_end;
|
|
};
|
|
struct test_stats{
|
|
int len;
|
|
struct test_local_stats* test_local_stats[];
|
|
};
|
|
struct struct_info{
|
|
struct test_info* test_info;
|
|
struct test_stats* test_stats;
|
|
};
|
|
|
|
|
|
struct struct_info info;
|
|
|
|
struct tred_pizdec{
|
|
uint32_t* mem;
|
|
size_t words_stop;
|
|
int id;
|
|
size_t words_start;
|
|
int return_error;
|
|
bool test_tip;
|
|
struct test_stats* test_stats;
|
|
|
|
};
|
|
|
|
#include "multi_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);
|
|
if (!args.json){
|
|
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*20)*1024;
|
|
}
|
|
|
|
|
|
void meseng_proses(int test_tipe, int p){
|
|
if (args.json != 1){
|
|
if (test_tipe == 1){
|
|
printf("\rЗапушен патерн 0x%08X", test_patterns[p]);
|
|
fflush(stdout);
|
|
}
|
|
else{
|
|
printf("\rЗапушен патерн %s", test_name[test_tipe-2]);
|
|
fflush(stdout);
|
|
}
|
|
}
|
|
}
|
|
void meseng_test_and_slip(){
|
|
if (pretest_delay!= 0){
|
|
printf("\rЖду ");
|
|
fflush(stdout);
|
|
usleep(pretest_delay*1000000);
|
|
}
|
|
if (args.json != 1){
|
|
printf("\r-- Проверяю ");
|
|
fflush(stdout);
|
|
}
|
|
}
|
|
|
|
void test_patern(struct tred_pizdec** meta,unsigned long* thread, int tred, int* err, int p, int test_tipe){
|
|
meseng_proses(test_tipe, p);
|
|
for (bool i = 0;(i != tred); i++){// test
|
|
meta[i]->id = p;
|
|
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++) //sink tred
|
|
pthread_join(thread[i], NULL);
|
|
//fill_pattern(mem, words, test_patterns[p]);
|
|
meseng_test_and_slip();
|
|
//int err = check_pattern(mem, words, test_patterns[p]);
|
|
for (bool i = 0;(i != tred); i++){// test
|
|
pthread_create(&thread[i], NULL, check_pattern_multi_tred, (void*)meta[i]);
|
|
//pthread_join(thread[i], NULL);
|
|
}
|
|
for (bool i = 0;(i != tred); i++){ //sink tred
|
|
pthread_join(thread[i], NULL);
|
|
*err += meta[i]->return_error;
|
|
}
|
|
if (!args.json){
|
|
if (*err == 0){
|
|
printf("\rOK\n");
|
|
fflush(stdout);
|
|
}
|
|
else printf("Errors: %d\n", *err);
|
|
}
|
|
}
|
|
|
|
void json_create(struct tred_pizdec** meta){
|
|
cJSON *main_ob = cJSON_CreateObject();
|
|
//cJSON_AddItemToArray(main_Array, main_ob);
|
|
cJSON *test_ob = cJSON_CreateObject();
|
|
cJSON_AddItemToObject(main_ob, "test", test_ob);
|
|
char* putaa = malloc(11);
|
|
unsigned int error_int=0;
|
|
for (int i = 0;i != sizeof(test_patterns)/sizeof(test_patterns[0]); ++i){
|
|
sprintf(putaa, "0x%08X",test_patterns[i]);
|
|
cJSON *error_ob = cJSON_CreateObject();
|
|
cJSON *error_info_array = cJSON_CreateArray();
|
|
unsigned int error_int_local=0;
|
|
for (int t=0; t != args.tred; t++){
|
|
struct error_info* error_info_A = meta[t]->test_stats->test_local_stats[i]->error_info;
|
|
error_int_local += meta[t]->test_stats->test_local_stats[i]->error_int;
|
|
while(NULL != error_info_A){
|
|
//for(){};
|
|
//p += meta[t]->return_error;
|
|
cJSON *error_local_info_array = cJSON_CreateObject();
|
|
{
|
|
char* putaa = malloc(16);
|
|
sprintf(putaa, "%p",(void*)&error_info_A->error_adres);
|
|
cJSON *error_adres = cJSON_CreateString(putaa);
|
|
cJSON_AddItemToObject(error_local_info_array, "error_adres", error_adres);
|
|
}
|
|
{
|
|
char* putaa = malloc(11);
|
|
sprintf(putaa, "0x%08X",error_info_A->expected);
|
|
cJSON *expected = cJSON_CreateString(putaa);
|
|
cJSON_AddItemToObject(error_local_info_array, "expected", expected);
|
|
}
|
|
{
|
|
char* putaa = malloc(11);
|
|
sprintf(putaa, "0x%08X",error_info_A->actual);
|
|
cJSON *actual = cJSON_CreateString(putaa);
|
|
cJSON_AddItemToObject(error_local_info_array, "actual", actual);
|
|
}
|
|
cJSON_AddItemToArray(error_info_array, error_local_info_array);
|
|
error_info_A = error_info_A->error_info_next;
|
|
}
|
|
}
|
|
error_int += error_int_local;
|
|
cJSON *error_int_j = cJSON_CreateNumber(error_int_local);
|
|
cJSON_AddItemToObject(error_ob, "error", error_int_j);
|
|
cJSON_AddItemToObject(error_ob, "error_info", error_info_array);
|
|
cJSON_AddItemToObject(test_ob, putaa, error_ob);
|
|
|
|
}
|
|
for (int i = 0;i != sizeof(test_name)/sizeof(test_name[0]); ++i){
|
|
int error_int_local=0;
|
|
cJSON *error_int_j = cJSON_CreateNumber(error_int_local);
|
|
cJSON *error_ob = cJSON_CreateObject();
|
|
cJSON *error_info_array = cJSON_CreateArray();
|
|
cJSON_AddItemToObject(error_ob, "error", error_int_j);
|
|
cJSON_AddItemToObject(error_ob, "error_info", error_info_array);
|
|
cJSON_AddItemToObject(test_ob, test_name[i], error_ob);
|
|
|
|
}
|
|
free(putaa);
|
|
cJSON *test_info_ob = cJSON_CreateObject();
|
|
cJSON_AddItemToObject(main_ob, "test_info", test_info_ob);
|
|
cJSON *error_int_j = cJSON_CreateNumber(error_int);
|
|
cJSON_AddItemToObject(test_info_ob, "error", error_int_j);
|
|
cJSON *message_str;
|
|
if (error_int)
|
|
message_str = cJSON_CreateString("Тест пройден неудачно!");
|
|
else
|
|
message_str = cJSON_CreateString("Тест пройден успешно!");
|
|
cJSON_AddItemToObject(test_info_ob, "message", message_str);
|
|
cJSON *number_addresses_int = cJSON_CreateNumber(args.words);
|
|
cJSON_AddItemToObject(test_info_ob, "number_addresses", number_addresses_int);
|
|
cJSON *mod_test_str = cJSON_CreateString("user_mod");
|
|
cJSON_AddItemToObject(test_info_ob, "mod_test", mod_test_str);
|
|
char *string = cJSON_Print(main_ob);
|
|
printf("%s", string);
|
|
|
|
//cJSON *volume_js = cJSON_CreateNumber(volume);
|
|
//cJSON_AddItemToObject(main_ob, "volume", volume_js);
|
|
//cJSON_AddItemToObject(main_ob, "content", content_Array);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int main(int argc, char *argv[]){
|
|
if (mlockall(MCL_CURRENT | MCL_FUTURE) != 0) {
|
|
perror("mlockall ошибка!\nВозможно недостаточно прав!\n");
|
|
return 1;
|
|
}
|
|
|
|
args.tred = -1;
|
|
args.iterations = 1;
|
|
args.json = 0;
|
|
|
|
aaa(&argc, argv, &pretest_delay);
|
|
|
|
if (!args.json)
|
|
printf("threads: %d\n", args.tred);
|
|
|
|
unsigned long int mem_size = get_mem_available_mb();
|
|
size_t words = mem_size / sizeof(uint32_t);
|
|
args.words = words;
|
|
uint32_t *mem = malloc(mem_size);
|
|
if (!mem) {
|
|
printf("Память не выделена!");
|
|
return 1;
|
|
}
|
|
//struct tred_pizdec* meta[];
|
|
//pthread_t thread[];
|
|
int err = 0, iterations = args.iterations;
|
|
struct tred_pizdec** meta = malloc(sizeof(struct tred_pizdec) * args.tred);
|
|
pthread_t *thread = malloc(sizeof(pthread_t) * args.tred);
|
|
if (!args.json)
|
|
printf("iterations: %i\n", iterations);
|
|
for (;iterations != 0; iterations--){
|
|
if (args.tred != -1){
|
|
for (bool i = 0;(i != args.tred); i++){// test
|
|
meta[i] = malloc(sizeof(struct tred_pizdec));
|
|
meta[i]->test_stats = malloc(sizeof(struct test_stats) +
|
|
(sizeof(test_list)/sizeof(test_list[0]) + sizeof(test_patterns)/sizeof(test_patterns[0])) * sizeof(struct test_local_stats*)
|
|
);
|
|
meta[i]->test_stats->len = (sizeof(test_list)/sizeof(test_list[0]) + sizeof(test_patterns)/sizeof(test_patterns[0]));
|
|
//meta[i]->test_stats = malloc(meta[i]->test_stats->len);
|
|
for (int m=0;m != meta[i]->test_stats->len;m++){
|
|
meta[i]->test_stats->test_local_stats[m] = malloc(sizeof(struct test_local_stats));
|
|
meta[i]->test_stats->test_local_stats[m]->error_int = 0;
|
|
meta[i]->test_stats->test_local_stats[m]->error_info = NULL;
|
|
//meta[i]->test_stats->test_local_stats[m]->
|
|
}
|
|
meta[i]->mem = mem;
|
|
meta[i]->words_stop = words/args.tred*(i+1);
|
|
meta[i]->words_start = i * words/args.tred;
|
|
meta[i]->return_error = 0;
|
|
DEBUG_PRINT("words_stop: %zu\n",meta[i]->words_stop);
|
|
DEBUG_PRINT("words_start:%zu\n",meta[i]->words_start);
|
|
}
|
|
for (size_t p = 0; p < sizeof(test_patterns)/sizeof(test_patterns[0]); ++p){
|
|
test_patern(meta, thread, args.tred, &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, args.tred, &err, 0, test_list[test_list_id]);
|
|
}
|
|
free(mem);
|
|
if (args.json)
|
|
json_create(meta);
|
|
for (bool i = 0;(i != args.tred); i++)
|
|
free(meta[i]);
|
|
}
|
|
else{
|
|
struct tred_pizdec meta;
|
|
meta.mem = mem;
|
|
meta.words_stop = words;
|
|
meta.words_start = 0;
|
|
meta.test_tip = 1;
|
|
// Основные паттерны 0x00000000, 0xFFFFFFFF, 0xAAAAAAAA, 0x55555555
|
|
for (size_t p = 0; p < sizeof(test_patterns)/sizeof(test_patterns[0]); ++p){
|
|
//struct tred_pizdec meta = malloc(sizeof(struct tred_pizdec));
|
|
meta.id = p;
|
|
meseng_proses(meta.test_tip, meta.id);
|
|
fill_pattern_multi_tred((void*)&meta);
|
|
//fill_pattern(mem, words, test_patterns[p]);
|
|
meseng_test_and_slip();
|
|
check_pattern_multi_tred((void*)&meta);
|
|
err = meta.return_error;
|
|
//err += check_pattern(mem, words, test_patterns[p]);
|
|
free(mem);
|
|
if (!args.json){
|
|
if (err == 0){
|
|
printf("\rOK\n");
|
|
fflush(stdout);
|
|
}
|
|
else printf("\nErrors: %d\n", err);
|
|
}
|
|
}
|
|
for (int test_list_id = 0; test_list_id < sizeof(test_list)/sizeof(test_list[0]); ++test_list_id){
|
|
meta.test_tip = test_list[test_list_id];
|
|
meseng_proses(meta.test_tip, meta.id);
|
|
fill_pattern_multi_tred((void*)&meta);
|
|
meseng_test_and_slip();
|
|
check_pattern_multi_tred((void*)&meta);
|
|
if (!args.json){
|
|
if(meta.return_error == 0){
|
|
printf("\rOK\n");
|
|
fflush(stdout);
|
|
}
|
|
else printf("Errors: %d\n", meta.return_error);
|
|
}
|
|
if (!args.json){
|
|
if (err == 0){
|
|
printf("\rOK");
|
|
fflush(stdout);
|
|
}
|
|
else printf("\nErrors: %d\n", err);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
//if(args.json)
|
|
//for (bool i = 0;(args.tred != -1 || i != args.tred); i++)
|
|
// free(meta[i]);
|
|
return 0;
|
|
}
|