From b0ed77f36c82b785f193bf0a41b6fae1760b87e1 Mon Sep 17 00:00:00 2001
From: FlorealRISSO <floreal.risso@univ-tlse3.fr>
Date: Mon, 27 Mar 2023 12:39:16 +0200
Subject: [PATCH 01/16] fix: fmt error msg
---
tests/small_test.h | 4 ++--
1 file changed, 2 insertions(+), 2 deletions(-)
diff --git a/tests/small_test.h b/tests/small_test.h
index 8301ae7..7e8c11e 100644
--- a/tests/small_test.h
+++ b/tests/small_test.h
@@ -270,8 +270,8 @@ int test(char *file, int line, unsigned int __indentation_level, const void *res
static char buffer_expected[FMT_BUFFER_SIZE];
int is_equal = interface->compare(result, expected);
- char *fmt_result = interface->format(buffer_expected, expected);
- char *fmt_expected = interface->format(buffer_result, result);
+ char *fmt_expected = interface->format(buffer_expected, expected);
+ char *fmt_result = interface->format(buffer_result, result);
if (!is_equal) {
INDENTED_PRINT("%s:%d: failed, expected <%s>, got <%s>\n", file, line, fmt_expected, fmt_result);
}
--
GitLab
From dadb4703629af08e5c329c0d2e1e67330874f6e3 Mon Sep 17 00:00:00 2001
From: FlorealRISSO <floreal.risso@univ-tlse3.fr>
Date: Mon, 27 Mar 2023 12:39:59 +0200
Subject: [PATCH 02/16] getline without alloc
---
lib/info_reader.h | 59 +++++++++++++++++++++++--
tests/info_reader.c | 90 ++++++++++++++++++++++++++++++--------
tests/info_reader_test.txt | 9 ++++
3 files changed, 137 insertions(+), 21 deletions(-)
create mode 100644 tests/info_reader_test.txt
diff --git a/lib/info_reader.h b/lib/info_reader.h
index ec28db6..15a077c 100644
--- a/lib/info_reader.h
+++ b/lib/info_reader.h
@@ -105,6 +105,24 @@ static bool start_with(const char *prefix, const char *string);
*/
static unsigned int match(Parser *parser, char *line, KeyFinder **key_finder, char **raw_value);
+/**
+* @brief Reads a line of text from a file stream and stores it in a static
+ buffer with a maximum size of PAGE_SIZE.
+
+* This function reads a line of text from the input stream pointed to by
+* 'stream'. The line of text is stored in a static buffer with a maximum size of
+* PAGE_SIZE. The function updates the pointer pointed to by 'lineptr' to point to
+* the buffer containing the line of text. If the line of text is longer than the
+* buffer, the function returns -1. If an error occurs,
+
+* @param lineptr A pointer to a pointer to the buffer where the line of text
+ will be stored.
+* @param stream A pointer to the input stream to read from.
+* @return The number of characters read, or -1 if an error occurred the
+ function returns -1.
+*/
+ssize_t buffer_getline(char **lineptr, FILE *stream);
+
typedef size_t GenericPointer;
typedef GenericPointer (CopyAllocator) (char *string);
typedef void (Setter) (GenericPointer storage, GenericPointer value);
@@ -166,14 +184,50 @@ static unsigned int move_to_next(Parser *parser)
return 1;
}
+
+#define PAGE_SIZE 4096
+ssize_t buffer_getline(char **lineptr, FILE *stream) {
+ ssize_t num_chars_read = 0;
+ static char buffer[PAGE_SIZE] = {0};
+
+ if (!lineptr || !stream) {
+ return -1;
+ }
+
+ while (1) {
+ int ch = fgetc(stream);
+ if (ch == EOF) {
+ if (num_chars_read == 0) {
+ return -1;
+ } else {
+ break;
+ }
+ }
+
+ if (num_chars_read == PAGE_SIZE - 1) {
+ return -1;
+ }
+
+ buffer[num_chars_read++] = ch;
+ if (ch == '\n') {
+ break;
+ }
+ }
+
+ buffer[num_chars_read] = '\0';
+ *lineptr = buffer;
+
+ return num_chars_read;
+}
+
+
static unsigned int parse(Parser *parser)
{
char *line = NULL;
- size_t len = 0;
ssize_t read;
unsigned int key_assigned = 0;
- while ((read = getline(&line, &len, parser->file)) != -1) {
+ while ((read = buffer_getline(&line, parser->file)) != -1) {
if (key_assigned == parser->nb_keys && read > 1) {
continue;
} else if (read == 1) {
@@ -194,7 +248,6 @@ static unsigned int parse(Parser *parser)
if (key_assigned > 0) {
parser->nb_stored++;
}
- free(line);
return 1;
}
diff --git a/tests/info_reader.c b/tests/info_reader.c
index 5000f48..92f2ff9 100644
--- a/tests/info_reader.c
+++ b/tests/info_reader.c
@@ -169,28 +169,36 @@ TFUNCTION(test_start_with, {
})
#define NONE 0
+#define INIT_KEYFINDER(__key_finder, __key, __delimiter, __copy, __set) \
+ do { \
+ __key_finder = (KeyFinder) { \
+ .key = __key, \
+ .delimiter = __delimiter, \
+ .copy = __copy, \
+ .set = __set \
+ }; \
+ } while (0);
+
#define DUMMY_KEYFINDER(__key_finder, __key, __delimiter) \
- do { \
- __key_finder = (KeyFinder) { \
- .key = __key, \
- .delimiter = __delimiter, \
- .copy = NONE, \
- .set = NONE \
- }; \
+ INIT_KEYFINDER(__key_finder, __key, __delimiter, NONE, NONE) \
+
+#define INIT_PARSER(__parser, __storage, __nb_stored, __capacity, \
+ __storage_struct_size, __keys, __nb_keys, __file) \
+do { \
+ __parser = (Parser) { \
+ .storage = __storage, \
+ .nb_stored = __nb_stored, \
+ .capacity = __capacity, \
+ .storage_struct_size = __storage_struct_size, \
+ .keys = __keys, \
+ .nb_keys = __nb_keys, \
+ .file = __file \
+ }; \
} while (0);
+
#define DUMMY_PARSER(__parser, __keys, __nb_keys) \
- do { \
- __parser = (Parser) { \
- .storage = NONE, \
- .nb_stored = NONE, \
- .capacity = NONE, \
- .storage_struct_size = NONE, \
- .keys = __keys, \
- .nb_keys = __nb_keys, \
- .file = NONE \
- }; \
- } while (0);
+ INIT_PARSER(__parser, NONE, NONE, NONE, NONE, __keys, __nb_keys, NONE)
TFUNCTION(test_match, {
@@ -275,10 +283,56 @@ TFUNCTION(test_match, {
TEST_STR(raw_value, NULL);
})
+
+#define __NB_KEYS 4
+
+typedef struct {
+ int values[__NB_KEYS];
+} IntArray;
+
+GenericPointer __test_file_int_allocator(char *s)
+{
+ unsigned int value = atoi(s);
+ return (GenericPointer) value;
+}
+
+void __test_file_set_int(GenericPointer storage, GenericPointer data)
+{
+ IntArray *array = (IntArray*) storage;
+ int i = (int) data;
+ array->values[i] = i;
+}
+
+TFUNCTION(test_dummy_file, {
+ KeyFinder keys[__NB_KEYS];
+ INIT_KEYFINDER(keys[0], "int0", " : ", __test_file_int_allocator, __test_file_set_int);
+ INIT_KEYFINDER(keys[1], "int1", " ", __test_file_int_allocator, __test_file_set_int);
+ INIT_KEYFINDER(keys[2], "int2", " -> ", __test_file_int_allocator, __test_file_set_int);
+ INIT_KEYFINDER(keys[3], "int3", "--", __test_file_int_allocator, __test_file_set_int);
+
+ IntArray results;
+ IntArray expected;
+
+ expected.values[0] = 0;
+ expected.values[1] = 1;
+ expected.values[2] = 2;
+ expected.values[3] = 3;
+
+ Parser parser;
+ FILE* file = fopen("./tests/info_reader_test.txt", "r");
+ INIT_PARSER(parser, (GenericPointer) &results, 0, 1, sizeof(IntArray), keys, __NB_KEYS, file);
+ parse(&parser);
+
+ for (unsigned int i = 0; i < __NB_KEYS; i++) {
+ TEST_INT(&(results.values[i]), &(expected.values[i]));
+ }
+})
+
TFILE_ENTRY_POINT(test_info_reader, {
CALL_TFUNCTION(test_replace_first);
CALL_TFUNCTION(test_split_on_delimiter);
CALL_TFUNCTION(test_start_with);
CALL_TFUNCTION(test_match);
+ CALL_TFUNCTION(test_dummy_file);
})
diff --git a/tests/info_reader_test.txt b/tests/info_reader_test.txt
new file mode 100644
index 0000000..17d4ee4
--- /dev/null
+++ b/tests/info_reader_test.txt
@@ -0,0 +1,9 @@
+noise:
+int0 : 0
+noise--
+int1 1
+int2 -> 2
+noise->
+int3--3
+noise----->>ss<<
+noiseee
--
GitLab
From e6199994a3da3d66e0addd1eefd487e263d6cc19 Mon Sep 17 00:00:00 2001
From: FlorealRISSO <floreal.risso@univ-tlse3.fr>
Date: Mon, 27 Mar 2023 15:18:50 +0200
Subject: [PATCH 03/16] fix: leak close
---
tests/info_reader.c | 1 +
1 file changed, 1 insertion(+)
diff --git a/tests/info_reader.c b/tests/info_reader.c
index 92f2ff9..af2873c 100644
--- a/tests/info_reader.c
+++ b/tests/info_reader.c
@@ -326,6 +326,7 @@ TFUNCTION(test_dummy_file, {
for (unsigned int i = 0; i < __NB_KEYS; i++) {
TEST_INT(&(results.values[i]), &(expected.values[i]));
}
+ fclose(file);
})
TFILE_ENTRY_POINT(test_info_reader, {
--
GitLab
From 881086c732d33f02d7a3ef77d9620f06dd33d042 Mon Sep 17 00:00:00 2001
From: FlorealRISSO <floreal.risso@univ-tlse3.fr>
Date: Mon, 27 Mar 2023 15:20:19 +0200
Subject: [PATCH 04/16] fix: make format
---
src/amd_rapl.c | 34 +++++++++++++--------------
src/network.c | 6 ++---
tests/info_reader.c | 9 ++++----
tests/util.c | 56 ++++++++++++++++++++++-----------------------
4 files changed, 53 insertions(+), 52 deletions(-)
diff --git a/src/amd_rapl.c b/src/amd_rapl.c
index 9eaac45..572ac56 100644
--- a/src/amd_rapl.c
+++ b/src/amd_rapl.c
@@ -201,7 +201,7 @@ void debug_print_amd_rapl(AmdRapl *rapl)
unsigned int get_nb_cpu()
{
char filename[BUFFER_SIZE];
- int cpy_errno;
+ int cpy_errno;
unsigned int n_cpu = 0;
for (;; n_cpu++) {
@@ -215,22 +215,22 @@ unsigned int get_nb_cpu()
close(fd);
}
- if (n_cpu == 0) {
- perror("open()");
- fprintf(stderr, "on the file: '%s'\n", filename);
- switch (cpy_errno) {
- case ENOENT:
- fprintf(stderr, "Amd rapl works with msr module, try to run 'sudo modprobe msr', then retry.\n");
- exit(99);
- case EACCES:
- fprintf(stderr, "Amd rapl must be executed with the administrator privilege, try with 'sudo'.\n");
- exit(98);
- default:
- fprintf(stderr, "Unexpected error\n");
- exit(97);
- }
- }
- // n_cpu > 0
+ if (n_cpu == 0) {
+ perror("open()");
+ fprintf(stderr, "on the file: '%s'\n", filename);
+ switch (cpy_errno) {
+ case ENOENT:
+ fprintf(stderr, "Amd rapl works with msr module, try to run 'sudo modprobe msr', then retry.\n");
+ exit(99);
+ case EACCES:
+ fprintf(stderr, "Amd rapl must be executed with the administrator privilege, try with 'sudo'.\n");
+ exit(98);
+ default:
+ fprintf(stderr, "Unexpected error\n");
+ exit(97);
+ }
+ }
+ // n_cpu > 0
return n_cpu;
}
diff --git a/src/network.c b/src/network.c
index a668725..fec9424 100644
--- a/src/network.c
+++ b/src/network.c
@@ -159,9 +159,9 @@ unsigned int init_network(char *dev, void **ptr)
/* compare dev name to the previously saved one */
int newdev = 1;
for (int i = 0; i < state->ndev && newdev; i++) {
- if (strncmp(start_of_dev, state->devs[i], s - start_of_dev) == 0) {
- newdev = 0;
- }
+ if (strncmp(start_of_dev, state->devs[i], s - start_of_dev) == 0) {
+ newdev = 0;
+ }
}
if (newdev) {
if (state->ndev >= NB_MAX_DEV) {
diff --git a/tests/info_reader.c b/tests/info_reader.c
index af2873c..1e4f281 100644
--- a/tests/info_reader.c
+++ b/tests/info_reader.c
@@ -287,7 +287,7 @@ TFUNCTION(test_match, {
#define __NB_KEYS 4
typedef struct {
- int values[__NB_KEYS];
+ int values[__NB_KEYS];
} IntArray;
GenericPointer __test_file_int_allocator(char *s)
@@ -298,7 +298,7 @@ GenericPointer __test_file_int_allocator(char *s)
void __test_file_set_int(GenericPointer storage, GenericPointer data)
{
- IntArray *array = (IntArray*) storage;
+ IntArray *array = (IntArray *) storage;
int i = (int) data;
array->values[i] = i;
}
@@ -319,11 +319,12 @@ TFUNCTION(test_dummy_file, {
expected.values[3] = 3;
Parser parser;
- FILE* file = fopen("./tests/info_reader_test.txt", "r");
+ FILE *file = fopen("./tests/info_reader_test.txt", "r");
INIT_PARSER(parser, (GenericPointer) &results, 0, 1, sizeof(IntArray), keys, __NB_KEYS, file);
parse(&parser);
- for (unsigned int i = 0; i < __NB_KEYS; i++) {
+ for (unsigned int i = 0; i < __NB_KEYS; i++)
+ {
TEST_INT(&(results.values[i]), &(expected.values[i]));
}
fclose(file);
diff --git a/tests/util.c b/tests/util.c
index 231ab47..ff979b9 100644
--- a/tests/util.c
+++ b/tests/util.c
@@ -78,45 +78,45 @@ TFUNCTION(test_modulo_substraction, {
})
TFUNCTION(test_max, {
- int expected = 0;
- int result = 0;
+ int expected = 0;
+ int result = 0;
- expected = 10;
- result = MAX(expected, 9);
- TEST_INT(&result, &expected);
+ expected = 10;
+ result = MAX(expected, 9);
+ TEST_INT(&result, &expected);
- expected = -15;
- result = MAX(expected, -16);
- TEST_INT(&result, &expected);
+ expected = -15;
+ result = MAX(expected, -16);
+ TEST_INT(&result, &expected);
- expected = 0;
- result = MAX(expected, -1);
- TEST_INT(&result, &expected);
+ expected = 0;
+ result = MAX(expected, -1);
+ TEST_INT(&result, &expected);
- expected = 1;
- result = MAX(expected, 0);
- TEST_INT(&result, &expected);
+ expected = 1;
+ result = MAX(expected, 0);
+ TEST_INT(&result, &expected);
})
TFUNCTION(test_min, {
- int expected = 0;
- int result = 0;
+ int expected = 0;
+ int result = 0;
- expected = 9;
- result = MIN(expected, 10);
- TEST_INT(&result, &expected);
+ expected = 9;
+ result = MIN(expected, 10);
+ TEST_INT(&result, &expected);
- expected = -16;
- result = MIN(expected, -15);
- TEST_INT(&result, &expected);
+ expected = -16;
+ result = MIN(expected, -15);
+ TEST_INT(&result, &expected);
- expected = -1;
- result = MIN(expected, 0);
- TEST_INT(&result, &expected);
+ expected = -1;
+ result = MIN(expected, 0);
+ TEST_INT(&result, &expected);
- expected = 0;
- result = MIN(expected, 1);
- TEST_INT(&result, &expected);
+ expected = 0;
+ result = MIN(expected, 1);
+ TEST_INT(&result, &expected);
})
TFILE_ENTRY_POINT(test_util, {
--
GitLab
From 064cfdf09660498e5b001c5d075585c7530164c3 Mon Sep 17 00:00:00 2001
From: FlorealRISSO <floreal.risso@univ-tlse3.fr>
Date: Mon, 27 Mar 2023 18:55:37 +0200
Subject: [PATCH 05/16] working on progress
---
meminfo_option.sh | 48 ++++++
src/meminfo_option.h | 402 +++++++++++++++++++++++++++++++++++++++++++
src/memory_extra.c | 95 ++++++++++
3 files changed, 545 insertions(+)
create mode 100644 meminfo_option.sh
create mode 100644 src/meminfo_option.h
create mode 100644 src/memory_extra.c
diff --git a/meminfo_option.sh b/meminfo_option.sh
new file mode 100644
index 0000000..4443868
--- /dev/null
+++ b/meminfo_option.sh
@@ -0,0 +1,48 @@
+#!bin/sh
+
+MEMINFO="/proc/meminfo"
+COUNT=0
+
+function get_meminfo_words {
+ printf "char *meminfo_words[] = {\n"
+ while read line; do
+ COUNT=$(expr $COUNT + 1)
+ word=$(echo $line | awk '{print $1}')
+ printf " \"${word::-1}\",\n"
+ done <$MEMINFO
+
+ printf "};\n\n"
+}
+
+function get_count {
+ printf "static const unsigned int meminfo_count = $COUNT;\n\n"
+}
+
+function get_meminfo_setter {
+ count=0
+ while [ $count -lt $COUNT ]; do
+ printf "void set_result_offset$count(GenericPointer ptr, GenericPointer data) {
+ uint64_t* result = (uint64_t *) ptr;
+ result[$count] = (uint64_t) data;
+}\n\n"
+ count=$(expr $count + 1)
+ done
+}
+
+function get_functions {
+ printf "static void (*setter_functions[])(GenericPointer, GenericPointer) = {\n"
+ count=0
+ while [ $count -lt $COUNT ]; do
+ printf " set_result_offset$count,\n"
+ count=$(expr $count + 1)
+ done
+ printf "};\n\n"
+}
+
+DEST="./src/meminfo_option.h"
+printf "#include \"inttypes.h\"\n" >$DEST
+printf "#include <info_reader.h>\n\n" >>$DEST
+get_meminfo_words "./text.h" >>$DEST
+get_count >>$DEST
+get_meminfo_setter >>$DEST
+get_functions >>$DEST
diff --git a/src/meminfo_option.h b/src/meminfo_option.h
new file mode 100644
index 0000000..f3369b8
--- /dev/null
+++ b/src/meminfo_option.h
@@ -0,0 +1,402 @@
+#include "inttypes.h"
+#include <info_reader.h>
+char *meminfo_words[] = {
+ "MemTotal",
+ "MemFree",
+ "MemAvailable",
+ "Buffers",
+ "Cached",
+ "SwapCached",
+ "Active",
+ "Inactive",
+ "Active(anon)",
+ "Inactive(anon)",
+ "Active(file)",
+ "Inactive(file)",
+ "Unevictable",
+ "Mlocked",
+ "SwapTotal",
+ "SwapFree",
+ "Zswap",
+ "Zswapped",
+ "Dirty",
+ "Writeback",
+ "AnonPages",
+ "Mapped",
+ "Shmem",
+ "KReclaimable",
+ "Slab",
+ "SReclaimable",
+ "SUnreclaim",
+ "KernelStack",
+ "PageTables",
+ "SecPageTables",
+ "NFS_Unstable",
+ "Bounce",
+ "WritebackTmp",
+ "CommitLimit",
+ "Committed_AS",
+ "VmallocTotal",
+ "VmallocUsed",
+ "VmallocChunk",
+ "Percpu",
+ "HardwareCorrupted",
+ "AnonHugePages",
+ "ShmemHugePages",
+ "ShmemPmdMapped",
+ "FileHugePages",
+ "FilePmdMapped",
+ "CmaTotal",
+ "CmaFree",
+ "HugePages_Total",
+ "HugePages_Free",
+ "HugePages_Rsvd",
+ "HugePages_Surp",
+ "Hugepagesize",
+ "Hugetlb",
+ "DirectMap4k",
+ "DirectMap2M",
+ "DirectMap1G",
+};
+
+static const unsigned int meminfo_count = 56;
+
+void set_result_offset0(GenericPointer ptr, GenericPointer data) {
+ uint64_t* result = (uint64_t *) ptr;
+ result[0] = (uint64_t) data;
+}
+
+void set_result_offset1(GenericPointer ptr, GenericPointer data) {
+ uint64_t* result = (uint64_t *) ptr;
+ result[1] = (uint64_t) data;
+}
+
+void set_result_offset2(GenericPointer ptr, GenericPointer data) {
+ uint64_t* result = (uint64_t *) ptr;
+ result[2] = (uint64_t) data;
+}
+
+void set_result_offset3(GenericPointer ptr, GenericPointer data) {
+ uint64_t* result = (uint64_t *) ptr;
+ result[3] = (uint64_t) data;
+}
+
+void set_result_offset4(GenericPointer ptr, GenericPointer data) {
+ uint64_t* result = (uint64_t *) ptr;
+ result[4] = (uint64_t) data;
+}
+
+void set_result_offset5(GenericPointer ptr, GenericPointer data) {
+ uint64_t* result = (uint64_t *) ptr;
+ result[5] = (uint64_t) data;
+}
+
+void set_result_offset6(GenericPointer ptr, GenericPointer data) {
+ uint64_t* result = (uint64_t *) ptr;
+ result[6] = (uint64_t) data;
+}
+
+void set_result_offset7(GenericPointer ptr, GenericPointer data) {
+ uint64_t* result = (uint64_t *) ptr;
+ result[7] = (uint64_t) data;
+}
+
+void set_result_offset8(GenericPointer ptr, GenericPointer data) {
+ uint64_t* result = (uint64_t *) ptr;
+ result[8] = (uint64_t) data;
+}
+
+void set_result_offset9(GenericPointer ptr, GenericPointer data) {
+ uint64_t* result = (uint64_t *) ptr;
+ result[9] = (uint64_t) data;
+}
+
+void set_result_offset10(GenericPointer ptr, GenericPointer data) {
+ uint64_t* result = (uint64_t *) ptr;
+ result[10] = (uint64_t) data;
+}
+
+void set_result_offset11(GenericPointer ptr, GenericPointer data) {
+ uint64_t* result = (uint64_t *) ptr;
+ result[11] = (uint64_t) data;
+}
+
+void set_result_offset12(GenericPointer ptr, GenericPointer data) {
+ uint64_t* result = (uint64_t *) ptr;
+ result[12] = (uint64_t) data;
+}
+
+void set_result_offset13(GenericPointer ptr, GenericPointer data) {
+ uint64_t* result = (uint64_t *) ptr;
+ result[13] = (uint64_t) data;
+}
+
+void set_result_offset14(GenericPointer ptr, GenericPointer data) {
+ uint64_t* result = (uint64_t *) ptr;
+ result[14] = (uint64_t) data;
+}
+
+void set_result_offset15(GenericPointer ptr, GenericPointer data) {
+ uint64_t* result = (uint64_t *) ptr;
+ result[15] = (uint64_t) data;
+}
+
+void set_result_offset16(GenericPointer ptr, GenericPointer data) {
+ uint64_t* result = (uint64_t *) ptr;
+ result[16] = (uint64_t) data;
+}
+
+void set_result_offset17(GenericPointer ptr, GenericPointer data) {
+ uint64_t* result = (uint64_t *) ptr;
+ result[17] = (uint64_t) data;
+}
+
+void set_result_offset18(GenericPointer ptr, GenericPointer data) {
+ uint64_t* result = (uint64_t *) ptr;
+ result[18] = (uint64_t) data;
+}
+
+void set_result_offset19(GenericPointer ptr, GenericPointer data) {
+ uint64_t* result = (uint64_t *) ptr;
+ result[19] = (uint64_t) data;
+}
+
+void set_result_offset20(GenericPointer ptr, GenericPointer data) {
+ uint64_t* result = (uint64_t *) ptr;
+ result[20] = (uint64_t) data;
+}
+
+void set_result_offset21(GenericPointer ptr, GenericPointer data) {
+ uint64_t* result = (uint64_t *) ptr;
+ result[21] = (uint64_t) data;
+}
+
+void set_result_offset22(GenericPointer ptr, GenericPointer data) {
+ uint64_t* result = (uint64_t *) ptr;
+ result[22] = (uint64_t) data;
+}
+
+void set_result_offset23(GenericPointer ptr, GenericPointer data) {
+ uint64_t* result = (uint64_t *) ptr;
+ result[23] = (uint64_t) data;
+}
+
+void set_result_offset24(GenericPointer ptr, GenericPointer data) {
+ uint64_t* result = (uint64_t *) ptr;
+ result[24] = (uint64_t) data;
+}
+
+void set_result_offset25(GenericPointer ptr, GenericPointer data) {
+ uint64_t* result = (uint64_t *) ptr;
+ result[25] = (uint64_t) data;
+}
+
+void set_result_offset26(GenericPointer ptr, GenericPointer data) {
+ uint64_t* result = (uint64_t *) ptr;
+ result[26] = (uint64_t) data;
+}
+
+void set_result_offset27(GenericPointer ptr, GenericPointer data) {
+ uint64_t* result = (uint64_t *) ptr;
+ result[27] = (uint64_t) data;
+}
+
+void set_result_offset28(GenericPointer ptr, GenericPointer data) {
+ uint64_t* result = (uint64_t *) ptr;
+ result[28] = (uint64_t) data;
+}
+
+void set_result_offset29(GenericPointer ptr, GenericPointer data) {
+ uint64_t* result = (uint64_t *) ptr;
+ result[29] = (uint64_t) data;
+}
+
+void set_result_offset30(GenericPointer ptr, GenericPointer data) {
+ uint64_t* result = (uint64_t *) ptr;
+ result[30] = (uint64_t) data;
+}
+
+void set_result_offset31(GenericPointer ptr, GenericPointer data) {
+ uint64_t* result = (uint64_t *) ptr;
+ result[31] = (uint64_t) data;
+}
+
+void set_result_offset32(GenericPointer ptr, GenericPointer data) {
+ uint64_t* result = (uint64_t *) ptr;
+ result[32] = (uint64_t) data;
+}
+
+void set_result_offset33(GenericPointer ptr, GenericPointer data) {
+ uint64_t* result = (uint64_t *) ptr;
+ result[33] = (uint64_t) data;
+}
+
+void set_result_offset34(GenericPointer ptr, GenericPointer data) {
+ uint64_t* result = (uint64_t *) ptr;
+ result[34] = (uint64_t) data;
+}
+
+void set_result_offset35(GenericPointer ptr, GenericPointer data) {
+ uint64_t* result = (uint64_t *) ptr;
+ result[35] = (uint64_t) data;
+}
+
+void set_result_offset36(GenericPointer ptr, GenericPointer data) {
+ uint64_t* result = (uint64_t *) ptr;
+ result[36] = (uint64_t) data;
+}
+
+void set_result_offset37(GenericPointer ptr, GenericPointer data) {
+ uint64_t* result = (uint64_t *) ptr;
+ result[37] = (uint64_t) data;
+}
+
+void set_result_offset38(GenericPointer ptr, GenericPointer data) {
+ uint64_t* result = (uint64_t *) ptr;
+ result[38] = (uint64_t) data;
+}
+
+void set_result_offset39(GenericPointer ptr, GenericPointer data) {
+ uint64_t* result = (uint64_t *) ptr;
+ result[39] = (uint64_t) data;
+}
+
+void set_result_offset40(GenericPointer ptr, GenericPointer data) {
+ uint64_t* result = (uint64_t *) ptr;
+ result[40] = (uint64_t) data;
+}
+
+void set_result_offset41(GenericPointer ptr, GenericPointer data) {
+ uint64_t* result = (uint64_t *) ptr;
+ result[41] = (uint64_t) data;
+}
+
+void set_result_offset42(GenericPointer ptr, GenericPointer data) {
+ uint64_t* result = (uint64_t *) ptr;
+ result[42] = (uint64_t) data;
+}
+
+void set_result_offset43(GenericPointer ptr, GenericPointer data) {
+ uint64_t* result = (uint64_t *) ptr;
+ result[43] = (uint64_t) data;
+}
+
+void set_result_offset44(GenericPointer ptr, GenericPointer data) {
+ uint64_t* result = (uint64_t *) ptr;
+ result[44] = (uint64_t) data;
+}
+
+void set_result_offset45(GenericPointer ptr, GenericPointer data) {
+ uint64_t* result = (uint64_t *) ptr;
+ result[45] = (uint64_t) data;
+}
+
+void set_result_offset46(GenericPointer ptr, GenericPointer data) {
+ uint64_t* result = (uint64_t *) ptr;
+ result[46] = (uint64_t) data;
+}
+
+void set_result_offset47(GenericPointer ptr, GenericPointer data) {
+ uint64_t* result = (uint64_t *) ptr;
+ result[47] = (uint64_t) data;
+}
+
+void set_result_offset48(GenericPointer ptr, GenericPointer data) {
+ uint64_t* result = (uint64_t *) ptr;
+ result[48] = (uint64_t) data;
+}
+
+void set_result_offset49(GenericPointer ptr, GenericPointer data) {
+ uint64_t* result = (uint64_t *) ptr;
+ result[49] = (uint64_t) data;
+}
+
+void set_result_offset50(GenericPointer ptr, GenericPointer data) {
+ uint64_t* result = (uint64_t *) ptr;
+ result[50] = (uint64_t) data;
+}
+
+void set_result_offset51(GenericPointer ptr, GenericPointer data) {
+ uint64_t* result = (uint64_t *) ptr;
+ result[51] = (uint64_t) data;
+}
+
+void set_result_offset52(GenericPointer ptr, GenericPointer data) {
+ uint64_t* result = (uint64_t *) ptr;
+ result[52] = (uint64_t) data;
+}
+
+void set_result_offset53(GenericPointer ptr, GenericPointer data) {
+ uint64_t* result = (uint64_t *) ptr;
+ result[53] = (uint64_t) data;
+}
+
+void set_result_offset54(GenericPointer ptr, GenericPointer data) {
+ uint64_t* result = (uint64_t *) ptr;
+ result[54] = (uint64_t) data;
+}
+
+void set_result_offset55(GenericPointer ptr, GenericPointer data) {
+ uint64_t* result = (uint64_t *) ptr;
+ result[55] = (uint64_t) data;
+}
+
+static void (*setter_functions[])(GenericPointer, GenericPointer) = {
+ set_result_offset0,
+ set_result_offset1,
+ set_result_offset2,
+ set_result_offset3,
+ set_result_offset4,
+ set_result_offset5,
+ set_result_offset6,
+ set_result_offset7,
+ set_result_offset8,
+ set_result_offset9,
+ set_result_offset10,
+ set_result_offset11,
+ set_result_offset12,
+ set_result_offset13,
+ set_result_offset14,
+ set_result_offset15,
+ set_result_offset16,
+ set_result_offset17,
+ set_result_offset18,
+ set_result_offset19,
+ set_result_offset20,
+ set_result_offset21,
+ set_result_offset22,
+ set_result_offset23,
+ set_result_offset24,
+ set_result_offset25,
+ set_result_offset26,
+ set_result_offset27,
+ set_result_offset28,
+ set_result_offset29,
+ set_result_offset30,
+ set_result_offset31,
+ set_result_offset32,
+ set_result_offset33,
+ set_result_offset34,
+ set_result_offset35,
+ set_result_offset36,
+ set_result_offset37,
+ set_result_offset38,
+ set_result_offset39,
+ set_result_offset40,
+ set_result_offset41,
+ set_result_offset42,
+ set_result_offset43,
+ set_result_offset44,
+ set_result_offset45,
+ set_result_offset46,
+ set_result_offset47,
+ set_result_offset48,
+ set_result_offset49,
+ set_result_offset50,
+ set_result_offset51,
+ set_result_offset52,
+ set_result_offset53,
+ set_result_offset54,
+ set_result_offset55,
+};
+
diff --git a/src/memory_extra.c b/src/memory_extra.c
new file mode 100644
index 0000000..f616870
--- /dev/null
+++ b/src/memory_extra.c
@@ -0,0 +1,95 @@
+#include "meminfo_option.h"
+#include <info_reader.h>
+#include <inttypes.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+static const char *path = "/proc/meminfo";
+
+GenericPointer long_allocator(char *s) {
+ long value = atol(s);
+ return (GenericPointer)value;
+}
+
+KeyFinder *build_keyfinder(unsigned int count, unsigned int *indexes) {
+ KeyFinder *keys = (KeyFinder *)calloc(count, sizeof(KeyFinder));
+ for (unsigned int i = 0; i < count; i++) {
+ unsigned int idx = indexes[i];
+ KeyFinder key = {.key = meminfo_words[idx],
+ .delimiter = ":",
+ .copy = long_allocator,
+ .set = setter_functions[i]};
+ memcpy(&keys[i], &key, sizeof(KeyFinder));
+ }
+ return keys;
+}
+
+void memory_list(char *memory_string, unsigned int *count,
+ unsigned int *indexes) {
+ char *token;
+ *count = 0;
+
+ while ((token = strtok(memory_string, ",")) != NULL) {
+ memory_string = NULL;
+
+ unsigned int i;
+ for (i = 0; i < meminfo_count; i++) {
+ if (strcmp(meminfo_words[i], token) == 0) {
+ (*count)++;
+ indexes[*count - 1] = i;
+ break;
+ }
+ }
+
+ if (i == meminfo_count) {
+ fprintf(stderr, "Unknown memory counter: %s\n", token);
+ exit(EXIT_FAILURE);
+ }
+
+ if ((*count) > meminfo_count) {
+ fprintf(stderr, "Too much counters, there are probably duplicates\n");
+ exit(EXIT_FAILURE);
+ }
+ }
+}
+
+int main(int argc, char **argv) {
+
+ if (argc != 2) {
+ fprintf(stderr, "Usage ... [elem1,elem2...]\n");
+ exit(EXIT_FAILURE);
+ }
+
+ unsigned int indexes[meminfo_count];
+ unsigned int count = 0;
+ memory_list(argv[1], &count, indexes);
+
+ printf("%d, count \n", count);
+
+ KeyFinder *keys = build_keyfinder(count, indexes);
+ uint64_t value[count];
+
+ // -- Init the parser
+ Parser parser = {.storage = (GenericPointer)&value,
+ .capacity = 1,
+ .storage_struct_size = sizeof(uint64_t) * count,
+ .keys = keys,
+ .nb_keys = count,
+ .file = fopen(path, "r")};
+
+ // -- Parse the file
+ while (1) {
+ parse(&parser);
+ for (unsigned int i = 0; i < count; i++) {
+ printf("%s: %" PRIu64 "\n", keys[i].key, value[i]);
+ }
+ }
+
+ free(keys);
+
+ // Print and free the results
+
+ fclose(parser.file);
+ return 0;
+}
--
GitLab
From 5149f2fe08bc672f671b9afff72192885f14b120 Mon Sep 17 00:00:00 2001
From: FlorealRISSO <floreal.risso@univ-tlse3.fr>
Date: Tue, 28 Mar 2023 09:36:14 +0200
Subject: [PATCH 06/16] update: script
---
.gitignore | 1 +
meminfo_option.sh | 48 ---
src/meminfo_option.h | 402 ----------------------
src/meminfo_option.sh | 46 +++
src/{memory_extra.c => memory_counters.c} | 12 +-
5 files changed, 53 insertions(+), 456 deletions(-)
delete mode 100644 meminfo_option.sh
delete mode 100644 src/meminfo_option.h
create mode 100644 src/meminfo_option.sh
rename src/{memory_extra.c => memory_counters.c} (89%)
diff --git a/.gitignore b/.gitignore
index 83a8dc0..eb6940e 100644
--- a/.gitignore
+++ b/.gitignore
@@ -6,6 +6,7 @@ doc/info_reader_ex
doc/mojitos.1
tests/run
src/counters_option.h
+src/meminfo_option.h
src/sensors.h
sensors.mk
bin
diff --git a/meminfo_option.sh b/meminfo_option.sh
deleted file mode 100644
index 4443868..0000000
--- a/meminfo_option.sh
+++ /dev/null
@@ -1,48 +0,0 @@
-#!bin/sh
-
-MEMINFO="/proc/meminfo"
-COUNT=0
-
-function get_meminfo_words {
- printf "char *meminfo_words[] = {\n"
- while read line; do
- COUNT=$(expr $COUNT + 1)
- word=$(echo $line | awk '{print $1}')
- printf " \"${word::-1}\",\n"
- done <$MEMINFO
-
- printf "};\n\n"
-}
-
-function get_count {
- printf "static const unsigned int meminfo_count = $COUNT;\n\n"
-}
-
-function get_meminfo_setter {
- count=0
- while [ $count -lt $COUNT ]; do
- printf "void set_result_offset$count(GenericPointer ptr, GenericPointer data) {
- uint64_t* result = (uint64_t *) ptr;
- result[$count] = (uint64_t) data;
-}\n\n"
- count=$(expr $count + 1)
- done
-}
-
-function get_functions {
- printf "static void (*setter_functions[])(GenericPointer, GenericPointer) = {\n"
- count=0
- while [ $count -lt $COUNT ]; do
- printf " set_result_offset$count,\n"
- count=$(expr $count + 1)
- done
- printf "};\n\n"
-}
-
-DEST="./src/meminfo_option.h"
-printf "#include \"inttypes.h\"\n" >$DEST
-printf "#include <info_reader.h>\n\n" >>$DEST
-get_meminfo_words "./text.h" >>$DEST
-get_count >>$DEST
-get_meminfo_setter >>$DEST
-get_functions >>$DEST
diff --git a/src/meminfo_option.h b/src/meminfo_option.h
deleted file mode 100644
index f3369b8..0000000
--- a/src/meminfo_option.h
+++ /dev/null
@@ -1,402 +0,0 @@
-#include "inttypes.h"
-#include <info_reader.h>
-char *meminfo_words[] = {
- "MemTotal",
- "MemFree",
- "MemAvailable",
- "Buffers",
- "Cached",
- "SwapCached",
- "Active",
- "Inactive",
- "Active(anon)",
- "Inactive(anon)",
- "Active(file)",
- "Inactive(file)",
- "Unevictable",
- "Mlocked",
- "SwapTotal",
- "SwapFree",
- "Zswap",
- "Zswapped",
- "Dirty",
- "Writeback",
- "AnonPages",
- "Mapped",
- "Shmem",
- "KReclaimable",
- "Slab",
- "SReclaimable",
- "SUnreclaim",
- "KernelStack",
- "PageTables",
- "SecPageTables",
- "NFS_Unstable",
- "Bounce",
- "WritebackTmp",
- "CommitLimit",
- "Committed_AS",
- "VmallocTotal",
- "VmallocUsed",
- "VmallocChunk",
- "Percpu",
- "HardwareCorrupted",
- "AnonHugePages",
- "ShmemHugePages",
- "ShmemPmdMapped",
- "FileHugePages",
- "FilePmdMapped",
- "CmaTotal",
- "CmaFree",
- "HugePages_Total",
- "HugePages_Free",
- "HugePages_Rsvd",
- "HugePages_Surp",
- "Hugepagesize",
- "Hugetlb",
- "DirectMap4k",
- "DirectMap2M",
- "DirectMap1G",
-};
-
-static const unsigned int meminfo_count = 56;
-
-void set_result_offset0(GenericPointer ptr, GenericPointer data) {
- uint64_t* result = (uint64_t *) ptr;
- result[0] = (uint64_t) data;
-}
-
-void set_result_offset1(GenericPointer ptr, GenericPointer data) {
- uint64_t* result = (uint64_t *) ptr;
- result[1] = (uint64_t) data;
-}
-
-void set_result_offset2(GenericPointer ptr, GenericPointer data) {
- uint64_t* result = (uint64_t *) ptr;
- result[2] = (uint64_t) data;
-}
-
-void set_result_offset3(GenericPointer ptr, GenericPointer data) {
- uint64_t* result = (uint64_t *) ptr;
- result[3] = (uint64_t) data;
-}
-
-void set_result_offset4(GenericPointer ptr, GenericPointer data) {
- uint64_t* result = (uint64_t *) ptr;
- result[4] = (uint64_t) data;
-}
-
-void set_result_offset5(GenericPointer ptr, GenericPointer data) {
- uint64_t* result = (uint64_t *) ptr;
- result[5] = (uint64_t) data;
-}
-
-void set_result_offset6(GenericPointer ptr, GenericPointer data) {
- uint64_t* result = (uint64_t *) ptr;
- result[6] = (uint64_t) data;
-}
-
-void set_result_offset7(GenericPointer ptr, GenericPointer data) {
- uint64_t* result = (uint64_t *) ptr;
- result[7] = (uint64_t) data;
-}
-
-void set_result_offset8(GenericPointer ptr, GenericPointer data) {
- uint64_t* result = (uint64_t *) ptr;
- result[8] = (uint64_t) data;
-}
-
-void set_result_offset9(GenericPointer ptr, GenericPointer data) {
- uint64_t* result = (uint64_t *) ptr;
- result[9] = (uint64_t) data;
-}
-
-void set_result_offset10(GenericPointer ptr, GenericPointer data) {
- uint64_t* result = (uint64_t *) ptr;
- result[10] = (uint64_t) data;
-}
-
-void set_result_offset11(GenericPointer ptr, GenericPointer data) {
- uint64_t* result = (uint64_t *) ptr;
- result[11] = (uint64_t) data;
-}
-
-void set_result_offset12(GenericPointer ptr, GenericPointer data) {
- uint64_t* result = (uint64_t *) ptr;
- result[12] = (uint64_t) data;
-}
-
-void set_result_offset13(GenericPointer ptr, GenericPointer data) {
- uint64_t* result = (uint64_t *) ptr;
- result[13] = (uint64_t) data;
-}
-
-void set_result_offset14(GenericPointer ptr, GenericPointer data) {
- uint64_t* result = (uint64_t *) ptr;
- result[14] = (uint64_t) data;
-}
-
-void set_result_offset15(GenericPointer ptr, GenericPointer data) {
- uint64_t* result = (uint64_t *) ptr;
- result[15] = (uint64_t) data;
-}
-
-void set_result_offset16(GenericPointer ptr, GenericPointer data) {
- uint64_t* result = (uint64_t *) ptr;
- result[16] = (uint64_t) data;
-}
-
-void set_result_offset17(GenericPointer ptr, GenericPointer data) {
- uint64_t* result = (uint64_t *) ptr;
- result[17] = (uint64_t) data;
-}
-
-void set_result_offset18(GenericPointer ptr, GenericPointer data) {
- uint64_t* result = (uint64_t *) ptr;
- result[18] = (uint64_t) data;
-}
-
-void set_result_offset19(GenericPointer ptr, GenericPointer data) {
- uint64_t* result = (uint64_t *) ptr;
- result[19] = (uint64_t) data;
-}
-
-void set_result_offset20(GenericPointer ptr, GenericPointer data) {
- uint64_t* result = (uint64_t *) ptr;
- result[20] = (uint64_t) data;
-}
-
-void set_result_offset21(GenericPointer ptr, GenericPointer data) {
- uint64_t* result = (uint64_t *) ptr;
- result[21] = (uint64_t) data;
-}
-
-void set_result_offset22(GenericPointer ptr, GenericPointer data) {
- uint64_t* result = (uint64_t *) ptr;
- result[22] = (uint64_t) data;
-}
-
-void set_result_offset23(GenericPointer ptr, GenericPointer data) {
- uint64_t* result = (uint64_t *) ptr;
- result[23] = (uint64_t) data;
-}
-
-void set_result_offset24(GenericPointer ptr, GenericPointer data) {
- uint64_t* result = (uint64_t *) ptr;
- result[24] = (uint64_t) data;
-}
-
-void set_result_offset25(GenericPointer ptr, GenericPointer data) {
- uint64_t* result = (uint64_t *) ptr;
- result[25] = (uint64_t) data;
-}
-
-void set_result_offset26(GenericPointer ptr, GenericPointer data) {
- uint64_t* result = (uint64_t *) ptr;
- result[26] = (uint64_t) data;
-}
-
-void set_result_offset27(GenericPointer ptr, GenericPointer data) {
- uint64_t* result = (uint64_t *) ptr;
- result[27] = (uint64_t) data;
-}
-
-void set_result_offset28(GenericPointer ptr, GenericPointer data) {
- uint64_t* result = (uint64_t *) ptr;
- result[28] = (uint64_t) data;
-}
-
-void set_result_offset29(GenericPointer ptr, GenericPointer data) {
- uint64_t* result = (uint64_t *) ptr;
- result[29] = (uint64_t) data;
-}
-
-void set_result_offset30(GenericPointer ptr, GenericPointer data) {
- uint64_t* result = (uint64_t *) ptr;
- result[30] = (uint64_t) data;
-}
-
-void set_result_offset31(GenericPointer ptr, GenericPointer data) {
- uint64_t* result = (uint64_t *) ptr;
- result[31] = (uint64_t) data;
-}
-
-void set_result_offset32(GenericPointer ptr, GenericPointer data) {
- uint64_t* result = (uint64_t *) ptr;
- result[32] = (uint64_t) data;
-}
-
-void set_result_offset33(GenericPointer ptr, GenericPointer data) {
- uint64_t* result = (uint64_t *) ptr;
- result[33] = (uint64_t) data;
-}
-
-void set_result_offset34(GenericPointer ptr, GenericPointer data) {
- uint64_t* result = (uint64_t *) ptr;
- result[34] = (uint64_t) data;
-}
-
-void set_result_offset35(GenericPointer ptr, GenericPointer data) {
- uint64_t* result = (uint64_t *) ptr;
- result[35] = (uint64_t) data;
-}
-
-void set_result_offset36(GenericPointer ptr, GenericPointer data) {
- uint64_t* result = (uint64_t *) ptr;
- result[36] = (uint64_t) data;
-}
-
-void set_result_offset37(GenericPointer ptr, GenericPointer data) {
- uint64_t* result = (uint64_t *) ptr;
- result[37] = (uint64_t) data;
-}
-
-void set_result_offset38(GenericPointer ptr, GenericPointer data) {
- uint64_t* result = (uint64_t *) ptr;
- result[38] = (uint64_t) data;
-}
-
-void set_result_offset39(GenericPointer ptr, GenericPointer data) {
- uint64_t* result = (uint64_t *) ptr;
- result[39] = (uint64_t) data;
-}
-
-void set_result_offset40(GenericPointer ptr, GenericPointer data) {
- uint64_t* result = (uint64_t *) ptr;
- result[40] = (uint64_t) data;
-}
-
-void set_result_offset41(GenericPointer ptr, GenericPointer data) {
- uint64_t* result = (uint64_t *) ptr;
- result[41] = (uint64_t) data;
-}
-
-void set_result_offset42(GenericPointer ptr, GenericPointer data) {
- uint64_t* result = (uint64_t *) ptr;
- result[42] = (uint64_t) data;
-}
-
-void set_result_offset43(GenericPointer ptr, GenericPointer data) {
- uint64_t* result = (uint64_t *) ptr;
- result[43] = (uint64_t) data;
-}
-
-void set_result_offset44(GenericPointer ptr, GenericPointer data) {
- uint64_t* result = (uint64_t *) ptr;
- result[44] = (uint64_t) data;
-}
-
-void set_result_offset45(GenericPointer ptr, GenericPointer data) {
- uint64_t* result = (uint64_t *) ptr;
- result[45] = (uint64_t) data;
-}
-
-void set_result_offset46(GenericPointer ptr, GenericPointer data) {
- uint64_t* result = (uint64_t *) ptr;
- result[46] = (uint64_t) data;
-}
-
-void set_result_offset47(GenericPointer ptr, GenericPointer data) {
- uint64_t* result = (uint64_t *) ptr;
- result[47] = (uint64_t) data;
-}
-
-void set_result_offset48(GenericPointer ptr, GenericPointer data) {
- uint64_t* result = (uint64_t *) ptr;
- result[48] = (uint64_t) data;
-}
-
-void set_result_offset49(GenericPointer ptr, GenericPointer data) {
- uint64_t* result = (uint64_t *) ptr;
- result[49] = (uint64_t) data;
-}
-
-void set_result_offset50(GenericPointer ptr, GenericPointer data) {
- uint64_t* result = (uint64_t *) ptr;
- result[50] = (uint64_t) data;
-}
-
-void set_result_offset51(GenericPointer ptr, GenericPointer data) {
- uint64_t* result = (uint64_t *) ptr;
- result[51] = (uint64_t) data;
-}
-
-void set_result_offset52(GenericPointer ptr, GenericPointer data) {
- uint64_t* result = (uint64_t *) ptr;
- result[52] = (uint64_t) data;
-}
-
-void set_result_offset53(GenericPointer ptr, GenericPointer data) {
- uint64_t* result = (uint64_t *) ptr;
- result[53] = (uint64_t) data;
-}
-
-void set_result_offset54(GenericPointer ptr, GenericPointer data) {
- uint64_t* result = (uint64_t *) ptr;
- result[54] = (uint64_t) data;
-}
-
-void set_result_offset55(GenericPointer ptr, GenericPointer data) {
- uint64_t* result = (uint64_t *) ptr;
- result[55] = (uint64_t) data;
-}
-
-static void (*setter_functions[])(GenericPointer, GenericPointer) = {
- set_result_offset0,
- set_result_offset1,
- set_result_offset2,
- set_result_offset3,
- set_result_offset4,
- set_result_offset5,
- set_result_offset6,
- set_result_offset7,
- set_result_offset8,
- set_result_offset9,
- set_result_offset10,
- set_result_offset11,
- set_result_offset12,
- set_result_offset13,
- set_result_offset14,
- set_result_offset15,
- set_result_offset16,
- set_result_offset17,
- set_result_offset18,
- set_result_offset19,
- set_result_offset20,
- set_result_offset21,
- set_result_offset22,
- set_result_offset23,
- set_result_offset24,
- set_result_offset25,
- set_result_offset26,
- set_result_offset27,
- set_result_offset28,
- set_result_offset29,
- set_result_offset30,
- set_result_offset31,
- set_result_offset32,
- set_result_offset33,
- set_result_offset34,
- set_result_offset35,
- set_result_offset36,
- set_result_offset37,
- set_result_offset38,
- set_result_offset39,
- set_result_offset40,
- set_result_offset41,
- set_result_offset42,
- set_result_offset43,
- set_result_offset44,
- set_result_offset45,
- set_result_offset46,
- set_result_offset47,
- set_result_offset48,
- set_result_offset49,
- set_result_offset50,
- set_result_offset51,
- set_result_offset52,
- set_result_offset53,
- set_result_offset54,
- set_result_offset55,
-};
-
diff --git a/src/meminfo_option.sh b/src/meminfo_option.sh
new file mode 100644
index 0000000..54a2c6e
--- /dev/null
+++ b/src/meminfo_option.sh
@@ -0,0 +1,46 @@
+#!/bin/sh
+
+# SPDX-License-Identifier: GPL-3.0-or-later
+# Copyright (C) 2018-2023 Georges Da Costa <georges.da-costa@irit.fr>
+
+MEMINFO_PATH="/proc/meminfo"
+
+FUNCTION_TEMPLATE="void set_result_offset%s(GenericPointer ptr, GenericPointer data)
+{
+ uint64_t* result = (uint64_t *) ptr;
+ result[%s] = (uint64_t) data;
+}\n\n"
+
+nb_counters=0
+
+echo '#include <inttypes.h>'
+echo "#include <info_reader.h>"
+echo
+
+echo 'static char *memory_counters[] = {'
+while read line; do
+ nb_counters=$(expr $nb_counters + 1)
+ word=$(echo $line | awk '{print $1}')
+ echo " \"${word::-1}\","
+done <$MEMINFO_PATH
+echo "};"
+echo
+
+echo "#define NB_COUNTERS $nb_counters"
+echo
+
+count=0
+while [ $count -lt $nb_counters ]; do
+ printf "$FUNCTION_TEMPLATE" $count $count
+ count=$(expr $count + 1)
+done
+
+echo "static void (*setter_functions[])(GenericPointer, GenericPointer) = {"
+count=0
+while [ $count -lt $nb_counters ]; do
+ echo " set_result_offset$count,"
+ count=$(expr $count + 1)
+done
+echo "};"
+echo
+
diff --git a/src/memory_extra.c b/src/memory_counters.c
similarity index 89%
rename from src/memory_extra.c
rename to src/memory_counters.c
index f616870..4572ff0 100644
--- a/src/memory_extra.c
+++ b/src/memory_counters.c
@@ -16,7 +16,7 @@ KeyFinder *build_keyfinder(unsigned int count, unsigned int *indexes) {
KeyFinder *keys = (KeyFinder *)calloc(count, sizeof(KeyFinder));
for (unsigned int i = 0; i < count; i++) {
unsigned int idx = indexes[i];
- KeyFinder key = {.key = meminfo_words[idx],
+ KeyFinder key = {.key = memory_counters[idx],
.delimiter = ":",
.copy = long_allocator,
.set = setter_functions[i]};
@@ -34,20 +34,20 @@ void memory_list(char *memory_string, unsigned int *count,
memory_string = NULL;
unsigned int i;
- for (i = 0; i < meminfo_count; i++) {
- if (strcmp(meminfo_words[i], token) == 0) {
+ for (i = 0; i < NB_COUNTERS; i++) {
+ if (strcmp(memory_counters[i], token) == 0) {
(*count)++;
indexes[*count - 1] = i;
break;
}
}
- if (i == meminfo_count) {
+ if (i == NB_COUNTERS) {
fprintf(stderr, "Unknown memory counter: %s\n", token);
exit(EXIT_FAILURE);
}
- if ((*count) > meminfo_count) {
+ if ((*count) > NB_COUNTERS) {
fprintf(stderr, "Too much counters, there are probably duplicates\n");
exit(EXIT_FAILURE);
}
@@ -61,7 +61,7 @@ int main(int argc, char **argv) {
exit(EXIT_FAILURE);
}
- unsigned int indexes[meminfo_count];
+ unsigned int indexes[NB_COUNTERS];
unsigned int count = 0;
memory_list(argv[1], &count, indexes);
--
GitLab
From db433cca717ddc0ec8842eb6a3c155817e95a7fc Mon Sep 17 00:00:00 2001
From: FlorealRISSO <floreal.risso@univ-tlse3.fr>
Date: Tue, 28 Mar 2023 10:00:50 +0200
Subject: [PATCH 07/16] update: create api
---
src/memory_counters.c | 74 +++++++++++++++++++++++++------------------
1 file changed, 44 insertions(+), 30 deletions(-)
diff --git a/src/memory_counters.c b/src/memory_counters.c
index 4572ff0..7225352 100644
--- a/src/memory_counters.c
+++ b/src/memory_counters.c
@@ -1,4 +1,6 @@
#include "meminfo_option.h"
+#include <bits/stdint-uintn.h>
+#include <fcntl.h>
#include <info_reader.h>
#include <inttypes.h>
#include <stdio.h>
@@ -7,6 +9,12 @@
static const char *path = "/proc/meminfo";
+typedef struct {
+ KeyFinder *keys;
+ unsigned int count;
+ FILE *file;
+} MemoryCounters;
+
GenericPointer long_allocator(char *s) {
long value = atol(s);
return (GenericPointer)value;
@@ -54,42 +62,48 @@ void memory_list(char *memory_string, unsigned int *count,
}
}
-int main(int argc, char **argv) {
-
- if (argc != 2) {
- fprintf(stderr, "Usage ... [elem1,elem2...]\n");
- exit(EXIT_FAILURE);
- }
-
+unsigned int init_memory_counters(char *args, void **ptr) {
unsigned int indexes[NB_COUNTERS];
unsigned int count = 0;
- memory_list(argv[1], &count, indexes);
-
- printf("%d, count \n", count);
+ memory_list(args, &count, indexes);
KeyFinder *keys = build_keyfinder(count, indexes);
- uint64_t value[count];
+ FILE *file = fopen(path, "r");
- // -- Init the parser
- Parser parser = {.storage = (GenericPointer)&value,
- .capacity = 1,
- .storage_struct_size = sizeof(uint64_t) * count,
- .keys = keys,
- .nb_keys = count,
- .file = fopen(path, "r")};
-
- // -- Parse the file
- while (1) {
- parse(&parser);
- for (unsigned int i = 0; i < count; i++) {
- printf("%s: %" PRIu64 "\n", keys[i].key, value[i]);
- }
- }
+ MemoryCounters *counters = calloc(1, sizeof(MemoryCounters));
+ counters->keys = keys;
+ counters->count = count;
+ counters->file = file;
- free(keys);
+ *ptr = (void *)counters;
+ return count;
+}
- // Print and free the results
+unsigned int get_memory_counters(uint64_t *results, void *ptr) {
+ MemoryCounters *counters = (MemoryCounters *)ptr;
+ fseek(counters->file, 0, SEEK_SET);
+ Parser parser = {.storage = (GenericPointer)results,
+ .capacity = 1,
+ .nb_stored = 0,
+ .storage_struct_size = sizeof(uint64_t) * counters->count,
+ .keys = counters->keys,
+ .nb_keys = counters->count,
+ .file = counters->file};
+
+ parse(&parser);
+ return counters->count;
+}
+
+void label_memory_counters(char **labels, void *ptr) {
+ MemoryCounters *counters = (MemoryCounters *)ptr;
+ for (unsigned int i = 0; i < counters->count; i++) {
+ labels[i] = counters->keys[i].key;
+ }
+}
- fclose(parser.file);
- return 0;
+void clean_memory_counters(void *ptr) {
+ MemoryCounters *counters = (MemoryCounters *)ptr;
+ fclose(counters->file);
+ free(counters->keys);
+ free(ptr);
}
--
GitLab
From f1348876b0dd2f8872f0ebf0bab6b9f80ca63f79 Mon Sep 17 00:00:00 2001
From: FlorealRISSO <floreal.risso@univ-tlse3.fr>
Date: Tue, 28 Mar 2023 10:11:08 +0200
Subject: [PATCH 08/16] update header
---
src/memory_counters.c | 13 ++++++++++-
src/memory_counters.h | 54 +++++++++++++++++++++++++++++++++++++++++++
2 files changed, 66 insertions(+), 1 deletion(-)
create mode 100644 src/memory_counters.h
diff --git a/src/memory_counters.c b/src/memory_counters.c
index 7225352..23e3f96 100644
--- a/src/memory_counters.c
+++ b/src/memory_counters.c
@@ -1,5 +1,5 @@
#include "meminfo_option.h"
-#include <bits/stdint-uintn.h>
+#include "util.h"
#include <fcntl.h>
#include <info_reader.h>
#include <inttypes.h>
@@ -107,3 +107,14 @@ void clean_memory_counters(void *ptr) {
free(counters->keys);
free(ptr);
}
+
+void *show_all_memory_counters(void *none1, size_t none2) {
+ for (unsigned int i = 0; i < NB_COUNTERS; i++) {
+ printf("%s\n", memory_counters[i]);
+ }
+
+ UNUSED(none1);
+ UNUSED(none2);
+ exit(EXIT_SUCCESS);
+ return NULL; /* not reached */
+}
diff --git a/src/memory_counters.h b/src/memory_counters.h
new file mode 100644
index 0000000..a066c42
--- /dev/null
+++ b/src/memory_counters.h
@@ -0,0 +1,54 @@
+/*******************************************************
+ Copyright (C) 2023-2023 Georges Da Costa <georges.da-costa@irit.fr>
+
+ This file is part of Mojitos.
+
+ Mojitos is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ Mojitos is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with MojitO/S. If not, see <https://www.gnu.org/licenses/>.
+
+ *******************************************************/
+
+unsigned int init_memory_counters(char *args, void **ptr);
+unsigned int get_memory_counters(uint64_t *results, void *ptr);
+void label_memory_counters(char **labels, void *ptr);
+void clean_memory_counters(void *ptr);
+void *show_all_memory_counters(void *, size_t);
+
+sensor memory_counters = {
+ .init = init_memory_counters,
+ .get = get_memory_counters,
+ .clean = clean_memory_counters,
+ .label = label_memory_counters,
+ .nb_opt = 2,
+};
+
+Optparse memory_counters_opt[2] = {
+ {
+ .longname = "memory-counters",
+ .shortname = 'M',
+ .argtype = OPTPARSE_REQUIRED,
+ .usage_arg = "<memory_list>",
+ .usage_msg =
+ "memory counters\n"
+ "\tmemory_list is a coma separated list of memory counters.\n"
+ "\tEx: Zswap,Zswapped",
+ },
+ {
+ .longname = "memory-list",
+ .shortname = 'L',
+ .argtype = OPTPARSE_NONE,
+ .usage_arg = NULL,
+ .usage_msg = "list the available performance counters and quit",
+ .fn = show_all_memory_counters,
+ },
+};
--
GitLab
From a9496a7f8861c9bbe7994b110f89a93f2d6bfdd5 Mon Sep 17 00:00:00 2001
From: FlorealRISSO <floreal.risso@univ-tlse3.fr>
Date: Tue, 28 Mar 2023 10:28:33 +0200
Subject: [PATCH 09/16] update: add in autoconf
---
.gitignore | 2 +-
configure.sh | 1 +
makefile | 6 +++++-
src/memory_counters.h | 2 +-
src/{meminfo_option.sh => memory_option.sh} | 0
5 files changed, 8 insertions(+), 3 deletions(-)
rename src/{meminfo_option.sh => memory_option.sh} (100%)
mode change 100644 => 100755
diff --git a/.gitignore b/.gitignore
index eb6940e..d652549 100644
--- a/.gitignore
+++ b/.gitignore
@@ -6,7 +6,7 @@ doc/info_reader_ex
doc/mojitos.1
tests/run
src/counters_option.h
-src/meminfo_option.h
+src/memory_option.h
src/sensors.h
sensors.mk
bin
diff --git a/configure.sh b/configure.sh
index 7e10ec3..56abf93 100755
--- a/configure.sh
+++ b/configure.sh
@@ -117,6 +117,7 @@ detect_caps() {
[ -r /usr/include/linux/perf_event.h ] && hdr_whitelist=counters
[ -d /sys/class/infiniband ] && hdr_whitelist="${hdr_whitelist}|infiniband"
[ -r /proc/stat ] && hdr_whitelist="${hdr_whitelist}|load"
+ [ -r /proc/meminfo ] && hdr_whitelist="${hdr_whitelist}|memory_counters"
if [ "$(uname -r | cut -d "." -f 1)" -gt "2" ]; then
hdr_whitelist="${hdr_whitelist}|memory"
diff --git a/makefile b/makefile
index f25d563..63fa983 100644
--- a/makefile
+++ b/makefile
@@ -40,8 +40,9 @@ $(BIN): $(BIN_DIR) $(OBJ) $(OBJ_DIR)/$(BIN).o
$(OBJ): $(OBJ_DIR)
$(OBJ_DIR)/counters.o: $(SRC_DIR)/counters_option.h
+$(OBJ_DIR)/memory_counters.o: $(SRC_DIR)/memory_option.h
-$(OBJ_DIR)/$(BIN).o: $(SRC_DIR)/$(BIN).c $(SRC_DIR)/counters_option.h
+$(OBJ_DIR)/$(BIN).o: $(SRC_DIR)/$(BIN).c $(SRC_DIR)/counters_option.h $(SRC_DIR)/memory_counters.h
$(CC) $(CFLAGS) -c $< -o $@
$(OBJ_DIR)/util.o: $(SRC_DIR)/util.c $(SRC_DIR)/util.h
@@ -50,6 +51,9 @@ $(OBJ_DIR)/util.o: $(SRC_DIR)/util.c $(SRC_DIR)/util.h
$(SRC_DIR)/counters_option.h: $(SRC_DIR)/counters_option.sh
sh ./$(SRC_DIR)/counters_option.sh > $(SRC_DIR)/counters_option.h
+$(SRC_DIR)/memory_option.h: $(SRC_DIR)/memory_option.sh
+ sh ./$(SRC_DIR)/memory_option.sh > $(SRC_DIR)/memory_option.h
+
$(OBJ_DIR):
mkdir -p $(OBJ_DIR)
diff --git a/src/memory_counters.h b/src/memory_counters.h
index a066c42..a0b9613 100644
--- a/src/memory_counters.h
+++ b/src/memory_counters.h
@@ -24,7 +24,7 @@ void label_memory_counters(char **labels, void *ptr);
void clean_memory_counters(void *ptr);
void *show_all_memory_counters(void *, size_t);
-sensor memory_counters = {
+Sensor memory_counters = {
.init = init_memory_counters,
.get = get_memory_counters,
.clean = clean_memory_counters,
diff --git a/src/meminfo_option.sh b/src/memory_option.sh
old mode 100644
new mode 100755
similarity index 100%
rename from src/meminfo_option.sh
rename to src/memory_option.sh
--
GitLab
From 0e090d56181052a6fd014377602915efd8d69c7c Mon Sep 17 00:00:00 2001
From: FlorealRISSO <floreal.risso@univ-tlse3.fr>
Date: Tue, 28 Mar 2023 10:29:39 +0200
Subject: [PATCH 10/16] fix header name
---
src/memory_counters.c | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/src/memory_counters.c b/src/memory_counters.c
index 23e3f96..8e8e916 100644
--- a/src/memory_counters.c
+++ b/src/memory_counters.c
@@ -1,4 +1,4 @@
-#include "meminfo_option.h"
+#include "memory_option.h"
#include "util.h"
#include <fcntl.h>
#include <info_reader.h>
--
GitLab
From e969987e3c39fdd4e7ddcdbc084a89fb00431cda Mon Sep 17 00:00:00 2001
From: FlorealRISSO <floreal.risso@univ-tlse3.fr>
Date: Tue, 28 Mar 2023 10:43:45 +0200
Subject: [PATCH 11/16] fix: clean, usage
---
makefile | 1 +
src/memory_counters.h | 2 +-
2 files changed, 2 insertions(+), 1 deletion(-)
diff --git a/makefile b/makefile
index 63fa983..a57eca2 100644
--- a/makefile
+++ b/makefile
@@ -75,6 +75,7 @@ format:
clean:
\rm -f $(OBJ_DIR)/* $(BIN_DIR)/* \
$(SRC_DIR)/counters_option.h \
+ $(SRC_DIR)/memory_option.h \
$(TESTS_DIR)/run \
$(DOC_DIR)/test_main_ex \
$(DOC_DIR)/info_reader_ex
diff --git a/src/memory_counters.h b/src/memory_counters.h
index a0b9613..50e0be3 100644
--- a/src/memory_counters.h
+++ b/src/memory_counters.h
@@ -48,7 +48,7 @@ Optparse memory_counters_opt[2] = {
.shortname = 'L',
.argtype = OPTPARSE_NONE,
.usage_arg = NULL,
- .usage_msg = "list the available performance counters and quit",
+ .usage_msg = "list the available memory counters and quit",
.fn = show_all_memory_counters,
},
};
--
GitLab
From aa98e7f8ce29bd899fd484883bb3865d063d4d97 Mon Sep 17 00:00:00 2001
From: FlorealRISSO <floreal.risso@univ-tlse3.fr>
Date: Tue, 28 Mar 2023 10:52:08 +0200
Subject: [PATCH 12/16] format
---
src/memory_counters.c | 180 ++++++++++++++++++++++--------------------
src/memory_counters.h | 6 +-
2 files changed, 98 insertions(+), 88 deletions(-)
diff --git a/src/memory_counters.c b/src/memory_counters.c
index 8e8e916..185f454 100644
--- a/src/memory_counters.c
+++ b/src/memory_counters.c
@@ -10,111 +10,121 @@
static const char *path = "/proc/meminfo";
typedef struct {
- KeyFinder *keys;
- unsigned int count;
- FILE *file;
+ KeyFinder *keys;
+ unsigned int count;
+ FILE *file;
} MemoryCounters;
-GenericPointer long_allocator(char *s) {
- long value = atol(s);
- return (GenericPointer)value;
+GenericPointer long_allocator(char *s)
+{
+ long value = atol(s);
+ return (GenericPointer)value;
}
-KeyFinder *build_keyfinder(unsigned int count, unsigned int *indexes) {
- KeyFinder *keys = (KeyFinder *)calloc(count, sizeof(KeyFinder));
- for (unsigned int i = 0; i < count; i++) {
- unsigned int idx = indexes[i];
- KeyFinder key = {.key = memory_counters[idx],
- .delimiter = ":",
- .copy = long_allocator,
- .set = setter_functions[i]};
- memcpy(&keys[i], &key, sizeof(KeyFinder));
- }
- return keys;
+KeyFinder *build_keyfinder(unsigned int count, unsigned int *indexes)
+{
+ KeyFinder *keys = (KeyFinder *)calloc(count, sizeof(KeyFinder));
+ for (unsigned int i = 0; i < count; i++) {
+ unsigned int idx = indexes[i];
+ KeyFinder key = {.key = memory_counters[idx],
+ .delimiter = ":",
+ .copy = long_allocator,
+ .set = setter_functions[i]
+ };
+ memcpy(&keys[i], &key, sizeof(KeyFinder));
+ }
+ return keys;
}
void memory_list(char *memory_string, unsigned int *count,
- unsigned int *indexes) {
- char *token;
- *count = 0;
-
- while ((token = strtok(memory_string, ",")) != NULL) {
- memory_string = NULL;
-
- unsigned int i;
- for (i = 0; i < NB_COUNTERS; i++) {
- if (strcmp(memory_counters[i], token) == 0) {
- (*count)++;
- indexes[*count - 1] = i;
- break;
- }
- }
-
- if (i == NB_COUNTERS) {
- fprintf(stderr, "Unknown memory counter: %s\n", token);
- exit(EXIT_FAILURE);
+ unsigned int *indexes)
+{
+ char *token;
+ *count = 0;
+
+ while ((token = strtok(memory_string, ",")) != NULL) {
+ memory_string = NULL;
+
+ unsigned int i;
+ for (i = 0; i < NB_COUNTERS; i++) {
+ if (strcmp(memory_counters[i], token) == 0) {
+ (*count)++;
+ indexes[*count - 1] = i;
+ break;
+ }
+ }
+
+ if (i == NB_COUNTERS) {
+ fprintf(stderr, "Unknown memory counter: %s\n", token);
+ exit(EXIT_FAILURE);
+ }
+
+ if ((*count) > NB_COUNTERS) {
+ fprintf(stderr, "Too much counters, there are probably duplicates\n");
+ exit(EXIT_FAILURE);
+ }
}
-
- if ((*count) > NB_COUNTERS) {
- fprintf(stderr, "Too much counters, there are probably duplicates\n");
- exit(EXIT_FAILURE);
- }
- }
}
-unsigned int init_memory_counters(char *args, void **ptr) {
- unsigned int indexes[NB_COUNTERS];
- unsigned int count = 0;
- memory_list(args, &count, indexes);
+unsigned int init_memory_counters(char *args, void **ptr)
+{
+ unsigned int indexes[NB_COUNTERS];
+ unsigned int count = 0;
+ memory_list(args, &count, indexes);
- KeyFinder *keys = build_keyfinder(count, indexes);
- FILE *file = fopen(path, "r");
+ KeyFinder *keys = build_keyfinder(count, indexes);
+ FILE *file = fopen(path, "r");
- MemoryCounters *counters = calloc(1, sizeof(MemoryCounters));
- counters->keys = keys;
- counters->count = count;
- counters->file = file;
+ MemoryCounters *counters = calloc(1, sizeof(MemoryCounters));
+ counters->keys = keys;
+ counters->count = count;
+ counters->file = file;
- *ptr = (void *)counters;
- return count;
+ *ptr = (void *)counters;
+ return count;
}
-unsigned int get_memory_counters(uint64_t *results, void *ptr) {
- MemoryCounters *counters = (MemoryCounters *)ptr;
- fseek(counters->file, 0, SEEK_SET);
- Parser parser = {.storage = (GenericPointer)results,
- .capacity = 1,
- .nb_stored = 0,
- .storage_struct_size = sizeof(uint64_t) * counters->count,
- .keys = counters->keys,
- .nb_keys = counters->count,
- .file = counters->file};
-
- parse(&parser);
- return counters->count;
+unsigned int get_memory_counters(uint64_t *results, void *ptr)
+{
+ MemoryCounters *counters = (MemoryCounters *)ptr;
+ fseek(counters->file, 0, SEEK_SET);
+ Parser parser = {.storage = (GenericPointer)results,
+ .capacity = 1,
+ .nb_stored = 0,
+ .storage_struct_size = sizeof(uint64_t) * counters->count,
+ .keys = counters->keys,
+ .nb_keys = counters->count,
+ .file = counters->file
+ };
+
+ parse(&parser);
+ return counters->count;
}
-void label_memory_counters(char **labels, void *ptr) {
- MemoryCounters *counters = (MemoryCounters *)ptr;
- for (unsigned int i = 0; i < counters->count; i++) {
- labels[i] = counters->keys[i].key;
- }
+void label_memory_counters(char **labels, void *ptr)
+{
+ MemoryCounters *counters = (MemoryCounters *)ptr;
+ for (unsigned int i = 0; i < counters->count; i++) {
+ labels[i] = counters->keys[i].key;
+ }
}
-void clean_memory_counters(void *ptr) {
- MemoryCounters *counters = (MemoryCounters *)ptr;
- fclose(counters->file);
- free(counters->keys);
- free(ptr);
+void clean_memory_counters(void *ptr)
+{
+ MemoryCounters *counters = (MemoryCounters *)ptr;
+ fclose(counters->file);
+ free(counters->keys);
+ free(ptr);
}
-void *show_all_memory_counters(void *none1, size_t none2) {
- for (unsigned int i = 0; i < NB_COUNTERS; i++) {
- printf("%s\n", memory_counters[i]);
- }
+void *show_all_memory_counters(void *none1, size_t none2)
+{
+ for (unsigned int i = 0; i < NB_COUNTERS; i++) {
+ printf("%s\n", memory_counters[i]);
+ }
- UNUSED(none1);
- UNUSED(none2);
- exit(EXIT_SUCCESS);
- return NULL; /* not reached */
+ UNUSED(none1);
+ UNUSED(none2);
+ exit(EXIT_SUCCESS);
+ return NULL; /* not reached */
}
diff --git a/src/memory_counters.h b/src/memory_counters.h
index 50e0be3..eaf9f36 100644
--- a/src/memory_counters.h
+++ b/src/memory_counters.h
@@ -39,9 +39,9 @@ Optparse memory_counters_opt[2] = {
.argtype = OPTPARSE_REQUIRED,
.usage_arg = "<memory_list>",
.usage_msg =
- "memory counters\n"
- "\tmemory_list is a coma separated list of memory counters.\n"
- "\tEx: Zswap,Zswapped",
+ "memory counters\n"
+ "\tmemory_list is a coma separated list of memory counters.\n"
+ "\tEx: Zswap,Zswapped",
},
{
.longname = "memory-list",
--
GitLab
From b6fb43a0eb175610ea618bcee8ab765e511c3c05 Mon Sep 17 00:00:00 2001
From: ghuter <ghuter@disroot.org>
Date: Thu, 30 Mar 2023 15:58:48 +0200
Subject: [PATCH 13/16] modify memory_option.sh
---
src/memory_option.sh | 25 ++++++++++++-------------
1 file changed, 12 insertions(+), 13 deletions(-)
diff --git a/src/memory_option.sh b/src/memory_option.sh
index 54a2c6e..30a3831 100755
--- a/src/memory_option.sh
+++ b/src/memory_option.sh
@@ -3,9 +3,9 @@
# SPDX-License-Identifier: GPL-3.0-or-later
# Copyright (C) 2018-2023 Georges Da Costa <georges.da-costa@irit.fr>
-MEMINFO_PATH="/proc/meminfo"
+meminfo_path=/proc/meminfo
-FUNCTION_TEMPLATE="void set_result_offset%s(GenericPointer ptr, GenericPointer data)
+function_template="void set_result_offset%s(GenericPointer ptr, GenericPointer data)
{
uint64_t* result = (uint64_t *) ptr;
result[%s] = (uint64_t) data;
@@ -14,16 +14,15 @@ FUNCTION_TEMPLATE="void set_result_offset%s(GenericPointer ptr, GenericPointer d
nb_counters=0
echo '#include <inttypes.h>'
-echo "#include <info_reader.h>"
+echo '#include <info_reader.h>'
echo
echo 'static char *memory_counters[] = {'
while read line; do
- nb_counters=$(expr $nb_counters + 1)
- word=$(echo $line | awk '{print $1}')
- echo " \"${word::-1}\","
-done <$MEMINFO_PATH
-echo "};"
+ : $((nb_counters += 1))
+ echo "$line" | awk -F ':' '{printf(" \"%s\",\n", $1)}'
+done < "$meminfo_path"
+echo '};'
echo
echo "#define NB_COUNTERS $nb_counters"
@@ -31,16 +30,16 @@ echo
count=0
while [ $count -lt $nb_counters ]; do
- printf "$FUNCTION_TEMPLATE" $count $count
- count=$(expr $count + 1)
+ printf "$function_template" $count $count
+ : $((count += 1))
done
-echo "static void (*setter_functions[])(GenericPointer, GenericPointer) = {"
+echo 'static void (*setter_functions[])(GenericPointer, GenericPointer) = {'
count=0
while [ $count -lt $nb_counters ]; do
echo " set_result_offset$count,"
- count=$(expr $count + 1)
+ : $((count += 1))
done
-echo "};"
+echo '};'
echo
--
GitLab
From 2ad61f79f7eb594e04afb260db8839cb0be5ec53 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Flor=C3=A9al=20Risso?= <floreal.risso@univ-tlse3.fr>
Date: Wed, 19 Apr 2023 08:48:51 +0200
Subject: [PATCH 14/16] fix: make dependency
---
makefile | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/makefile b/makefile
index a57eca2..3997f40 100644
--- a/makefile
+++ b/makefile
@@ -42,7 +42,7 @@ $(OBJ): $(OBJ_DIR)
$(OBJ_DIR)/counters.o: $(SRC_DIR)/counters_option.h
$(OBJ_DIR)/memory_counters.o: $(SRC_DIR)/memory_option.h
-$(OBJ_DIR)/$(BIN).o: $(SRC_DIR)/$(BIN).c $(SRC_DIR)/counters_option.h $(SRC_DIR)/memory_counters.h
+$(OBJ_DIR)/$(BIN).o: $(SRC_DIR)/$(BIN).c
$(CC) $(CFLAGS) -c $< -o $@
$(OBJ_DIR)/util.o: $(SRC_DIR)/util.c $(SRC_DIR)/util.h
--
GitLab
From a7c3287ae184633e49b732938eaf4d6ecfd0dd56 Mon Sep 17 00:00:00 2001
From: FlorealRISSO <floreal.risso@univ-tlse3.fr>
Date: Thu, 20 Apr 2023 10:05:05 +0200
Subject: [PATCH 15/16] fix make
---
README.md | 14 ++-
configure.sh | 4 +-
lib/info_reader.c | 146 ++++++++++++++++++++++++++
lib/info_reader.h | 236 ++++++++++--------------------------------
makefile | 15 ++-
src/memory_counters.c | 180 +++++++++++++++-----------------
6 files changed, 313 insertions(+), 282 deletions(-)
create mode 100644 lib/info_reader.c
diff --git a/README.md b/README.md
index 9fee622..4c0b186 100644
--- a/README.md
+++ b/README.md
@@ -27,7 +27,7 @@ The following is an exhaustive list of all the sensors (it is very likely
that one will not have all the sensors activated in his build):
```bash
SENSORS:
--a|--amd-rapl
+-r|--amd-rapl
AMD RAPL
-p|--perf-list <perf_list>
performance counters
@@ -41,8 +41,20 @@ SENSORS:
system load
-d|--net-dev <net_dev>
network monitoring (if network_device is X, tries to detect it automatically)
+-n|--nvidia-gpu
+ provides basic gpu information [clocks, memory, utilization, power, temperature].
-r|--intel-rapl
INTEL RAPL
+-c|--cpu-temp
+ processor temperature
+-m|--memory
+ Retrieves information about the memory via the syscall 'sysinfo(2)'.
+-M|--memory-counters <memory_list>
+ memory counters
+ memory_list is a coma separated list of memory counters.
+ Ex: Zswap,Zswapped
+-L|--memory-list
+ list the available memory counters and quit
```
## Installation Instructions
diff --git a/configure.sh b/configure.sh
index 56abf93..1246b0c 100755
--- a/configure.sh
+++ b/configure.sh
@@ -29,7 +29,7 @@ debug=0
target_hdr=src/sensors.h
target_mk=sensors.mk
-nonsensor='counters_option|sensors|util'
+nonsensor='counters_option|memory_option|sensors|util'
hdr_blacklist=$nonsensor
hdr_whitelist=''
@@ -157,6 +157,8 @@ detect_caps() {
case $1 in
--all | -a)
all=1
+ NVML_LDFLAGS="-L/usr/local/cuda/lib64 -lnvidia-ml"
+ NVML_IFLAGS="-I/usr/local/cuda/include"
;;
esac
diff --git a/lib/info_reader.c b/lib/info_reader.c
new file mode 100644
index 0000000..d23f554
--- /dev/null
+++ b/lib/info_reader.c
@@ -0,0 +1,146 @@
+#include <info_reader.h>
+
+ void set_value(Parser *parser, KeyFinder *key_finder, char *raw_value)
+{
+ GenericPointer address = parser->storage + (parser->storage_struct_size * parser->nb_stored);
+ GenericPointer value = key_finder->copy(raw_value);
+ key_finder->set(address, value);
+}
+
+ unsigned int match(Parser *parser, char *line, KeyFinder **key_finder, char **raw_value)
+{
+ for (unsigned int i = 0; i < parser->nb_keys; i++) {
+ KeyFinder *finder = &parser->keys[i];
+
+ if (start_with(finder->key, line)) {
+ char *value = NULL;
+ char *key = NULL;
+
+ split_on_delimiter(line, finder->delimiter, &key, &value);
+ if ( key == NULL || value == NULL) {
+ return 0;
+ }
+ *key_finder = finder;
+ *raw_value = value;
+ return 1;
+ }
+ }
+ return 0;
+}
+
+ unsigned int move_to_next(Parser *parser)
+{
+ parser->nb_stored += 1;
+ if (parser->nb_stored >= parser->capacity) {
+ return 0;
+ }
+ return 1;
+}
+
+
+#define PAGE_SIZE 4096
+ssize_t buffer_getline(char **lineptr, FILE *stream) {
+ ssize_t num_chars_read = 0;
+ static char buffer[PAGE_SIZE] = {0};
+
+ if (!lineptr || !stream) {
+ return -1;
+ }
+
+ while (1) {
+ int ch = fgetc(stream);
+ if (ch == EOF) {
+ if (num_chars_read == 0) {
+ return -1;
+ } else {
+ break;
+ }
+ }
+
+ if (num_chars_read == PAGE_SIZE - 1) {
+ return -1;
+ }
+
+ buffer[num_chars_read++] = ch;
+ if (ch == '\n') {
+ break;
+ }
+ }
+
+ buffer[num_chars_read] = '\0';
+ *lineptr = buffer;
+
+ return num_chars_read;
+}
+
+
+ unsigned int parse(Parser *parser)
+{
+ char *line = NULL;
+ ssize_t read;
+ unsigned int key_assigned = 0;
+
+ while ((read = buffer_getline(&line, parser->file)) != -1) {
+ if (key_assigned == parser->nb_keys && read > 1) {
+ continue;
+ } else if (read == 1) {
+ if (!move_to_next(parser)) {
+ return 0;
+ }
+ key_assigned = 0;
+ } else {
+ KeyFinder *key_finder = NULL;
+ char *raw_value = NULL;
+ replace_first(line, '\n', '\0');
+ if (match(parser, line, &key_finder, &raw_value)) {
+ set_value(parser, key_finder, raw_value);
+ ++key_assigned;
+ }
+ }
+ }
+ if (key_assigned > 0) {
+ parser->nb_stored++;
+ }
+ return 1;
+}
+
+
+
+ void replace_first(char *string, char from, char to)
+{
+ for (int i = 0; string[i] != '\0'; i++) {
+ if (string[i] == from) {
+ string[i] = to;
+ break;
+ }
+ }
+}
+
+ void split_on_delimiter(char *string, const char *delimiter, char **key, char **value)
+{
+ *key = NULL;
+ *value = NULL;
+ size_t delimiter_len = strlen(delimiter);
+ char *start_delimiter = strstr(string, delimiter);
+ if (start_delimiter != NULL) {
+ *start_delimiter = '\0';
+ *key = string;
+ *value = start_delimiter + delimiter_len;
+ }
+}
+
+bool start_with(const char *prefix, const char *string)
+{
+ if (prefix == NULL || string == NULL) {
+ return false;
+ }
+
+ size_t prefix_len = strlen(prefix);
+ size_t string_len = strlen(string);
+
+ if (string_len < prefix_len) {
+ return false;
+ } else {
+ return memcmp(prefix, string, prefix_len) == 0;
+ }
+}
diff --git a/lib/info_reader.h b/lib/info_reader.h
index 15a077c..403bb19 100644
--- a/lib/info_reader.h
+++ b/lib/info_reader.h
@@ -21,36 +21,42 @@
#ifndef _INFO_READER_H
#define _INFO_READER_H
-#include <string.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
+#include <string.h>
/**
* @struct Parser
* @brief The parser struct
- * The struct containing all the necessary informations and functions to parse a file
+ * The struct containing all the necessary informations and functions to parse a
+ * file
*
- * @var storage : GenericPointer : pointer to the storage where the parsed data will be stored
+ * @var storage : GenericPointer : pointer to the storage where the parsed data
+ * will be stored
* @var nb_stored : unsigned int : the number of struct stored
- * @var capacity : unsigned int : the maximum number of struct that can be stored
- * @var storage_struct_size : size_t : the size of the struct stored in the storage
- * @var keys : KeyFinder* : pointer to an array of KeyFinder containing the possible keys
+ * @var capacity : unsigned int : the maximum number of struct that can be
+ * stored
+ * @var storage_struct_size : size_t : the size of the struct stored in the
+ * storage
+ * @var keys : KeyFinder* : pointer to an array of KeyFinder containing the
+ * possible keys
* @var nb_keys : unsigned int : number of key finders
* @var file : FILE* : pointer to the file that will be parsed
-*/
+ */
typedef struct Parser Parser;
/**
* @struct KeyFinder
* @brief The key finder struct
- * The struct containing all the necessary informations and functions to find a key in a line of text
+ * The struct containing all the necessary informations and functions to find a
+ * key in a line of text
*
* @var key : char* : the key to be found
* @var delimiter : char* : the delimiter between the key and the value
* @var copy : CopyAllocator*: the function to use to make a copy of the value
* @var set : Setter*: the function to use to store the value in the storage
-*/
+ */
typedef struct KeyFinder KeyFinder;
/**
@@ -68,20 +74,24 @@ typedef struct KeyFinder KeyFinder;
* @param[out] value A pointer to a char pointer where the value will be stored.
* @return None.
*/
-static void split_on_delimiter(char *string, const char *delimiter, char **key, char **value);
+void split_on_delimiter(char *string, const char *delimiter, char **key,
+ char **value);
/**
- * @brief Replace the first occurrence of a character in a string with another character.
+ * @brief Replace the first occurrence of a character in a string with another
+ * character.
*
- * The function takes a string and two characters as input, and replaces the first
- * occurrence of the first character in the string with the second character.
+ * The function takes a string and two characters as input, and replaces the
+ * first occurrence of the first character in the string with the second
+ * character.
*
- * @param[in,out] string The input string where the replacement should take place.
+ * @param[in,out] string The input string where the replacement should take
+ * place.
* @param[in] from The character to be replaced.
* @param[in] to The character to replace with.
* @return None.
*/
-static void replace_first(char *string, char from, char to);
+void replace_first(char *string, char from, char to);
/**
* @brief Check if a string starts with a prefix.
@@ -89,21 +99,25 @@ static void replace_first(char *string, char from, char to);
* @param[in] prefix The prefix to check.
* @param[in] string The string to check.
* @return true The string starts with the prefix.
- * @return false The string does not start with the prefix or one of the input pointers is NULL.
+ * @return false The string does not start with the prefix or one of the input
+ * pointers is NULL.
*/
-static bool start_with(const char *prefix, const char *string);
+bool start_with(const char *prefix, const char *string);
/**
* @brief Matches a line of text to a key in the parser's list of keys.
*
* @param[in] parser Pointer to the Parser struct.
* @param[in] line Line of text to match.
- * @param[out] key_finder Pointer to a KeyFinder pointer where the matched key will be stored.
- * @param[out] raw_value Pointer to a char pointer where the value associated with the matched key will be stored.
+ * @param[out] key_finder Pointer to a KeyFinder pointer where the matched key
+ * will be stored.
+ * @param[out] raw_value Pointer to a char pointer where the value associated
+ * with the matched key will be stored.
*
* @return Returns 1 if a key is matched, 0 otherwise.
*/
-static unsigned int match(Parser *parser, char *line, KeyFinder **key_finder, char **raw_value);
+unsigned int match(Parser *parser, char *line, KeyFinder **key_finder,
+ char **raw_value);
/**
* @brief Reads a line of text from a file stream and stores it in a static
@@ -111,7 +125,8 @@ static unsigned int match(Parser *parser, char *line, KeyFinder **key_finder, ch
* This function reads a line of text from the input stream pointed to by
* 'stream'. The line of text is stored in a static buffer with a maximum size of
-* PAGE_SIZE. The function updates the pointer pointed to by 'lineptr' to point to
+* PAGE_SIZE. The function updates the pointer pointed to by 'lineptr' to point
+to
* the buffer containing the line of text. If the line of text is longer than the
* buffer, the function returns -1. If an error occurs,
@@ -123,174 +138,35 @@ static unsigned int match(Parser *parser, char *line, KeyFinder **key_finder, ch
*/
ssize_t buffer_getline(char **lineptr, FILE *stream);
+/**
+ * @brief Parse with the configured parser.
+ *
+ * @param parser the parser.
+ */
+unsigned int parse(Parser *parser);
+
typedef size_t GenericPointer;
-typedef GenericPointer (CopyAllocator) (char *string);
-typedef void (Setter) (GenericPointer storage, GenericPointer value);
+typedef GenericPointer(CopyAllocator)(char *string);
+typedef void(Setter)(GenericPointer storage, GenericPointer value);
struct KeyFinder {
- char *key;
- char *delimiter;
+ char *key;
+ char *delimiter;
- CopyAllocator *copy;
- Setter *set;
+ CopyAllocator *copy;
+ Setter *set;
};
struct Parser {
- GenericPointer storage;
- unsigned int nb_stored;
- unsigned int capacity;
- size_t storage_struct_size;
+ GenericPointer storage;
+ unsigned int nb_stored;
+ unsigned int capacity;
+ size_t storage_struct_size;
- KeyFinder *keys;
- unsigned int nb_keys;
+ KeyFinder *keys;
+ unsigned int nb_keys;
- FILE *file;
+ FILE *file;
};
-static void set_value(Parser *parser, KeyFinder *key_finder, char *raw_value)
-{
- GenericPointer address = parser->storage + (parser->storage_struct_size * parser->nb_stored);
- GenericPointer value = key_finder->copy(raw_value);
- key_finder->set(address, value);
-}
-
-static unsigned int match(Parser *parser, char *line, KeyFinder **key_finder, char **raw_value)
-{
- for (unsigned int i = 0; i < parser->nb_keys; i++) {
- KeyFinder *finder = &parser->keys[i];
-
- if (start_with(finder->key, line)) {
- char *value = NULL;
- char *key = NULL;
-
- split_on_delimiter(line, finder->delimiter, &key, &value);
- if ( key == NULL || value == NULL) {
- return 0;
- }
- *key_finder = finder;
- *raw_value = value;
- return 1;
- }
- }
- return 0;
-}
-
-static unsigned int move_to_next(Parser *parser)
-{
- parser->nb_stored += 1;
- if (parser->nb_stored >= parser->capacity) {
- return 0;
- }
- return 1;
-}
-
-
-#define PAGE_SIZE 4096
-ssize_t buffer_getline(char **lineptr, FILE *stream) {
- ssize_t num_chars_read = 0;
- static char buffer[PAGE_SIZE] = {0};
-
- if (!lineptr || !stream) {
- return -1;
- }
-
- while (1) {
- int ch = fgetc(stream);
- if (ch == EOF) {
- if (num_chars_read == 0) {
- return -1;
- } else {
- break;
- }
- }
-
- if (num_chars_read == PAGE_SIZE - 1) {
- return -1;
- }
-
- buffer[num_chars_read++] = ch;
- if (ch == '\n') {
- break;
- }
- }
-
- buffer[num_chars_read] = '\0';
- *lineptr = buffer;
-
- return num_chars_read;
-}
-
-
-static unsigned int parse(Parser *parser)
-{
- char *line = NULL;
- ssize_t read;
- unsigned int key_assigned = 0;
-
- while ((read = buffer_getline(&line, parser->file)) != -1) {
- if (key_assigned == parser->nb_keys && read > 1) {
- continue;
- } else if (read == 1) {
- if (!move_to_next(parser)) {
- return 0;
- }
- key_assigned = 0;
- } else {
- KeyFinder *key_finder = NULL;
- char *raw_value = NULL;
- replace_first(line, '\n', '\0');
- if (match(parser, line, &key_finder, &raw_value)) {
- set_value(parser, key_finder, raw_value);
- ++key_assigned;
- }
- }
- }
- if (key_assigned > 0) {
- parser->nb_stored++;
- }
- return 1;
-}
-
-
-
-static void replace_first(char *string, char from, char to)
-{
- for (int i = 0; string[i] != '\0'; i++) {
- if (string[i] == from) {
- string[i] = to;
- break;
- }
- }
-}
-
-static void split_on_delimiter(char *string, const char *delimiter, char **key, char **value)
-{
- *key = NULL;
- *value = NULL;
- size_t delimiter_len = strlen(delimiter);
- char *start_delimiter = strstr(string, delimiter);
- if (start_delimiter != NULL) {
- *start_delimiter = '\0';
- *key = string;
- *value = start_delimiter + delimiter_len;
- }
-}
-
-static bool start_with(const char *prefix, const char *string)
-{
- if (prefix == NULL || string == NULL) {
- return false;
- }
-
- size_t prefix_len = strlen(prefix);
- size_t string_len = strlen(string);
-
- if (string_len < prefix_len) {
- return false;
- } else {
- return memcmp(prefix, string, prefix_len) == 0;
- }
-}
-
#endif
-
diff --git a/makefile b/makefile
index 3997f40..4dcbce4 100644
--- a/makefile
+++ b/makefile
@@ -3,6 +3,7 @@
SRC_DIR = src
DOC_DIR = doc
OBJ_DIR = obj
+LIB_DIR = lib
BIN_DIR = bin
TESTS_DIR = tests
@@ -25,8 +26,9 @@ NVML_IFLAGS =
include ./sensors.mk
OBJ = \
- $(CAPTOR_OBJ) \
- $(OBJ_DIR)/util.o
+ $(OBJ_DIR)/util.o \
+ $(OBJ_DIR)/info_reader.o \
+ $(CAPTOR_OBJ)
options:
@echo BIN: $(BIN)
@@ -48,6 +50,9 @@ $(OBJ_DIR)/$(BIN).o: $(SRC_DIR)/$(BIN).c
$(OBJ_DIR)/util.o: $(SRC_DIR)/util.c $(SRC_DIR)/util.h
$(CC) $(CFLAGS) -c $< -o $@
+$(OBJ_DIR)/info_reader.o: $(LIB_DIR)/info_reader.c
+ $(CC) $(CFLAGS) -c $< -o $@
+
$(SRC_DIR)/counters_option.h: $(SRC_DIR)/counters_option.sh
sh ./$(SRC_DIR)/counters_option.sh > $(SRC_DIR)/counters_option.h
@@ -63,8 +68,8 @@ $(BIN_DIR):
debug: CFLAGS = $(CPPFLAGS) -DDEBUG -g -Og
debug: $(BIN)
-tests:
- $(CC) $(CPPFLAGS) $(TESTS_DIR)/main.c $(SRC_DIR)/util.c -o $(TESTS_DIR)/run
+tests: $(OBJ_DIR)/util.o $(OBJ_DIR)/info_reader.o
+ $(CC) $(CPPFLAGS) $(OBJ_DIR)/util.o $(OBJ_DIR)/info_reader.o $(TESTS_DIR)/main.c -o $(TESTS_DIR)/run
$(TESTS_DIR)/run
format:
@@ -80,7 +85,7 @@ clean:
$(DOC_DIR)/test_main_ex \
$(DOC_DIR)/info_reader_ex
-readme: $(BIN)
+readme:
sh ./tools/update-readme-usage.sh
man: $(BIN)
diff --git a/src/memory_counters.c b/src/memory_counters.c
index 185f454..8e8e916 100644
--- a/src/memory_counters.c
+++ b/src/memory_counters.c
@@ -10,121 +10,111 @@
static const char *path = "/proc/meminfo";
typedef struct {
- KeyFinder *keys;
- unsigned int count;
- FILE *file;
+ KeyFinder *keys;
+ unsigned int count;
+ FILE *file;
} MemoryCounters;
-GenericPointer long_allocator(char *s)
-{
- long value = atol(s);
- return (GenericPointer)value;
+GenericPointer long_allocator(char *s) {
+ long value = atol(s);
+ return (GenericPointer)value;
}
-KeyFinder *build_keyfinder(unsigned int count, unsigned int *indexes)
-{
- KeyFinder *keys = (KeyFinder *)calloc(count, sizeof(KeyFinder));
- for (unsigned int i = 0; i < count; i++) {
- unsigned int idx = indexes[i];
- KeyFinder key = {.key = memory_counters[idx],
- .delimiter = ":",
- .copy = long_allocator,
- .set = setter_functions[i]
- };
- memcpy(&keys[i], &key, sizeof(KeyFinder));
- }
- return keys;
+KeyFinder *build_keyfinder(unsigned int count, unsigned int *indexes) {
+ KeyFinder *keys = (KeyFinder *)calloc(count, sizeof(KeyFinder));
+ for (unsigned int i = 0; i < count; i++) {
+ unsigned int idx = indexes[i];
+ KeyFinder key = {.key = memory_counters[idx],
+ .delimiter = ":",
+ .copy = long_allocator,
+ .set = setter_functions[i]};
+ memcpy(&keys[i], &key, sizeof(KeyFinder));
+ }
+ return keys;
}
void memory_list(char *memory_string, unsigned int *count,
- unsigned int *indexes)
-{
- char *token;
- *count = 0;
-
- while ((token = strtok(memory_string, ",")) != NULL) {
- memory_string = NULL;
-
- unsigned int i;
- for (i = 0; i < NB_COUNTERS; i++) {
- if (strcmp(memory_counters[i], token) == 0) {
- (*count)++;
- indexes[*count - 1] = i;
- break;
- }
- }
-
- if (i == NB_COUNTERS) {
- fprintf(stderr, "Unknown memory counter: %s\n", token);
- exit(EXIT_FAILURE);
- }
-
- if ((*count) > NB_COUNTERS) {
- fprintf(stderr, "Too much counters, there are probably duplicates\n");
- exit(EXIT_FAILURE);
- }
+ unsigned int *indexes) {
+ char *token;
+ *count = 0;
+
+ while ((token = strtok(memory_string, ",")) != NULL) {
+ memory_string = NULL;
+
+ unsigned int i;
+ for (i = 0; i < NB_COUNTERS; i++) {
+ if (strcmp(memory_counters[i], token) == 0) {
+ (*count)++;
+ indexes[*count - 1] = i;
+ break;
+ }
+ }
+
+ if (i == NB_COUNTERS) {
+ fprintf(stderr, "Unknown memory counter: %s\n", token);
+ exit(EXIT_FAILURE);
}
+
+ if ((*count) > NB_COUNTERS) {
+ fprintf(stderr, "Too much counters, there are probably duplicates\n");
+ exit(EXIT_FAILURE);
+ }
+ }
}
-unsigned int init_memory_counters(char *args, void **ptr)
-{
- unsigned int indexes[NB_COUNTERS];
- unsigned int count = 0;
- memory_list(args, &count, indexes);
+unsigned int init_memory_counters(char *args, void **ptr) {
+ unsigned int indexes[NB_COUNTERS];
+ unsigned int count = 0;
+ memory_list(args, &count, indexes);
- KeyFinder *keys = build_keyfinder(count, indexes);
- FILE *file = fopen(path, "r");
+ KeyFinder *keys = build_keyfinder(count, indexes);
+ FILE *file = fopen(path, "r");
- MemoryCounters *counters = calloc(1, sizeof(MemoryCounters));
- counters->keys = keys;
- counters->count = count;
- counters->file = file;
+ MemoryCounters *counters = calloc(1, sizeof(MemoryCounters));
+ counters->keys = keys;
+ counters->count = count;
+ counters->file = file;
- *ptr = (void *)counters;
- return count;
+ *ptr = (void *)counters;
+ return count;
}
-unsigned int get_memory_counters(uint64_t *results, void *ptr)
-{
- MemoryCounters *counters = (MemoryCounters *)ptr;
- fseek(counters->file, 0, SEEK_SET);
- Parser parser = {.storage = (GenericPointer)results,
- .capacity = 1,
- .nb_stored = 0,
- .storage_struct_size = sizeof(uint64_t) * counters->count,
- .keys = counters->keys,
- .nb_keys = counters->count,
- .file = counters->file
- };
-
- parse(&parser);
- return counters->count;
+unsigned int get_memory_counters(uint64_t *results, void *ptr) {
+ MemoryCounters *counters = (MemoryCounters *)ptr;
+ fseek(counters->file, 0, SEEK_SET);
+ Parser parser = {.storage = (GenericPointer)results,
+ .capacity = 1,
+ .nb_stored = 0,
+ .storage_struct_size = sizeof(uint64_t) * counters->count,
+ .keys = counters->keys,
+ .nb_keys = counters->count,
+ .file = counters->file};
+
+ parse(&parser);
+ return counters->count;
}
-void label_memory_counters(char **labels, void *ptr)
-{
- MemoryCounters *counters = (MemoryCounters *)ptr;
- for (unsigned int i = 0; i < counters->count; i++) {
- labels[i] = counters->keys[i].key;
- }
+void label_memory_counters(char **labels, void *ptr) {
+ MemoryCounters *counters = (MemoryCounters *)ptr;
+ for (unsigned int i = 0; i < counters->count; i++) {
+ labels[i] = counters->keys[i].key;
+ }
}
-void clean_memory_counters(void *ptr)
-{
- MemoryCounters *counters = (MemoryCounters *)ptr;
- fclose(counters->file);
- free(counters->keys);
- free(ptr);
+void clean_memory_counters(void *ptr) {
+ MemoryCounters *counters = (MemoryCounters *)ptr;
+ fclose(counters->file);
+ free(counters->keys);
+ free(ptr);
}
-void *show_all_memory_counters(void *none1, size_t none2)
-{
- for (unsigned int i = 0; i < NB_COUNTERS; i++) {
- printf("%s\n", memory_counters[i]);
- }
+void *show_all_memory_counters(void *none1, size_t none2) {
+ for (unsigned int i = 0; i < NB_COUNTERS; i++) {
+ printf("%s\n", memory_counters[i]);
+ }
- UNUSED(none1);
- UNUSED(none2);
- exit(EXIT_SUCCESS);
- return NULL; /* not reached */
+ UNUSED(none1);
+ UNUSED(none2);
+ exit(EXIT_SUCCESS);
+ return NULL; /* not reached */
}
--
GitLab
From 079b25060bce14922749bc006e2dd8b08486baa1 Mon Sep 17 00:00:00 2001
From: FlorealRISSO <floreal.risso@univ-tlse3.fr>
Date: Thu, 20 Apr 2023 10:15:52 +0200
Subject: [PATCH 16/16] format
---
doc/info_reader_ex.c | 85 +++++++++++++-------
src/memory_counters.c | 180 ++++++++++++++++++++++--------------------
2 files changed, 152 insertions(+), 113 deletions(-)
diff --git a/doc/info_reader_ex.c b/doc/info_reader_ex.c
index f1e6d96..d99e916 100644
--- a/doc/info_reader_ex.c
+++ b/doc/info_reader_ex.c
@@ -18,8 +18,10 @@
*******************************************************/
+// ~/mojitos/doc/$ gcc -Wall -Wextra -Wpedantic -O3 -o info_reader_ex
+// info_reader_ex.c ./../src/util.c && ./info_reader_ex
-// ~/mojitos/doc/$ gcc -Wall -Wextra -Wpedantic -O3 -o info_reader_ex info_reader_ex.c ./../src/util.c && ./info_reader_ex
+#include "./../lib/info_reader.c"
#include "./../lib/info_reader.h"
#define MAX_PROCS 64
@@ -40,7 +42,7 @@ typedef struct {
GenericPointer int_allocator(char *s)
{
unsigned int value = atoi(s);
- return (GenericPointer) value;
+ return (GenericPointer)value;
}
// -- Define the behaviour if the attempted value is a string
@@ -48,49 +50,49 @@ GenericPointer string_allocator(char *s)
{
char *value = malloc(strlen(s) + 1);
strcpy(value, s);
- return (GenericPointer) value;
+ return (GenericPointer)value;
}
// -- Define the processor setter
void set_processor(GenericPointer storage, GenericPointer data)
{
- Cpu *cpu = (Cpu *) storage;
+ Cpu *cpu = (Cpu *)storage;
cpu->processor = data;
}
// -- Define the vendor_id setter
void set_vendor_id(GenericPointer storage, GenericPointer data)
{
- Cpu *cpu = (Cpu *) storage;
- cpu->vendor_id = (char *) data;
+ Cpu *cpu = (Cpu *)storage;
+ cpu->vendor_id = (char *)data;
}
// -- Define the family setter
void set_family(GenericPointer storage, GenericPointer data)
{
- Cpu *cpu = (Cpu *) storage;
+ Cpu *cpu = (Cpu *)storage;
cpu->family = data;
}
// -- Define the core_id setter
void set_core_id(GenericPointer storage, GenericPointer data)
{
- Cpu *cpu = (Cpu *) storage;
+ Cpu *cpu = (Cpu *)storage;
cpu->core_id = data;
}
// -- Define the physical_id setter
void set_physical_id(GenericPointer storage, GenericPointer data)
{
- Cpu *cpu = (Cpu *) storage;
+ Cpu *cpu = (Cpu *)storage;
cpu->physical_id = data;
}
// -- Define the model_name setter
void set_model_name(GenericPointer storage, GenericPointer data)
{
- Cpu *cpu = (Cpu *) storage;
- cpu->model_name = (char *) data;
+ Cpu *cpu = (Cpu *)storage;
+ cpu->model_name = (char *)data;
}
int main()
@@ -98,26 +100,54 @@ int main()
Cpu cpus[MAX_PROCS];
// -- Define the setter, the allocator for each key / separator.
- KeyFinder keys[] = {
- {.key = "processor", .delimiter = ": ", .copy = (CopyAllocator *) int_allocator, .set = (Setter *)set_processor},
- {.key = "vendor_id", .delimiter = ": ", .copy = (CopyAllocator *) string_allocator, .set = (Setter *)set_vendor_id},
- {.key = "cpu family", .delimiter = ": ", .copy = (CopyAllocator *) int_allocator, .set = (Setter *)set_family},
- {.key = "core id", .delimiter = ": ", .copy = (CopyAllocator *) int_allocator, .set = (Setter *)set_core_id},
- {.key = "physical id", .delimiter = ": ", .copy = (CopyAllocator *) int_allocator, .set = (Setter *)set_physical_id},
- {.key = "model name", .delimiter = ": ", .copy = (CopyAllocator *) string_allocator, .set = (Setter *)set_model_name}
+ KeyFinder keys[] = {{
+ .key = "processor",
+ .delimiter = ": ",
+ .copy = (CopyAllocator *)int_allocator,
+ .set = (Setter *)set_processor
+ },
+ {
+ .key = "vendor_id",
+ .delimiter = ": ",
+ .copy = (CopyAllocator *)string_allocator,
+ .set = (Setter *)set_vendor_id
+ },
+ {
+ .key = "cpu family",
+ .delimiter = ": ",
+ .copy = (CopyAllocator *)int_allocator,
+ .set = (Setter *)set_family
+ },
+ {
+ .key = "core id",
+ .delimiter = ": ",
+ .copy = (CopyAllocator *)int_allocator,
+ .set = (Setter *)set_core_id
+ },
+ {
+ .key = "physical id",
+ .delimiter = ": ",
+ .copy = (CopyAllocator *)int_allocator,
+ .set = (Setter *)set_physical_id
+ },
+ {
+ .key = "model name",
+ .delimiter = ": ",
+ .copy = (CopyAllocator *)string_allocator,
+ .set = (Setter *)set_model_name
+ }
};
- size_t nb_keys = sizeof(keys)/sizeof(KeyFinder);
+ size_t nb_keys = sizeof(keys) / sizeof(KeyFinder);
// -- Init the parser
- Parser parser = {
- .storage = (GenericPointer) cpus,
- .capacity = MAX_PROCS,
- .storage_struct_size = sizeof(Cpu),
- .keys = keys,
- .nb_keys = nb_keys,
- .file = fopen("/proc/cpuinfo", "r")
- };
+ Parser parser = {.storage = (GenericPointer)cpus,
+ .capacity = MAX_PROCS,
+ .storage_struct_size = sizeof(Cpu),
+ .keys = keys,
+ .nb_keys = nb_keys,
+ .file = fopen("/proc/cpuinfo", "r")
+ };
// -- Parse the file
parse(&parser);
@@ -137,4 +167,3 @@ int main()
printf("==============================\n");
return 0;
}
-
diff --git a/src/memory_counters.c b/src/memory_counters.c
index 8e8e916..185f454 100644
--- a/src/memory_counters.c
+++ b/src/memory_counters.c
@@ -10,111 +10,121 @@
static const char *path = "/proc/meminfo";
typedef struct {
- KeyFinder *keys;
- unsigned int count;
- FILE *file;
+ KeyFinder *keys;
+ unsigned int count;
+ FILE *file;
} MemoryCounters;
-GenericPointer long_allocator(char *s) {
- long value = atol(s);
- return (GenericPointer)value;
+GenericPointer long_allocator(char *s)
+{
+ long value = atol(s);
+ return (GenericPointer)value;
}
-KeyFinder *build_keyfinder(unsigned int count, unsigned int *indexes) {
- KeyFinder *keys = (KeyFinder *)calloc(count, sizeof(KeyFinder));
- for (unsigned int i = 0; i < count; i++) {
- unsigned int idx = indexes[i];
- KeyFinder key = {.key = memory_counters[idx],
- .delimiter = ":",
- .copy = long_allocator,
- .set = setter_functions[i]};
- memcpy(&keys[i], &key, sizeof(KeyFinder));
- }
- return keys;
+KeyFinder *build_keyfinder(unsigned int count, unsigned int *indexes)
+{
+ KeyFinder *keys = (KeyFinder *)calloc(count, sizeof(KeyFinder));
+ for (unsigned int i = 0; i < count; i++) {
+ unsigned int idx = indexes[i];
+ KeyFinder key = {.key = memory_counters[idx],
+ .delimiter = ":",
+ .copy = long_allocator,
+ .set = setter_functions[i]
+ };
+ memcpy(&keys[i], &key, sizeof(KeyFinder));
+ }
+ return keys;
}
void memory_list(char *memory_string, unsigned int *count,
- unsigned int *indexes) {
- char *token;
- *count = 0;
-
- while ((token = strtok(memory_string, ",")) != NULL) {
- memory_string = NULL;
-
- unsigned int i;
- for (i = 0; i < NB_COUNTERS; i++) {
- if (strcmp(memory_counters[i], token) == 0) {
- (*count)++;
- indexes[*count - 1] = i;
- break;
- }
- }
-
- if (i == NB_COUNTERS) {
- fprintf(stderr, "Unknown memory counter: %s\n", token);
- exit(EXIT_FAILURE);
+ unsigned int *indexes)
+{
+ char *token;
+ *count = 0;
+
+ while ((token = strtok(memory_string, ",")) != NULL) {
+ memory_string = NULL;
+
+ unsigned int i;
+ for (i = 0; i < NB_COUNTERS; i++) {
+ if (strcmp(memory_counters[i], token) == 0) {
+ (*count)++;
+ indexes[*count - 1] = i;
+ break;
+ }
+ }
+
+ if (i == NB_COUNTERS) {
+ fprintf(stderr, "Unknown memory counter: %s\n", token);
+ exit(EXIT_FAILURE);
+ }
+
+ if ((*count) > NB_COUNTERS) {
+ fprintf(stderr, "Too much counters, there are probably duplicates\n");
+ exit(EXIT_FAILURE);
+ }
}
-
- if ((*count) > NB_COUNTERS) {
- fprintf(stderr, "Too much counters, there are probably duplicates\n");
- exit(EXIT_FAILURE);
- }
- }
}
-unsigned int init_memory_counters(char *args, void **ptr) {
- unsigned int indexes[NB_COUNTERS];
- unsigned int count = 0;
- memory_list(args, &count, indexes);
+unsigned int init_memory_counters(char *args, void **ptr)
+{
+ unsigned int indexes[NB_COUNTERS];
+ unsigned int count = 0;
+ memory_list(args, &count, indexes);
- KeyFinder *keys = build_keyfinder(count, indexes);
- FILE *file = fopen(path, "r");
+ KeyFinder *keys = build_keyfinder(count, indexes);
+ FILE *file = fopen(path, "r");
- MemoryCounters *counters = calloc(1, sizeof(MemoryCounters));
- counters->keys = keys;
- counters->count = count;
- counters->file = file;
+ MemoryCounters *counters = calloc(1, sizeof(MemoryCounters));
+ counters->keys = keys;
+ counters->count = count;
+ counters->file = file;
- *ptr = (void *)counters;
- return count;
+ *ptr = (void *)counters;
+ return count;
}
-unsigned int get_memory_counters(uint64_t *results, void *ptr) {
- MemoryCounters *counters = (MemoryCounters *)ptr;
- fseek(counters->file, 0, SEEK_SET);
- Parser parser = {.storage = (GenericPointer)results,
- .capacity = 1,
- .nb_stored = 0,
- .storage_struct_size = sizeof(uint64_t) * counters->count,
- .keys = counters->keys,
- .nb_keys = counters->count,
- .file = counters->file};
-
- parse(&parser);
- return counters->count;
+unsigned int get_memory_counters(uint64_t *results, void *ptr)
+{
+ MemoryCounters *counters = (MemoryCounters *)ptr;
+ fseek(counters->file, 0, SEEK_SET);
+ Parser parser = {.storage = (GenericPointer)results,
+ .capacity = 1,
+ .nb_stored = 0,
+ .storage_struct_size = sizeof(uint64_t) * counters->count,
+ .keys = counters->keys,
+ .nb_keys = counters->count,
+ .file = counters->file
+ };
+
+ parse(&parser);
+ return counters->count;
}
-void label_memory_counters(char **labels, void *ptr) {
- MemoryCounters *counters = (MemoryCounters *)ptr;
- for (unsigned int i = 0; i < counters->count; i++) {
- labels[i] = counters->keys[i].key;
- }
+void label_memory_counters(char **labels, void *ptr)
+{
+ MemoryCounters *counters = (MemoryCounters *)ptr;
+ for (unsigned int i = 0; i < counters->count; i++) {
+ labels[i] = counters->keys[i].key;
+ }
}
-void clean_memory_counters(void *ptr) {
- MemoryCounters *counters = (MemoryCounters *)ptr;
- fclose(counters->file);
- free(counters->keys);
- free(ptr);
+void clean_memory_counters(void *ptr)
+{
+ MemoryCounters *counters = (MemoryCounters *)ptr;
+ fclose(counters->file);
+ free(counters->keys);
+ free(ptr);
}
-void *show_all_memory_counters(void *none1, size_t none2) {
- for (unsigned int i = 0; i < NB_COUNTERS; i++) {
- printf("%s\n", memory_counters[i]);
- }
+void *show_all_memory_counters(void *none1, size_t none2)
+{
+ for (unsigned int i = 0; i < NB_COUNTERS; i++) {
+ printf("%s\n", memory_counters[i]);
+ }
- UNUSED(none1);
- UNUSED(none2);
- exit(EXIT_SUCCESS);
- return NULL; /* not reached */
+ UNUSED(none1);
+ UNUSED(none2);
+ exit(EXIT_SUCCESS);
+ return NULL; /* not reached */
}
--
GitLab