Написал генератор json сейчас информация только по 0x00000000, 0xFFFFFFFF, 0xAAAAAAAA, 0x55555555 но это божет не работать без -t

CMakeLists.txt

@@ -2,6 +2,6 @@ cmake_minimum_required(VERSION 3.0)
 
 project(memtest LANGUAGES C)
 
-add_executable(memtest main.c)
+add_executable(memtest main.c cJSON/cJSON.c)
 
 install(TARGETS memtest RUNTIME DESTINATION bin)

args_parser.h

@@ -0,0 +1,52 @@
+#pragma once
+
+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");
+    printf("  -p, --pretest-delay N указать сколько секунд ждать\n\t\t\tперед проверкой памяти после записи\n");
+}
+
+
+void aaa(int* argc, char *argv[], int* pretest_delay){
+    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'},
+        {"pretest-delay", no_argument,      0, 'p'},
+        {0, 0, 0, 0}
+    };
+
+    int opt;
+    while ((opt = getopt_long(*argc, argv, "ht:i:jp:", long_options, NULL)) != -1) {
+        switch (opt) {
+            case 'h':
+                print_help(argv[0]);
+                exit(0);
+            case 't':
+                args.tred = atoi(optarg);
+                break;
+            case 'i':
+                args.iterations = atoi(optarg);
+                break;
+            case 'p':
+                *pretest_delay = atoi(optarg);
+                break;
+            case 'j':
+                args.json = 1;
+                break;
+            default:
+                print_help(argv[0]);
+                exit(1);
+        }
+    }
+}
+
+
+
+
+

cJSON/cJSON.h

@@ -0,0 +1,300 @@
+/*
+  Copyright (c) 2009-2017 Dave Gamble and cJSON contributors
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy
+  of this software and associated documentation files (the "Software"), to deal
+  in the Software without restriction, including without limitation the rights
+  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+  copies of the Software, and to permit persons to whom the Software is
+  furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included in
+  all copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+  THE SOFTWARE.
+*/
+
+#ifndef cJSON__h
+#define cJSON__h
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+#if !defined(__WINDOWS__) && (defined(WIN32) || defined(WIN64) || defined(_MSC_VER) || defined(_WIN32))
+#define __WINDOWS__
+#endif
+
+#ifdef __WINDOWS__
+
+/* When compiling for windows, we specify a specific calling convention to avoid issues where we are being called from a project with a different default calling convention.  For windows you have 3 define options:
+
+CJSON_HIDE_SYMBOLS - Define this in the case where you don't want to ever dllexport symbols
+CJSON_EXPORT_SYMBOLS - Define this on library build when you want to dllexport symbols (default)
+CJSON_IMPORT_SYMBOLS - Define this if you want to dllimport symbol
+
+For *nix builds that support visibility attribute, you can define similar behavior by
+
+setting default visibility to hidden by adding
+-fvisibility=hidden (for gcc)
+or
+-xldscope=hidden (for sun cc)
+to CFLAGS
+
+then using the CJSON_API_VISIBILITY flag to "export" the same symbols the way CJSON_EXPORT_SYMBOLS does
+
+*/
+
+#define CJSON_CDECL __cdecl
+#define CJSON_STDCALL __stdcall
+
+/* export symbols by default, this is necessary for copy pasting the C and header file */
+#if !defined(CJSON_HIDE_SYMBOLS) && !defined(CJSON_IMPORT_SYMBOLS) && !defined(CJSON_EXPORT_SYMBOLS)
+#define CJSON_EXPORT_SYMBOLS
+#endif
+
+#if defined(CJSON_HIDE_SYMBOLS)
+#define CJSON_PUBLIC(type)   type CJSON_STDCALL
+#elif defined(CJSON_EXPORT_SYMBOLS)
+#define CJSON_PUBLIC(type)   __declspec(dllexport) type CJSON_STDCALL
+#elif defined(CJSON_IMPORT_SYMBOLS)
+#define CJSON_PUBLIC(type)   __declspec(dllimport) type CJSON_STDCALL
+#endif
+#else /* !__WINDOWS__ */
+#define CJSON_CDECL
+#define CJSON_STDCALL
+
+#if (defined(__GNUC__) || defined(__SUNPRO_CC) || defined (__SUNPRO_C)) && defined(CJSON_API_VISIBILITY)
+#define CJSON_PUBLIC(type)   __attribute__((visibility("default"))) type
+#else
+#define CJSON_PUBLIC(type) type
+#endif
+#endif
+
+/* project version */
+#define CJSON_VERSION_MAJOR 1
+#define CJSON_VERSION_MINOR 7
+#define CJSON_VERSION_PATCH 16
+
+#include <stddef.h>
+
+/* cJSON Types: */
+#define cJSON_Invalid (0)
+#define cJSON_False  (1 << 0)
+#define cJSON_True   (1 << 1)
+#define cJSON_NULL   (1 << 2)
+#define cJSON_Number (1 << 3)
+#define cJSON_String (1 << 4)
+#define cJSON_Array  (1 << 5)
+#define cJSON_Object (1 << 6)
+#define cJSON_Raw    (1 << 7) /* raw json */
+
+#define cJSON_IsReference 256
+#define cJSON_StringIsConst 512
+
+/* The cJSON structure: */
+typedef struct cJSON
+{
+    /* next/prev allow you to walk array/object chains. Alternatively, use GetArraySize/GetArrayItem/GetObjectItem */
+    struct cJSON *next;
+    struct cJSON *prev;
+    /* An array or object item will have a child pointer pointing to a chain of the items in the array/object. */
+    struct cJSON *child;
+
+    /* The type of the item, as above. */
+    int type;
+
+    /* The item's string, if type==cJSON_String  and type == cJSON_Raw */
+    char *valuestring;
+    /* writing to valueint is DEPRECATED, use cJSON_SetNumberValue instead */
+    int valueint;
+    /* The item's number, if type==cJSON_Number */
+    double valuedouble;
+
+    /* The item's name string, if this item is the child of, or is in the list of subitems of an object. */
+    char *string;
+} cJSON;
+
+typedef struct cJSON_Hooks
+{
+      /* malloc/free are CDECL on Windows regardless of the default calling convention of the compiler, so ensure the hooks allow passing those functions directly. */
+      void *(CJSON_CDECL *malloc_fn)(size_t sz);
+      void (CJSON_CDECL *free_fn)(void *ptr);
+} cJSON_Hooks;
+
+typedef int cJSON_bool;
+
+/* Limits how deeply nested arrays/objects can be before cJSON rejects to parse them.
+ * This is to prevent stack overflows. */
+#ifndef CJSON_NESTING_LIMIT
+#define CJSON_NESTING_LIMIT 1000
+#endif
+
+/* returns the version of cJSON as a string */
+CJSON_PUBLIC(const char*) cJSON_Version(void);
+
+/* Supply malloc, realloc and free functions to cJSON */
+CJSON_PUBLIC(void) cJSON_InitHooks(cJSON_Hooks* hooks);
+
+/* Memory Management: the caller is always responsible to free the results from all variants of cJSON_Parse (with cJSON_Delete) and cJSON_Print (with stdlib free, cJSON_Hooks.free_fn, or cJSON_free as appropriate). The exception is cJSON_PrintPreallocated, where the caller has full responsibility of the buffer. */
+/* Supply a block of JSON, and this returns a cJSON object you can interrogate. */
+CJSON_PUBLIC(cJSON *) cJSON_Parse(const char *value);
+CJSON_PUBLIC(cJSON *) cJSON_ParseWithLength(const char *value, size_t buffer_length);
+/* ParseWithOpts allows you to require (and check) that the JSON is null terminated, and to retrieve the pointer to the final byte parsed. */
+/* If you supply a ptr in return_parse_end and parsing fails, then return_parse_end will contain a pointer to the error so will match cJSON_GetErrorPtr(). */
+CJSON_PUBLIC(cJSON *) cJSON_ParseWithOpts(const char *value, const char **return_parse_end, cJSON_bool require_null_terminated);
+CJSON_PUBLIC(cJSON *) cJSON_ParseWithLengthOpts(const char *value, size_t buffer_length, const char **return_parse_end, cJSON_bool require_null_terminated);
+
+/* Render a cJSON entity to text for transfer/storage. */
+CJSON_PUBLIC(char *) cJSON_Print(const cJSON *item);
+/* Render a cJSON entity to text for transfer/storage without any formatting. */
+CJSON_PUBLIC(char *) cJSON_PrintUnformatted(const cJSON *item);
+/* Render a cJSON entity to text using a buffered strategy. prebuffer is a guess at the final size. guessing well reduces reallocation. fmt=0 gives unformatted, =1 gives formatted */
+CJSON_PUBLIC(char *) cJSON_PrintBuffered(const cJSON *item, int prebuffer, cJSON_bool fmt);
+/* Render a cJSON entity to text using a buffer already allocated in memory with given length. Returns 1 on success and 0 on failure. */
+/* NOTE: cJSON is not always 100% accurate in estimating how much memory it will use, so to be safe allocate 5 bytes more than you actually need */
+CJSON_PUBLIC(cJSON_bool) cJSON_PrintPreallocated(cJSON *item, char *buffer, const int length, const cJSON_bool format);
+/* Delete a cJSON entity and all subentities. */
+CJSON_PUBLIC(void) cJSON_Delete(cJSON *item);
+
+/* Returns the number of items in an array (or object). */
+CJSON_PUBLIC(int) cJSON_GetArraySize(const cJSON *array);
+/* Retrieve item number "index" from array "array". Returns NULL if unsuccessful. */
+CJSON_PUBLIC(cJSON *) cJSON_GetArrayItem(const cJSON *array, int index);
+/* Get item "string" from object. Case insensitive. */
+CJSON_PUBLIC(cJSON *) cJSON_GetObjectItem(const cJSON * const object, const char * const string);
+CJSON_PUBLIC(cJSON *) cJSON_GetObjectItemCaseSensitive(const cJSON * const object, const char * const string);
+CJSON_PUBLIC(cJSON_bool) cJSON_HasObjectItem(const cJSON *object, const char *string);
+/* For analysing failed parses. This returns a pointer to the parse error. You'll probably need to look a few chars back to make sense of it. Defined when cJSON_Parse() returns 0. 0 when cJSON_Parse() succeeds. */
+CJSON_PUBLIC(const char *) cJSON_GetErrorPtr(void);
+
+/* Check item type and return its value */
+CJSON_PUBLIC(char *) cJSON_GetStringValue(const cJSON * const item);
+CJSON_PUBLIC(double) cJSON_GetNumberValue(const cJSON * const item);
+
+/* These functions check the type of an item */
+CJSON_PUBLIC(cJSON_bool) cJSON_IsInvalid(const cJSON * const item);
+CJSON_PUBLIC(cJSON_bool) cJSON_IsFalse(const cJSON * const item);
+CJSON_PUBLIC(cJSON_bool) cJSON_IsTrue(const cJSON * const item);
+CJSON_PUBLIC(cJSON_bool) cJSON_IsBool(const cJSON * const item);
+CJSON_PUBLIC(cJSON_bool) cJSON_IsNull(const cJSON * const item);
+CJSON_PUBLIC(cJSON_bool) cJSON_IsNumber(const cJSON * const item);
+CJSON_PUBLIC(cJSON_bool) cJSON_IsString(const cJSON * const item);
+CJSON_PUBLIC(cJSON_bool) cJSON_IsArray(const cJSON * const item);
+CJSON_PUBLIC(cJSON_bool) cJSON_IsObject(const cJSON * const item);
+CJSON_PUBLIC(cJSON_bool) cJSON_IsRaw(const cJSON * const item);
+
+/* These calls create a cJSON item of the appropriate type. */
+CJSON_PUBLIC(cJSON *) cJSON_CreateNull(void);
+CJSON_PUBLIC(cJSON *) cJSON_CreateTrue(void);
+CJSON_PUBLIC(cJSON *) cJSON_CreateFalse(void);
+CJSON_PUBLIC(cJSON *) cJSON_CreateBool(cJSON_bool boolean);
+CJSON_PUBLIC(cJSON *) cJSON_CreateNumber(double num);
+CJSON_PUBLIC(cJSON *) cJSON_CreateString(const char *string);
+/* raw json */
+CJSON_PUBLIC(cJSON *) cJSON_CreateRaw(const char *raw);
+CJSON_PUBLIC(cJSON *) cJSON_CreateArray(void);
+CJSON_PUBLIC(cJSON *) cJSON_CreateObject(void);
+
+/* Create a string where valuestring references a string so
+ * it will not be freed by cJSON_Delete */
+CJSON_PUBLIC(cJSON *) cJSON_CreateStringReference(const char *string);
+/* Create an object/array that only references it's elements so
+ * they will not be freed by cJSON_Delete */
+CJSON_PUBLIC(cJSON *) cJSON_CreateObjectReference(const cJSON *child);
+CJSON_PUBLIC(cJSON *) cJSON_CreateArrayReference(const cJSON *child);
+
+/* These utilities create an Array of count items.
+ * The parameter count cannot be greater than the number of elements in the number array, otherwise array access will be out of bounds.*/
+CJSON_PUBLIC(cJSON *) cJSON_CreateIntArray(const int *numbers, int count);
+CJSON_PUBLIC(cJSON *) cJSON_CreateFloatArray(const float *numbers, int count);
+CJSON_PUBLIC(cJSON *) cJSON_CreateDoubleArray(const double *numbers, int count);
+CJSON_PUBLIC(cJSON *) cJSON_CreateStringArray(const char *const *strings, int count);
+
+/* Append item to the specified array/object. */
+CJSON_PUBLIC(cJSON_bool) cJSON_AddItemToArray(cJSON *array, cJSON *item);
+CJSON_PUBLIC(cJSON_bool) cJSON_AddItemToObject(cJSON *object, const char *string, cJSON *item);
+/* Use this when string is definitely const (i.e. a literal, or as good as), and will definitely survive the cJSON object.
+ * WARNING: When this function was used, make sure to always check that (item->type & cJSON_StringIsConst) is zero before
+ * writing to `item->string` */
+CJSON_PUBLIC(cJSON_bool) cJSON_AddItemToObjectCS(cJSON *object, const char *string, cJSON *item);
+/* Append reference to item to the specified array/object. Use this when you want to add an existing cJSON to a new cJSON, but don't want to corrupt your existing cJSON. */
+CJSON_PUBLIC(cJSON_bool) cJSON_AddItemReferenceToArray(cJSON *array, cJSON *item);
+CJSON_PUBLIC(cJSON_bool) cJSON_AddItemReferenceToObject(cJSON *object, const char *string, cJSON *item);
+
+/* Remove/Detach items from Arrays/Objects. */
+CJSON_PUBLIC(cJSON *) cJSON_DetachItemViaPointer(cJSON *parent, cJSON * const item);
+CJSON_PUBLIC(cJSON *) cJSON_DetachItemFromArray(cJSON *array, int which);
+CJSON_PUBLIC(void) cJSON_DeleteItemFromArray(cJSON *array, int which);
+CJSON_PUBLIC(cJSON *) cJSON_DetachItemFromObject(cJSON *object, const char *string);
+CJSON_PUBLIC(cJSON *) cJSON_DetachItemFromObjectCaseSensitive(cJSON *object, const char *string);
+CJSON_PUBLIC(void) cJSON_DeleteItemFromObject(cJSON *object, const char *string);
+CJSON_PUBLIC(void) cJSON_DeleteItemFromObjectCaseSensitive(cJSON *object, const char *string);
+
+/* Update array items. */
+CJSON_PUBLIC(cJSON_bool) cJSON_InsertItemInArray(cJSON *array, int which, cJSON *newitem); /* Shifts pre-existing items to the right. */
+CJSON_PUBLIC(cJSON_bool) cJSON_ReplaceItemViaPointer(cJSON * const parent, cJSON * const item, cJSON * replacement);
+CJSON_PUBLIC(cJSON_bool) cJSON_ReplaceItemInArray(cJSON *array, int which, cJSON *newitem);
+CJSON_PUBLIC(cJSON_bool) cJSON_ReplaceItemInObject(cJSON *object,const char *string,cJSON *newitem);
+CJSON_PUBLIC(cJSON_bool) cJSON_ReplaceItemInObjectCaseSensitive(cJSON *object,const char *string,cJSON *newitem);
+
+/* Duplicate a cJSON item */
+CJSON_PUBLIC(cJSON *) cJSON_Duplicate(const cJSON *item, cJSON_bool recurse);
+/* Duplicate will create a new, identical cJSON item to the one you pass, in new memory that will
+ * need to be released. With recurse!=0, it will duplicate any children connected to the item.
+ * The item->next and ->prev pointers are always zero on return from Duplicate. */
+/* Recursively compare two cJSON items for equality. If either a or b is NULL or invalid, they will be considered unequal.
+ * case_sensitive determines if object keys are treated case sensitive (1) or case insensitive (0) */
+CJSON_PUBLIC(cJSON_bool) cJSON_Compare(const cJSON * const a, const cJSON * const b, const cJSON_bool case_sensitive);
+
+/* Minify a strings, remove blank characters(such as ' ', '\t', '\r', '\n') from strings.
+ * The input pointer json cannot point to a read-only address area, such as a string constant, 
+ * but should point to a readable and writable address area. */
+CJSON_PUBLIC(void) cJSON_Minify(char *json);
+
+/* Helper functions for creating and adding items to an object at the same time.
+ * They return the added item or NULL on failure. */
+CJSON_PUBLIC(cJSON*) cJSON_AddNullToObject(cJSON * const object, const char * const name);
+CJSON_PUBLIC(cJSON*) cJSON_AddTrueToObject(cJSON * const object, const char * const name);
+CJSON_PUBLIC(cJSON*) cJSON_AddFalseToObject(cJSON * const object, const char * const name);
+CJSON_PUBLIC(cJSON*) cJSON_AddBoolToObject(cJSON * const object, const char * const name, const cJSON_bool boolean);
+CJSON_PUBLIC(cJSON*) cJSON_AddNumberToObject(cJSON * const object, const char * const name, const double number);
+CJSON_PUBLIC(cJSON*) cJSON_AddStringToObject(cJSON * const object, const char * const name, const char * const string);
+CJSON_PUBLIC(cJSON*) cJSON_AddRawToObject(cJSON * const object, const char * const name, const char * const raw);
+CJSON_PUBLIC(cJSON*) cJSON_AddObjectToObject(cJSON * const object, const char * const name);
+CJSON_PUBLIC(cJSON*) cJSON_AddArrayToObject(cJSON * const object, const char * const name);
+
+/* When assigning an integer value, it needs to be propagated to valuedouble too. */
+#define cJSON_SetIntValue(object, number) ((object) ? (object)->valueint = (object)->valuedouble = (number) : (number))
+/* helper for the cJSON_SetNumberValue macro */
+CJSON_PUBLIC(double) cJSON_SetNumberHelper(cJSON *object, double number);
+#define cJSON_SetNumberValue(object, number) ((object != NULL) ? cJSON_SetNumberHelper(object, (double)number) : (number))
+/* Change the valuestring of a cJSON_String object, only takes effect when type of object is cJSON_String */
+CJSON_PUBLIC(char*) cJSON_SetValuestring(cJSON *object, const char *valuestring);
+
+/* If the object is not a boolean type this does nothing and returns cJSON_Invalid else it returns the new type*/
+#define cJSON_SetBoolValue(object, boolValue) ( \
+    (object != NULL && ((object)->type & (cJSON_False|cJSON_True))) ? \
+    (object)->type=((object)->type &(~(cJSON_False|cJSON_True)))|((boolValue)?cJSON_True:cJSON_False) : \
+    cJSON_Invalid\
+)
+
+/* Macro for iterating over an array or object */
+#define cJSON_ArrayForEach(element, array) for(element = (array != NULL) ? (array)->child : NULL; element != NULL; element = element->next)
+
+/* malloc/free objects using the malloc/free functions that have been set with cJSON_InitHooks */
+CJSON_PUBLIC(void *) cJSON_malloc(size_t size);
+CJSON_PUBLIC(void) cJSON_free(void *object);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

main.c

@@ -10,6 +10,18 @@
 #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
 
@@ -26,9 +38,41 @@
 #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;
@@ -36,10 +80,11 @@ struct tred_pizdec{
     size_t words_start;
     int return_error;
     bool test_tip;
+    struct test_stats* test_stats;
+    
 };
 
 #include "multi_tred.h"
-#include "single_tred.h"
 
 // Получить доступную память из /proc/meminfo
 unsigned long int get_mem_available_mb() {
@@ -51,189 +96,270 @@ unsigned long int get_mem_available_mb() {
         if (sscanf(line, "MemAvailable: %lu kB", &available) == 1) break;
     }
     fclose(f);
-    printf("mem Gb: %lu\n",(available-available/100*10)/1024/1024);
+    if (!args.json){
-    printf("mem MB: %lu\n",(available-available/100*10)/1024);
+        printf("mem Gb: %lu\n",(available-available/100*10)/1024/1024);
-    return (available - available/100*10)*1024;
+        printf("mem MB: %lu\n",(available-available/100*10)/1024);
+    }
+    return (available - available/100*20)*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){
+void meseng_proses(int test_tipe, int p){
-    if (test_tipe == 1){
+    if (args.json != 1){
-    printf("\rЗапушен патерн 0x%08X", test_patterns[p]);
+        if (test_tipe == 1){
-    fflush(stdout);
+            printf("\rЗапушен патерн 0x%08X", test_patterns[p]);
+            fflush(stdout);
+        }
+        else{
+            printf("\rЗапушен патерн %s", test_name[test_tipe-2]);
+            fflush(stdout);
+        }
     }
-    else if (test_tipe == 2){
+}
-        printf("\rЗапушен патерн инкрементации");
+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);
     }
-    else if (test_tipe == 3){
+}
-        printf("\rЗапушен патерн ones test");
+
-        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);
-    else if (test_tipe == 4){
+    for (bool i = 0;(i != tred); i++){// test
-        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++)
+    for (bool i = 0;(i != tred); i++) //sink tred
         pthread_join(thread[i], NULL);
     //fill_pattern(mem, words, test_patterns[p]);
-    //printf("Жду\n");
+    meseng_test_and_slip();
-    //usleep(10000000);
-    printf("\r-- Проверяю   ");
-    fflush(stdout);
     //int err = check_pattern(mem, words, test_patterns[p]);
-    
+    for (bool i = 0;(i != tred); i++){// test
-    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++){
+    for (bool i = 0;(i != tred); i++){ //sink tred
         pthread_join(thread[i], NULL);
         *err += meta[i]->return_error;
-        free(meta[i]);
     }
-    if (*err == 0){
+    if (!args.json){
-        printf("\rOK\n");
+        if (*err == 0){
-        fflush(stdout);
+            printf("\rOK\n");
+            fflush(stdout);
+        }
+        else printf("Errors: %d\n", *err);
     }
-    else printf("Errors: %d\n", *err);
 }
-void print_help(const char *progname) {
+
-    printf("Использование: %s [опции]\n", progname);
+void json_create(struct tred_pizdec** meta){
-    printf("  -h, --help            показать это сообщение\n");
+    cJSON *main_ob = cJSON_CreateObject();
-    printf("  -t, --threads N       указать число потоков\n");
+        //cJSON_AddItemToArray(main_Array, main_ob);
-    printf("  -i, --iterations N    указать число повторения тестов\n");
+        cJSON *test_ob = cJSON_CreateObject();
-    printf("  -j, --json            вывод в виде json\n");
+        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;
     }
-    int tred = -1, iterations = 1;
+    
+    args.tred = -1;
+    args.iterations = 1;
+    args.json = 0;
 
-    const struct option long_options[] = {
+    aaa(&argc, argv, &pretest_delay);
-        {"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;
+    if (!args.json)
-    while ((opt = getopt_long(argc, argv, "ht:i:j", long_options, NULL)) != -1) {
+        printf("threads: %d\n", args.tred);
-        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);
+    args.words = words;
     uint32_t *mem = malloc(mem_size);
     if (!mem) {
-        perror("Память выделена!");
+        printf("Память не выделена!");
         return 1;
     }
     //struct tred_pizdec* meta[];
     //pthread_t thread[];
-    int err = 0;
+    int err = 0, iterations = args.iterations;
-    struct tred_pizdec** meta = malloc(sizeof(struct tred_pizdec) * tred);
+    struct tred_pizdec** meta = malloc(sizeof(struct tred_pizdec) * args.tred);
-    pthread_t *thread = malloc(sizeof(pthread_t) * tred);
+    pthread_t *thread = malloc(sizeof(pthread_t) * args.tred);
-    printf("iterations: %i\n", iterations);
+    if (!args.json)
+        printf("iterations: %i\n", iterations);
     for (;iterations != 0; iterations--){
-        if (tred != -1){
+        if (args.tred != -1){
-            for (size_t p = 0; p < sizeof(test_patterns)/sizeof(test_patterns[0]); ++p)
+            for (bool i = 0;(i != args.tred); i++){// test
-                test_patern(meta, thread, tred, words, mem, &err, p, 1);// Основные паттерны 0x00000000, 0xFFFFFFFF, 0xAAAAAAAA, 0x55555555
+                meta[i] = malloc(sizeof(struct tred_pizdec));
-            for (int test_list_id = 0; test_list_id < sizeof(test_list)/sizeof(test_list[0]); ++test_list_id){
+                meta[i]->test_stats = malloc(sizeof(struct test_stats) + 
-                test_patern(meta, thread, tred, words, mem, &err, 0, test_list[test_list_id]);
+                (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){
-                printf("\rЗапушен патерн 0x%08X", test_patterns[p]);
+                //struct tred_pizdec meta = malloc(sizeof(struct tred_pizdec));
-                fflush(stdout);
+                meta.id = p;
-                fill_pattern(mem, words, test_patterns[p]);
+                meseng_proses(meta.test_tip, meta.id);
-                printf("\r-- Проверяю   ");
+                fill_pattern_multi_tred((void*)&meta);
-                fflush(stdout);
+                //fill_pattern(mem, words, test_patterns[p]);
-                err += check_pattern(mem, words, test_patterns[p]);
+                meseng_test_and_slip();
-                if (err == 0){ 
+                check_pattern_multi_tred((void*)&meta);
-                    printf("\rOK");
+                err = meta.return_error;
-                    fflush(stdout);
+                //err += check_pattern(mem, words, test_patterns[p]);
-                }
+                free(mem);
-                else printf("\nErrors: %d\n", err);
+                if (!args.json){
-            }
+                    if (err == 0){ 
-            // Инкремент
+                        printf("\rOK\n");
-            printf("\rЗапушен патерн инкрементации");
+                        fflush(stdout);
-            fflush(stdout);
+                    }
-            fill_increment(mem, words);
+                    else printf("\nErrors: %d\n", err);
-            //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");
+            for (int test_list_id = 0; test_list_id < sizeof(test_list)/sizeof(test_list[0]); ++test_list_id){
-            fflush(stdout);
+                meta.test_tip = test_list[test_list_id];
-            fill_walking_ones(mem, words);
+                meseng_proses(meta.test_tip, meta.id);
-            if (0 == fill_walking_ones_test(mem, words)){
+                fill_pattern_multi_tred((void*)&meta);
-                printf("\rOK");
+                meseng_test_and_slip();
-                fflush(stdout);
+                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);
+                }
             }
-            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);
         }
     }
-
+    //if(args.json)
-    
+    //for (bool i = 0;(args.tred != -1 || i != args.tred); i++)
-
+    //    free(meta[i]);
-    free(mem);
     return 0;
 }

multi_tred.h

@@ -1,89 +1,102 @@
-void fill_pattern(uint32_t *buf, size_t words, uint32_t pattern) {
+#pragma once
-    for (size_t i = 0; i < words; i++) {
+#include <time.h>
-        buf[i] = pattern;
-    }
-}
 
-void fill_increment(uint32_t *buf, size_t words) {
+int one_percent_chance(){
-    for (size_t i = 0; i < words; i++) {
+    static int initialized = 0;
-        buf[i] = (uint32_t)i;
+    if (!initialized) {
+        srand((unsigned int)time(NULL));
+        initialized = 1;
     }
+    return (rand() % 1000000) == 0;
 }
-int check_pattern(uint32_t *buf, size_t words, uint32_t pattern) {
+int a =1;
-    int errors = 0;
-    for (size_t i = 0; i < words; i++) {
-        if (buf[i] != pattern) {
-            printf("\nОшибка в тесте %zu: должен быть: 0x%08X, фактический: 0x%08X\n", i, pattern, buf[i]);
-            errors++;
-            if (errors > 10) break;
-        }
-    }
-    return errors;
-}
 void* fill_pattern_multi_tred(void *arg) {
     struct tred_pizdec* meta = (struct tred_pizdec*) arg;
     DEBUG_PRINT("id: 0x%08X\n", test_patterns[meta->id]);
-    if (meta->test_tip == 1){
+    switch (meta->test_tip){
-        for (size_t i = meta->words_start; i < meta->words_stop; i++) {
+        case 1:
-            meta->mem[i] = test_patterns[meta->id];
+            for (size_t i = meta->words_start; i < meta->words_stop; i++){
-        }
+                if (a && i % 1000 == 0 && one_percent_chance()) {
+                    meta->mem[i] = 45345345;
+                }
+                else
+                    meta->mem[i] = test_patterns[meta->id];
+                
+            }
+            break;
+        case 2:
+            for (size_t i = meta->words_start; i < meta->words_stop; i++)
+                meta->mem[i] = (uint32_t)i;
+            break;
+        case 3:
+            for (size_t i = meta->words_start; i < meta->words_stop; i++)
+                meta->mem[i] = 1U << (i % 32);
+            break;
+        case 4:
+            for (size_t i = meta->words_start; i < meta->words_stop; i++)
+                meta->mem[i] = ~(1U << (i % 32));
+            break;
     }
-    
     return NULL;
 }
 void* check_pattern_multi_tred(void *arg) {
     struct tred_pizdec* meta = (struct tred_pizdec*) arg;
     meta->return_error = 0;
-    if (meta->test_tip == 1){
+    switch (meta->test_tip){
-        for (size_t i = meta->words_start; i < meta->words_stop; i++){
+        case 1:
-            if (meta->mem[i] != test_patterns[meta->id]) {
+            for (size_t i = meta->words_start; i < meta->words_stop; i++){
-                printf("\nОшибка в тесте %zu: должен быть: 0x%08X, фактический: 0x%08X\n", i, test_patterns[meta->id], meta->mem[i]);
+                if (meta->mem[i] != test_patterns[meta->id]) {
-                meta->return_error++;
+                    if (args.json){
-                if (meta->return_error > 10) break;
+                        struct error_info* error_str = malloc(sizeof(struct error_info));
-            }
+                        error_str->expected = test_patterns[meta->id];
-        }
+                        error_str->actual = meta->mem[i];
-    }
+                        error_str->error_adres = meta->mem[i];
-    else if (meta->test_tip == 2){
+                        if (!meta->test_stats->test_local_stats[meta->id]->error_int){
-        for (size_t i = meta->words_start; i < meta->words_stop; i++) {
+                            if (meta->test_stats->test_local_stats[meta->id] != NULL){
-            if (meta->mem[i] != (uint32_t)i) {
+                                
-                printf("Ошибка в тесте %zu: должен быть: 0x%08X, фактический: 0x%08X\n", i, (uint32_t)i, meta->mem[i]);
+                            }
-                meta->return_error++;
+                            meta->test_stats->test_local_stats[meta->id]->error_info = error_str;
-                if (meta->return_error > 10) break;
+                        }
+                        else
+                            meta->test_stats->test_local_stats[meta->id]->error_info_end->error_info_next = error_str;
+                        meta->test_stats->test_local_stats[meta->id]->error_info_end = error_str;
+                    }
+                    else{
+                        printf("\nОшибка в тесте %zu: должен быть: 0x%08X, фактический: 0x%08X\n", i, test_patterns[meta->id], meta->mem[i]);
+                    }
+                    meta->test_stats->test_local_stats[meta->id]->error_int++;
+                    if (meta->return_error > 10) break;
+                }
+            }
+            break;
+        case 2:
+            for (size_t i = meta->words_start; i < meta->words_stop; i++) {
+                if (meta->mem[i] != (uint32_t)i) {
+                    printf("\nОшибка в тесте %zu: должен быть: 0x%08X, фактический: 0x%08X\n", i, (uint32_t)i, meta->mem[i]);
+                    meta->return_error++;
+                    if (meta->return_error > 10) break;
+                }
+                //printf("Адрес памяти: %p\n", (void*)meta->mem[i]);
+            }
+            break;
+        case 3:
+            for (size_t i = meta->words_start; i < meta->words_stop; i++) {
+                if (meta->mem[i] != 1U << (i % 32)){
+                    printf("\nПиздец_3\n");
+                    meta->return_error++;
+                }
+            }
+            break;
+        case 4:
+            for (size_t i = meta->words_start; i < meta->words_stop; i++) {
+                if (meta->mem[i] != ~(1U << (i % 32))){
+                    printf("\nПиздец_4\n");
+                    meta->return_error++;
             }
         }
+        break;
     }
     return NULL;
 }
 
-void fill_walking_ones(uint32_t *mem, size_t words) {
-    for (size_t i = 0; i < words; i++) {
-        mem[i] = 1U << (i % 32);
-    }
-}
-int fill_walking_ones_test(uint32_t *mem, size_t words) {
-    int errors = 0;
-    for (size_t i = 0; i < words; i++) {
-        if (mem[i] != 1U << (i % 32)){
-            printf("\nПиздец\n");
-            errors++;
-        }
-    }
-    return errors;
-}
-void fill_walking_zeros(uint32_t *mem, size_t words) {
-    for (size_t i = 0; i < words; i++) {
-        mem[i] = ~(1U << (i % 32));
-    }
-}
-int fill_walking_zeros_test(uint32_t *mem, size_t words) {
-    int errors = 0;
-    for (size_t i = 0; i < words; i++) {
-        if (mem[i] != ~(1U << (i % 32))){
-            printf("\nПиздец\n");
-            errors++;
-        }
-    }
-    return errors;
-}
-
 

single_tred.h

@@ -0,0 +1,58 @@
+#pragma once
+
+void fill_pattern(uint32_t *buf, size_t words, uint32_t pattern) {
+    for (size_t i = 0; i < words; i++) {
+        buf[i] = pattern;
+    }
+}
+
+void fill_increment(uint32_t *buf, size_t words) {
+    for (size_t i = 0; i < words; i++) {
+        buf[i] = (uint32_t)i;
+    }
+}
+int check_pattern(uint32_t *buf, size_t words, uint32_t pattern) {
+    int errors = 0;
+    for (size_t i = 0; i < words; i++) {
+        if (buf[i] != pattern) {
+            printf("\nОшибка в тесте %zu: должен быть: 0x%08X, фактический: 0x%08X\n", i, pattern, buf[i]);
+            errors++;
+            if (errors > 10) break;
+        }
+    }
+    return errors;
+}
+
+
+void fill_walking_ones(uint32_t *mem, size_t words) {
+    for (size_t i = 0; i < words; i++) {
+        mem[i] = 1U << (i % 32);
+    }
+}
+int fill_walking_ones_test(uint32_t *mem, size_t words) {
+    int errors = 0;
+    for (size_t i = 0; i < words; i++) {
+        if (mem[i] != 1U << (i % 32)){
+            printf("\nПиздец\n");
+            errors++;
+        }
+    }
+    return errors;
+}
+void fill_walking_zeros(uint32_t *mem, size_t words) {
+    for (size_t i = 0; i < words; i++) {
+        mem[i] = ~(1U << (i % 32));
+    }
+}
+int fill_walking_zeros_test(uint32_t *mem, size_t words) {
+    int errors = 0;
+    for (size_t i = 0; i < words; i++) {
+        if (mem[i] != ~(1U << (i % 32))){
+            printf("\nПиздец\n");
+            errors++;
+        }
+    }
+    return errors;
+}
+
+

test_logik.c

@@ -0,0 +1,58 @@
+#pragma once
+
+void fill_pattern(uint32_t *buf, size_t words, uint32_t pattern) {
+    for (unsigned int i = 0; i < words; i++) {
+        buf[i] = pattern;
+    }
+}
+
+void fill_increment(uint32_t *buf, size_t words) {
+    for (unsigned int i = 0; i < words; i++) {
+        buf[i] = (uint32_t)i;
+    }
+}
+int check_pattern(uint32_t *buf, size_t words, uint32_t pattern) {
+    int errors = 0;
+    for (unsigned int i = 0; i < words; i++) {
+        if (buf[i] != pattern) {
+            printf("\nОшибка в тесте %zu: должен быть: 0x%08X, фактический: 0x%08X\n", i, pattern, buf[i]);
+            errors++;
+            if (errors > 10) break;
+        }
+    }
+    return errors;
+}
+
+
+void fill_walking_ones(uint32_t *mem, size_t words) {
+    for (unsigned int i = 0; i < words; i++) {
+        mem[i] = 1U << (i % 32);
+    }
+}
+int fill_walking_ones_test(uint32_t *mem, size_t words) {
+    int errors = 0;
+    for (unsigned int i = 0; i < words; i++) {
+        if (mem[i] != 1U << (i % 32)){
+            printf("\nПиздец\n");
+            errors++;
+        }
+    }
+    return errors;
+}
+void fill_walking_zeros(uint32_t *mem, size_t words) {
+    for (unsigned int i = 0; i < words; i++) {
+        mem[i] = ~(1U << (i % 32));
+    }
+}
+int fill_walking_zeros_test(uint32_t *mem, size_t words) {
+    int errors = 0;
+    for (unsigned int i = 0; i < words; i++) {
+        if (mem[i] != ~(1U << (i % 32))){
+            printf("\nПиздец\n");
+            errors++;
+        }
+    }
+    return errors;
+}
+
+