diff --git a/.gitignore b/.gitignore
index 83a8dc00367e5de634dfdb98da09de87e5de9c48..d6525496ab19c98c64b26a4bd57cc249881139c5 100644
--- a/.gitignore
+++ b/.gitignore
@@ -6,6 +6,7 @@ doc/info_reader_ex
doc/mojitos.1
tests/run
src/counters_option.h
+src/memory_option.h
src/sensors.h
sensors.mk
bin
diff --git a/README.md b/README.md
index 9fee622a82e3a0e684fa2eaa67adcb1768e974e7..4c0b18600b5a436352ed8ce9a5aeeb7385fe7130 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 7e10ec378cdb26b03b660f5d79b2ed78fba6c475..1246b0cb7fc9d9aad8673c55fec016387cd75090 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=''
@@ -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"
@@ -156,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/doc/info_reader_ex.c b/doc/info_reader_ex.c
index f1e6d96118f9bad951c516c5cb8392c5470141fb..d99e916fc6c98f5dc22bc0d99d8bb85d433cce33 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/lib/info_reader.c b/lib/info_reader.c
new file mode 100644
index 0000000000000000000000000000000000000000..d23f5547c03e3d507fc292748e87b892be0b43db
--- /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 ec28db62867db4c1b9f64d3e61008dc418fd1bc1..403bb197f4995654e63e25bdf3acd22b9489eab4 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,155 +99,74 @@ 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
+ 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);
+
+/**
+ * @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;
-}
-
-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) {
- 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++;
- }
- free(line);
- 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 f25d5630f9f65be71fb7220785bc97a30ea6030a..4dcbce48455abcce4d567201af99f7fb24a39552 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)
@@ -40,16 +42,23 @@ $(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
$(CC) $(CFLAGS) -c $< -o $@
$(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
+$(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)
@@ -59,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:
@@ -71,11 +80,12 @@ 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
-readme: $(BIN)
+readme:
sh ./tools/update-readme-usage.sh
man: $(BIN)
diff --git a/src/amd_rapl.c b/src/amd_rapl.c
index 9eaac45938a1ed0f9e44d68408f4a8796103e96e..572ac564693db3b4f5c221595a5f6629047d60d0 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/memory_counters.c b/src/memory_counters.c
new file mode 100644
index 0000000000000000000000000000000000000000..185f454e0bbe2b1e84606c8c7179386087971313
--- /dev/null
+++ b/src/memory_counters.c
@@ -0,0 +1,130 @@
+#include "memory_option.h"
+#include "util.h"
+#include <fcntl.h>
+#include <info_reader.h>
+#include <inttypes.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+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;
+}
+
+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 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");
+
+ MemoryCounters *counters = calloc(1, sizeof(MemoryCounters));
+ counters->keys = keys;
+ counters->count = count;
+ counters->file = file;
+
+ *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;
+}
+
+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 *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 0000000000000000000000000000000000000000..eaf9f369463e92f7a6f3c1b6bb0989bf8b4d5a11
--- /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 memory counters and quit",
+ .fn = show_all_memory_counters,
+ },
+};
diff --git a/src/memory_option.sh b/src/memory_option.sh
new file mode 100755
index 0000000000000000000000000000000000000000..30a3831264af3075170e20cd68ff5add5b9f1e75
--- /dev/null
+++ b/src/memory_option.sh
@@ -0,0 +1,45 @@
+#!/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 += 1))
+ echo "$line" | awk -F ':' '{printf(" \"%s\",\n", $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 += 1))
+done
+
+echo 'static void (*setter_functions[])(GenericPointer, GenericPointer) = {'
+count=0
+while [ $count -lt $nb_counters ]; do
+ echo " set_result_offset$count,"
+ : $((count += 1))
+done
+echo '};'
+echo
+
diff --git a/src/network.c b/src/network.c
index a668725dcd51825c2245c34b7ae387cd7125b294..fec9424365ee933537aae64c0fb7d41858908951 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 5000f485e7218676974af828bc75d33da474ddd4..1e4f281f046adb9de795f945b69f38fb6f5b1f4d 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,58 @@ 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]));
+ }
+ fclose(file);
+})
+
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 0000000000000000000000000000000000000000..17d4ee43fd318faf156932d60dad44116ca6e503
--- /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
diff --git a/tests/small_test.h b/tests/small_test.h
index 8301ae7ea0f8247b3b6c81cefab86c26f13aa1c7..7e8c11e4e12b92ac97106dc392873a3496977a40 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);
}
diff --git a/tests/util.c b/tests/util.c
index 231ab47487224a3f384d44f6b969be8fee2e25b4..ff979b943368f40dec153c955377dedf3d2cb3f6 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, {