summaryrefslogtreecommitdiffstats
path: root/tests/profile
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--tests/profile/Makefile51
-rw-r--r--tests/profile/benchmark-dictionary.c130
-rw-r--r--tests/profile/benchmark-line-parsing.c702
-rw-r--r--tests/profile/benchmark-procfile-parser.c329
-rw-r--r--tests/profile/benchmark-registry.c227
-rw-r--r--tests/profile/benchmark-value-pairs.c623
-rw-r--r--tests/profile/statsd-stress.c151
-rw-r--r--tests/profile/test-eval.c289
8 files changed, 2502 insertions, 0 deletions
diff --git a/tests/profile/Makefile b/tests/profile/Makefile
new file mode 100644
index 0000000..b3510e6
--- /dev/null
+++ b/tests/profile/Makefile
@@ -0,0 +1,51 @@
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+COMMON_CFLAGS = -I ../../ -Wall -Wextra
+PROFILE_CFLAGS = -O1 -ggdb $(COMMON_CFLAGS)
+PERFORMANCE_CFLAGS = -O2 $(COMMON_CFLAGS)
+
+CFLAGS = $(PERFORMANCE_CFLAGS)
+
+LIBNETDATA_FILES = \
+ ../../libnetdata/popen/popen.o \
+ ../../libnetdata/storage_number/storage_number.o \
+ ../../libnetdata/avl/avl.o \
+ ../../libnetdata/socket/socket.o \
+ ../../libnetdata/os.o \
+ ../../libnetdata/clocks/clocks.o \
+ ../../libnetdata/procfile/procfile.o \
+ ../../libnetdata/statistical/statistical.o \
+ ../../libnetdata/eval/eval.o \
+ ../../libnetdata/threads/threads.o \
+ ../../libnetdata/dictionary/dictionary.o \
+ ../../libnetdata/simple_pattern/simple_pattern.o \
+ ../../libnetdata/url/url.o \
+ ../../libnetdata/config/appconfig.o \
+ ../../libnetdata/libnetdata.o \
+ ../../libnetdata/buffer/buffer.o \
+ ../../libnetdata/adaptive_resortable_list/adaptive_resortable_list.o \
+ ../../libnetdata/locks/locks.o \
+ ../../libnetdata/log/log.o \
+ $(NULL)
+
+COMMON_LDFLAGS = $(LIBNETDATA_FILES) -pthread -lm
+
+all: statsd-stress benchmark-procfile-parser test-eval benchmark-dictionary benchmark-value-pairs
+
+benchmark-procfile-parser: benchmark-procfile-parser.c
+ gcc ${CFLAGS} -o $@ $^ ${COMMON_LDFLAGS}
+
+benchmark-dictionary: benchmark-dictionary.c
+ gcc ${CFLAGS} -o $@ $^ ${COMMON_LDFLAGS}
+
+benchmark-value-pairs: benchmark-value-pairs.c
+ gcc ${CFLAGS} -o $@ $^ ${COMMON_LDFLAGS}
+
+statsd-stress: statsd-stress.c
+ gcc ${CFLAGS} -o $@ $^ ${COMMON_LDFLAGS}
+
+test-eval: test-eval.c
+ gcc ${CFLAGS} -o $@ $^ ${COMMON_LDFLAGS}
+
+clean:
+ rm -f benchmark-procfile-parser statsd-stress test-eval benchmark-dictionary benchmark-value-pairs
diff --git a/tests/profile/benchmark-dictionary.c b/tests/profile/benchmark-dictionary.c
new file mode 100644
index 0000000..7cc9ab0
--- /dev/null
+++ b/tests/profile/benchmark-dictionary.c
@@ -0,0 +1,130 @@
+/* SPDX-License-Identifier: GPL-3.0-or-later */
+/*
+ * 1. build netdata (as normally)
+ * 2. cd tests/profile/
+ * 3. compile with:
+ * gcc -O3 -Wall -Wextra -I ../../src/ -I ../../ -o benchmark-dictionary benchmark-dictionary.c ../../src/dictionary.o ../../src/log.o ../../src/avl.o ../../src/common.o -pthread
+ *
+ */
+
+#include "config.h"
+#include "libnetdata/libnetdata.h"
+
+struct myvalue {
+ int i;
+};
+
+void netdata_cleanup_and_exit(int ret) { exit(ret); }
+
+int main(int argc, char **argv) {
+ if(argc || argv) {;}
+
+// DICTIONARY *dict = dictionary_create(DICT_OPTION_SINGLE_THREADED|DICT_OPTION_WITH_STATISTICS);
+ DICTIONARY *dict = dictionary_create(DICT_OPTION_STATS);
+ if(!dict) fatal("Cannot create dictionary.");
+
+ struct rusage start, end;
+ unsigned long long dt;
+ char buf[100 + 1];
+ struct myvalue value, *v;
+ int i, max = 30000000, max2;
+
+ // ------------------------------------------------------------------------
+
+ getrusage(RUSAGE_SELF, &start);
+ dict->stats->inserts = dict->stats->deletes = dict->stats->searches = 0ULL;
+ fprintf(stderr, "Inserting %d entries in the dictionary\n", max);
+ for(i = 0; i < max; i++) {
+ value.i = i;
+ snprintf(buf, 100, "%d", i);
+
+ dictionary_set(dict, buf, &value, sizeof(struct myvalue));
+ }
+ getrusage(RUSAGE_SELF, &end);
+ dt = (end.ru_utime.tv_sec * 1000000ULL + end.ru_utime.tv_usec) - (start.ru_utime.tv_sec * 1000000ULL + start.ru_utime.tv_usec);
+ fprintf(stderr, "Added %d entries in %llu nanoseconds: %llu inserts per second\n", max, dt, max * 1000000ULL / dt);
+ fprintf(stderr, " > Dictionary: %llu inserts, %llu deletes, %llu searches\n\n", dict->stats->inserts, dict->stats->deletes, dict->stats->searches);
+
+ // ------------------------------------------------------------------------
+
+ getrusage(RUSAGE_SELF, &start);
+ dict->stats->inserts = dict->stats->deletes = dict->stats->searches = 0ULL;
+ fprintf(stderr, "Retrieving %d entries from the dictionary\n", max);
+ for(i = 0; i < max; i++) {
+ value.i = i;
+ snprintf(buf, 100, "%d", i);
+
+ v = dictionary_get(dict, buf);
+ if(!v)
+ fprintf(stderr, "ERROR: cannot get value %d from the dictionary\n", i);
+ else if(v->i != i)
+ fprintf(stderr, "ERROR: expected %d but got %d\n", i, v->i);
+ }
+ getrusage(RUSAGE_SELF, &end);
+ dt = (end.ru_utime.tv_sec * 1000000ULL + end.ru_utime.tv_usec) - (start.ru_utime.tv_sec * 1000000ULL + start.ru_utime.tv_usec);
+ fprintf(stderr, "Read %d entries in %llu nanoseconds: %llu searches per second\n", max, dt, max * 1000000ULL / dt);
+ fprintf(stderr, " > Dictionary: %llu inserts, %llu deletes, %llu searches\n\n", dict->stats->inserts, dict->stats->deletes, dict->stats->searches);
+
+ // ------------------------------------------------------------------------
+
+ getrusage(RUSAGE_SELF, &start);
+ dict->stats->inserts = dict->stats->deletes = dict->stats->searches = 0ULL;
+ fprintf(stderr, "Resetting %d entries in the dictionary\n", max);
+ for(i = 0; i < max; i++) {
+ value.i = i;
+ snprintf(buf, 100, "%d", i);
+
+ dictionary_set(dict, buf, &value, sizeof(struct myvalue));
+ }
+ getrusage(RUSAGE_SELF, &end);
+ dt = (end.ru_utime.tv_sec * 1000000ULL + end.ru_utime.tv_usec) - (start.ru_utime.tv_sec * 1000000ULL + start.ru_utime.tv_usec);
+ fprintf(stderr, "Reset %d entries in %llu nanoseconds: %llu resets per second\n", max, dt, max * 1000000ULL / dt);
+ fprintf(stderr, " > Dictionary: %llu inserts, %llu deletes, %llu searches\n\n", dict->stats->inserts, dict->stats->deletes, dict->stats->searches);
+
+ // ------------------------------------------------------------------------
+
+ getrusage(RUSAGE_SELF, &start);
+ dict->stats->inserts = dict->stats->deletes = dict->stats->searches = 0ULL;
+ fprintf(stderr, "Searching %d non-existing entries in the dictionary\n", max);
+ max2 = max * 2;
+ for(i = max; i < max2; i++) {
+ value.i = i;
+ snprintf(buf, 100, "%d", i);
+
+ v = dictionary_get(dict, buf);
+ if(v)
+ fprintf(stderr, "ERROR: cannot got non-existing value %d from the dictionary\n", i);
+ }
+ getrusage(RUSAGE_SELF, &end);
+ dt = (end.ru_utime.tv_sec * 1000000ULL + end.ru_utime.tv_usec) - (start.ru_utime.tv_sec * 1000000ULL + start.ru_utime.tv_usec);
+ fprintf(stderr, "Searched %d non-existing entries in %llu nanoseconds: %llu not found searches per second\n", max, dt, max * 1000000ULL / dt);
+ fprintf(stderr, " > Dictionary: %llu inserts, %llu deletes, %llu searches\n\n", dict->stats->inserts, dict->stats->deletes, dict->stats->searches);
+
+ // ------------------------------------------------------------------------
+
+ getrusage(RUSAGE_SELF, &start);
+ dict->stats->inserts = dict->stats->deletes = dict->stats->searches = 0ULL;
+ fprintf(stderr, "Deleting %d entries from the dictionary\n", max);
+ for(i = 0; i < max; i++) {
+ value.i = i;
+ snprintf(buf, 100, "%d", i);
+
+ dictionary_del(dict, buf);
+ }
+ getrusage(RUSAGE_SELF, &end);
+ dt = (end.ru_utime.tv_sec * 1000000ULL + end.ru_utime.tv_usec) - (start.ru_utime.tv_sec * 1000000ULL + start.ru_utime.tv_usec);
+ fprintf(stderr, "Deleted %d entries in %llu nanoseconds: %llu deletes per second\n", max, dt, max * 1000000ULL / dt);
+ fprintf(stderr, " > Dictionary: %llu inserts, %llu deletes, %llu searches\n\n", dict->stats->inserts, dict->stats->deletes, dict->stats->searches);
+
+ // ------------------------------------------------------------------------
+
+ getrusage(RUSAGE_SELF, &start);
+ dict->stats->inserts = dict->stats->deletes = dict->stats->searches = 0ULL;
+ fprintf(stderr, "Destroying dictionary\n");
+ dictionary_destroy(dict);
+ getrusage(RUSAGE_SELF, &end);
+ dt = (end.ru_utime.tv_sec * 1000000ULL + end.ru_utime.tv_usec) - (start.ru_utime.tv_sec * 1000000ULL + start.ru_utime.tv_usec);
+ fprintf(stderr, "Destroyed in %llu nanoseconds\n", dt);
+
+ return 0;
+}
diff --git a/tests/profile/benchmark-line-parsing.c b/tests/profile/benchmark-line-parsing.c
new file mode 100644
index 0000000..1d47cc8
--- /dev/null
+++ b/tests/profile/benchmark-line-parsing.c
@@ -0,0 +1,702 @@
+/* SPDX-License-Identifier: GPL-3.0-or-later */
+#include <stdio.h>
+#include <inttypes.h>
+#include <string.h>
+#include <stdlib.h>
+#include <ctype.h>
+#include <sys/time.h>
+
+#define likely(x) __builtin_expect(!!(x), 1)
+#define unlikely(x) __builtin_expect(!!(x), 0)
+
+#define simple_hash(name) ({ \
+ register unsigned char *__hash_source = (unsigned char *)(name); \
+ register uint32_t __hash_value = 0x811c9dc5; \
+ while (*__hash_source) { \
+ __hash_value *= 16777619; \
+ __hash_value ^= (uint32_t) *__hash_source++; \
+ } \
+ __hash_value; \
+})
+
+static inline uint32_t simple_hash2(const char *name) {
+ register unsigned char *s = (unsigned char *)name;
+ register uint32_t hval = 0x811c9dc5;
+ while (*s) {
+ hval *= 16777619;
+ hval ^= (uint32_t) *s++;
+ }
+ return hval;
+}
+
+static inline unsigned long long fast_strtoull(const char *s) {
+ register unsigned long long n = 0;
+ register char c;
+ for(c = *s; c >= '0' && c <= '9' ; c = *(++s)) {
+ n *= 10;
+ n += c - '0';
+ // n = (n << 1) + (n << 3) + (c - '0');
+ }
+ return n;
+}
+
+static uint32_t cache_hash = 0;
+static uint32_t rss_hash = 0;
+static uint32_t rss_huge_hash = 0;
+static uint32_t mapped_file_hash = 0;
+static uint32_t writeback_hash = 0;
+static uint32_t dirty_hash = 0;
+static uint32_t swap_hash = 0;
+static uint32_t pgpgin_hash = 0;
+static uint32_t pgpgout_hash = 0;
+static uint32_t pgfault_hash = 0;
+static uint32_t pgmajfault_hash = 0;
+static uint32_t inactive_anon_hash = 0;
+static uint32_t active_anon_hash = 0;
+static uint32_t inactive_file_hash = 0;
+static uint32_t active_file_hash = 0;
+static uint32_t unevictable_hash = 0;
+static uint32_t hierarchical_memory_limit_hash = 0;
+static uint32_t total_cache_hash = 0;
+static uint32_t total_rss_hash = 0;
+static uint32_t total_rss_huge_hash = 0;
+static uint32_t total_mapped_file_hash = 0;
+static uint32_t total_writeback_hash = 0;
+static uint32_t total_dirty_hash = 0;
+static uint32_t total_swap_hash = 0;
+static uint32_t total_pgpgin_hash = 0;
+static uint32_t total_pgpgout_hash = 0;
+static uint32_t total_pgfault_hash = 0;
+static uint32_t total_pgmajfault_hash = 0;
+static uint32_t total_inactive_anon_hash = 0;
+static uint32_t total_active_anon_hash = 0;
+static uint32_t total_inactive_file_hash = 0;
+static uint32_t total_active_file_hash = 0;
+static uint32_t total_unevictable_hash = 0;
+
+char *strings[] = {
+ "cache",
+ "rss",
+ "rss_huge",
+ "mapped_file",
+ "writeback",
+ "dirty",
+ "swap",
+ "pgpgin",
+ "pgpgout",
+ "pgfault",
+ "pgmajfault",
+ "inactive_anon",
+ "active_anon",
+ "inactive_file",
+ "active_file",
+ "unevictable",
+ "hierarchical_memory_limit",
+ "total_cache",
+ "total_rss",
+ "total_rss_huge",
+ "total_mapped_file",
+ "total_writeback",
+ "total_dirty",
+ "total_swap",
+ "total_pgpgin",
+ "total_pgpgout",
+ "total_pgfault",
+ "total_pgmajfault",
+ "total_inactive_anon",
+ "total_active_anon",
+ "total_inactive_file",
+ "total_active_file",
+ "total_unevictable",
+ NULL
+};
+
+unsigned long long values1[12] = { 0 };
+unsigned long long values2[12] = { 0 };
+unsigned long long values3[12] = { 0 };
+unsigned long long values4[12] = { 0 };
+unsigned long long values5[12] = { 0 };
+unsigned long long values6[12] = { 0 };
+
+#define NUMBER1 "12345678901234"
+#define NUMBER2 "23456789012345"
+#define NUMBER3 "34567890123456"
+#define NUMBER4 "45678901234567"
+#define NUMBER5 "56789012345678"
+#define NUMBER6 "67890123456789"
+#define NUMBER7 "78901234567890"
+#define NUMBER8 "89012345678901"
+#define NUMBER9 "90123456789012"
+#define NUMBER10 "12345678901234"
+#define NUMBER11 "23456789012345"
+
+// simple system strcmp()
+void test1() {
+ int i;
+ for(i = 0; strings[i] ; i++) {
+ char *s = strings[i];
+
+ if(unlikely(!strcmp(s, "cache")))
+ values1[i] = strtoull(NUMBER1, NULL, 10);
+
+ else if(unlikely(!strcmp(s, "rss")))
+ values1[i] = strtoull(NUMBER2, NULL, 10);
+
+ else if(unlikely(!strcmp(s, "rss_huge")))
+ values1[i] = strtoull(NUMBER3, NULL, 10);
+
+ else if(unlikely(!strcmp(s, "mapped_file")))
+ values1[i] = strtoull(NUMBER4, NULL, 10);
+
+ else if(unlikely(!strcmp(s, "writeback")))
+ values1[i] = strtoull(NUMBER5, NULL, 10);
+
+ else if(unlikely(!strcmp(s, "dirty")))
+ values1[i] = strtoull(NUMBER6, NULL, 10);
+
+ else if(unlikely(!strcmp(s, "swap")))
+ values1[i] = strtoull(NUMBER7, NULL, 10);
+
+ else if(unlikely(!strcmp(s, "pgpgin")))
+ values1[i] = strtoull(NUMBER8, NULL, 10);
+
+ else if(unlikely(!strcmp(s, "pgpgout")))
+ values1[i] = strtoull(NUMBER9, NULL, 10);
+
+ else if(unlikely(!strcmp(s, "pgfault")))
+ values1[i] = strtoull(NUMBER10, NULL, 10);
+
+ else if(unlikely(!strcmp(s, "pgmajfault")))
+ values1[i] = strtoull(NUMBER11, NULL, 10);
+ }
+}
+
+// inline simple_hash() with system strtoull()
+void test2() {
+ int i;
+ for(i = 0; strings[i] ; i++) {
+ char *s = strings[i];
+ uint32_t hash = simple_hash2(s);
+
+ if(unlikely(hash == cache_hash && !strcmp(s, "cache")))
+ values2[i] = strtoull(NUMBER1, NULL, 10);
+
+ else if(unlikely(hash == rss_hash && !strcmp(s, "rss")))
+ values2[i] = strtoull(NUMBER2, NULL, 10);
+
+ else if(unlikely(hash == rss_huge_hash && !strcmp(s, "rss_huge")))
+ values2[i] = strtoull(NUMBER3, NULL, 10);
+
+ else if(unlikely(hash == mapped_file_hash && !strcmp(s, "mapped_file")))
+ values2[i] = strtoull(NUMBER4, NULL, 10);
+
+ else if(unlikely(hash == writeback_hash && !strcmp(s, "writeback")))
+ values2[i] = strtoull(NUMBER5, NULL, 10);
+
+ else if(unlikely(hash == dirty_hash && !strcmp(s, "dirty")))
+ values2[i] = strtoull(NUMBER6, NULL, 10);
+
+ else if(unlikely(hash == swap_hash && !strcmp(s, "swap")))
+ values2[i] = strtoull(NUMBER7, NULL, 10);
+
+ else if(unlikely(hash == pgpgin_hash && !strcmp(s, "pgpgin")))
+ values2[i] = strtoull(NUMBER8, NULL, 10);
+
+ else if(unlikely(hash == pgpgout_hash && !strcmp(s, "pgpgout")))
+ values2[i] = strtoull(NUMBER9, NULL, 10);
+
+ else if(unlikely(hash == pgfault_hash && !strcmp(s, "pgfault")))
+ values2[i] = strtoull(NUMBER10, NULL, 10);
+
+ else if(unlikely(hash == pgmajfault_hash && !strcmp(s, "pgmajfault")))
+ values2[i] = strtoull(NUMBER11, NULL, 10);
+ }
+}
+
+// statement expression simple_hash(), system strtoull()
+void test3() {
+ int i;
+ for(i = 0; strings[i] ; i++) {
+ char *s = strings[i];
+ uint32_t hash = simple_hash(s);
+
+ if(unlikely(hash == cache_hash && !strcmp(s, "cache")))
+ values3[i] = strtoull(NUMBER1, NULL, 10);
+
+ else if(unlikely(hash == rss_hash && !strcmp(s, "rss")))
+ values3[i] = strtoull(NUMBER2, NULL, 10);
+
+ else if(unlikely(hash == rss_huge_hash && !strcmp(s, "rss_huge")))
+ values3[i] = strtoull(NUMBER3, NULL, 10);
+
+ else if(unlikely(hash == mapped_file_hash && !strcmp(s, "mapped_file")))
+ values3[i] = strtoull(NUMBER4, NULL, 10);
+
+ else if(unlikely(hash == writeback_hash && !strcmp(s, "writeback")))
+ values3[i] = strtoull(NUMBER5, NULL, 10);
+
+ else if(unlikely(hash == dirty_hash && !strcmp(s, "dirty")))
+ values3[i] = strtoull(NUMBER6, NULL, 10);
+
+ else if(unlikely(hash == swap_hash && !strcmp(s, "swap")))
+ values3[i] = strtoull(NUMBER7, NULL, 10);
+
+ else if(unlikely(hash == pgpgin_hash && !strcmp(s, "pgpgin")))
+ values3[i] = strtoull(NUMBER8, NULL, 10);
+
+ else if(unlikely(hash == pgpgout_hash && !strcmp(s, "pgpgout")))
+ values3[i] = strtoull(NUMBER9, NULL, 10);
+
+ else if(unlikely(hash == pgfault_hash && !strcmp(s, "pgfault")))
+ values3[i] = strtoull(NUMBER10, NULL, 10);
+
+ else if(unlikely(hash == pgmajfault_hash && !strcmp(s, "pgmajfault")))
+ values3[i] = strtoull(NUMBER11, NULL, 10);
+ }
+}
+
+
+// inline simple_hash(), if-continue checks
+void test4() {
+ int i;
+ for(i = 0; strings[i] ; i++) {
+ char *s = strings[i];
+ uint32_t hash = simple_hash2(s);
+
+ if(unlikely(hash == cache_hash && !strcmp(s, "cache"))) {
+ values4[i] = strtoull(NUMBER1, NULL, 0);
+ continue;
+ }
+
+ if(unlikely(hash == rss_hash && !strcmp(s, "rss"))) {
+ values4[i] = strtoull(NUMBER2, NULL, 0);
+ continue;
+ }
+
+ if(unlikely(hash == rss_huge_hash && !strcmp(s, "rss_huge"))) {
+ values4[i] = strtoull(NUMBER3, NULL, 0);
+ continue;
+ }
+
+ if(unlikely(hash == mapped_file_hash && !strcmp(s, "mapped_file"))) {
+ values4[i] = strtoull(NUMBER4, NULL, 0);
+ continue;
+ }
+
+ if(unlikely(hash == writeback_hash && !strcmp(s, "writeback"))) {
+ values4[i] = strtoull(NUMBER5, NULL, 0);
+ continue;
+ }
+
+ if(unlikely(hash == dirty_hash && !strcmp(s, "dirty"))) {
+ values4[i] = strtoull(NUMBER6, NULL, 0);
+ continue;
+ }
+
+ if(unlikely(hash == swap_hash && !strcmp(s, "swap"))) {
+ values4[i] = strtoull(NUMBER7, NULL, 0);
+ continue;
+ }
+
+ if(unlikely(hash == pgpgin_hash && !strcmp(s, "pgpgin"))) {
+ values4[i] = strtoull(NUMBER8, NULL, 0);
+ continue;
+ }
+
+ if(unlikely(hash == pgpgout_hash && !strcmp(s, "pgpgout"))) {
+ values4[i] = strtoull(NUMBER9, NULL, 0);
+ continue;
+ }
+
+ if(unlikely(hash == pgfault_hash && !strcmp(s, "pgfault"))) {
+ values4[i] = strtoull(NUMBER10, NULL, 0);
+ continue;
+ }
+
+ if(unlikely(hash == pgmajfault_hash && !strcmp(s, "pgmajfault"))) {
+ values4[i] = strtoull(NUMBER11, NULL, 0);
+ continue;
+ }
+ }
+}
+
+// inline simple_hash(), if-else-if-else-if (netdata default)
+void test5() {
+ int i;
+ for(i = 0; strings[i] ; i++) {
+ char *s = strings[i];
+ uint32_t hash = simple_hash2(s);
+
+ if(unlikely(hash == cache_hash && !strcmp(s, "cache")))
+ values5[i] = fast_strtoull(NUMBER1);
+
+ else if(unlikely(hash == rss_hash && !strcmp(s, "rss")))
+ values5[i] = fast_strtoull(NUMBER2);
+
+ else if(unlikely(hash == rss_huge_hash && !strcmp(s, "rss_huge")))
+ values5[i] = fast_strtoull(NUMBER3);
+
+ else if(unlikely(hash == mapped_file_hash && !strcmp(s, "mapped_file")))
+ values5[i] = fast_strtoull(NUMBER4);
+
+ else if(unlikely(hash == writeback_hash && !strcmp(s, "writeback")))
+ values5[i] = fast_strtoull(NUMBER5);
+
+ else if(unlikely(hash == dirty_hash && !strcmp(s, "dirty")))
+ values5[i] = fast_strtoull(NUMBER6);
+
+ else if(unlikely(hash == swap_hash && !strcmp(s, "swap")))
+ values5[i] = fast_strtoull(NUMBER7);
+
+ else if(unlikely(hash == pgpgin_hash && !strcmp(s, "pgpgin")))
+ values5[i] = fast_strtoull(NUMBER8);
+
+ else if(unlikely(hash == pgpgout_hash && !strcmp(s, "pgpgout")))
+ values5[i] = fast_strtoull(NUMBER9);
+
+ else if(unlikely(hash == pgfault_hash && !strcmp(s, "pgfault")))
+ values5[i] = fast_strtoull(NUMBER10);
+
+ else if(unlikely(hash == pgmajfault_hash && !strcmp(s, "pgmajfault")))
+ values5[i] = fast_strtoull(NUMBER11);
+ }
+}
+
+// ----------------------------------------------------------------------------
+
+struct entry {
+ char *name;
+ uint32_t hash;
+ int found;
+ void (*func)(void *data1, void *data2);
+ void *data1;
+ void *data2;
+ struct entry *prev, *next;
+};
+
+struct base {
+ int iteration;
+ int registered;
+ int wanted;
+ int found;
+ struct entry *entries, *last;
+};
+
+static inline void callback(void *data1, void *data2) {
+ char *string = data1;
+ unsigned long long *value = data2;
+ *value = fast_strtoull(string);
+}
+
+static inline void callback_system_strtoull(void *data1, void *data2) {
+ char *string = data1;
+ unsigned long long *value = data2;
+ *value = strtoull(string, NULL, 10);
+}
+
+
+static inline struct base *entry(struct base *base, const char *name, void *data1, void *data2, void (*func)(void *, void *)) {
+ if(!base)
+ base = calloc(1, sizeof(struct base));
+
+ struct entry *e = malloc(sizeof(struct entry));
+ e->name = strdup(name);
+ e->hash = simple_hash2(e->name);
+ e->data1 = data1;
+ e->data2 = data2;
+ e->func = func;
+ e->prev = NULL;
+ e->next = base->entries;
+
+ if(base->entries) base->entries->prev = e;
+ else base->last = e;
+
+ base->entries = e;
+ base->registered++;
+ base->wanted = base->registered;
+
+ return base;
+}
+
+static inline int check(struct base *base, const char *s) {
+ uint32_t hash = simple_hash2(s);
+
+ if(likely(!strcmp(s, base->last->name))) {
+ base->last->found = 1;
+ base->found++;
+ if(base->last->func) base->last->func(base->last->data1, base->last->data2);
+ base->last = base->last->next;
+
+ if(!base->last)
+ base->last = base->entries;
+
+ if(base->found == base->registered)
+ return 1;
+
+ return 0;
+ }
+
+ // find it
+ struct entry *e;
+ for(e = base->entries; e ; e = e->next)
+ if(e->hash == hash && !strcmp(e->name, s))
+ break;
+
+ if(e == base->last) {
+ printf("ERROR\n");
+ exit(1);
+ }
+
+ if(e) {
+ // found
+
+ // run it
+ if(e->func) e->func(e->data1, e->data2);
+
+ // unlink it
+ if(e->next) e->next->prev = e->prev;
+ if(e->prev) e->prev->next = e->next;
+
+ if(base->entries == e)
+ base->entries = e->next;
+ }
+ else {
+ // not found
+
+ // create it
+ e = calloc(1, sizeof(struct entry));
+ e->name = strdup(s);
+ e->hash = hash;
+ }
+
+ // link it here
+ e->next = base->last;
+ if(base->last) {
+ e->prev = base->last->prev;
+ base->last->prev = e;
+
+ if(base->entries == base->last)
+ base->entries = e;
+ }
+ else
+ e->prev = NULL;
+
+ if(e->prev)
+ e->prev->next = e;
+
+ base->last = e->next;
+ if(!base->last)
+ base->last = base->entries;
+
+ e->found = 1;
+ base->found++;
+
+ if(base->found == base->registered)
+ return 1;
+
+ printf("relinked '%s' after '%s' and before '%s': ", e->name, e->prev?e->prev->name:"NONE", e->next?e->next->name:"NONE");
+ for(e = base->entries; e ; e = e->next) printf("%s ", e->name);
+ printf("\n");
+
+ return 0;
+}
+
+static inline void begin(struct base *base) {
+
+ if(unlikely(base->iteration % 60) == 1) {
+ base->wanted = 0;
+ struct entry *e;
+ for(e = base->entries; e ; e = e->next)
+ if(e->found) base->wanted++;
+ }
+
+ base->iteration++;
+ base->last = base->entries;
+ base->found = 0;
+}
+
+void test6() {
+
+ static struct base *base = NULL;
+
+ if(unlikely(!base)) {
+ base = entry(base, "cache", NUMBER1, &values6[0], callback_system_strtoull);
+ base = entry(base, "rss", NUMBER2, &values6[1], callback_system_strtoull);
+ base = entry(base, "rss_huge", NUMBER3, &values6[2], callback_system_strtoull);
+ base = entry(base, "mapped_file", NUMBER4, &values6[3], callback_system_strtoull);
+ base = entry(base, "writeback", NUMBER5, &values6[4], callback_system_strtoull);
+ base = entry(base, "dirty", NUMBER6, &values6[5], callback_system_strtoull);
+ base = entry(base, "swap", NUMBER7, &values6[6], callback_system_strtoull);
+ base = entry(base, "pgpgin", NUMBER8, &values6[7], callback_system_strtoull);
+ base = entry(base, "pgpgout", NUMBER9, &values6[8], callback_system_strtoull);
+ base = entry(base, "pgfault", NUMBER10, &values6[9], callback_system_strtoull);
+ base = entry(base, "pgmajfault", NUMBER11, &values6[10], callback_system_strtoull);
+ }
+
+ begin(base);
+
+ int i;
+ for(i = 0; strings[i] ; i++) {
+ if(check(base, strings[i]))
+ break;
+ }
+}
+
+void test7() {
+
+ static struct base *base = NULL;
+
+ if(unlikely(!base)) {
+ base = entry(base, "cache", NUMBER1, &values6[0], callback);
+ base = entry(base, "rss", NUMBER2, &values6[1], callback);
+ base = entry(base, "rss_huge", NUMBER3, &values6[2], callback);
+ base = entry(base, "mapped_file", NUMBER4, &values6[3], callback);
+ base = entry(base, "writeback", NUMBER5, &values6[4], callback);
+ base = entry(base, "dirty", NUMBER6, &values6[5], callback);
+ base = entry(base, "swap", NUMBER7, &values6[6], callback);
+ base = entry(base, "pgpgin", NUMBER8, &values6[7], callback);
+ base = entry(base, "pgpgout", NUMBER9, &values6[8], callback);
+ base = entry(base, "pgfault", NUMBER10, &values6[9], callback);
+ base = entry(base, "pgmajfault", NUMBER11, &values6[10], callback);
+ }
+
+ begin(base);
+
+ int i;
+ for(i = 0; strings[i] ; i++) {
+ if(check(base, strings[i]))
+ break;
+ }
+}
+
+// ----------------------------------------------------------------------------
+
+
+// ==============
+// --- Poor man cycle counting.
+static unsigned long tsc;
+
+static void begin_tsc(void)
+{
+ unsigned long a, d;
+ asm volatile ("cpuid\nrdtsc" : "=a" (a), "=d" (d) : "0" (0) : "ebx", "ecx");
+ tsc = ((unsigned long)d << 32) | (unsigned long)a;
+}
+
+static unsigned long end_tsc(void)
+{
+ unsigned long a, d;
+ asm volatile ("rdtscp" : "=a" (a), "=d" (d) : : "ecx");
+ return (((unsigned long)d << 32) | (unsigned long)a) - tsc;
+}
+// ===============
+
+static unsigned long long clk;
+
+static void begin_clock() {
+ struct timeval tv;
+ if(unlikely(gettimeofday(&tv, NULL) == -1))
+ return;
+ clk = tv.tv_sec * 1000000 + tv.tv_usec;
+}
+
+static unsigned long long end_clock() {
+ struct timeval tv;
+ if(unlikely(gettimeofday(&tv, NULL) == -1))
+ return -1;
+ return clk = tv.tv_sec * 1000000 + tv.tv_usec - clk;
+}
+
+void main(void)
+{
+ cache_hash = simple_hash("cache");
+ rss_hash = simple_hash("rss");
+ rss_huge_hash = simple_hash("rss_huge");
+ mapped_file_hash = simple_hash("mapped_file");
+ writeback_hash = simple_hash("writeback");
+ dirty_hash = simple_hash("dirty");
+ swap_hash = simple_hash("swap");
+ pgpgin_hash = simple_hash("pgpgin");
+ pgpgout_hash = simple_hash("pgpgout");
+ pgfault_hash = simple_hash("pgfault");
+ pgmajfault_hash = simple_hash("pgmajfault");
+ inactive_anon_hash = simple_hash("inactive_anon");
+ active_anon_hash = simple_hash("active_anon");
+ inactive_file_hash = simple_hash("inactive_file");
+ active_file_hash = simple_hash("active_file");
+ unevictable_hash = simple_hash("unevictable");
+ hierarchical_memory_limit_hash = simple_hash("hierarchical_memory_limit");
+ total_cache_hash = simple_hash("total_cache");
+ total_rss_hash = simple_hash("total_rss");
+ total_rss_huge_hash = simple_hash("total_rss_huge");
+ total_mapped_file_hash = simple_hash("total_mapped_file");
+ total_writeback_hash = simple_hash("total_writeback");
+ total_dirty_hash = simple_hash("total_dirty");
+ total_swap_hash = simple_hash("total_swap");
+ total_pgpgin_hash = simple_hash("total_pgpgin");
+ total_pgpgout_hash = simple_hash("total_pgpgout");
+ total_pgfault_hash = simple_hash("total_pgfault");
+ total_pgmajfault_hash = simple_hash("total_pgmajfault");
+ total_inactive_anon_hash = simple_hash("total_inactive_anon");
+ total_active_anon_hash = simple_hash("total_active_anon");
+ total_inactive_file_hash = simple_hash("total_inactive_file");
+ total_active_file_hash = simple_hash("total_active_file");
+ total_unevictable_hash = simple_hash("total_unevictable");
+
+ unsigned long i, c1 = 0, c2 = 0, c3 = 0, c4 = 0, c5 = 0, c6 = 0, c7;
+ unsigned long max = 1000000;
+
+ // let the processor get up to speed
+ begin_clock();
+ for(i = 0; i <= max ;i++) test1();
+ c1 = end_clock();
+
+ begin_clock();
+ for(i = 0; i <= max ;i++) test1();
+ c1 = end_clock();
+
+ begin_clock();
+ for(i = 0; i <= max ;i++) test2();
+ c2 = end_clock();
+
+ begin_clock();
+ for(i = 0; i <= max ;i++) test3();
+ c3 = end_clock();
+
+ begin_clock();
+ for(i = 0; i <= max ;i++) test4();
+ c4 = end_clock();
+
+ begin_clock();
+ for(i = 0; i <= max ;i++) test5();
+ c5 = end_clock();
+
+ begin_clock();
+ for(i = 0; i <= max ;i++) test6();
+ c6 = end_clock();
+
+ begin_clock();
+ for(i = 0; i <= max ;i++) test7();
+ c7 = end_clock();
+
+ for(i = 0; i < 11 ; i++)
+ printf("value %lu: %llu %llu %llu %llu %llu %llu\n", i, values1[i], values2[i], values3[i], values4[i], values5[i], values6[i]);
+
+ printf("\n\nRESULTS\n");
+ printf("test1() in %lu usecs: if-else-if-else-if, simple strcmp() with system strtoull().\n"
+ "test2() in %lu usecs: inline simple_hash() if-else-if-else-if, with system strtoull().\n"
+ "test3() in %lu usecs: statement expression simple_hash(), system strtoull().\n"
+ "test4() in %lu usecs: inline simple_hash(), if-continue checks, system strtoull().\n"
+ "test5() in %lu usecs: inline simple_hash(), if-else-if-else-if, custom strtoull() (netdata default prior to ARL).\n"
+ "test6() in %lu usecs: adaptive re-sortable list, system strtoull() (wow!)\n"
+ "test7() in %lu usecs: adaptive re-sortable list, custom strtoull() (wow!)\n"
+ , c1
+ , c2
+ , c3
+ , c4
+ , c5
+ , c6
+ , c7
+ );
+
+}
diff --git a/tests/profile/benchmark-procfile-parser.c b/tests/profile/benchmark-procfile-parser.c
new file mode 100644
index 0000000..214ca94
--- /dev/null
+++ b/tests/profile/benchmark-procfile-parser.c
@@ -0,0 +1,329 @@
+/* SPDX-License-Identifier: GPL-3.0-or-later */
+
+#include "config.h"
+#include "libnetdata/libnetdata.h"
+
+void netdata_cleanup_and_exit(int ret) {
+ exit(ret);
+}
+
+#define PF_PREFIX "PROCFILE"
+#define PFWORDS_INCREASE_STEP 200
+#define PFLINES_INCREASE_STEP 10
+#define PROCFILE_INCREMENT_BUFFER 512
+extern size_t procfile_max_lines;
+extern size_t procfile_max_words;
+extern size_t procfile_max_allocation;
+
+
+static inline void pflines_reset(pflines *fl) {
+ // debug(D_PROCFILE, PF_PREFIX ": resetting lines");
+
+ fl->len = 0;
+}
+
+static inline void pflines_free(pflines *fl) {
+ // debug(D_PROCFILE, PF_PREFIX ": freeing lines");
+
+ freez(fl);
+}
+
+static inline void pfwords_reset(pfwords *fw) {
+ // debug(D_PROCFILE, PF_PREFIX ": resetting words");
+ fw->len = 0;
+}
+
+
+static inline void pfwords_add(procfile *ff, char *str) {
+ // debug(D_PROCFILE, PF_PREFIX ": adding word No %d: '%s'", fw->len, str);
+
+ pfwords *fw = ff->words;
+ if(unlikely(fw->len == fw->size)) {
+ // debug(D_PROCFILE, PF_PREFIX ": expanding words");
+
+ ff->words = fw = reallocz(fw, sizeof(pfwords) + (fw->size + PFWORDS_INCREASE_STEP) * sizeof(char *));
+ fw->size += PFWORDS_INCREASE_STEP;
+ }
+
+ fw->words[fw->len++] = str;
+}
+
+NEVERNULL
+static inline size_t *pflines_add(procfile *ff) {
+ // debug(D_PROCFILE, PF_PREFIX ": adding line %d at word %d", fl->len, first_word);
+
+ pflines *fl = ff->lines;
+ if(unlikely(fl->len == fl->size)) {
+ // debug(D_PROCFILE, PF_PREFIX ": expanding lines");
+
+ ff->lines = fl = reallocz(fl, sizeof(pflines) + (fl->size + PFLINES_INCREASE_STEP) * sizeof(ffline));
+ fl->size += PFLINES_INCREASE_STEP;
+ }
+
+ ffline *ffl = &fl->lines[fl->len++];
+ ffl->words = 0;
+ ffl->first = ff->words->len;
+
+ return &ffl->words;
+}
+
+
+NOINLINE
+static void procfile_parser(procfile *ff) {
+ // debug(D_PROCFILE, PF_PREFIX ": Parsing file '%s'", ff->filename);
+
+ char *s = ff->data // our current position
+ , *e = &ff->data[ff->len] // the terminating null
+ , *t = ff->data; // the first character of a word (or quoted / parenthesized string)
+
+ // the look up array to find our type of character
+ PF_CHAR_TYPE *separators = ff->separators;
+
+ char quote = 0; // the quote character - only when in quoted string
+ size_t opened = 0; // counts the number of open parenthesis
+
+ size_t *line_words = pflines_add(ff);
+
+ while(s < e) {
+ PF_CHAR_TYPE ct = separators[(unsigned char)(*s)];
+
+ // this is faster than a switch()
+ // read more here: http://lazarenko.me/switch/
+ switch(ct) {
+ case PF_CHAR_IS_SEPARATOR:
+ if(!quote && !opened) {
+ if (s != t) {
+ // separator, but we have word before it
+ *s = '\0';
+ pfwords_add(ff, t);
+ (*line_words)++;
+ }
+ t = s + 1;
+ }
+ // fallthrough
+
+ case PF_CHAR_IS_WORD:
+ s++;
+ break;
+
+
+ case PF_CHAR_IS_NEWLINE:
+ // end of line
+
+ *s = '\0';
+ pfwords_add(ff, t);
+ (*line_words)++;
+ t = ++s;
+
+ // debug(D_PROCFILE, PF_PREFIX ": ended line %d with %d words", l, ff->lines->lines[l].words);
+
+ line_words = pflines_add(ff);
+ break;
+
+ case PF_CHAR_IS_QUOTE:
+ if(unlikely(!quote && s == t)) {
+ // quote opened at the beginning
+ quote = *s;
+ t = ++s;
+ }
+ else if(unlikely(quote && quote == *s)) {
+ // quote closed
+ quote = 0;
+
+ *s = '\0';
+ pfwords_add(ff, t);
+ (*line_words)++;
+ t = ++s;
+ }
+ else
+ s++;
+ break;
+
+ case PF_CHAR_IS_OPEN:
+ if(s == t) {
+ opened++;
+ t = ++s;
+ }
+ else if(opened) {
+ opened++;
+ s++;
+ }
+ else
+ s++;
+ break;
+
+ case PF_CHAR_IS_CLOSE:
+ if(opened) {
+ opened--;
+
+ if(!opened) {
+ *s = '\0';
+ pfwords_add(ff, t);
+ (*line_words)++;
+ t = ++s;
+ }
+ else
+ s++;
+ }
+ else
+ s++;
+ break;
+
+ default:
+ fatal("Internal Error: procfile_readall() does not handle all the cases.");
+ }
+ }
+
+ if(likely(s > t && t < e)) {
+ // the last word
+ if(unlikely(ff->len >= ff->size)) {
+ // we are going to loose the last byte
+ s = &ff->data[ff->size - 1];
+ }
+
+ *s = '\0';
+ pfwords_add(ff, t);
+ (*line_words)++;
+ // t = ++s;
+ }
+}
+
+
+procfile *procfile_readall1(procfile *ff) {
+ // debug(D_PROCFILE, PF_PREFIX ": Reading file '%s'.", ff->filename);
+
+ ff->len = 0; // zero the used size
+ ssize_t r = 1; // read at least once
+ while(r > 0) {
+ ssize_t s = ff->len;
+ ssize_t x = ff->size - s;
+
+ if(unlikely(!x)) {
+ debug(D_PROCFILE, PF_PREFIX ": Expanding data buffer for file '%s'.", procfile_filename(ff));
+ ff = reallocz(ff, sizeof(procfile) + ff->size + PROCFILE_INCREMENT_BUFFER);
+ ff->size += PROCFILE_INCREMENT_BUFFER;
+ }
+
+ debug(D_PROCFILE, "Reading file '%s', from position %zd with length %zd", procfile_filename(ff), s, (ssize_t)(ff->size - s));
+ r = read(ff->fd, &ff->data[s], ff->size - s);
+ if(unlikely(r == -1)) {
+ if(unlikely(!(ff->flags & PROCFILE_FLAG_NO_ERROR_ON_FILE_IO))) error(PF_PREFIX ": Cannot read from file '%s' on fd %d", procfile_filename(ff), ff->fd);
+ procfile_close(ff);
+ return NULL;
+ }
+
+ ff->len += r;
+ }
+
+ // debug(D_PROCFILE, "Rewinding file '%s'", ff->filename);
+ if(unlikely(lseek(ff->fd, 0, SEEK_SET) == -1)) {
+ if(unlikely(!(ff->flags & PROCFILE_FLAG_NO_ERROR_ON_FILE_IO))) error(PF_PREFIX ": Cannot rewind on file '%s'.", procfile_filename(ff));
+ procfile_close(ff);
+ return NULL;
+ }
+
+ pflines_reset(ff->lines);
+ pfwords_reset(ff->words);
+ procfile_parser(ff);
+
+ if(unlikely(procfile_adaptive_initial_allocation)) {
+ if(unlikely(ff->len > procfile_max_allocation)) procfile_max_allocation = ff->len;
+ if(unlikely(ff->lines->len > procfile_max_lines)) procfile_max_lines = ff->lines->len;
+ if(unlikely(ff->words->len > procfile_max_words)) procfile_max_words = ff->words->len;
+ }
+
+ // debug(D_PROCFILE, "File '%s' updated.", ff->filename);
+ return ff;
+}
+
+
+
+
+
+
+
+
+// ==============
+// --- Poor man cycle counting.
+static unsigned long tsc;
+
+void begin_tsc(void)
+{
+ unsigned long a, d;
+ asm volatile ("cpuid\nrdtsc" : "=a" (a), "=d" (d) : "0" (0) : "ebx", "ecx");
+ tsc = ((unsigned long)d << 32) | (unsigned long)a;
+}
+
+unsigned long end_tsc(void)
+{
+ unsigned long a, d;
+ asm volatile ("rdtscp" : "=a" (a), "=d" (d) : : "ecx");
+ return (((unsigned long)d << 32) | (unsigned long)a) - tsc;
+}
+// ==============
+
+
+unsigned long test_netdata_internal(void) {
+ static procfile *ff = NULL;
+
+ ff = procfile_reopen(ff, "/proc/self/status", " \t:,-()/", PROCFILE_FLAG_NO_ERROR_ON_FILE_IO);
+ if(!ff) {
+ fprintf(stderr, "Failed to open filename\n");
+ exit(1);
+ }
+
+ begin_tsc();
+ ff = procfile_readall(ff);
+ unsigned long c = end_tsc();
+
+ if(!ff) {
+ fprintf(stderr, "Failed to read filename\n");
+ exit(1);
+ }
+
+ return c;
+}
+
+unsigned long test_method1(void) {
+ static procfile *ff = NULL;
+
+ ff = procfile_reopen(ff, "/proc/self/status", " \t:,-()/", PROCFILE_FLAG_NO_ERROR_ON_FILE_IO);
+ if(!ff) {
+ fprintf(stderr, "Failed to open filename\n");
+ exit(1);
+ }
+
+ begin_tsc();
+ ff = procfile_readall1(ff);
+ unsigned long c = end_tsc();
+
+ if(!ff) {
+ fprintf(stderr, "Failed to read filename\n");
+ exit(1);
+ }
+
+ return c;
+}
+
+//--- Test
+int main(int argc, char **argv)
+{
+ (void)argc; (void)argv;
+
+ int i, max = 1000000;
+
+ unsigned long c1 = 0;
+ test_netdata_internal();
+ for(i = 0; i < max ; i++)
+ c1 += test_netdata_internal();
+
+ unsigned long c2 = 0;
+ test_method1();
+ for(i = 0; i < max ; i++)
+ c2 += test_method1();
+
+ printf("netdata internal: completed in %lu cycles, %lu cycles per read, %0.2f %%.\n", c1, c1 / max, (float)c1 * 100.0 / (float)c1);
+ printf("method1 : completed in %lu cycles, %lu cycles per read, %0.2f %%.\n", c2, c2 / max, (float)c2 * 100.0 / (float)c1);
+
+ return 0;
+}
diff --git a/tests/profile/benchmark-registry.c b/tests/profile/benchmark-registry.c
new file mode 100644
index 0000000..cfed6d7
--- /dev/null
+++ b/tests/profile/benchmark-registry.c
@@ -0,0 +1,227 @@
+/* SPDX-License-Identifier: GPL-3.0-or-later */
+
+/*
+ * compile with
+ * gcc -O1 -ggdb -Wall -Wextra -I ../src/ -I ../ -o benchmark-registry benchmark-registry.c ../src/dictionary.o ../src/log.o ../src/avl.o ../src/common.o ../src/appconfig.o ../src/web_buffer.o ../src/storage_number.o ../src/rrd.o ../src/health.o -pthread -luuid -lm -DHAVE_CONFIG_H -DVARLIB_DIR="\"/tmp\""
+ */
+
+char *hostname = "me";
+
+#include "../src/registry.c"
+
+void netdata_cleanup_and_exit(int ret) { exit(ret); }
+
+// ----------------------------------------------------------------------------
+// TESTS
+
+int test1(int argc, char **argv) {
+
+ void print_stats(uint32_t requests, unsigned long long start, unsigned long long end) {
+ fprintf(stderr, " > SPEED: %u requests served in %0.2f seconds ( >>> %llu per second <<< )\n",
+ requests, (end-start) / 1000000.0, (unsigned long long)requests * 1000000ULL / (end-start));
+
+ fprintf(stderr, " > DB : persons %llu, machines %llu, unique URLs %llu, accesses %llu, URLs: for persons %llu, for machines %llu\n",
+ registry.persons_count, registry.machines_count, registry.urls_count, registry.usages_count,
+ registry.persons_urls_count, registry.machines_urls_count);
+ }
+
+ (void) argc;
+ (void) argv;
+
+ uint32_t u, users = 1000000;
+ uint32_t m, machines = 200000;
+ uint32_t machines2 = machines * 2;
+
+ char **users_guids = malloc(users * sizeof(char *));
+ char **machines_guids = malloc(machines2 * sizeof(char *));
+ char **machines_urls = malloc(machines2 * sizeof(char *));
+ unsigned long long start;
+
+ registry_init();
+
+ fprintf(stderr, "Generating %u machine guids\n", machines2);
+ for(m = 0; m < machines2 ;m++) {
+ uuid_t uuid;
+ machines_guids[m] = malloc(36+1);
+ uuid_generate(uuid);
+ uuid_unparse(uuid, machines_guids[m]);
+
+ char buf[FILENAME_MAX + 1];
+ snprintfz(buf, FILENAME_MAX, "http://%u.netdata.rocks/", m+1);
+ machines_urls[m] = strdup(buf);
+
+ // fprintf(stderr, "\tmachine %u: '%s', url: '%s'\n", m + 1, machines_guids[m], machines_urls[m]);
+ }
+
+ start = timems();
+ fprintf(stderr, "\nGenerating %u users accessing %u machines\n", users, machines);
+ m = 0;
+ time_t now = time(NULL);
+ for(u = 0; u < users ; u++) {
+ if(++m == machines) m = 0;
+
+ PERSON *p = registry_request_access(NULL, machines_guids[m], machines_urls[m], "test", now);
+ users_guids[u] = p->guid;
+ }
+ print_stats(u, start, timems());
+
+ start = timems();
+ fprintf(stderr, "\nAll %u users accessing again the same %u servers\n", users, machines);
+ m = 0;
+ now = time(NULL);
+ for(u = 0; u < users ; u++) {
+ if(++m == machines) m = 0;
+
+ PERSON *p = registry_request_access(users_guids[u], machines_guids[m], machines_urls[m], "test", now);
+
+ if(p->guid != users_guids[u])
+ fprintf(stderr, "ERROR: expected to get user guid '%s' but git '%s'", users_guids[u], p->guid);
+ }
+ print_stats(u, start, timems());
+
+ start = timems();
+ fprintf(stderr, "\nAll %u users accessing a new server, out of the %u servers\n", users, machines);
+ m = 1;
+ now = time(NULL);
+ for(u = 0; u < users ; u++) {
+ if(++m == machines) m = 0;
+
+ PERSON *p = registry_request_access(users_guids[u], machines_guids[m], machines_urls[m], "test", now);
+
+ if(p->guid != users_guids[u])
+ fprintf(stderr, "ERROR: expected to get user guid '%s' but git '%s'", users_guids[u], p->guid);
+ }
+ print_stats(u, start, timems());
+
+ start = timems();
+ fprintf(stderr, "\n%u random users accessing a random server, out of the %u servers\n", users, machines);
+ now = time(NULL);
+ for(u = 0; u < users ; u++) {
+ uint32_t tu = random() * users / RAND_MAX;
+ uint32_t tm = random() * machines / RAND_MAX;
+
+ PERSON *p = registry_request_access(users_guids[tu], machines_guids[tm], machines_urls[tm], "test", now);
+
+ if(p->guid != users_guids[tu])
+ fprintf(stderr, "ERROR: expected to get user guid '%s' but git '%s'", users_guids[tu], p->guid);
+ }
+ print_stats(u, start, timems());
+
+ start = timems();
+ fprintf(stderr, "\n%u random users accessing a random server, out of %u servers\n", users, machines2);
+ now = time(NULL);
+ for(u = 0; u < users ; u++) {
+ uint32_t tu = random() * users / RAND_MAX;
+ uint32_t tm = random() * machines2 / RAND_MAX;
+
+ PERSON *p = registry_request_access(users_guids[tu], machines_guids[tm], machines_urls[tm], "test", now);
+
+ if(p->guid != users_guids[tu])
+ fprintf(stderr, "ERROR: expected to get user guid '%s' but git '%s'", users_guids[tu], p->guid);
+ }
+ print_stats(u, start, timems());
+
+ for(m = 0; m < 10; m++) {
+ start = timems();
+ fprintf(stderr,
+ "\n%u random user accesses to a random server, out of %u servers,\n > using 1/10000 with a random url, 1/1000 with a mismatched url\n",
+ users * 2, machines2);
+ now = time(NULL);
+ for (u = 0; u < users * 2; u++) {
+ uint32_t tu = random() * users / RAND_MAX;
+ uint32_t tm = random() * machines2 / RAND_MAX;
+
+ char *url = machines_urls[tm];
+ char buf[FILENAME_MAX + 1];
+ if (random() % 10000 == 1234) {
+ snprintfz(buf, FILENAME_MAX, "http://random.%ld.netdata.rocks/", random());
+ url = buf;
+ }
+ else if (random() % 1000 == 123)
+ url = machines_urls[random() * machines2 / RAND_MAX];
+
+ PERSON *p = registry_request_access(users_guids[tu], machines_guids[tm], url, "test", now);
+
+ if (p->guid != users_guids[tu])
+ fprintf(stderr, "ERROR: expected to get user guid '%s' but git '%s'", users_guids[tu], p->guid);
+ }
+ print_stats(u, start, timems());
+ }
+
+ fprintf(stderr, "\n\nSAVE\n");
+ start = timems();
+ registry_save();
+ print_stats(registry.persons_count, start, timems());
+
+ fprintf(stderr, "\n\nCLEANUP\n");
+ start = timems();
+ registry_free();
+ print_stats(registry.persons_count, start, timems());
+ return 0;
+}
+
+// ----------------------------------------------------------------------------
+// TESTING
+
+int main(int argc, char **argv) {
+ config_set_boolean("registry", "enabled", 1);
+
+ //debug_flags = 0xFFFFFFFF;
+ test1(argc, argv);
+ exit(0);
+
+ (void)argc;
+ (void)argv;
+
+
+ PERSON *p1, *p2;
+
+ fprintf(stderr, "\n\nINITIALIZATION\n");
+
+ registry_init();
+
+ int i = 2;
+
+ fprintf(stderr, "\n\nADDING ENTRY\n");
+ p1 = registry_request_access("2c95abd0-1542-11e6-8c66-00508db7e9c9", "7c173980-145c-11e6-b86f-00508db7e9c1", "http://localhost:19999/", "test", time(NULL));
+
+ if(0)
+ while(i--) {
+#ifdef REGISTRY_STDOUT_DUMP
+ fprintf(stderr, "\n\nADDING ENTRY\n");
+#endif /* REGISTRY_STDOUT_DUMP */
+ p1 = registry_request_access(NULL, "7c173980-145c-11e6-b86f-00508db7e9c1", "http://localhost:19999/", "test", time(NULL));
+
+#ifdef REGISTRY_STDOUT_DUMP
+ fprintf(stderr, "\n\nADDING ANOTHER URL\n");
+#endif /* REGISTRY_STDOUT_DUMP */
+ p1 = registry_request_access(p1->guid, "7c173980-145c-11e6-b86f-00508db7e9c1", "http://127.0.0.1:19999/", "test", time(NULL));
+
+#ifdef REGISTRY_STDOUT_DUMP
+ fprintf(stderr, "\n\nADDING ANOTHER URL\n");
+#endif /* REGISTRY_STDOUT_DUMP */
+ p1 = registry_request_access(p1->guid, "7c173980-145c-11e6-b86f-00508db7e9c1", "http://my.server:19999/", "test", time(NULL));
+
+#ifdef REGISTRY_STDOUT_DUMP
+ fprintf(stderr, "\n\nADDING ANOTHER MACHINE\n");
+#endif /* REGISTRY_STDOUT_DUMP */
+ p1 = registry_request_access(p1->guid, "7c173980-145c-11e6-b86f-00508db7e9c1", "http://my.server:19999/", "test", time(NULL));
+
+#ifdef REGISTRY_STDOUT_DUMP
+ fprintf(stderr, "\n\nADDING ANOTHER PERSON\n");
+#endif /* REGISTRY_STDOUT_DUMP */
+ p2 = registry_request_access(NULL, "7c173980-145c-11e6-b86f-00508db7e9c3", "http://localhost:19999/", "test", time(NULL));
+
+#ifdef REGISTRY_STDOUT_DUMP
+ fprintf(stderr, "\n\nADDING ANOTHER MACHINE\n");
+#endif /* REGISTRY_STDOUT_DUMP */
+ p2 = registry_request_access(p2->guid, "7c173980-145c-11e6-b86f-00508db7e9c3", "http://localhost:19999/", "test", time(NULL));
+ }
+
+ fprintf(stderr, "\n\nSAVE\n");
+ registry_save();
+
+ fprintf(stderr, "\n\nCLEANUP\n");
+ registry_free();
+ return 0;
+}
diff --git a/tests/profile/benchmark-value-pairs.c b/tests/profile/benchmark-value-pairs.c
new file mode 100644
index 0000000..ae4f53c
--- /dev/null
+++ b/tests/profile/benchmark-value-pairs.c
@@ -0,0 +1,623 @@
+/* SPDX-License-Identifier: GPL-3.0-or-later */
+
+#include "config.h"
+#include "libnetdata/libnetdata.h"
+
+#ifdef simple_hash
+#undef simple_hash
+#endif
+
+void netdata_cleanup_and_exit(int ret) {
+ exit(ret);
+}
+
+#define simple_hash(name) ({ \
+ register unsigned char *__hash_source = (unsigned char *)(name); \
+ register uint32_t __hash_value = 0x811c9dc5; \
+ while (*__hash_source) { \
+ __hash_value *= 16777619; \
+ __hash_value ^= (uint32_t) *__hash_source++; \
+ } \
+ __hash_value; \
+})
+
+static inline uint32_t simple_hash2(const char *name) {
+ register unsigned char *s = (unsigned char *)name;
+ register uint32_t hval = 0x811c9dc5;
+ while (*s) {
+ hval *= 16777619;
+ hval ^= (uint32_t) *s++;
+ }
+ return hval;
+}
+
+static inline unsigned long long fast_strtoull(const char *s) {
+ register unsigned long long n = 0;
+ register char c;
+ for(c = *s; c >= '0' && c <= '9' ; c = *(++s)) {
+ n *= 10;
+ n += c - '0';
+ // n = (n << 1) + (n << 3) + (c - '0');
+ }
+ return n;
+}
+
+static uint32_t cache_hash = 0;
+static uint32_t rss_hash = 0;
+static uint32_t rss_huge_hash = 0;
+static uint32_t mapped_file_hash = 0;
+static uint32_t writeback_hash = 0;
+static uint32_t dirty_hash = 0;
+static uint32_t swap_hash = 0;
+static uint32_t pgpgin_hash = 0;
+static uint32_t pgpgout_hash = 0;
+static uint32_t pgfault_hash = 0;
+static uint32_t pgmajfault_hash = 0;
+static uint32_t inactive_anon_hash = 0;
+static uint32_t active_anon_hash = 0;
+static uint32_t inactive_file_hash = 0;
+static uint32_t active_file_hash = 0;
+static uint32_t unevictable_hash = 0;
+static uint32_t hierarchical_memory_limit_hash = 0;
+static uint32_t total_cache_hash = 0;
+static uint32_t total_rss_hash = 0;
+static uint32_t total_rss_huge_hash = 0;
+static uint32_t total_mapped_file_hash = 0;
+static uint32_t total_writeback_hash = 0;
+static uint32_t total_dirty_hash = 0;
+static uint32_t total_swap_hash = 0;
+static uint32_t total_pgpgin_hash = 0;
+static uint32_t total_pgpgout_hash = 0;
+static uint32_t total_pgfault_hash = 0;
+static uint32_t total_pgmajfault_hash = 0;
+static uint32_t total_inactive_anon_hash = 0;
+static uint32_t total_active_anon_hash = 0;
+static uint32_t total_inactive_file_hash = 0;
+static uint32_t total_active_file_hash = 0;
+static uint32_t total_unevictable_hash = 0;
+
+unsigned long long values1[50] = { 0 };
+unsigned long long values2[50] = { 0 };
+unsigned long long values3[50] = { 0 };
+unsigned long long values4[50] = { 0 };
+unsigned long long values5[50] = { 0 };
+unsigned long long values6[50] = { 0 };
+unsigned long long values7[50] = { 0 };
+unsigned long long values8[50] = { 0 };
+unsigned long long values9[50] = { 0 };
+
+struct pair {
+ const char *name;
+ const char *value;
+ uint32_t hash;
+ unsigned long long *collected8;
+ unsigned long long *collected9;
+} pairs[] = {
+ { "cache", "12345678901234", 0, &values8[0] ,&values9[0] },
+ { "rss", "23456789012345", 0, &values8[1] ,&values9[1] },
+ { "rss_huge", "34567890123456", 0, &values8[2] ,&values9[2] },
+ { "mapped_file", "45678901234567", 0, &values8[3] ,&values9[3] },
+ { "writeback", "56789012345678", 0, &values8[4] ,&values9[4] },
+ { "dirty", "67890123456789", 0, &values8[5] ,&values9[5] },
+ { "swap", "78901234567890", 0, &values8[6] ,&values9[6] },
+ { "pgpgin", "89012345678901", 0, &values8[7] ,&values9[7] },
+ { "pgpgout", "90123456789012", 0, &values8[8] ,&values9[8] },
+ { "pgfault", "10345678901234", 0, &values8[9] ,&values9[9] },
+ { "pgmajfault", "11456789012345", 0, &values8[10] ,&values9[10] },
+ { "inactive_anon", "12000000000000", 0, &values8[11] ,&values9[11] },
+ { "active_anon", "13345678901234", 0, &values8[12] ,&values9[12] },
+ { "inactive_file", "14345678901234", 0, &values8[13] ,&values9[13] },
+ { "active_file", "15345678901234", 0, &values8[14] ,&values9[14] },
+ { "unevictable", "16345678901234", 0, &values8[15] ,&values9[15] },
+ { "hierarchical_memory_limit", "17345678901234", 0, &values8[16] ,&values9[16] },
+ { "total_cache", "18345678901234", 0, &values8[17] ,&values9[17] },
+ { "total_rss", "19345678901234", 0, &values8[18] ,&values9[18] },
+ { "total_rss_huge", "20345678901234", 0, &values8[19] ,&values9[19] },
+ { "total_mapped_file", "21345678901234", 0, &values8[20] ,&values9[20] },
+ { "total_writeback", "22345678901234", 0, &values8[21] ,&values9[21] },
+ { "total_dirty", "23000000000000", 0, &values8[22] ,&values9[22] },
+ { "total_swap", "24345678901234", 0, &values8[23] ,&values9[23] },
+ { "total_pgpgin", "25345678901234", 0, &values8[24] ,&values9[24] },
+ { "total_pgpgout", "26345678901234", 0, &values8[25] ,&values9[25] },
+ { "total_pgfault", "27345678901234", 0, &values8[26] ,&values9[26] },
+ { "total_pgmajfault", "28345678901234", 0, &values8[27] ,&values9[27] },
+ { "total_inactive_anon", "29345678901234", 0, &values8[28] ,&values9[28] },
+ { "total_active_anon", "30345678901234", 0, &values8[29] ,&values9[29] },
+ { "total_inactive_file", "31345678901234", 0, &values8[30] ,&values9[30] },
+ { "total_active_file", "32345678901234", 0, &values8[31] ,&values9[31] },
+ { "total_unevictable", "33345678901234", 0, &values8[32] ,&values9[32] },
+ { NULL, NULL , 0, NULL ,NULL }
+};
+
+// simple system strcmp()
+void test1() {
+ int i;
+ for(i = 0; pairs[i].name ; i++) {
+ const char *s = pairs[i].name;
+ const char *v = pairs[i].value;
+
+ if(unlikely(!strcmp(s, "cache")))
+ values1[i] = strtoull(v, NULL, 10);
+
+ else if(unlikely(!strcmp(s, "rss")))
+ values1[i] = strtoull(v, NULL, 10);
+
+ else if(unlikely(!strcmp(s, "rss_huge")))
+ values1[i] = strtoull(v, NULL, 10);
+
+ else if(unlikely(!strcmp(s, "mapped_file")))
+ values1[i] = strtoull(v, NULL, 10);
+
+ else if(unlikely(!strcmp(s, "writeback")))
+ values1[i] = strtoull(v, NULL, 10);
+
+ else if(unlikely(!strcmp(s, "dirty")))
+ values1[i] = strtoull(v, NULL, 10);
+
+ else if(unlikely(!strcmp(s, "swap")))
+ values1[i] = strtoull(v, NULL, 10);
+
+ else if(unlikely(!strcmp(s, "pgpgin")))
+ values1[i] = strtoull(v, NULL, 10);
+
+ else if(unlikely(!strcmp(s, "pgpgout")))
+ values1[i] = strtoull(v, NULL, 10);
+
+ else if(unlikely(!strcmp(s, "pgfault")))
+ values1[i] = strtoull(v, NULL, 10);
+
+ else if(unlikely(!strcmp(s, "pgmajfault")))
+ values1[i] = strtoull(v, NULL, 10);
+ }
+}
+
+// inline simple_hash() with system strtoull()
+void test2() {
+ int i;
+ for(i = 0; pairs[i].name ; i++) {
+ const char *s = pairs[i].name;
+ const char *v = pairs[i].value;
+
+ uint32_t hash = simple_hash2(s);
+
+ if(unlikely(hash == cache_hash && !strcmp(s, "cache")))
+ values2[i] = strtoull(v, NULL, 10);
+
+ else if(unlikely(hash == rss_hash && !strcmp(s, "rss")))
+ values2[i] = strtoull(v, NULL, 10);
+
+ else if(unlikely(hash == rss_huge_hash && !strcmp(s, "rss_huge")))
+ values2[i] = strtoull(v, NULL, 10);
+
+ else if(unlikely(hash == mapped_file_hash && !strcmp(s, "mapped_file")))
+ values2[i] = strtoull(v, NULL, 10);
+
+ else if(unlikely(hash == writeback_hash && !strcmp(s, "writeback")))
+ values2[i] = strtoull(v, NULL, 10);
+
+ else if(unlikely(hash == dirty_hash && !strcmp(s, "dirty")))
+ values2[i] = strtoull(v, NULL, 10);
+
+ else if(unlikely(hash == swap_hash && !strcmp(s, "swap")))
+ values2[i] = strtoull(v, NULL, 10);
+
+ else if(unlikely(hash == pgpgin_hash && !strcmp(s, "pgpgin")))
+ values2[i] = strtoull(v, NULL, 10);
+
+ else if(unlikely(hash == pgpgout_hash && !strcmp(s, "pgpgout")))
+ values2[i] = strtoull(v, NULL, 10);
+
+ else if(unlikely(hash == pgfault_hash && !strcmp(s, "pgfault")))
+ values2[i] = strtoull(v, NULL, 10);
+
+ else if(unlikely(hash == pgmajfault_hash && !strcmp(s, "pgmajfault")))
+ values2[i] = strtoull(v, NULL, 10);
+ }
+}
+
+// statement expression simple_hash(), system strtoull()
+void test3() {
+ int i;
+ for(i = 0; pairs[i].name ; i++) {
+ const char *s = pairs[i].name;
+ const char *v = pairs[i].value;
+
+ uint32_t hash = simple_hash(s);
+
+ if(unlikely(hash == cache_hash && !strcmp(s, "cache")))
+ values3[i] = strtoull(v, NULL, 10);
+
+ else if(unlikely(hash == rss_hash && !strcmp(s, "rss")))
+ values3[i] = strtoull(v, NULL, 10);
+
+ else if(unlikely(hash == rss_huge_hash && !strcmp(s, "rss_huge")))
+ values3[i] = strtoull(v, NULL, 10);
+
+ else if(unlikely(hash == mapped_file_hash && !strcmp(s, "mapped_file")))
+ values3[i] = strtoull(v, NULL, 10);
+
+ else if(unlikely(hash == writeback_hash && !strcmp(s, "writeback")))
+ values3[i] = strtoull(v, NULL, 10);
+
+ else if(unlikely(hash == dirty_hash && !strcmp(s, "dirty")))
+ values3[i] = strtoull(v, NULL, 10);
+
+ else if(unlikely(hash == swap_hash && !strcmp(s, "swap")))
+ values3[i] = strtoull(v, NULL, 10);
+
+ else if(unlikely(hash == pgpgin_hash && !strcmp(s, "pgpgin")))
+ values3[i] = strtoull(v, NULL, 10);
+
+ else if(unlikely(hash == pgpgout_hash && !strcmp(s, "pgpgout")))
+ values3[i] = strtoull(v, NULL, 10);
+
+ else if(unlikely(hash == pgfault_hash && !strcmp(s, "pgfault")))
+ values3[i] = strtoull(v, NULL, 10);
+
+ else if(unlikely(hash == pgmajfault_hash && !strcmp(s, "pgmajfault")))
+ values3[i] = strtoull(v, NULL, 10);
+ }
+}
+
+
+// inline simple_hash(), if-continue checks
+void test4() {
+ int i;
+ for(i = 0; pairs[i].name ; i++) {
+ const char *s = pairs[i].name;
+ const char *v = pairs[i].value;
+
+ uint32_t hash = simple_hash2(s);
+
+ if(unlikely(hash == cache_hash && !strcmp(s, "cache"))) {
+ values4[i] = strtoull(v, NULL, 0);
+ continue;
+ }
+
+ if(unlikely(hash == rss_hash && !strcmp(s, "rss"))) {
+ values4[i] = strtoull(v, NULL, 0);
+ continue;
+ }
+
+ if(unlikely(hash == rss_huge_hash && !strcmp(s, "rss_huge"))) {
+ values4[i] = strtoull(v, NULL, 0);
+ continue;
+ }
+
+ if(unlikely(hash == mapped_file_hash && !strcmp(s, "mapped_file"))) {
+ values4[i] = strtoull(v, NULL, 0);
+ continue;
+ }
+
+ if(unlikely(hash == writeback_hash && !strcmp(s, "writeback"))) {
+ values4[i] = strtoull(v, NULL, 0);
+ continue;
+ }
+
+ if(unlikely(hash == dirty_hash && !strcmp(s, "dirty"))) {
+ values4[i] = strtoull(v, NULL, 0);
+ continue;
+ }
+
+ if(unlikely(hash == swap_hash && !strcmp(s, "swap"))) {
+ values4[i] = strtoull(v, NULL, 0);
+ continue;
+ }
+
+ if(unlikely(hash == pgpgin_hash && !strcmp(s, "pgpgin"))) {
+ values4[i] = strtoull(v, NULL, 0);
+ continue;
+ }
+
+ if(unlikely(hash == pgpgout_hash && !strcmp(s, "pgpgout"))) {
+ values4[i] = strtoull(v, NULL, 0);
+ continue;
+ }
+
+ if(unlikely(hash == pgfault_hash && !strcmp(s, "pgfault"))) {
+ values4[i] = strtoull(v, NULL, 0);
+ continue;
+ }
+
+ if(unlikely(hash == pgmajfault_hash && !strcmp(s, "pgmajfault"))) {
+ values4[i] = strtoull(v, NULL, 0);
+ continue;
+ }
+ }
+}
+
+// inline simple_hash(), if-else-if-else-if (netdata default)
+void test5() {
+ int i;
+ for(i = 0; pairs[i].name ; i++) {
+ const char *s = pairs[i].name;
+ const char *v = pairs[i].value;
+
+ uint32_t hash = simple_hash2(s);
+
+ if(unlikely(hash == cache_hash && !strcmp(s, "cache")))
+ values5[i] = fast_strtoull(v);
+
+ else if(unlikely(hash == rss_hash && !strcmp(s, "rss")))
+ values5[i] = fast_strtoull(v);
+
+ else if(unlikely(hash == rss_huge_hash && !strcmp(s, "rss_huge")))
+ values5[i] = fast_strtoull(v);
+
+ else if(unlikely(hash == mapped_file_hash && !strcmp(s, "mapped_file")))
+ values5[i] = fast_strtoull(v);
+
+ else if(unlikely(hash == writeback_hash && !strcmp(s, "writeback")))
+ values5[i] = fast_strtoull(v);
+
+ else if(unlikely(hash == dirty_hash && !strcmp(s, "dirty")))
+ values5[i] = fast_strtoull(v);
+
+ else if(unlikely(hash == swap_hash && !strcmp(s, "swap")))
+ values5[i] = fast_strtoull(v);
+
+ else if(unlikely(hash == pgpgin_hash && !strcmp(s, "pgpgin")))
+ values5[i] = fast_strtoull(v);
+
+ else if(unlikely(hash == pgpgout_hash && !strcmp(s, "pgpgout")))
+ values5[i] = fast_strtoull(v);
+
+ else if(unlikely(hash == pgfault_hash && !strcmp(s, "pgfault")))
+ values5[i] = fast_strtoull(v);
+
+ else if(unlikely(hash == pgmajfault_hash && !strcmp(s, "pgmajfault")))
+ values5[i] = fast_strtoull(v);
+ }
+}
+
+// ----------------------------------------------------------------------------
+
+void arl_strtoull(const char *name, uint32_t hash, const char *value, void *dst) {
+ (void)name;
+ (void)hash;
+
+ register unsigned long long *d = dst;
+ *d = strtoull(value, NULL, 10);
+ // fprintf(stderr, "name '%s' with hash %u and value '%s' is %llu\n", name, hash, value, *d);
+}
+
+void test6() {
+ static ARL_BASE *base = NULL;
+
+ if(unlikely(!base)) {
+ base = arl_create("test6", arl_strtoull, 60);
+ arl_expect_custom(base, "cache", NULL, &values6[0]);
+ arl_expect_custom(base, "rss", NULL, &values6[1]);
+ arl_expect_custom(base, "rss_huge", NULL, &values6[2]);
+ arl_expect_custom(base, "mapped_file", NULL, &values6[3]);
+ arl_expect_custom(base, "writeback", NULL, &values6[4]);
+ arl_expect_custom(base, "dirty", NULL, &values6[5]);
+ arl_expect_custom(base, "swap", NULL, &values6[6]);
+ arl_expect_custom(base, "pgpgin", NULL, &values6[7]);
+ arl_expect_custom(base, "pgpgout", NULL, &values6[8]);
+ arl_expect_custom(base, "pgfault", NULL, &values6[9]);
+ arl_expect_custom(base, "pgmajfault", NULL, &values6[10]);
+ }
+
+ arl_begin(base);
+
+ int i;
+ for(i = 0; pairs[i].name ; i++)
+ if(arl_check(base, pairs[i].name, pairs[i].value)) break;
+}
+
+void arl_str2ull(const char *name, uint32_t hash, const char *value, void *dst) {
+ (void)name;
+ (void)hash;
+
+ register unsigned long long *d = dst;
+ *d = str2ull(value);
+ // fprintf(stderr, "name '%s' with hash %u and value '%s' is %llu\n", name, hash, value, *d);
+}
+
+void test7() {
+ static ARL_BASE *base = NULL;
+
+ if(unlikely(!base)) {
+ base = arl_create("test7", arl_str2ull, 60);
+ arl_expect_custom(base, "cache", NULL, &values7[0]);
+ arl_expect_custom(base, "rss", NULL, &values7[1]);
+ arl_expect_custom(base, "rss_huge", NULL, &values7[2]);
+ arl_expect_custom(base, "mapped_file", NULL, &values7[3]);
+ arl_expect_custom(base, "writeback", NULL, &values7[4]);
+ arl_expect_custom(base, "dirty", NULL, &values7[5]);
+ arl_expect_custom(base, "swap", NULL, &values7[6]);
+ arl_expect_custom(base, "pgpgin", NULL, &values7[7]);
+ arl_expect_custom(base, "pgpgout", NULL, &values7[8]);
+ arl_expect_custom(base, "pgfault", NULL, &values7[9]);
+ arl_expect_custom(base, "pgmajfault", NULL, &values7[10]);
+ }
+
+ arl_begin(base);
+
+ int i;
+ for(i = 0; pairs[i].name ; i++)
+ if(arl_check(base, pairs[i].name, pairs[i].value)) break;
+}
+
+void test8() {
+ int i;
+ for(i = 0; pairs[i].name; i++) {
+ uint32_t hash = simple_hash(pairs[i].name);
+
+ int j;
+ for(j = 0; pairs[j].name; j++) {
+ if(hash == pairs[j].hash && !strcmp(pairs[i].name, pairs[j].name)) {
+ *pairs[j].collected8 = strtoull(pairs[i].value, NULL, 10);
+ break;
+ }
+ }
+ }
+}
+
+void test9() {
+ int i;
+ for(i = 0; pairs[i].name; i++) {
+ uint32_t hash = simple_hash(pairs[i].name);
+
+ int j;
+ for(j = 0; pairs[j].name; j++) {
+ if(hash == pairs[j].hash && !strcmp(pairs[i].name, pairs[j].name)) {
+ *pairs[j].collected9 = str2ull(pairs[i].value);
+ break;
+ }
+ }
+ }
+}
+
+// ----------------------------------------------------------------------------
+
+/*
+// ==============
+// --- Poor man cycle counting.
+static unsigned long tsc;
+
+static void begin_tsc(void)
+{
+ unsigned long a, d;
+ asm volatile ("cpuid\nrdtsc" : "=a" (a), "=d" (d) : "0" (0) : "ebx", "ecx");
+ tsc = ((unsigned long)d << 32) | (unsigned long)a;
+}
+
+static unsigned long end_tsc(void)
+{
+ unsigned long a, d;
+ asm volatile ("rdtscp" : "=a" (a), "=d" (d) : : "ecx");
+ return (((unsigned long)d << 32) | (unsigned long)a) - tsc;
+}
+// ===============
+*/
+
+static unsigned long long clk;
+
+static void begin_clock() {
+ struct timeval tv;
+ if(unlikely(gettimeofday(&tv, NULL) == -1))
+ return;
+ clk = tv.tv_sec * 1000000 + tv.tv_usec;
+}
+
+static unsigned long long end_clock() {
+ struct timeval tv;
+ if(unlikely(gettimeofday(&tv, NULL) == -1))
+ return -1;
+ return clk = tv.tv_sec * 1000000 + tv.tv_usec - clk;
+}
+
+int main(void)
+{
+ {
+ int i;
+ for(i = 0; pairs[i].name; i++)
+ pairs[i].hash = simple_hash(pairs[i].name);
+ }
+
+ cache_hash = simple_hash("cache");
+ rss_hash = simple_hash("rss");
+ rss_huge_hash = simple_hash("rss_huge");
+ mapped_file_hash = simple_hash("mapped_file");
+ writeback_hash = simple_hash("writeback");
+ dirty_hash = simple_hash("dirty");
+ swap_hash = simple_hash("swap");
+ pgpgin_hash = simple_hash("pgpgin");
+ pgpgout_hash = simple_hash("pgpgout");
+ pgfault_hash = simple_hash("pgfault");
+ pgmajfault_hash = simple_hash("pgmajfault");
+ inactive_anon_hash = simple_hash("inactive_anon");
+ active_anon_hash = simple_hash("active_anon");
+ inactive_file_hash = simple_hash("inactive_file");
+ active_file_hash = simple_hash("active_file");
+ unevictable_hash = simple_hash("unevictable");
+ hierarchical_memory_limit_hash = simple_hash("hierarchical_memory_limit");
+ total_cache_hash = simple_hash("total_cache");
+ total_rss_hash = simple_hash("total_rss");
+ total_rss_huge_hash = simple_hash("total_rss_huge");
+ total_mapped_file_hash = simple_hash("total_mapped_file");
+ total_writeback_hash = simple_hash("total_writeback");
+ total_dirty_hash = simple_hash("total_dirty");
+ total_swap_hash = simple_hash("total_swap");
+ total_pgpgin_hash = simple_hash("total_pgpgin");
+ total_pgpgout_hash = simple_hash("total_pgpgout");
+ total_pgfault_hash = simple_hash("total_pgfault");
+ total_pgmajfault_hash = simple_hash("total_pgmajfault");
+ total_inactive_anon_hash = simple_hash("total_inactive_anon");
+ total_active_anon_hash = simple_hash("total_active_anon");
+ total_inactive_file_hash = simple_hash("total_inactive_file");
+ total_active_file_hash = simple_hash("total_active_file");
+ total_unevictable_hash = simple_hash("total_unevictable");
+
+ // cache functions
+ (void)simple_hash2("hello world");
+ (void)strcmp("1", "2");
+ (void)strtoull("123", NULL, 0);
+
+ unsigned long i, c1 = 0, c2 = 0, c3 = 0, c4 = 0, c5 = 0, c6 = 0, c7 = 0, c8 = 0, c9 = 0;
+ unsigned long max = 1000000;
+
+ begin_clock();
+ for(i = 0; i <= max ;i++) test1();
+ c1 = end_clock();
+
+ begin_clock();
+ for(i = 0; i <= max ;i++) test2();
+ c2 = end_clock();
+
+ begin_clock();
+ for(i = 0; i <= max ;i++) test3();
+ c3 = end_clock();
+
+ begin_clock();
+ for(i = 0; i <= max ;i++) test4();
+ c4 = end_clock();
+
+ begin_clock();
+ for(i = 0; i <= max ;i++) test5();
+ c5 = end_clock();
+
+ begin_clock();
+ for(i = 0; i <= max ;i++) test6();
+ c6 = end_clock();
+
+ begin_clock();
+ for(i = 0; i <= max ;i++) test7();
+ c7 = end_clock();
+
+ begin_clock();
+ for(i = 0; i <= max ;i++) test8();
+ c8 = end_clock();
+
+ begin_clock();
+ for(i = 0; i <= max ;i++) test9();
+ c9 = end_clock();
+
+ for(i = 0; i < 11 ; i++)
+ printf("value %lu: %llu %llu %llu %llu %llu %llu %llu %llu %llu\n", i, values1[i], values2[i], values3[i], values4[i], values5[i], values6[i], values7[i], values8[i], values9[i]);
+
+ printf("\n\nRESULTS\n");
+ printf("test1() [1] in %lu usecs: simple system strcmp().\n"
+ "test2() [4] in %lu usecs: inline simple_hash() with system strtoull().\n"
+ "test3() [5] in %lu usecs: statement expression simple_hash(), system strtoull().\n"
+ "test4() [6] in %lu usecs: inline simple_hash(), if-continue checks.\n"
+ "test5() [7] in %lu usecs: inline simple_hash(), if-else-if-else-if (netdata default prior to ARL).\n"
+ "test6() [8] in %lu usecs: adaptive re-sortable array with strtoull() (wow!)\n"
+ "test7() [9] in %lu usecs: adaptive re-sortable array with str2ull() (wow!)\n"
+ "test8() [2] in %lu usecs: nested loop with strtoull()\n"
+ "test9() [3] in %lu usecs: nested loop with str2ull()\n"
+ , c1
+ , c2
+ , c3
+ , c4
+ , c5
+ , c6
+ , c7
+ , c8
+ , c9
+ );
+
+ return 0;
+}
diff --git a/tests/profile/statsd-stress.c b/tests/profile/statsd-stress.c
new file mode 100644
index 0000000..435d58d
--- /dev/null
+++ b/tests/profile/statsd-stress.c
@@ -0,0 +1,151 @@
+/* SPDX-License-Identifier: GPL-3.0-or-later */
+#include <stdlib.h>
+#include <arpa/inet.h>
+#include <netinet/in.h>
+#include <stdio.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <unistd.h>
+#include <string.h>
+#include <time.h>
+#include <pthread.h>
+
+void diep(char *s)
+{
+ perror(s);
+ exit(1);
+}
+
+size_t run_threads = 1;
+size_t metrics = 1024;
+
+#define SERVER_IP "127.0.0.1"
+#define PORT 8125
+
+size_t myrand(size_t max) {
+ size_t loops = max / RAND_MAX;
+ size_t i;
+
+ size_t ret = rand();
+ for(i = 0; i < loops ;i++)
+ ret += rand();
+
+ return ret % max;
+}
+
+struct thread_data {
+ size_t id;
+ struct sockaddr_in *si_other;
+ int slen;
+ size_t counter;
+};
+
+static void *report_thread(void *__data) {
+ struct thread_data *data = (struct thread_data *)__data;
+
+ size_t last = 0;
+ for (;;) {
+ size_t i;
+ size_t total = 0;
+ for(i = 0; i < run_threads ;i++)
+ total += data[i].counter;
+
+ printf("%zu metrics/s\n", total-last);
+ last = total;
+
+ sleep(1);
+ printf("\033[F\033[J");
+ }
+
+ return NULL;
+}
+
+char *types[] = {"g", "c", "m", "ms", "h", "s", NULL};
+// char *types[] = {"g", "c", "C", "h", "ms", NULL}; // brubeck compatible
+
+static void *spam_thread(void *__data) {
+ struct thread_data *data = (struct thread_data *)__data;
+
+ int s;
+ char packet[1024];
+
+ if ((s = socket(AF_INET, SOCK_DGRAM, 0))==-1)
+ diep("socket");
+
+ char **packets = malloc(sizeof(char *) * metrics);
+ size_t i, *lengths = malloc(sizeof(size_t) * metrics);
+ size_t t;
+
+ for(i = 0, t = 0; i < metrics ;i++, t++) {
+ if(!types[t]) t = 0;
+ char *type = types[t];
+
+ lengths[i] = sprintf(packet, "stress.%s.t%zu.m%zu:%zu|%s", type, data->id, i, myrand(metrics), type);
+ packets[i] = strdup(packet);
+ // printf("packet %zu, of length %zu: '%s'\n", i, lengths[i], packets[i]);
+ }
+ //printf("\n");
+
+ for (;;) {
+ for(i = 0; i < metrics ;i++) {
+ if (sendto(s, packets[i], lengths[i], 0, (void *)data->si_other, data->slen) < 0) {
+ printf("C ==> DROPPED\n");
+ return NULL;
+ }
+ data->counter++;
+ }
+ }
+
+ free(packets);
+ free(lengths);
+ close(s);
+ return NULL;
+}
+
+int main(int argc, char *argv[])
+{
+ if (argc != 5) {
+ fprintf(stderr, "Usage: '%s THREADS METRICS IP PORT'\n", argv[0]);
+ exit(-1);
+ }
+
+ run_threads = atoi(argv[1]);
+ metrics = atoi(argv[2]);
+ char *ip = argv[3];
+ int port = atoi(argv[4]);
+
+ struct thread_data data[run_threads];
+ struct sockaddr_in si_other;
+ pthread_t threads[run_threads], report;
+ size_t i;
+
+ srand(time(NULL));
+
+ memset(&si_other, 0, sizeof(si_other));
+ si_other.sin_family = AF_INET;
+ si_other.sin_port = htons(port);
+ if (inet_aton(ip, &si_other.sin_addr)==0) {
+ fprintf(stderr, "inet_aton() of ip '%s' failed\n", ip);
+ exit(1);
+ }
+
+ for (i = 0; i < run_threads; ++i) {
+ data[i].id = i;
+ data[i].si_other = &si_other;
+ data[i].slen = sizeof(si_other);
+ data[i].counter = 0;
+ pthread_create(&threads[i], NULL, spam_thread, &data[i]);
+ }
+
+ printf("\n");
+ printf("THREADS : %zu\n", run_threads);
+ printf("METRICS : %zu\n", metrics);
+ printf("DESTINATION : %s:%d\n", ip, port);
+ printf("\n");
+ pthread_create(&report, NULL, report_thread, &data);
+
+ for (i =0; i < run_threads; ++i)
+ pthread_join(threads[i], NULL);
+
+ return 0;
+}
diff --git a/tests/profile/test-eval.c b/tests/profile/test-eval.c
new file mode 100644
index 0000000..3c46316
--- /dev/null
+++ b/tests/profile/test-eval.c
@@ -0,0 +1,289 @@
+/* SPDX-License-Identifier: GPL-3.0-or-later */
+
+/*
+ * 1. build netdata (as normally)
+ * 2. cd profile/
+ * 3. compile with:
+ * gcc -O1 -ggdb -Wall -Wextra -I ../src/ -I ../ -o test-eval test-eval.c ../src/log.o ../src/eval.o ../src/common.o ../src/clocks.o ../src/web_buffer.o ../src/storage_number.o -pthread -lm
+ */
+
+#include "config.h"
+#include "libnetdata/libnetdata.h"
+#include "libnetdata/required_dummies.h"
+#include "database/rrdcalc.h"
+
+/*
+void indent(int level, int show) {
+ int i = level;
+ while(i--) printf(" | ");
+ if(show) printf(" \\_ ");
+ else printf(" \\_ ");
+}
+
+void print_node(EVAL_NODE *op, int level);
+
+void print_value(EVAL_VALUE *v, int level) {
+ indent(level, 0);
+
+ switch(v->type) {
+ case EVAL_VALUE_INVALID:
+ printf("value (NOP)\n");
+ break;
+
+ case EVAL_VALUE_NUMBER:
+ printf("value %Lf (NUMBER)\n", v->number);
+ break;
+
+ case EVAL_VALUE_EXPRESSION:
+ printf("value (SUB-EXPRESSION)\n");
+ print_node(v->expression, level+1);
+ break;
+
+ default:
+ printf("value (INVALID type %d)\n", v->type);
+ break;
+
+ }
+}
+
+void print_node(EVAL_NODE *op, int level) {
+
+// if(op->operator != EVAL_OPERATOR_NOP) {
+ indent(level, 1);
+ if(op->operator) printf("%c (node %d, precedence: %d)\n", op->operator, op->id, op->precedence);
+ else printf("NOP (node %d, precedence: %d)\n", op->id, op->precedence);
+// }
+
+ int i = op->count;
+ while(i--) print_value(&op->ops[i], level + 1);
+}
+
+NETDATA_DOUBLE evaluate(EVAL_NODE *op, int depth);
+
+NETDATA_DOUBLE evaluate_value(EVAL_VALUE *v, int depth) {
+ switch(v->type) {
+ case EVAL_VALUE_NUMBER:
+ return v->number;
+
+ case EVAL_VALUE_EXPRESSION:
+ return evaluate(v->expression, depth);
+
+ default:
+ fatal("I don't know how to handle EVAL_VALUE type %d", v->type);
+ }
+}
+
+void print_depth(int depth) {
+ static int count = 0;
+
+ printf("%d. ", ++count);
+ while(depth--) printf(" ");
+}
+
+NETDATA_DOUBLE evaluate(EVAL_NODE *op, int depth) {
+ NETDATA_DOUBLE n1, n2, r;
+
+ switch(op->operator) {
+ case EVAL_OPERATOR_SIGN_PLUS:
+ r = evaluate_value(&op->ops[0], depth);
+ break;
+
+ case EVAL_OPERATOR_SIGN_MINUS:
+ r = -evaluate_value(&op->ops[0], depth);
+ break;
+
+ case EVAL_OPERATOR_PLUS:
+ if(op->count != 2)
+ fatal("Operator '%c' requires 2 values, but we have %d", op->operator, op->count);
+ n1 = evaluate_value(&op->ops[0], depth);
+ n2 = evaluate_value(&op->ops[1], depth);
+ r = n1 + n2;
+ print_depth(depth);
+ printf("%Lf = %Lf + %Lf\n", r, n1, n2);
+ break;
+
+ case EVAL_OPERATOR_MINUS:
+ if(op->count != 2)
+ fatal("Operator '%c' requires 2 values, but we have %d", op->operator, op->count);
+ n1 = evaluate_value(&op->ops[0], depth);
+ n2 = evaluate_value(&op->ops[1], depth);
+ r = n1 - n2;
+ print_depth(depth);
+ printf("%Lf = %Lf - %Lf\n", r, n1, n2);
+ break;
+
+ case EVAL_OPERATOR_MULTIPLY:
+ if(op->count != 2)
+ fatal("Operator '%c' requires 2 values, but we have %d", op->operator, op->count);
+ n1 = evaluate_value(&op->ops[0], depth);
+ n2 = evaluate_value(&op->ops[1], depth);
+ r = n1 * n2;
+ print_depth(depth);
+ printf("%Lf = %Lf * %Lf\n", r, n1, n2);
+ break;
+
+ case EVAL_OPERATOR_DIVIDE:
+ if(op->count != 2)
+ fatal("Operator '%c' requires 2 values, but we have %d", op->operator, op->count);
+ n1 = evaluate_value(&op->ops[0], depth);
+ n2 = evaluate_value(&op->ops[1], depth);
+ r = n1 / n2;
+ print_depth(depth);
+ printf("%Lf = %Lf / %Lf\n", r, n1, n2);
+ break;
+
+ case EVAL_OPERATOR_NOT:
+ n1 = evaluate_value(&op->ops[0], depth);
+ r = !n1;
+ print_depth(depth);
+ printf("%Lf = NOT %Lf\n", r, n1);
+ break;
+
+ case EVAL_OPERATOR_AND:
+ if(op->count != 2)
+ fatal("Operator '%c' requires 2 values, but we have %d", op->operator, op->count);
+ n1 = evaluate_value(&op->ops[0], depth);
+ n2 = evaluate_value(&op->ops[1], depth);
+ r = n1 && n2;
+ print_depth(depth);
+ printf("%Lf = %Lf AND %Lf\n", r, n1, n2);
+ break;
+
+ case EVAL_OPERATOR_OR:
+ if(op->count != 2)
+ fatal("Operator '%c' requires 2 values, but we have %d", op->operator, op->count);
+ n1 = evaluate_value(&op->ops[0], depth);
+ n2 = evaluate_value(&op->ops[1], depth);
+ r = n1 || n2;
+ print_depth(depth);
+ printf("%Lf = %Lf OR %Lf\n", r, n1, n2);
+ break;
+
+ case EVAL_OPERATOR_GREATER_THAN_OR_EQUAL:
+ if(op->count != 2)
+ fatal("Operator '%c' requires 2 values, but we have %d", op->operator, op->count);
+ n1 = evaluate_value(&op->ops[0], depth);
+ n2 = evaluate_value(&op->ops[1], depth);
+ r = n1 >= n2;
+ print_depth(depth);
+ printf("%Lf = %Lf >= %Lf\n", r, n1, n2);
+ break;
+
+ case EVAL_OPERATOR_LESS_THAN_OR_EQUAL:
+ if(op->count != 2)
+ fatal("Operator '%c' requires 2 values, but we have %d", op->operator, op->count);
+ n1 = evaluate_value(&op->ops[0], depth);
+ n2 = evaluate_value(&op->ops[1], depth);
+ r = n1 <= n2;
+ print_depth(depth);
+ printf("%Lf = %Lf <= %Lf\n", r, n1, n2);
+ break;
+
+ case EVAL_OPERATOR_GREATER:
+ if(op->count != 2)
+ fatal("Operator '%c' requires 2 values, but we have %d", op->operator, op->count);
+ n1 = evaluate_value(&op->ops[0], depth);
+ n2 = evaluate_value(&op->ops[1], depth);
+ r = n1 > n2;
+ print_depth(depth);
+ printf("%Lf = %Lf > %Lf\n", r, n1, n2);
+ break;
+
+ case EVAL_OPERATOR_LESS:
+ if(op->count != 2)
+ fatal("Operator '%c' requires 2 values, but we have %d", op->operator, op->count);
+ n1 = evaluate_value(&op->ops[0], depth);
+ n2 = evaluate_value(&op->ops[1], depth);
+ r = n1 < n2;
+ print_depth(depth);
+ printf("%Lf = %Lf < %Lf\n", r, n1, n2);
+ break;
+
+ case EVAL_OPERATOR_NOT_EQUAL:
+ if(op->count != 2)
+ fatal("Operator '%c' requires 2 values, but we have %d", op->operator, op->count);
+ n1 = evaluate_value(&op->ops[0], depth);
+ n2 = evaluate_value(&op->ops[1], depth);
+ r = n1 != n2;
+ print_depth(depth);
+ printf("%Lf = %Lf <> %Lf\n", r, n1, n2);
+ break;
+
+ case EVAL_OPERATOR_EQUAL:
+ if(op->count != 2)
+ fatal("Operator '%c' requires 2 values, but we have %d", op->operator, op->count);
+ n1 = evaluate_value(&op->ops[0], depth);
+ n2 = evaluate_value(&op->ops[1], depth);
+ r = n1 == n2;
+ print_depth(depth);
+ printf("%Lf = %Lf == %Lf\n", r, n1, n2);
+ break;
+
+ case EVAL_OPERATOR_EXPRESSION_OPEN:
+ printf("BEGIN SUB-EXPRESSION\n");
+ r = evaluate_value(&op->ops[0], depth + 1);
+ printf("END SUB-EXPRESSION\n");
+ break;
+
+ case EVAL_OPERATOR_NOP:
+ case EVAL_OPERATOR_VALUE:
+ r = evaluate_value(&op->ops[0], depth);
+ break;
+
+ default:
+ error("I don't know how to handle operator '%c'", op->operator);
+ r = 0;
+ break;
+ }
+
+ return r;
+}
+
+
+void print_expression(EVAL_NODE *op, const char *failed_at, int error) {
+ if(op) {
+ printf("expression tree:\n");
+ print_node(op, 0);
+
+ printf("\nevaluation steps:\n");
+ evaluate(op, 0);
+
+ int error;
+ NETDATA_DOUBLE ret = expression_evaluate(op, &error);
+ printf("\ninternal evaluator:\nSTATUS: %d, RESULT = %Lf\n", error, ret);
+
+ expression_free(op);
+ }
+ else {
+ printf("error: %d, failed_at: '%s'\n", error, (failed_at)?failed_at:"<NONE>");
+ }
+}
+*/
+
+int main(int argc, char **argv) {
+ if(argc != 2) {
+ fprintf(stderr, "I need an expression (enclose it in single-quotes (') as a single parameter)\n");
+ exit(1);
+ }
+
+ const char *failed_at = NULL;
+ int error;
+
+ EVAL_EXPRESSION *exp = expression_parse(argv[1], &failed_at, &error);
+ if(!exp)
+ printf("\nPARSING FAILED\nExpression: '%s'\nParsing stopped at: '%s'\nParsing error code: %d (%s)\n", argv[1], (failed_at)?((*failed_at)?failed_at:"<END OF EXPRESSION>"):"<NONE>", error, expression_strerror(error));
+
+ else {
+ printf("\nPARSING OK\nExpression: '%s'\nParsed as : '%s'\nParsing error code: %d (%s)\n", argv[1], exp->parsed_as, error, expression_strerror(error));
+
+ if(expression_evaluate(exp)) {
+ printf("\nEvaluates to: %Lf\n\n", exp->result);
+ }
+ else {
+ printf("\nEvaluation failed with code %d and message: %s\n\n", exp->error, buffer_tostring(exp->error_msg));
+ }
+ expression_free(exp);
+ }
+
+ return 0;
+}
generated by cgit v1.2.3 (git 2.39.1) at 2024-11-18 12:10:31 +0000