netdata doubles (#13217)
* netdata doubles * fix cmocka test * fix cmocka test again * fix left-overs of long double to NETDATA_DOUBLE * RRDDIM detached from disk representation; db settings in [db] section of netdata.conf * update the memory before saving * rrdset is now detached from file structures too * on memory mode map, update the memory mapped structures on every iteration * allow RRD_ID_LENGTH_MAX to be changed * granularity secs, back to update every * fix formatting * more formatting
Costa Tsaousis committed
Jun 28, 2022 at 17:04 UTC
c3dfbe52a61dd0d1995bc420b0e0576cf058fd74
114 files changed
+1787
-1503
aclk/aclk_rx_msgs.c
+4
-4
@@ -55,19 +55,19 @@ static int cloud_to_agent_parse(JSON_ENTRY *e)
55
break;
56
case JSON_NUMBER:
57
if (!strcmp(e->name, "version")) {
58
- data->version = e->data.number;
58
+ data->version = (int)e->data.number;
59
break;
60
}
61
if (!strcmp(e->name, "timeout")) {
62
- data->timeout = e->data.number;
62
+ data->timeout = (int)e->data.number;
63
break;
64
}
65
if (!strcmp(e->name, "min-version")) {
66
- data->min_version = e->data.number;
66
+ data->min_version = (int)e->data.number;
67
break;
68
}
69
if (!strcmp(e->name, "max-version")) {
70
- data->max_version = e->data.number;
70
+ data->max_version = (int)e->data.number;
71
break;
72
}
73
cli/README.md
+1
-1
@@ -20,7 +20,7 @@ reload-health
20
reload-labels
21
Reload all labels.
22
save-database
23
- Save internal DB to disk for memory mode save.
23
+ Save internal DB to disk for database mode save.
24
reopen-logs
25
Close and reopen log files.
26
shutdown-agent
collectors/apps.plugin/apps_plugin.c
+10
-8
@@ -173,7 +173,8 @@ static kernel_uint_t
173
global_gtime = 0;
174
175
// the normalization ratios, as calculated by normalize_utilization()
176
-double utime_fix_ratio = 1.0,
176
+NETDATA_DOUBLE
177
+ utime_fix_ratio = 1.0,
178
stime_fix_ratio = 1.0,
179
gtime_fix_ratio = 1.0,
180
minflt_fix_ratio = 1.0,
@@ -501,7 +502,8 @@ struct file_descriptor {
502
static int
503
all_files_len = 0,
504
all_files_size = 0;
504
- long double currentmaxfds = 0;
505
+
506
+long currentmaxfds = 0;
507
508
// ----------------------------------------------------------------------------
509
// read users and groups from files
@@ -3021,7 +3023,7 @@ static inline void aggregate_pid_fds_on_targets(struct pid_stat *p) {
3023
reallocate_target_fds(u);
3024
reallocate_target_fds(g);
3025
3024
- long double currentfds = 0;
3026
+ long currentfds = 0;
3027
size_t c, size = p->fds_size;
3028
struct pid_fd *fds = p->fds;
3029
for(c = 0; c < size ;c++) {
@@ -3373,7 +3375,7 @@ static void normalize_utilization(struct target *root) {
3375
gtime_fix_ratio =
3376
cutime_fix_ratio =
3377
cstime_fix_ratio =
3376
- cgtime_fix_ratio = 1.0; //(double)(global_utime + global_stime) / (double)(utime + cutime + stime + cstime);
3378
+ cgtime_fix_ratio = 1.0; //(NETDATA_DOUBLE)(global_utime + global_stime) / (NETDATA_DOUBLE)(utime + cutime + stime + cstime);
3379
}
3380
else if((global_utime + global_stime > utime + stime) && (cutime || cstime)) {
3381
// children resources are too high
@@ -3383,7 +3385,7 @@ static void normalize_utilization(struct target *root) {
3385
gtime_fix_ratio = 1.0;
3386
cutime_fix_ratio =
3387
cstime_fix_ratio =
3386
- cgtime_fix_ratio = (double)((global_utime + global_stime) - (utime + stime)) / (double)(cutime + cstime);
3388
+ cgtime_fix_ratio = (NETDATA_DOUBLE)((global_utime + global_stime) - (utime + stime)) / (NETDATA_DOUBLE)(cutime + cstime);
3389
}
3390
else if(utime || stime) {
3391
// even running processes are unrealistic
@@ -3391,7 +3393,7 @@ static void normalize_utilization(struct target *root) {
3393
// lower the running processes resources
3394
utime_fix_ratio =
3395
stime_fix_ratio =
3394
- gtime_fix_ratio = (double)(global_utime + global_stime) / (double)(utime + stime);
3396
+ gtime_fix_ratio = (NETDATA_DOUBLE)(global_utime + global_stime) / (NETDATA_DOUBLE)(utime + stime);
3397
cutime_fix_ratio =
3398
cstime_fix_ratio =
3399
cgtime_fix_ratio = 0.0;
@@ -3439,14 +3441,14 @@ static void normalize_utilization(struct target *root) {
3441
3442
if(utime || stime || gtime)
3443
majflt_fix_ratio =
3442
- minflt_fix_ratio = (double)(utime * utime_fix_ratio + stime * stime_fix_ratio + gtime * gtime_fix_ratio) / (double)(utime + stime + gtime);
3444
+ minflt_fix_ratio = (NETDATA_DOUBLE)(utime * utime_fix_ratio + stime * stime_fix_ratio + gtime * gtime_fix_ratio) / (NETDATA_DOUBLE)(utime + stime + gtime);
3445
else
3446
minflt_fix_ratio =
3447
majflt_fix_ratio = 1.0;
3448
3449
if(cutime || cstime || cgtime)
3450
cmajflt_fix_ratio =
3449
- cminflt_fix_ratio = (double)(cutime * cutime_fix_ratio + cstime * cstime_fix_ratio + cgtime * cgtime_fix_ratio) / (double)(cutime + cstime + cgtime);
3451
+ cminflt_fix_ratio = (NETDATA_DOUBLE)(cutime * cutime_fix_ratio + cstime * cstime_fix_ratio + cgtime * cgtime_fix_ratio) / (NETDATA_DOUBLE)(cutime + cstime + cgtime);
3452
else
3453
cminflt_fix_ratio =
3454
cmajflt_fix_ratio = 1.0;
collectors/cgroups.plugin/sys_fs_cgroup.c
+12
-12
@@ -835,7 +835,7 @@ struct cgroup {
835
unsigned long long cpu_cfs_quota;
836
837
RRDSETVAR *chart_var_cpu_limit;
838
- calculated_number prev_cpu_usage;
838
+ NETDATA_DOUBLE prev_cpu_usage;
839
840
char *filename_memory_limit;
841
unsigned long long memory_limit;
@@ -1012,7 +1012,7 @@ static unsigned long long calc_percentage(unsigned long long value, unsigned lon
1012
if (total == 0) {
1013
return 0;
1014
}
1015
- return (calculated_number)value / (calculated_number)total * 100;
1015
+ return (NETDATA_DOUBLE)value / (NETDATA_DOUBLE)total * 100;
1016
}
1017
1018
static int calc_cgroup_depth(const char *id) {
@@ -3686,7 +3686,7 @@ static inline int update_memory_limits(char **filename, RRDSETVAR **chart_var, u
3686
*filename = NULL;
3687
}
3688
else {
3689
- rrdsetvar_custom_chart_variable_set(*chart_var, (calculated_number)(*value / (1024 * 1024)));
3689
+ rrdsetvar_custom_chart_variable_set(*chart_var, (NETDATA_DOUBLE)(*value / (1024 * 1024)));
3690
return 1;
3691
}
3692
} else {
@@ -3701,11 +3701,11 @@ static inline int update_memory_limits(char **filename, RRDSETVAR **chart_var, u
3701
char *s = "max\n\0";
3702
if(strcmp(s, buffer) == 0){
3703
*value = UINT64_MAX;
3704
- rrdsetvar_custom_chart_variable_set(*chart_var, (calculated_number)(*value / (1024 * 1024)));
3704
+ rrdsetvar_custom_chart_variable_set(*chart_var, (NETDATA_DOUBLE)(*value / (1024 * 1024)));
3705
return 1;
3706
}
3707
*value = str2ull(buffer);
3708
- rrdsetvar_custom_chart_variable_set(*chart_var, (calculated_number)(*value / (1024 * 1024)));
3708
+ rrdsetvar_custom_chart_variable_set(*chart_var, (NETDATA_DOUBLE)(*value / (1024 * 1024)));
3709
return 1;
3710
}
3711
}
@@ -3814,17 +3814,17 @@ void update_cgroup_charts(int update_every) {
3814
}
3815
}
3816
else {
3817
- calculated_number value = 0, quota = 0;
3817
+ NETDATA_DOUBLE value = 0, quota = 0;
3818
3819
if(likely( ((!(cg->options & CGROUP_OPTIONS_IS_UNIFIED)) && (cg->filename_cpuset_cpus || (cg->filename_cpu_cfs_period && cg->filename_cpu_cfs_quota)))
3820
|| ((cg->options & CGROUP_OPTIONS_IS_UNIFIED) && cg->filename_cpu_cfs_quota))) {
3821
if(unlikely(cg->cpu_cfs_quota > 0))
3822
- quota = (calculated_number)cg->cpu_cfs_quota / (calculated_number)cg->cpu_cfs_period;
3822
+ quota = (NETDATA_DOUBLE)cg->cpu_cfs_quota / (NETDATA_DOUBLE)cg->cpu_cfs_period;
3823
3824
if(unlikely(quota > 0 && quota < cg->cpuset_cpus))
3825
value = quota * 100;
3826
else
3827
- value = (calculated_number)cg->cpuset_cpus * 100;
3827
+ value = (NETDATA_DOUBLE)cg->cpuset_cpus * 100;
3828
}
3829
if(likely(value)) {
3830
rrdsetvar_custom_chart_variable_set(cg->chart_var_cpu_limit, value);
@@ -3853,14 +3853,14 @@ void update_cgroup_charts(int update_every) {
3853
rrddim_add(cg->st_cpu_limit, "used", NULL, 1, system_hz, RRD_ALGORITHM_ABSOLUTE);
3854
else
3855
rrddim_add(cg->st_cpu_limit, "used", NULL, 1, 1000000, RRD_ALGORITHM_ABSOLUTE);
3856
- cg->prev_cpu_usage = (calculated_number)(cg->cpuacct_stat.user + cg->cpuacct_stat.system) * 100;
3856
+ cg->prev_cpu_usage = (NETDATA_DOUBLE)(cg->cpuacct_stat.user + cg->cpuacct_stat.system) * 100;
3857
}
3858
else
3859
rrdset_next(cg->st_cpu_limit);
3860
3861
- calculated_number cpu_usage = 0;
3862
- cpu_usage = (calculated_number)(cg->cpuacct_stat.user + cg->cpuacct_stat.system) * 100;
3863
- calculated_number cpu_used = 100 * (cpu_usage - cg->prev_cpu_usage) / (value * update_every);
3861
+ NETDATA_DOUBLE cpu_usage = 0;
3862
+ cpu_usage = (NETDATA_DOUBLE)(cg->cpuacct_stat.user + cg->cpuacct_stat.system) * 100;
3863
+ NETDATA_DOUBLE cpu_used = 100 * (cpu_usage - cg->prev_cpu_usage) / (value * update_every);
3864
3865
rrdset_isnot_obsolete(cg->st_cpu_limit);
3866
collectors/cgroups.plugin/tests/test_doubles.c
+1
-1
@@ -109,7 +109,7 @@ RRDSETVAR *rrdsetvar_custom_chart_variable_create(RRDSET *st, const char *name)
109
return NULL;
110
}
111
112
-void rrdsetvar_custom_chart_variable_set(RRDSETVAR *rs, calculated_number value)
112
+void rrdsetvar_custom_chart_variable_set(RRDSETVAR *rs, NETDATA_DOUBLE value)
113
{
114
UNUSED(rs);
115
UNUSED(value);
collectors/ebpf.plugin/ebpf_cachestat.c
+4
-4
@@ -367,23 +367,23 @@ void cachestat_update_publish(netdata_publish_cachestat_t *out, uint64_t mpa, ui
367
uint64_t apcl, uint64_t apd)
368
{
369
// Adapted algorithm from https://github.com/iovisor/bcc/blob/master/tools/cachestat.py#L126-L138
370
- calculated_number total = (calculated_number) (((long long)mpa) - ((long long)mbd));
370
+ NETDATA_DOUBLE total = (NETDATA_DOUBLE) (((long long)mpa) - ((long long)mbd));
371
if (total < 0)
372
total = 0;
373
374
- calculated_number misses = (calculated_number) ( ((long long) apcl) - ((long long) apd) );
374
+ NETDATA_DOUBLE misses = (NETDATA_DOUBLE) ( ((long long) apcl) - ((long long) apd) );
375
if (misses < 0)
376
misses = 0;
377
378
// If hits are < 0, then its possible misses are overestimate due to possibly page cache read ahead adding
379
// more pages than needed. In this case just assume misses as total and reset hits.
380
- calculated_number hits = total - misses;
380
+ NETDATA_DOUBLE hits = total - misses;
381
if (hits < 0 ) {
382
misses = total;
383
hits = 0;
384
}
385
386
- calculated_number ratio = (total > 0) ? hits/total : 1;
386
+ NETDATA_DOUBLE ratio = (total > 0) ? hits/total : 1;
387
388
out->ratio = (long long )(ratio*100);
389
out->hit = (long long)hits;
collectors/ebpf.plugin/ebpf_dcstat.c
+2
-2
@@ -239,8 +239,8 @@ static inline int ebpf_dc_load_and_attach(struct dc_bpf *obj, ebpf_module_t *em)
239
*/
240
void dcstat_update_publish(netdata_publish_dcstat_t *out, uint64_t cache_access, uint64_t not_found)
241
{
242
- calculated_number successful_access = (calculated_number) (((long long)cache_access) - ((long long)not_found));
243
- calculated_number ratio = (cache_access) ? successful_access/(calculated_number)cache_access : 0;
242
+ NETDATA_DOUBLE successful_access = (NETDATA_DOUBLE) (((long long)cache_access) - ((long long)not_found));
243
+ NETDATA_DOUBLE ratio = (cache_access) ? successful_access/(NETDATA_DOUBLE)cache_access : 0;
244
245
out->ratio = (long long )(ratio*100);
246
}
collectors/perf.plugin/perf_plugin.c
+2
-2
@@ -520,8 +520,8 @@ static void perf_send_metrics() {
520
, "instructions_per_cycle"
521
);
522
523
- calculated_number result = ((calculated_number)perf_events[EV_ID_INSTRUCTIONS].value /
524
- (calculated_number)perf_events[EV_ID_CPU_CYCLES].value) * 100.0;
523
+ NETDATA_DOUBLE result = ((NETDATA_DOUBLE)perf_events[EV_ID_INSTRUCTIONS].value /
524
+ (NETDATA_DOUBLE)perf_events[EV_ID_CPU_CYCLES].value) * 100.0;
525
printf("SET %s = %lld\n"
526
, "ipc"
527
, (collected_number) result
collectors/plugins.d/pluginsd_parser.c
+3
-3
@@ -96,7 +96,7 @@ PARSER_RC pluginsd_disable_action(void *user)
96
}
97
98
99
-PARSER_RC pluginsd_variable_action(void *user, RRDHOST *host, RRDSET *st, char *name, int global, calculated_number value)
99
+PARSER_RC pluginsd_variable_action(void *user, RRDHOST *host, RRDSET *st, char *name, int global, NETDATA_DOUBLE value)
100
{
101
UNUSED(user);
102
@@ -473,7 +473,7 @@ PARSER_RC pluginsd_variable(char **words, void *user, PLUGINSD_ACTION *plugins_
473
{
474
char *name = words[1];
475
char *value = words[2];
476
- calculated_number v;
476
+ NETDATA_DOUBLE v;
477
478
RRDSET *st = ((PARSER_USER_OBJECT *) user)->st;
479
RRDHOST *host = ((PARSER_USER_OBJECT *) user)->host;
@@ -513,7 +513,7 @@ PARSER_RC pluginsd_variable(char **words, void *user, PLUGINSD_ACTION *plugins_
513
}
514
515
char *endptr = NULL;
516
- v = (calculated_number)str2ld(value, &endptr);
516
+ v = (NETDATA_DOUBLE)str2ndd(value, &endptr);
517
if (unlikely(endptr && *endptr)) {
518
if (endptr == value)
519
error(
collectors/plugins.d/pluginsd_parser.h
+1
-2
@@ -30,8 +30,7 @@ extern PARSER_RC pluginsd_chart_action(void *user, char *type, char *id, char *n
30
char *title, char *units, char *plugin, char *module, int priority,
31
int update_every, RRDSET_TYPE chart_type, char *options);
32
extern PARSER_RC pluginsd_disable_action(void *user);
33
-extern PARSER_RC pluginsd_variable_action(void *user, RRDHOST *host, RRDSET *st, char *name, int global,
34
- calculated_number value);
33
+extern PARSER_RC pluginsd_variable_action(void *user, RRDHOST *host, RRDSET *st, char *name, int global, NETDATA_DOUBLE value);
34
extern PARSER_RC pluginsd_dimension_action(void *user, RRDSET *st, char *id, char *name, char *algorithm,
35
long multiplier, long divisor, char *options, RRD_ALGORITHM algorithm_type);
36
extern PARSER_RC pluginsd_label_action(void *user, char *key, char *value, RRDLABEL_SRC source);
collectors/proc.plugin/proc_diskstats.c
+1
-1
@@ -201,7 +201,7 @@ static unsigned long long int bcache_read_number_with_units(const char *filename
201
static int unknown_units_error = 10;
202
203
char *end = NULL;
204
- long double value = str2ld(buffer, &end);
204
+ NETDATA_DOUBLE value = str2ndd(buffer, &end);
205
if(end && *end) {
206
if(*end == 'k')
207
return (unsigned long long int)(value * 1024.0);
collectors/proc.plugin/proc_mdstat.c
+2
-2
@@ -263,7 +263,7 @@ int do_proc_mdstat(int update_every, usec_t dt)
263
word = procfile_lineword(ff, l, 3);
264
remove_trailing_chars(word, '%');
265
266
- unsigned long long percentage = (unsigned long long)(str2ld(word, NULL) * 100);
266
+ unsigned long long percentage = (unsigned long long)(str2ndd(word, NULL) * 100);
267
// possible operations: check, resync, recovery, reshape
268
// 4-th character is unique for each operation so it is checked
269
switch (procfile_lineword(ff, l, 1)[3]) {
@@ -287,7 +287,7 @@ int do_proc_mdstat(int update_every, usec_t dt)
287
word += 7; // skip leading "finish="
288
289
if (likely(s > word))
290
- raid->finish_in = (unsigned long long)(str2ld(word, NULL) * 60);
290
+ raid->finish_in = (unsigned long long)(str2ndd(word, NULL) * 60);
291
292
word = procfile_lineword(ff, l, 6);
293
s = remove_trailing_chars(word, 'K'); // remove trailing "K/sec"
collectors/proc.plugin/proc_net_dev.c
+1
-1
@@ -967,7 +967,7 @@ int do_proc_net_dev(int update_every, usec_t dt) {
967
d->filename_speed = NULL;
968
}
969
else {
970
- rrdsetvar_custom_chart_variable_set(d->chart_var_speed, (calculated_number) d->speed * KILOBITS_IN_A_MEGABIT);
970
+ rrdsetvar_custom_chart_variable_set(d->chart_var_speed, (NETDATA_DOUBLE) d->speed * KILOBITS_IN_A_MEGABIT);
971
972
if(d->do_speed != CONFIG_BOOLEAN_NO) {
973
if(unlikely(!d->st_speed)) {
collectors/proc.plugin/proc_net_wireless.c
+6
-6
@@ -24,9 +24,9 @@ static struct netwireless {
24
kernel_uint_t status;
25
26
// Quality
27
- calculated_number link;
28
- calculated_number level;
29
- calculated_number noise;
27
+ NETDATA_DOUBLE link;
28
+ NETDATA_DOUBLE level;
29
+ NETDATA_DOUBLE noise;
30
31
// Discarded packets
32
kernel_uint_t nwid;
@@ -281,9 +281,9 @@ int do_proc_net_wireless(int update_every, usec_t dt)
281
}
282
283
if (likely(do_quality != CONFIG_BOOLEAN_NO)) {
284
- wireless_dev->link = str2ld(procfile_lineword(ff, l, 2), NULL);
285
- wireless_dev->level = str2ld(procfile_lineword(ff, l, 3), NULL);
286
- wireless_dev->noise = str2ld(procfile_lineword(ff, l, 4), NULL);
284
+ wireless_dev->link = str2ndd(procfile_lineword(ff, l, 2), NULL);
285
+ wireless_dev->level = str2ndd(procfile_lineword(ff, l, 3), NULL);
286
+ wireless_dev->noise = str2ndd(procfile_lineword(ff, l, 4), NULL);
287
288
if (unlikely(!wireless_dev->st_link)) {
289
wireless_dev->st_link = rrdset_create_localhost("wireless",
collectors/proc.plugin/sys_devices_system_edac_mc.c
+1
-1
@@ -74,7 +74,7 @@ int do_proc_sys_devices_system_edac_mc(int update_every, usec_t dt) {
74
}
75
76
static int do_ce = -1, do_ue = -1;
77
- calculated_number ce_sum = 0, ue_sum = 0;
77
+ NETDATA_DOUBLE ce_sum = 0, ue_sum = 0;
78
struct mc *m;
79
80
if(unlikely(do_ce == -1)) {
collectors/statsd.plugin/statsd.c
+20
-20
@@ -35,7 +35,7 @@
35
// data specific to each metric type
36
37
typedef struct statsd_metric_gauge {
38
- LONG_DOUBLE value;
38
+ NETDATA_DOUBLE value;
39
} STATSD_METRIC_GAUGE;
40
41
typedef struct statsd_metric_counter { // counter and meter
@@ -64,7 +64,7 @@ typedef struct statsd_histogram_extensions {
64
65
size_t size;
66
size_t used;
67
- LONG_DOUBLE *values; // dynamic array of values collected
67
+ NETDATA_DOUBLE *values; // dynamic array of values collected
68
} STATSD_METRIC_HISTOGRAM_EXTENSIONS;
69
70
typedef struct statsd_metric_histogram { // histogram and timer
@@ -431,12 +431,12 @@ static inline STATSD_METRIC *statsd_find_or_add_metric(STATSD_INDEX *index, cons
431
// --------------------------------------------------------------------------------------------------------------------
432
// statsd parsing numbers
433
434
-static inline LONG_DOUBLE statsd_parse_float(const char *v, LONG_DOUBLE def) {
435
- LONG_DOUBLE value;
434
+static inline NETDATA_DOUBLE statsd_parse_float(const char *v, NETDATA_DOUBLE def) {
435
+ NETDATA_DOUBLE value;
436
437
if(likely(v && *v)) {
438
char *e = NULL;
439
- value = str2ld(v, &e);
439
+ value = str2ndd(v, &e);
440
if(unlikely(e && *e))
441
error("STATSD: excess data '%s' after value '%s'", e, v);
442
}
@@ -446,8 +446,8 @@ static inline LONG_DOUBLE statsd_parse_float(const char *v, LONG_DOUBLE def) {
446
return value;
447
}
448
449
-static inline LONG_DOUBLE statsd_parse_sampling_rate(const char *v) {
450
- LONG_DOUBLE sampling_rate = statsd_parse_float(v, 1.0);
449
+static inline NETDATA_DOUBLE statsd_parse_sampling_rate(const char *v) {
450
+ NETDATA_DOUBLE sampling_rate = statsd_parse_float(v, 1.0);
451
if(unlikely(isless(sampling_rate, 0.001))) sampling_rate = 0.001;
452
if(unlikely(isgreater(sampling_rate, 1.0))) sampling_rate = 1.0;
453
return sampling_rate;
@@ -522,7 +522,7 @@ static inline void statsd_process_counter_or_meter(STATSD_METRIC *m, const char
522
// magic loading of metric, without affecting anything
523
}
524
else {
525
- m->counter.value += llrintl((LONG_DOUBLE) statsd_parse_int(value, 1) / statsd_parse_sampling_rate(sampling));
525
+ m->counter.value += llrintndd((NETDATA_DOUBLE) statsd_parse_int(value, 1) / statsd_parse_sampling_rate(sampling));
526
527
m->events++;
528
m->count++;
@@ -549,18 +549,18 @@ static inline void statsd_process_histogram_or_timer(STATSD_METRIC *m, const cha
549
// magic loading of metric, without affecting anything
550
}
551
else {
552
- LONG_DOUBLE v = statsd_parse_float(value, 1.0);
553
- LONG_DOUBLE sampling_rate = statsd_parse_sampling_rate(sampling);
552
+ NETDATA_DOUBLE v = statsd_parse_float(value, 1.0);
553
+ NETDATA_DOUBLE sampling_rate = statsd_parse_sampling_rate(sampling);
554
if(unlikely(isless(sampling_rate, 0.01))) sampling_rate = 0.01;
555
if(unlikely(isgreater(sampling_rate, 1.0))) sampling_rate = 1.0;
556
557
- long long samples = llrintl(1.0 / sampling_rate);
557
+ long long samples = llrintndd(1.0 / sampling_rate);
558
while(samples-- > 0) {
559
560
if(unlikely(m->histogram.ext->used == m->histogram.ext->size)) {
561
netdata_mutex_lock(&m->histogram.ext->mutex);
562
m->histogram.ext->size += statsd.histogram_increase_step;
563
- m->histogram.ext->values = reallocz(m->histogram.ext->values, sizeof(LONG_DOUBLE) * m->histogram.ext->size);
563
+ m->histogram.ext->values = reallocz(m->histogram.ext->values, sizeof(NETDATA_DOUBLE) * m->histogram.ext->size);
564
netdata_mutex_unlock(&m->histogram.ext->mutex);
565
}
566
@@ -1945,21 +1945,21 @@ static inline void statsd_flush_timer_or_histogram(STATSD_METRIC *m, const char
1945
netdata_mutex_lock(&m->histogram.ext->mutex);
1946
1947
size_t len = m->histogram.ext->used;
1948
- LONG_DOUBLE *series = m->histogram.ext->values;
1948
+ NETDATA_DOUBLE *series = m->histogram.ext->values;
1949
sort_series(series, len);
1950
1951
- m->histogram.ext->last_min = (collected_number)roundl(series[0] * statsd.decimal_detail);
1952
- m->histogram.ext->last_max = (collected_number)roundl(series[len - 1] * statsd.decimal_detail);
1953
- m->last = (collected_number)roundl(average(series, len) * statsd.decimal_detail);
1954
- m->histogram.ext->last_median = (collected_number)roundl(median_on_sorted_series(series, len) * statsd.decimal_detail);
1955
- m->histogram.ext->last_stddev = (collected_number)roundl(standard_deviation(series, len) * statsd.decimal_detail);
1956
- m->histogram.ext->last_sum = (collected_number)roundl(sum(series, len) * statsd.decimal_detail);
1951
+ m->histogram.ext->last_min = (collected_number)roundndd(series[0] * statsd.decimal_detail);
1952
+ m->histogram.ext->last_max = (collected_number)roundndd(series[len - 1] * statsd.decimal_detail);
1953
+ m->last = (collected_number)roundndd(average(series, len) * statsd.decimal_detail);
1954
+ m->histogram.ext->last_median = (collected_number)roundndd(median_on_sorted_series(series, len) * statsd.decimal_detail);
1955
+ m->histogram.ext->last_stddev = (collected_number)roundndd(standard_deviation(series, len) * statsd.decimal_detail);
1956
+ m->histogram.ext->last_sum = (collected_number)roundndd(sum(series, len) * statsd.decimal_detail);
1957
1958
size_t pct_len = (size_t)floor((double)len * statsd.histogram_percentile / 100.0);
1959
if(pct_len < 1)
1960
m->histogram.ext->last_percentile = (collected_number)(series[0] * statsd.decimal_detail);
1961
else
1962
- m->histogram.ext->last_percentile = (collected_number)roundl(series[pct_len - 1] * statsd.decimal_detail);
1962
+ m->histogram.ext->last_percentile = (collected_number)roundndd(series[pct_len - 1] * statsd.decimal_detail);
1963
1964
netdata_mutex_unlock(&m->histogram.ext->mutex);
1965
daemon/config/README.md
+42
-36
@@ -26,20 +26,21 @@ the [web server access lists](/web/server/README.md#access-lists).
26
`netdata.conf` has sections stated with `[section]`. You will see the following sections:
27
28
1. `[global]` to [configure](#global-section-options) the [Netdata daemon](/daemon/README.md).
29
-2. `[directories]` to [configure](#directories-section-options) the directories used by Netdata.
30
-3. `[logs]` to [configure](#logs-section-options) the Netdata logging.
31
-4. `[environment variables]` to [configure](#environment-variables-section-options) the environment variables used
29
+2. `[db]` to [configure](#db-section-options) the database of Netdata.
30
+3. `[directories]` to [configure](#directories-section-options) the directories used by Netdata.
31
+4. `[logs]` to [configure](#logs-section-options) the Netdata logging.
32
+5. `[environment variables]` to [configure](#environment-variables-section-options) the environment variables used
33
Netdata.
33
-5. `[sqlite]` to [configure](#sqlite-section-options) the [Netdata daemon](/daemon/README.md) SQLite settings.
34
-6. `[ml]` to configure settings for [machine learning](/ml/README.md).
35
-7. `[health]` to [configure](#health-section-options) general settings for [health monitoring](/health/README.md).
36
-8. `[web]` to [configure the web server](/web/server/README.md).
37
-9. `[registry]` for the [Netdata registry](/registry/README.md).
38
-10. `[global statistics]` for the [Netdata registry](/registry/README.md).
39
-11. `[statsd]` for the general settings of the [stats.d.plugin](/collectors/statsd.plugin/README.md).
40
-12. `[plugins]` to [configure](#plugins-section-options) which [collectors](/collectors/README.md) to use and PATH
34
+6. `[sqlite]` to [configure](#sqlite-section-options) the [Netdata daemon](/daemon/README.md) SQLite settings.
35
+7. `[ml]` to configure settings for [machine learning](/ml/README.md).
36
+8. `[health]` to [configure](#health-section-options) general settings for [health monitoring](/health/README.md).
37
+9. `[web]` to [configure the web server](/web/server/README.md).
38
+10. `[registry]` for the [Netdata registry](/registry/README.md).
39
+11. `[global statistics]` for the [Netdata registry](/registry/README.md).
40
+12. `[statsd]` for the general settings of the [stats.d.plugin](/collectors/statsd.plugin/README.md).
41
+13. `[plugins]` to [configure](#plugins-section-options) which [collectors](/collectors/README.md) to use and PATH
42
settings.
42
-13. `[plugin:NAME]` sections for each collector plugin, under the
43
+14. `[plugin:NAME]` sections for each collector plugin, under the
44
comment [Per plugin configuration](#per-plugin-configuration).
45
46
The configuration file is a `name = value` dictionary. Netdata will not complain if you set options unknown to it. When
@@ -67,30 +68,35 @@ Please note that your data history will be lost if you have modified `history` p
68
69
### [global] section options
70
70
-| setting | default | info |
71
-|:-------------------------------------:|:------------------------------------------------------------------:|:---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
72
-| process scheduling policy | `keep` | See [Netdata process scheduling policy](/daemon/README.md#netdata-process-scheduling-policy) |
73
-| OOM score | `0` | |
74
-| glibc malloc arena max for plugins | `1` | See [Virtual memory](/daemon/README.md#virtual-memory). |
75
-| glibc malloc arena max for Netdata | `1` | See [Virtual memory](/daemon/README.md#virtual-memory). |
76
-| hostname | auto-detected | The hostname of the computer running Netdata. |
77
-| history | `3996` | Used with `memory mode = save/map/ram/alloc`, not the default `memory mode = dbengine`. This number reflects the number of entries the `netdata` daemon will by default keep in memory for each chart dimension. This setting can also be configured per chart. Check [Memory Requirements](/database/README.md) for more information. |
78
-| update every | `1` | The frequency in seconds, for data collection. For more information see the [performance guide](/docs/guides/configure/performance.md). |
79
-| memory mode | `dbengine` | `dbengine`: The default for long-term metrics storage with efficient RAM and disk usage. Can be extended with `page cache size` and `dbengine disk space`. <br />`save`: Netdata will save its round robin database on exit and load it on startup. <br />`map`: Cache files will be updated in real-time. Not ideal for systems with high load or slow disks (check `man mmap`). <br />`ram`: The round-robin database will be temporary and it will be lost when Netdata exits. <br />`none`: Disables the database at this host, and disables health monitoring entirely, as that requires a database of metrics. |
80
-| page cache size | 32 | Determines the amount of RAM in MiB that is dedicated to caching Netdata metric values. |
81
-| dbengine disk space | 256 | Determines the amount of disk space in MiB that is dedicated to storing Netdata metric values and all related metadata describing them. |
82
-| dbengine multihost disk space | 256 | Same functionality as `dbengine disk space`, but includes support for storing metrics streamed to a parent node by its children. Can be used in single-node environments as well. |
83
-| host access prefix | | This is used in docker environments where /proc, /sys, etc have to be accessed via another path. You may also have to set SYS_PTRACE capability on the docker for this work. Check [issue 43](https://github.com/netdata/netdata/issues/43). |
84
-| memory deduplication (ksm) | `yes` | When set to `yes`, Netdata will offer its in-memory round robin database to kernel same page merging (KSM) for deduplication. For more information check [Memory Deduplication - Kernel Same Page Merging - KSM](/database/README.md#ksm) |
85
-| timezone | auto-detected | The timezone retrieved from the environment variable |
86
-| run as user | `netdata` | The user Netdata will run as. |
87
-| pthread stack size | auto-detected | |
88
-| cleanup obsolete charts after seconds | `3600` | See [monitoring ephemeral containers](/collectors/cgroups.plugin/README.md#monitoring-ephemeral-containers), also sets the timeout for cleaning up obsolete dimensions |
89
-| gap when lost iterations above | `1` | |
90
-| cleanup orphan hosts after seconds | `3600` | How long to wait until automatically removing from the DB a remote Netdata host (child) that is no longer sending data. |
91
-| delete obsolete charts files | `yes` | See [monitoring ephemeral containers](/collectors/cgroups.plugin/README.md#monitoring-ephemeral-containers), also affects the deletion of files for obsolete dimensions |
92
-| delete orphan hosts files | `yes` | Set to `no` to disable non-responsive host removal. |
93
-| enable zero metrics | `no` | Set to `yes` to show charts when all their metrics are zero. |
71
+| setting | default | info |
72
+|:-------------------------------------:|:-------------:|:---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
73
+| process scheduling policy | `keep` | See [Netdata process scheduling policy](/daemon/README.md#netdata-process-scheduling-policy) |
74
+| OOM score | `0` | |
75
+| glibc malloc arena max for plugins | `1` | See [Virtual memory](/daemon/README.md#virtual-memory). |
76
+| glibc malloc arena max for Netdata | `1` | See [Virtual memory](/daemon/README.md#virtual-memory). |
77
+| hostname | auto-detected | The hostname of the computer running Netdata. |
78
+| host access prefix | empty | This is used in docker environments where /proc, /sys, etc have to be accessed via another path. You may also have to set SYS_PTRACE capability on the docker for this work. Check [issue 43](https://github.com/netdata/netdata/issues/43). |
79
+| timezone | auto-detected | The timezone retrieved from the environment variable |
80
+| run as user | `netdata` | The user Netdata will run as. |
81
+| pthread stack size | auto-detected | |
82
+
83
+### [db] section options
84
+
85
+| setting | default | info |
86
+|:----------------------------------:|:----------:|:---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
87
+| mode | `dbengine` | `dbengine`: The default for long-term metrics storage with efficient RAM and disk usage. Can be extended with `page cache size MB` and `dbengine disk space MB`. <br />`save`: Netdata will save its round robin database on exit and load it on startup. <br />`map`: Cache files will be updated in real-time. Not ideal for systems with high load or slow disks (check `man mmap`). <br />`ram`: The round-robin database will be temporary and it will be lost when Netdata exits. <br />`none`: Disables the database at this host, and disables health monitoring entirely, as that requires a database of metrics. |
88
+| retention | `3600` | Used with `mode = save/map/ram/alloc`, not the default `mode = dbengine`. This number reflects the number of entries the `netdata` daemon will by default keep in memory for each chart dimension. Check [Memory Requirements](/database/README.md) for more information. |
89
+| update every | `1` | The frequency in seconds, for data collection. For more information see the [performance guide](/docs/guides/configure/performance.md). |
90
+| page cache size MB | 32 | Determines the amount of RAM in MiB that is dedicated to caching Netdata metric values. |
91
+| dbengine disk space MB | 256 | Determines the amount of disk space in MiB that is dedicated to storing Netdata metric values and all related metadata describing them. |
92
+| dbengine multihost disk space MB | 256 | Same functionality as `dbengine disk space MB`, but includes support for storing metrics streamed to a parent node by its children. Can be used in single-node environments as well. |
93
+| memory deduplication (ksm) | `yes` | When set to `yes`, Netdata will offer its in-memory round robin database and the dbengine page cache to kernel same page merging (KSM) for deduplication. For more information check [Memory Deduplication - Kernel Same Page Merging - KSM](/database/README.md#ksm) |
94
+| cleanup obsolete charts after secs | `3600` | See [monitoring ephemeral containers](/collectors/cgroups.plugin/README.md#monitoring-ephemeral-containers), also sets the timeout for cleaning up obsolete dimensions |
95
+| gap when lost iterations above | `1` | |
96
+| cleanup orphan hosts after secs | `3600` | How long to wait until automatically removing from the DB a remote Netdata host (child) that is no longer sending data. |
97
+| delete obsolete charts files | `yes` | See [monitoring ephemeral containers](/collectors/cgroups.plugin/README.md#monitoring-ephemeral-containers), also affects the deletion of files for obsolete dimensions |
98
+| delete orphan hosts files | `yes` | Set to `no` to disable non-responsive host removal. |
99
+| enable zero metrics | `no` | Set to `yes` to show charts when all their metrics are zero. |
100
101
### [directories] section options
102
daemon/global_statistics.c
+1
-1
@@ -1146,7 +1146,7 @@ static void workers_utilization_update_chart(struct worker_utilization *wu) {
1146
if(wu->workers_cpu_registered == 0)
1147
rrddim_set_by_pointer(wu->st_workers_cpu, wu->rd_workers_cpu_avg, 0);
1148
else
1149
- rrddim_set_by_pointer(wu->st_workers_cpu, wu->rd_workers_cpu_avg, (collected_number)( wu->workers_cpu_total * 10000ULL / (calculated_number)wu->workers_cpu_registered ));
1149
+ rrddim_set_by_pointer(wu->st_workers_cpu, wu->rd_workers_cpu_avg, (collected_number)( wu->workers_cpu_total * 10000ULL / (NETDATA_DOUBLE)wu->workers_cpu_registered ));
1150
1151
rrdset_done(wu->st_workers_cpu);
1152
}
daemon/main.c
+105
-30
@@ -522,6 +522,58 @@ static void backwards_compatible_config() {
522
523
config_move(CONFIG_SECTION_STATSD, "enabled",
524
CONFIG_SECTION_PLUGINS, "statsd");
525
+
526
+ config_move(CONFIG_SECTION_GLOBAL, "memory mode",
527
+ CONFIG_SECTION_DB, "mode");
528
+
529
+ config_move(CONFIG_SECTION_GLOBAL, "history",
530
+ CONFIG_SECTION_DB, "retention");
531
+
532
+ config_move(CONFIG_SECTION_GLOBAL, "update every",
533
+ CONFIG_SECTION_DB, "update every");
534
+
535
+ config_move(CONFIG_SECTION_GLOBAL, "page cache size",
536
+ CONFIG_SECTION_DB, "page cache size MB");
537
+
538
+ config_move(CONFIG_SECTION_GLOBAL, "page cache uses malloc",
539
+ CONFIG_SECTION_DB, "page cache with malloc");
540
+
541
+ config_move(CONFIG_SECTION_GLOBAL, "dbengine disk space",
542
+ CONFIG_SECTION_DB, "dbengine disk space MB");
543
+
544
+ config_move(CONFIG_SECTION_GLOBAL, "dbengine multihost disk space",
545
+ CONFIG_SECTION_DB, "dbengine multihost disk space MB");
546
+
547
+ config_move(CONFIG_SECTION_GLOBAL, "memory deduplication (ksm)",
548
+ CONFIG_SECTION_DB, "memory deduplication (ksm)");
549
+
550
+ config_move(CONFIG_SECTION_GLOBAL, "dbengine page fetch timeout",
551
+ CONFIG_SECTION_DB, "dbengine page fetch timeout secs");
552
+
553
+ config_move(CONFIG_SECTION_GLOBAL, "dbengine page fetch retries",
554
+ CONFIG_SECTION_DB, "dbengine page fetch retries");
555
+
556
+ config_move(CONFIG_SECTION_GLOBAL, "dbengine extent pages",
557
+ CONFIG_SECTION_DB, "dbengine pages per extent");
558
+
559
+ config_move(CONFIG_SECTION_GLOBAL, "cleanup obsolete charts after seconds",
560
+ CONFIG_SECTION_DB, "cleanup obsolete charts after secs");
561
+
562
+ config_move(CONFIG_SECTION_GLOBAL, "gap when lost iterations above",
563
+ CONFIG_SECTION_DB, "gap when lost iterations above");
564
+
565
+ config_move(CONFIG_SECTION_GLOBAL, "cleanup orphan hosts after seconds",
566
+ CONFIG_SECTION_DB, "cleanup orphan hosts after secs");
567
+
568
+ config_move(CONFIG_SECTION_GLOBAL, "delete obsolete charts files",
569
+ CONFIG_SECTION_DB, "delete obsolete charts files");
570
+
571
+ config_move(CONFIG_SECTION_GLOBAL, "delete orphan hosts files",
572
+ CONFIG_SECTION_DB, "delete orphan hosts files");
573
+
574
+ config_move(CONFIG_SECTION_GLOBAL, "enable zero metrics",
575
+ CONFIG_SECTION_DB, "enable zero metrics");
576
+
577
}
578
579
static void get_netdata_configured_variables() {
@@ -539,28 +591,40 @@ static void get_netdata_configured_variables() {
591
debug(D_OPTIONS, "hostname set to '%s'", netdata_configured_hostname);
592
593
// ------------------------------------------------------------------------
542
- // get default database size
543
-
544
- default_rrd_history_entries = (int) config_get_number(CONFIG_SECTION_GLOBAL, "history", align_entries_to_pagesize(default_rrd_memory_mode, RRD_DEFAULT_HISTORY_ENTRIES));
594
+ // get default database update frequency
595
546
- long h = align_entries_to_pagesize(default_rrd_memory_mode, default_rrd_history_entries);
547
- if(h != default_rrd_history_entries) {
548
- config_set_number(CONFIG_SECTION_GLOBAL, "history", h);
549
- default_rrd_history_entries = (int)h;
596
+ default_rrd_update_every = (int) config_get_number(CONFIG_SECTION_DB, "update every", UPDATE_EVERY);
597
+ if(default_rrd_update_every < 1 || default_rrd_update_every > 600) {
598
+ error("Invalid data collection frequency (update every) %d given. Defaulting to %d.", default_rrd_update_every, UPDATE_EVERY);
599
+ default_rrd_update_every = UPDATE_EVERY;
600
+ config_set_number(CONFIG_SECTION_DB, "update every", default_rrd_update_every);
601
}
602
552
- if(default_rrd_history_entries < 5 || default_rrd_history_entries > RRD_HISTORY_ENTRIES_MAX) {
553
- error("Invalid history entries %d given. Defaulting to %d.", default_rrd_history_entries, RRD_DEFAULT_HISTORY_ENTRIES);
554
- default_rrd_history_entries = RRD_DEFAULT_HISTORY_ENTRIES;
603
+ // ------------------------------------------------------------------------
604
+ // get default memory mode for the database
605
+
606
+ {
607
+ const char *mode = config_get(CONFIG_SECTION_DB, "mode", rrd_memory_mode_name(default_rrd_memory_mode));
608
+ default_rrd_memory_mode = rrd_memory_mode_id(mode);
609
+ if(strcmp(mode, rrd_memory_mode_name(default_rrd_memory_mode)) != 0) {
610
+ error("Invalid memory mode '%s' given. Using '%s'", mode, rrd_memory_mode_name(default_rrd_memory_mode));
611
+ config_set(CONFIG_SECTION_DB, "mode", rrd_memory_mode_name(default_rrd_memory_mode));
612
+ }
613
}
614
615
// ------------------------------------------------------------------------
558
- // get default database update frequency
616
+ // get default database size
617
560
- default_rrd_update_every = (int) config_get_number(CONFIG_SECTION_GLOBAL, "update every", UPDATE_EVERY);
561
- if(default_rrd_update_every < 1 || default_rrd_update_every > 600) {
562
- error("Invalid data collection frequency (update every) %d given. Defaulting to %d.", default_rrd_update_every, UPDATE_EVERY_MAX);
563
- default_rrd_update_every = UPDATE_EVERY;
618
+ if(default_rrd_memory_mode != RRD_MEMORY_MODE_DBENGINE && default_rrd_memory_mode != RRD_MEMORY_MODE_NONE) {
619
+ default_rrd_history_entries = (int)config_get_number(
620
+ CONFIG_SECTION_DB, "retention",
621
+ align_entries_to_pagesize(default_rrd_memory_mode, RRD_DEFAULT_HISTORY_ENTRIES));
622
+
623
+ long h = align_entries_to_pagesize(default_rrd_memory_mode, default_rrd_history_entries);
624
+ if (h != default_rrd_history_entries) {
625
+ config_set_number(CONFIG_SECTION_DB, "retention", h);
626
+ default_rrd_history_entries = (int)h;
627
+ }
628
}
629
630
// ------------------------------------------------------------------------
@@ -582,39 +646,38 @@ static void get_netdata_configured_variables() {
646
netdata_configured_primary_plugins_dir = plugin_directories[PLUGINSD_STOCK_PLUGINS_DIRECTORY_PATH];
647
}
648
585
- // ------------------------------------------------------------------------
586
- // get default memory mode for the database
587
-
588
- default_rrd_memory_mode = rrd_memory_mode_id(config_get(CONFIG_SECTION_GLOBAL, "memory mode", rrd_memory_mode_name(default_rrd_memory_mode)));
649
#ifdef ENABLE_DBENGINE
650
// ------------------------------------------------------------------------
651
// get default Database Engine page cache size in MiB
652
593
- db_engine_use_malloc = config_get_boolean(CONFIG_SECTION_GLOBAL, "page cache uses malloc", CONFIG_BOOLEAN_NO);
594
- default_rrdeng_page_cache_mb = (int) config_get_number(CONFIG_SECTION_GLOBAL, "page cache size", default_rrdeng_page_cache_mb);
653
+ db_engine_use_malloc = config_get_boolean(CONFIG_SECTION_DB, "page cache with malloc", CONFIG_BOOLEAN_NO);
654
+ default_rrdeng_page_cache_mb = (int) config_get_number(CONFIG_SECTION_DB, "page cache size MB", default_rrdeng_page_cache_mb);
655
if(default_rrdeng_page_cache_mb < RRDENG_MIN_PAGE_CACHE_SIZE_MB) {
656
error("Invalid page cache size %d given. Defaulting to %d.", default_rrdeng_page_cache_mb, RRDENG_MIN_PAGE_CACHE_SIZE_MB);
657
default_rrdeng_page_cache_mb = RRDENG_MIN_PAGE_CACHE_SIZE_MB;
658
+ config_set_number(CONFIG_SECTION_DB, "page cache size MB", default_rrdeng_page_cache_mb);
659
}
660
661
// ------------------------------------------------------------------------
662
// get default Database Engine disk space quota in MiB
663
603
- default_rrdeng_disk_quota_mb = (int) config_get_number(CONFIG_SECTION_GLOBAL, "dbengine disk space", default_rrdeng_disk_quota_mb);
664
+ default_rrdeng_disk_quota_mb = (int) config_get_number(CONFIG_SECTION_DB, "dbengine disk space MB", default_rrdeng_disk_quota_mb);
665
if(default_rrdeng_disk_quota_mb < RRDENG_MIN_DISK_SPACE_MB) {
666
error("Invalid dbengine disk space %d given. Defaulting to %d.", default_rrdeng_disk_quota_mb, RRDENG_MIN_DISK_SPACE_MB);
667
default_rrdeng_disk_quota_mb = RRDENG_MIN_DISK_SPACE_MB;
668
+ config_set_number(CONFIG_SECTION_DB, "dbengine disk space MB", default_rrdeng_disk_quota_mb);
669
}
670
609
- default_multidb_disk_quota_mb = (int) config_get_number(CONFIG_SECTION_GLOBAL, "dbengine multihost disk space", compute_multidb_diskspace());
671
+ default_multidb_disk_quota_mb = (int) config_get_number(CONFIG_SECTION_DB, "dbengine multihost disk space MB", compute_multidb_diskspace());
672
if(default_multidb_disk_quota_mb < RRDENG_MIN_DISK_SPACE_MB) {
673
error("Invalid multidb disk space %d given. Defaulting to %d.", default_multidb_disk_quota_mb, default_rrdeng_disk_quota_mb);
674
default_multidb_disk_quota_mb = default_rrdeng_disk_quota_mb;
675
+ config_set_number(CONFIG_SECTION_DB, "dbengine multihost disk space MB", default_multidb_disk_quota_mb);
676
}
677
#else
678
if (default_rrd_memory_mode == RRD_MEMORY_MODE_DBENGINE) {
616
- error_report("RRD_MEMORY_MODE_DBENGINE is not supported in this platform. The agent will use memory mode ram instead.");
617
- default_rrd_memory_mode = RRD_MEMORY_MODE_RAM;
679
+ error_report("RRD_MEMORY_MODE_DBENGINE is not supported in this platform. The agent will use db mode 'save' instead.");
680
+ default_rrd_memory_mode = RRD_MEMORY_MODE_SAVE;
681
}
682
#endif
683
// ------------------------------------------------------------------------
@@ -626,11 +689,12 @@ static void get_netdata_configured_variables() {
689
// get KSM settings
690
691
#ifdef MADV_MERGEABLE
629
- enable_ksm = config_get_boolean(CONFIG_SECTION_GLOBAL, "memory deduplication (ksm)", enable_ksm);
692
+ enable_ksm = config_get_boolean(CONFIG_SECTION_DB, "memory deduplication (ksm)", enable_ksm);
693
#endif
694
695
// --------------------------------------------------------------------
696
// metric correlations
697
+
698
enable_metric_correlations = config_get_boolean(CONFIG_SECTION_GLOBAL, "enable metric correlations", enable_metric_correlations);
699
default_metric_correlations_method = mc_string_to_method(config_get(CONFIG_SECTION_GLOBAL, "metric correlations method", mc_method_to_string(default_metric_correlations_method)));
700
@@ -1232,39 +1296,47 @@ int main(int argc, char **argv) {
1296
1297
// --------------------------------------------------------------------
1298
// get log filenames and settings
1299
+
1300
log_init();
1301
error_log_limit_unlimited();
1302
+
1303
// initialize the log files
1304
open_all_log_files();
1305
1306
#ifdef ENABLE_DBENGINE
1241
- default_rrdeng_page_fetch_timeout = (int) config_get_number(CONFIG_SECTION_GLOBAL, "dbengine page fetch timeout", PAGE_CACHE_FETCH_WAIT_TIMEOUT);
1307
+ default_rrdeng_page_fetch_timeout = (int) config_get_number(CONFIG_SECTION_DB, "dbengine page fetch timeout secs", PAGE_CACHE_FETCH_WAIT_TIMEOUT);
1308
if (default_rrdeng_page_fetch_timeout < 1) {
1243
- info("\"dbengine page fetch timeout\" found in netdata.conf cannot be %d, using 1", default_rrdeng_page_fetch_timeout);
1309
+ info("'dbengine page fetch timeout secs' cannot be %d, using 1", default_rrdeng_page_fetch_timeout);
1310
default_rrdeng_page_fetch_timeout = 1;
1311
+ config_set_number(CONFIG_SECTION_DB, "dbengine page fetch timeout secs", default_rrdeng_page_fetch_timeout);
1312
}
1313
1247
- default_rrdeng_page_fetch_retries = (int) config_get_number(CONFIG_SECTION_GLOBAL, "dbengine page fetch retries", MAX_PAGE_CACHE_FETCH_RETRIES);
1314
+ default_rrdeng_page_fetch_retries = (int) config_get_number(CONFIG_SECTION_DB, "dbengine page fetch retries", MAX_PAGE_CACHE_FETCH_RETRIES);
1315
if (default_rrdeng_page_fetch_retries < 1) {
1316
info("\"dbengine page fetch retries\" found in netdata.conf cannot be %d, using 1", default_rrdeng_page_fetch_retries);
1317
default_rrdeng_page_fetch_retries = 1;
1318
+ config_set_number(CONFIG_SECTION_DB, "dbengine page fetch retries", default_rrdeng_page_fetch_retries);
1319
}
1320
#endif
1321
1322
get_system_timezone();
1323
+
1324
// --------------------------------------------------------------------
1325
// get the certificate and start security
1326
+
1327
#ifdef ENABLE_HTTPS
1328
security_init();
1329
#endif
1330
1331
// --------------------------------------------------------------------
1332
// This is the safest place to start the SILENCERS structure
1333
+
1334
set_silencers_filename();
1335
health_initialize_global_silencers();
1336
1337
// --------------------------------------------------------------------
1338
// Initialize ML configuration
1339
+
1340
ml_init();
1341
1342
// --------------------------------------------------------------------
@@ -1272,9 +1344,11 @@ int main(int argc, char **argv) {
1344
1345
// block signals while initializing threads.
1346
// this causes the threads to block signals.
1347
+
1348
signals_block();
1349
1350
// setup the signals we want to use
1351
+
1352
signals_init();
1353
1354
// setup threads configs
@@ -1303,6 +1377,7 @@ int main(int argc, char **argv) {
1377
1378
if(web_server_mode != WEB_SERVER_MODE_NONE)
1379
api_listen_sockets_setup();
1380
+
1381
}
1382
1383
#ifdef NETDATA_INTERNAL_CHECKS
@@ -1386,7 +1461,7 @@ int main(int argc, char **argv) {
1461
1462
web_server_config_options();
1463
1389
- netdata_zero_metrics_enabled = config_get_boolean_ondemand(CONFIG_SECTION_GLOBAL, "enable zero metrics", CONFIG_BOOLEAN_NO);
1464
+ netdata_zero_metrics_enabled = config_get_boolean_ondemand(CONFIG_SECTION_DB, "enable zero metrics", CONFIG_BOOLEAN_NO);
1465
1466
set_late_global_environment();
1467
daemon/unit_test.c
+131
-120
@@ -4,7 +4,7 @@
4
5
static int check_number_printing(void) {
6
struct {
7
- calculated_number n;
7
+ NETDATA_DOUBLE n;
8
const char *correct;
9
} values[] = {
10
{ .n = 0, .correct = "0" },
@@ -22,8 +22,8 @@ static int check_number_printing(void) {
22
char netdata[50], system[50];
23
int i, failed = 0;
24
for(i = 0; values[i].correct ; i++) {
25
- print_calculated_number(netdata, values[i].n);
26
- snprintfz(system, 49, "%0.12" LONG_DOUBLE_MODIFIER, (LONG_DOUBLE)values[i].n);
25
+ print_netdata_double(netdata, values[i].n);
26
+ snprintfz(system, 49, "%0.12" NETDATA_DOUBLE_MODIFIER, (NETDATA_DOUBLE)values[i].n);
27
28
int ok = 1;
29
if(strcmp(netdata, values[i].correct) != 0) {
@@ -95,35 +95,36 @@ static int check_rrdcalc_comparisons(void) {
95
return 0;
96
}
97
98
-int check_storage_number(calculated_number n, int debug) {
98
+int check_storage_number(NETDATA_DOUBLE n, int debug) {
99
char buffer[100];
100
uint32_t flags = SN_DEFAULT_FLAGS;
101
102
storage_number s = pack_storage_number(n, flags);
103
- calculated_number d = unpack_storage_number(s);
103
+ NETDATA_DOUBLE d = unpack_storage_number(s);
104
105
if(!does_storage_number_exist(s)) {
106
- fprintf(stderr, "Exists flags missing for number " CALCULATED_NUMBER_FORMAT "!\n", n);
106
+ fprintf(stderr, "Exists flags missing for number " NETDATA_DOUBLE_FORMAT "!\n", n);
107
return 5;
108
}
109
110
- calculated_number ddiff = d - n;
111
- calculated_number dcdiff = ddiff * 100.0 / n;
110
+ NETDATA_DOUBLE ddiff = d - n;
111
+ NETDATA_DOUBLE dcdiff = ddiff * 100.0 / n;
112
113
if(dcdiff < 0) dcdiff = -dcdiff;
114
115
- size_t len = (size_t)print_calculated_number(buffer, d);
116
- calculated_number p = str2ld(buffer, NULL);
117
- calculated_number pdiff = n - p;
118
- calculated_number pcdiff = pdiff * 100.0 / n;
115
+ size_t len = (size_t)print_netdata_double(buffer, d);
116
+ NETDATA_DOUBLE p = str2ndd(buffer, NULL);
117
+ NETDATA_DOUBLE pdiff = n - p;
118
+ NETDATA_DOUBLE pcdiff = pdiff * 100.0 / n;
119
if(pcdiff < 0) pcdiff = -pcdiff;
120
121
if(debug) {
122
fprintf(stderr,
123
- CALCULATED_NUMBER_FORMAT " original\n"
124
- CALCULATED_NUMBER_FORMAT " packed and unpacked, (stored as 0x%08X, diff " CALCULATED_NUMBER_FORMAT ", " CALCULATED_NUMBER_FORMAT "%%)\n"
125
- "%s printed after unpacked (%zu bytes)\n"
126
- CALCULATED_NUMBER_FORMAT " re-parsed from printed (diff " CALCULATED_NUMBER_FORMAT ", " CALCULATED_NUMBER_FORMAT "%%)\n\n",
123
+ NETDATA_DOUBLE_FORMAT
124
+ " original\n" NETDATA_DOUBLE_FORMAT " packed and unpacked, (stored as 0x%08X, diff " NETDATA_DOUBLE_FORMAT
125
+ ", " NETDATA_DOUBLE_FORMAT "%%)\n"
126
+ "%s printed after unpacked (%zu bytes)\n" NETDATA_DOUBLE_FORMAT
127
+ " re-parsed from printed (diff " NETDATA_DOUBLE_FORMAT ", " NETDATA_DOUBLE_FORMAT "%%)\n\n",
128
n,
129
d, s, ddiff, dcdiff,
130
buffer, len,
@@ -132,10 +133,11 @@ int check_storage_number(calculated_number n, int debug) {
133
if(len != strlen(buffer)) fprintf(stderr, "ERROR: printed number %s is reported to have length %zu but it has %zu\n", buffer, len, strlen(buffer));
134
135
if(dcdiff > ACCURACY_LOSS_ACCEPTED_PERCENT)
135
- fprintf(stderr, "WARNING: packing number " CALCULATED_NUMBER_FORMAT " has accuracy loss " CALCULATED_NUMBER_FORMAT " %%\n", n, dcdiff);
136
+ fprintf(stderr, "WARNING: packing number " NETDATA_DOUBLE_FORMAT " has accuracy loss " NETDATA_DOUBLE_FORMAT " %%\n", n, dcdiff);
137
138
if(pcdiff > ACCURACY_LOSS_ACCEPTED_PERCENT)
138
- fprintf(stderr, "WARNING: re-parsing the packed, unpacked and printed number " CALCULATED_NUMBER_FORMAT " has accuracy loss " CALCULATED_NUMBER_FORMAT " %%\n", n, pcdiff);
139
+ fprintf(stderr, "WARNING: re-parsing the packed, unpacked and printed number " NETDATA_DOUBLE_FORMAT
140
+ " has accuracy loss " NETDATA_DOUBLE_FORMAT " %%\n", n, pcdiff);
141
}
142
143
if(len != strlen(buffer)) return 1;
@@ -144,8 +146,8 @@ int check_storage_number(calculated_number n, int debug) {
146
return 0;
147
}
148
147
-calculated_number storage_number_min(calculated_number n) {
148
- calculated_number r = 1, last;
149
+NETDATA_DOUBLE storage_number_min(NETDATA_DOUBLE n) {
150
+ NETDATA_DOUBLE r = 1, last;
151
152
do {
153
last = n;
@@ -159,12 +161,12 @@ calculated_number storage_number_min(calculated_number n) {
161
162
void benchmark_storage_number(int loop, int multiplier) {
163
int i, j;
162
- calculated_number n, d;
164
+ NETDATA_DOUBLE n, d;
165
storage_number s;
166
unsigned long long user, system, total, mine, their;
167
166
- calculated_number storage_number_positive_min = unpack_storage_number(STORAGE_NUMBER_POSITIVE_MIN_RAW);
167
- calculated_number storage_number_positive_max = unpack_storage_number(STORAGE_NUMBER_POSITIVE_MAX_RAW);
168
+ NETDATA_DOUBLE storage_number_positive_min = unpack_storage_number(STORAGE_NUMBER_POSITIVE_MIN_RAW);
169
+ NETDATA_DOUBLE storage_number_positive_max = unpack_storage_number(STORAGE_NUMBER_POSITIVE_MAX_RAW);
170
171
char buffer[100];
172
@@ -174,25 +176,25 @@ void benchmark_storage_number(int loop, int multiplier) {
176
177
// ------------------------------------------------------------------------
178
177
- fprintf(stderr, "SYSTEM LONG DOUBLE SIZE: %zu bytes\n", sizeof(calculated_number));
179
+ fprintf(stderr, "SYSTEM LONG DOUBLE SIZE: %zu bytes\n", sizeof(NETDATA_DOUBLE));
180
fprintf(stderr, "NETDATA FLOATING POINT SIZE: %zu bytes\n", sizeof(storage_number));
181
180
- mine = (calculated_number)sizeof(storage_number) * (calculated_number)loop;
181
- their = (calculated_number)sizeof(calculated_number) * (calculated_number)loop;
182
+ mine = (NETDATA_DOUBLE)sizeof(storage_number) * (NETDATA_DOUBLE)loop;
183
+ their = (NETDATA_DOUBLE)sizeof(NETDATA_DOUBLE) * (NETDATA_DOUBLE)loop;
184
185
if(mine > their) {
184
- fprintf(stderr, "\nNETDATA NEEDS %0.2" LONG_DOUBLE_MODIFIER " TIMES MORE MEMORY. Sorry!\n", (LONG_DOUBLE)(mine / their));
186
+ fprintf(stderr, "\nNETDATA NEEDS %0.2" NETDATA_DOUBLE_MODIFIER " TIMES MORE MEMORY. Sorry!\n", (NETDATA_DOUBLE)(mine / their));
187
}
188
else {
187
- fprintf(stderr, "\nNETDATA INTERNAL FLOATING POINT ARITHMETICS NEEDS %0.2" LONG_DOUBLE_MODIFIER " TIMES LESS MEMORY.\n", (LONG_DOUBLE)(their / mine));
189
+ fprintf(stderr, "\nNETDATA INTERNAL FLOATING POINT ARITHMETICS NEEDS %0.2" NETDATA_DOUBLE_MODIFIER " TIMES LESS MEMORY.\n", (NETDATA_DOUBLE)(their / mine));
190
}
191
192
fprintf(stderr, "\nNETDATA FLOATING POINT\n");
191
- fprintf(stderr, "MIN POSITIVE VALUE " CALCULATED_NUMBER_FORMAT "\n", unpack_storage_number(STORAGE_NUMBER_POSITIVE_MIN_RAW));
192
- fprintf(stderr, "MAX POSITIVE VALUE " CALCULATED_NUMBER_FORMAT "\n", unpack_storage_number(STORAGE_NUMBER_POSITIVE_MAX_RAW));
193
- fprintf(stderr, "MIN NEGATIVE VALUE " CALCULATED_NUMBER_FORMAT "\n", unpack_storage_number(STORAGE_NUMBER_NEGATIVE_MIN_RAW));
194
- fprintf(stderr, "MAX NEGATIVE VALUE " CALCULATED_NUMBER_FORMAT "\n", unpack_storage_number(STORAGE_NUMBER_NEGATIVE_MAX_RAW));
195
- fprintf(stderr, "Maximum accuracy loss accepted: " CALCULATED_NUMBER_FORMAT "%%\n\n\n", (calculated_number)ACCURACY_LOSS_ACCEPTED_PERCENT);
193
+ fprintf(stderr, "MIN POSITIVE VALUE " NETDATA_DOUBLE_FORMAT "\n", unpack_storage_number(STORAGE_NUMBER_POSITIVE_MIN_RAW));
194
+ fprintf(stderr, "MAX POSITIVE VALUE " NETDATA_DOUBLE_FORMAT "\n", unpack_storage_number(STORAGE_NUMBER_POSITIVE_MAX_RAW));
195
+ fprintf(stderr, "MIN NEGATIVE VALUE " NETDATA_DOUBLE_FORMAT "\n", unpack_storage_number(STORAGE_NUMBER_NEGATIVE_MIN_RAW));
196
+ fprintf(stderr, "MAX NEGATIVE VALUE " NETDATA_DOUBLE_FORMAT "\n", unpack_storage_number(STORAGE_NUMBER_NEGATIVE_MAX_RAW));
197
+ fprintf(stderr, "Maximum accuracy loss accepted: " NETDATA_DOUBLE_FORMAT "%%\n\n\n", (NETDATA_DOUBLE)ACCURACY_LOSS_ACCEPTED_PERCENT);
198
199
// ------------------------------------------------------------------------
200
@@ -207,7 +209,7 @@ void benchmark_storage_number(int loop, int multiplier) {
209
n *= multiplier;
210
if(n > storage_number_positive_max) n = storage_number_positive_min;
211
210
- print_calculated_number(buffer, n);
212
+ print_netdata_double(buffer, n);
213
}
214
}
215
@@ -217,7 +219,8 @@ void benchmark_storage_number(int loop, int multiplier) {
219
total = user + system;
220
mine = total;
221
220
- fprintf(stderr, "user %0.5" LONG_DOUBLE_MODIFIER", system %0.5" LONG_DOUBLE_MODIFIER ", total %0.5" LONG_DOUBLE_MODIFIER "\n", (LONG_DOUBLE)(user / 1000000.0), (LONG_DOUBLE)(system / 1000000.0), (LONG_DOUBLE)(total / 1000000.0));
222
+ fprintf(stderr, "user %0.5" NETDATA_DOUBLE_MODIFIER ", system %0.5" NETDATA_DOUBLE_MODIFIER
223
+ ", total %0.5" NETDATA_DOUBLE_MODIFIER "\n", (NETDATA_DOUBLE)(user / 1000000.0), (NETDATA_DOUBLE)(system / 1000000.0), (NETDATA_DOUBLE)(total / 1000000.0));
224
225
// ------------------------------------------------------------------------
226
@@ -231,7 +234,7 @@ void benchmark_storage_number(int loop, int multiplier) {
234
for(i = 0; i < loop ;i++) {
235
n *= multiplier;
236
if(n > storage_number_positive_max) n = storage_number_positive_min;
234
- snprintfz(buffer, 100, CALCULATED_NUMBER_FORMAT, n);
237
+ snprintfz(buffer, 100, NETDATA_DOUBLE_FORMAT, n);
238
}
239
}
240
@@ -241,13 +244,14 @@ void benchmark_storage_number(int loop, int multiplier) {
244
total = user + system;
245
their = total;
246
244
- fprintf(stderr, "user %0.5" LONG_DOUBLE_MODIFIER ", system %0.5" LONG_DOUBLE_MODIFIER ", total %0.5" LONG_DOUBLE_MODIFIER "\n", (LONG_DOUBLE)(user / 1000000.0), (LONG_DOUBLE)(system / 1000000.0), (LONG_DOUBLE)(total / 1000000.0));
247
+ fprintf(stderr, "user %0.5" NETDATA_DOUBLE_MODIFIER ", system %0.5" NETDATA_DOUBLE_MODIFIER
248
+ ", total %0.5" NETDATA_DOUBLE_MODIFIER "\n", (NETDATA_DOUBLE)(user / 1000000.0), (NETDATA_DOUBLE)(system / 1000000.0), (NETDATA_DOUBLE)(total / 1000000.0));
249
250
if(mine > total) {
247
- fprintf(stderr, "NETDATA CODE IS SLOWER %0.2" LONG_DOUBLE_MODIFIER " %%\n", (LONG_DOUBLE)(mine * 100.0 / their - 100.0));
251
+ fprintf(stderr, "NETDATA CODE IS SLOWER %0.2" NETDATA_DOUBLE_MODIFIER " %%\n", (NETDATA_DOUBLE)(mine * 100.0 / their - 100.0));
252
}
253
else {
250
- fprintf(stderr, "NETDATA CODE IS F A S T E R %0.2" LONG_DOUBLE_MODIFIER " %%\n", (LONG_DOUBLE)(their * 100.0 / mine - 100.0));
254
+ fprintf(stderr, "NETDATA CODE IS F A S T E R %0.2" NETDATA_DOUBLE_MODIFIER " %%\n", (NETDATA_DOUBLE)(their * 100.0 / mine - 100.0));
255
}
256
257
// ------------------------------------------------------------------------
@@ -265,7 +269,7 @@ void benchmark_storage_number(int loop, int multiplier) {
269
270
s = pack_storage_number(n, SN_DEFAULT_FLAGS);
271
d = unpack_storage_number(s);
268
- print_calculated_number(buffer, d);
272
+ print_netdata_double(buffer, d);
273
}
274
}
275
@@ -275,13 +279,14 @@ void benchmark_storage_number(int loop, int multiplier) {
279
total = user + system;
280
mine = total;
281
278
- fprintf(stderr, "user %0.5" LONG_DOUBLE_MODIFIER ", system %0.5" LONG_DOUBLE_MODIFIER ", total %0.5" LONG_DOUBLE_MODIFIER "\n", (LONG_DOUBLE)(user / 1000000.0), (LONG_DOUBLE)(system / 1000000.0), (LONG_DOUBLE)(total / 1000000.0));
282
+ fprintf(stderr, "user %0.5" NETDATA_DOUBLE_MODIFIER ", system %0.5" NETDATA_DOUBLE_MODIFIER
283
+ ", total %0.5" NETDATA_DOUBLE_MODIFIER "\n", (NETDATA_DOUBLE)(user / 1000000.0), (NETDATA_DOUBLE)(system / 1000000.0), (NETDATA_DOUBLE)(total / 1000000.0));
284
285
if(mine > their) {
281
- fprintf(stderr, "WITH PACKING UNPACKING NETDATA CODE IS SLOWER %0.2" LONG_DOUBLE_MODIFIER " %%\n", (LONG_DOUBLE)(mine * 100.0 / their - 100.0));
286
+ fprintf(stderr, "WITH PACKING UNPACKING NETDATA CODE IS SLOWER %0.2" NETDATA_DOUBLE_MODIFIER " %%\n", (NETDATA_DOUBLE)(mine * 100.0 / their - 100.0));
287
}
288
else {
284
- fprintf(stderr, "EVEN WITH PACKING AND UNPACKING, NETDATA CODE IS F A S T E R %0.2" LONG_DOUBLE_MODIFIER " %%\n", (LONG_DOUBLE)(their * 100.0 / mine - 100.0));
289
+ fprintf(stderr, "EVEN WITH PACKING AND UNPACKING, NETDATA CODE IS F A S T E R %0.2" NETDATA_DOUBLE_MODIFIER " %%\n", (NETDATA_DOUBLE)(their * 100.0 / mine - 100.0));
290
}
291
292
// ------------------------------------------------------------------------
@@ -290,13 +295,13 @@ void benchmark_storage_number(int loop, int multiplier) {
295
296
static int check_storage_number_exists() {
297
uint32_t flags = SN_DEFAULT_FLAGS;
293
- calculated_number n = 0.0;
298
+ NETDATA_DOUBLE n = 0.0;
299
300
storage_number s = pack_storage_number(n, flags);
296
- calculated_number d = unpack_storage_number(s);
301
+ NETDATA_DOUBLE d = unpack_storage_number(s);
302
303
if(n != d) {
299
- fprintf(stderr, "Wrong number returned. Expected " CALCULATED_NUMBER_FORMAT ", returned " CALCULATED_NUMBER_FORMAT "!\n", n, d);
304
+ fprintf(stderr, "Wrong number returned. Expected " NETDATA_DOUBLE_FORMAT ", returned " NETDATA_DOUBLE_FORMAT "!\n", n, d);
305
return 1;
306
}
307
@@ -306,10 +311,10 @@ static int check_storage_number_exists() {
311
int unit_test_storage() {
312
if(check_storage_number_exists()) return 0;
313
309
- calculated_number storage_number_positive_min = unpack_storage_number(STORAGE_NUMBER_POSITIVE_MIN_RAW);
310
- calculated_number storage_number_negative_max = unpack_storage_number(STORAGE_NUMBER_NEGATIVE_MAX_RAW);
314
+ NETDATA_DOUBLE storage_number_positive_min = unpack_storage_number(STORAGE_NUMBER_POSITIVE_MIN_RAW);
315
+ NETDATA_DOUBLE storage_number_negative_max = unpack_storage_number(STORAGE_NUMBER_NEGATIVE_MAX_RAW);
316
312
- calculated_number c, a = 0;
317
+ NETDATA_DOUBLE c, a = 0;
318
int i, j, g, r = 0;
319
320
for(g = -1; g <= 1 ; g++) {
@@ -343,23 +348,26 @@ int unit_test_str2ld() {
348
int i;
349
for(i = 0; values[i] ; i++) {
350
char *e_mine = "hello", *e_sys = "world";
346
- LONG_DOUBLE mine = str2ld(values[i], &e_mine);
347
- LONG_DOUBLE sys = strtold(values[i], &e_sys);
351
+ NETDATA_DOUBLE mine = str2ndd(values[i], &e_mine);
352
+ NETDATA_DOUBLE sys = strtondd(values[i], &e_sys);
353
354
if(isnan(mine)) {
355
if(!isnan(sys)) {
351
- fprintf(stderr, "Value '%s' is parsed as %" LONG_DOUBLE_MODIFIER ", but system believes it is %" LONG_DOUBLE_MODIFIER ".\n", values[i], mine, sys);
356
+ fprintf(stderr, "Value '%s' is parsed as %" NETDATA_DOUBLE_MODIFIER
357
+ ", but system believes it is %" NETDATA_DOUBLE_MODIFIER ".\n", values[i], mine, sys);
358
return -1;
359
}
360
}
361
else if(isinf(mine)) {
362
if(!isinf(sys)) {
357
- fprintf(stderr, "Value '%s' is parsed as %" LONG_DOUBLE_MODIFIER ", but system believes it is %" LONG_DOUBLE_MODIFIER ".\n", values[i], mine, sys);
363
+ fprintf(stderr, "Value '%s' is parsed as %" NETDATA_DOUBLE_MODIFIER
364
+ ", but system believes it is %" NETDATA_DOUBLE_MODIFIER ".\n", values[i], mine, sys);
365
return -1;
366
}
367
}
368
else if(mine != sys && ABS(mine-sys) > 0.000001) {
362
- fprintf(stderr, "Value '%s' is parsed as %" LONG_DOUBLE_MODIFIER ", but system believes it is %" LONG_DOUBLE_MODIFIER ", delta %" LONG_DOUBLE_MODIFIER ".\n", values[i], mine, sys, sys-mine);
369
+ fprintf(stderr, "Value '%s' is parsed as %" NETDATA_DOUBLE_MODIFIER
370
+ ", but system believes it is %" NETDATA_DOUBLE_MODIFIER ", delta %" NETDATA_DOUBLE_MODIFIER ".\n", values[i], mine, sys, sys-mine);
371
return -1;
372
}
373
@@ -368,7 +376,8 @@ int unit_test_str2ld() {
376
return -1;
377
}
378
371
- fprintf(stderr, "str2ld() parsed value '%s' exactly the same way with strtold(), returned %" LONG_DOUBLE_MODIFIER " vs %" LONG_DOUBLE_MODIFIER "\n", values[i], mine, sys);
379
+ fprintf(stderr, "str2ndd() parsed value '%s' exactly the same way with strtold(), returned %" NETDATA_DOUBLE_MODIFIER
380
+ " vs %" NETDATA_DOUBLE_MODIFIER "\n", values[i], mine, sys);
381
}
382
383
return 0;
@@ -461,10 +470,10 @@ struct test {
470
unsigned long feed_entries;
471
unsigned long result_entries;
472
struct feed_values *feed;
464
- calculated_number *results;
473
+ NETDATA_DOUBLE *results;
474
475
collected_number *feed2;
467
- calculated_number *results2;
476
+ NETDATA_DOUBLE *results2;
477
};
478
479
// --------------------------------------------------------------------------------------------------------------------
@@ -484,7 +493,7 @@ struct feed_values test1_feed[] = {
493
{ 1000000, 100 },
494
};
495
487
-calculated_number test1_results[] = {
496
+NETDATA_DOUBLE test1_results[] = {
497
20, 30, 40, 50, 60, 70, 80, 90, 100
498
};
499
@@ -520,7 +529,7 @@ struct feed_values test2_feed[] = {
529
{ 1000000, 100 },
530
};
531
523
-calculated_number test2_results[] = {
532
+NETDATA_DOUBLE test2_results[] = {
533
20, 30, 40, 50, 60, 70, 80, 90, 100
534
};
535
@@ -555,7 +564,7 @@ struct feed_values test3_feed[] = {
564
{ 1000000, 100 },
565
};
566
558
-calculated_number test3_results[] = {
567
+NETDATA_DOUBLE test3_results[] = {
568
10, 10, 10, 10, 10, 10, 10, 10, 10
569
};
570
@@ -590,7 +599,7 @@ struct feed_values test4_feed[] = {
599
{ 1000000, 100 },
600
};
601
593
-calculated_number test4_results[] = {
602
+NETDATA_DOUBLE test4_results[] = {
603
10, 10, 10, 10, 10, 10, 10, 10, 10
604
};
605
@@ -625,7 +634,7 @@ struct feed_values test5_feed[] = {
634
{ 1000000, 0x00000000FFFFFFFFULL / 15 * 0 },
635
};
636
628
-calculated_number test5_results[] = {
637
+NETDATA_DOUBLE test5_results[] = {
638
0x00000000FFFFFFFFULL / 15 * 7,
639
0x00000000FFFFFFFFULL / 15 * 7,
640
0x00000000FFFFFFFFULL / 15,
@@ -668,7 +677,7 @@ struct feed_values test5b_feed[] = {
677
{ 1000000, 0xFFFFFFFFFFFFFFFFULL / 15 * 0 },
678
};
679
671
-calculated_number test5b_results[] = {
680
+NETDATA_DOUBLE test5b_results[] = {
681
0xFFFFFFFFFFFFFFFFULL / 15 * 7,
682
0xFFFFFFFFFFFFFFFFULL / 15 * 7,
683
0xFFFFFFFFFFFFFFFFULL / 15,
@@ -717,7 +726,7 @@ struct feed_values test6_feed[] = {
726
{ 250000, 16000 },
727
};
728
720
-calculated_number test6_results[] = {
729
+NETDATA_DOUBLE test6_results[] = {
730
4000, 4000, 4000, 4000
731
};
732
@@ -752,7 +761,7 @@ struct feed_values test7_feed[] = {
761
{ 2000000, 10000 },
762
};
763
755
-calculated_number test7_results[] = {
764
+NETDATA_DOUBLE test7_results[] = {
765
500, 500, 500, 500, 500, 500, 500, 500, 500, 500, 500, 500, 500, 500, 500, 500, 500, 500, 500
766
};
767
@@ -783,7 +792,7 @@ struct feed_values test8_feed[] = {
792
{ 2000000, 6000 },
793
};
794
786
-calculated_number test8_results[] = {
795
+NETDATA_DOUBLE test8_results[] = {
796
1250, 2000, 2250, 3000, 3250, 4000, 4250, 5000, 5250, 6000
797
};
798
@@ -824,7 +833,7 @@ struct feed_values test9_feed[] = {
833
{ 250000, 16000 },
834
};
835
827
-calculated_number test9_results[] = {
836
+NETDATA_DOUBLE test9_results[] = {
837
4000, 8000, 12000, 16000
838
};
839
@@ -859,7 +868,7 @@ struct feed_values test10_feed[] = {
868
{ 1000000, 6900 + 1000 },
869
};
870
862
-calculated_number test10_results[] = {
871
+NETDATA_DOUBLE test10_results[] = {
872
1000, 1000, 1000, 1000, 1000, 1000, 1000
873
};
874
@@ -898,11 +907,11 @@ collected_number test11_feed2[] = {
907
10, 20, 30, 40, 50, 60, 70, 80, 90, 100
908
};
909
901
-calculated_number test11_results[] = {
910
+NETDATA_DOUBLE test11_results[] = {
911
50, 50, 50, 50, 50, 50, 50, 50, 50
912
};
913
905
-calculated_number test11_results2[] = {
914
+NETDATA_DOUBLE test11_results2[] = {
915
50, 50, 50, 50, 50, 50, 50, 50, 50
916
};
917
@@ -941,11 +950,11 @@ collected_number test12_feed2[] = {
950
10*3, 20*3, 30*3, 40*3, 50*3, 60*3, 70*3, 80*3, 90*3, 100*3
951
};
952
944
-calculated_number test12_results[] = {
953
+NETDATA_DOUBLE test12_results[] = {
954
25, 25, 25, 25, 25, 25, 25, 25, 25
955
};
956
948
-calculated_number test12_results2[] = {
957
+NETDATA_DOUBLE test12_results2[] = {
958
75, 75, 75, 75, 75, 75, 75, 75, 75
959
};
960
@@ -980,7 +989,7 @@ struct feed_values test13_feed[] = {
989
{ 1000000, 6900 + 1000 },
990
};
991
983
-calculated_number test13_results[] = {
992
+NETDATA_DOUBLE test13_results[] = {
993
83.3333300, 100, 100, 100, 100, 100, 100
994
};
995
@@ -1015,7 +1024,7 @@ struct feed_values test14_feed[] = {
1024
{ 29942000, 0x0153987f888982d0ULL },
1025
};
1026
1018
-calculated_number test14_results[] = {
1027
+NETDATA_DOUBLE test14_results[] = {
1028
23.1383300, 21.8515600, 21.8804600, 21.7788000, 22.0112200, 22.4386100, 22.0906100, 21.9150800
1029
};
1030
@@ -1047,7 +1056,7 @@ struct feed_values test14b_feed[] = {
1056
{ 29942000, 13573000 + 29969000 + 29958000 + 30054000 + 34952000 + 25046000 + 29947000 + 30054000 + 29942000 },
1057
};
1058
1050
-calculated_number test14b_results[] = {
1059
+NETDATA_DOUBLE test14b_results[] = {
1060
1000000, 1000000, 1000000, 1000000, 1000000, 1000000, 1000000, 1000000
1061
};
1062
@@ -1079,7 +1088,7 @@ struct feed_values test14c_feed[] = {
1088
{ 30000000, 29000000 + 1000000 + 30000000 + 30000000 + 30000000 + 30000000 + 30000000 + 30000000 + 30000000 + 30000000 },
1089
};
1090
1082
-calculated_number test14c_results[] = {
1091
+NETDATA_DOUBLE test14c_results[] = {
1092
1000000, 1000000, 1000000, 1000000, 1000000, 1000000, 1000000, 1000000, 1000000
1093
};
1094
@@ -1118,11 +1127,11 @@ collected_number test15_feed2[] = {
1127
178825286, 178825286, 178825286, 178825286, 178825498, 178825498, 179165652, 179202964, 179203282, 179204130
1128
};
1129
1121
-calculated_number test15_results[] = {
1130
+NETDATA_DOUBLE test15_results[] = {
1131
5857.4080000, 5898.4540000, 5891.6590000, 5806.3160000, 5914.2640000, 3202.2630000, 5589.6560000, 5822.5260000, 5911.7520000
1132
};
1133
1125
-calculated_number test15_results2[] = {
1134
+NETDATA_DOUBLE test15_results2[] = {
1135
0.0000000, 0.0000000, 0.0024944, 1.6324779, 0.0212777, 2655.1890000, 290.5387000, 5.6733610, 6.5960220
1136
};
1137
@@ -1173,12 +1182,13 @@ int run_test(struct test *test)
1182
1183
if(c) {
1184
time_now += test->feed[c].microseconds;
1176
- fprintf(stderr, " > %s: feeding position %lu, after %0.3f seconds (%0.3f seconds from start), delta " CALCULATED_NUMBER_FORMAT ", rate " CALCULATED_NUMBER_FORMAT "\n",
1185
+ fprintf(stderr, " > %s: feeding position %lu, after %0.3f seconds (%0.3f seconds from start), delta " NETDATA_DOUBLE_FORMAT
1186
+ ", rate " NETDATA_DOUBLE_FORMAT "\n",
1187
test->name, c+1,
1188
(float)test->feed[c].microseconds / 1000000.0,
1189
(float)time_now / 1000000.0,
1180
- ((calculated_number)test->feed[c].value - (calculated_number)last) * (calculated_number)test->multiplier / (calculated_number)test->divisor,
1181
- (((calculated_number)test->feed[c].value - (calculated_number)last) * (calculated_number)test->multiplier / (calculated_number)test->divisor) / (calculated_number)test->feed[c].microseconds * (calculated_number)1000000);
1190
+ ((NETDATA_DOUBLE)test->feed[c].value - (NETDATA_DOUBLE)last) * (NETDATA_DOUBLE)test->multiplier / (NETDATA_DOUBLE)test->divisor,
1191
+ (((NETDATA_DOUBLE)test->feed[c].value - (NETDATA_DOUBLE)last) * (NETDATA_DOUBLE)test->multiplier / (NETDATA_DOUBLE)test->divisor) / (NETDATA_DOUBLE)test->feed[c].microseconds * (NETDATA_DOUBLE)1000000);
1192
1193
// rrdset_next_usec_unfiltered(st, test->feed[c].microseconds);
1194
st->usec_since_last_update = test->feed[c].microseconds;
@@ -1216,10 +1226,11 @@ int run_test(struct test *test)
1226
1227
unsigned long max = (st->counter < test->result_entries)?st->counter:test->result_entries;
1228
for(c = 0 ; c < max ; c++) {
1219
- calculated_number v = unpack_storage_number(rd->values[c]);
1220
- calculated_number n = unpack_storage_number(pack_storage_number(test->results[c], SN_DEFAULT_FLAGS));
1221
- int same = (calculated_number_round(v * 10000000.0) == calculated_number_round(n * 10000000.0))?1:0;
1222
- fprintf(stderr, " %s/%s: checking position %lu (at %"PRId64" secs), expecting value " CALCULATED_NUMBER_FORMAT ", found " CALCULATED_NUMBER_FORMAT ", %s\n",
1229
+ NETDATA_DOUBLE v = unpack_storage_number(rd->db[c]);
1230
+ NETDATA_DOUBLE n = unpack_storage_number(pack_storage_number(test->results[c], SN_DEFAULT_FLAGS));
1231
+ int same = (roundndd(v * 10000000.0) == roundndd(n * 10000000.0))?1:0;
1232
+ fprintf(stderr, " %s/%s: checking position %lu (at %"PRId64" secs), expecting value " NETDATA_DOUBLE_FORMAT
1233
+ ", found " NETDATA_DOUBLE_FORMAT ", %s\n",
1234
test->name, rd->name, c+1,
1235
(int64_t)((rrdset_first_entry_t(st) + c * st->update_every) - time_start),
1236
n, v, (same)?"OK":"### E R R O R ###");
@@ -1227,10 +1238,11 @@ int run_test(struct test *test)
1238
if(!same) errors++;
1239
1240
if(rd2) {
1230
- v = unpack_storage_number(rd2->values[c]);
1241
+ v = unpack_storage_number(rd2->db[c]);
1242
n = test->results2[c];
1232
- same = (calculated_number_round(v * 10000000.0) == calculated_number_round(n * 10000000.0))?1:0;
1233
- fprintf(stderr, " %s/%s: checking position %lu (at %"PRId64" secs), expecting value " CALCULATED_NUMBER_FORMAT ", found " CALCULATED_NUMBER_FORMAT ", %s\n",
1243
+ same = (roundndd(v * 10000000.0) == roundndd(n * 10000000.0))?1:0;
1244
+ fprintf(stderr, " %s/%s: checking position %lu (at %"PRId64" secs), expecting value " NETDATA_DOUBLE_FORMAT
1245
+ ", found " NETDATA_DOUBLE_FORMAT ", %s\n",
1246
test->name, rd2->name, c+1,
1247
(int64_t)((rrdset_first_entry_t(st) + c * st->update_every) - time_start),
1248
n, v, (same)?"OK":"### E R R O R ###");
@@ -1470,14 +1482,14 @@ int unit_test(long delay, long shift)
1482
1483
int ret = 0;
1484
storage_number sn;
1473
- calculated_number cn, v;
1485
+ NETDATA_DOUBLE cn, v;
1486
for(c = 0 ; c < st->counter ; c++) {
1487
fprintf(stderr, "\nPOSITION: c = %lu, EXPECTED VALUE %lu\n", c, (oincrement + c * increment + increment * (1000000 - shift) / 1000000 )* 10);
1488
1489
for(rd = st->dimensions ; rd ; rd = rd->next) {
1478
- sn = rd->values[c];
1490
+ sn = rd->db[c];
1491
cn = unpack_storage_number(sn);
1480
- fprintf(stderr, "\t %s " CALCULATED_NUMBER_FORMAT " (PACKED AS " STORAGE_NUMBER_FORMAT ") -> ", rd->id, cn, sn);
1492
+ fprintf(stderr, "\t %s " NETDATA_DOUBLE_FORMAT " (PACKED AS " STORAGE_NUMBER_FORMAT ") -> ", rd->id, cn, sn);
1493
1494
if(rd == rdabs) v =
1495
( oincrement
@@ -1492,7 +1504,7 @@ int unit_test(long delay, long shift)
1504
1505
if(v == cn) fprintf(stderr, "passed.\n");
1506
else {
1495
- fprintf(stderr, "ERROR! (expected " CALCULATED_NUMBER_FORMAT ")\n", v);
1507
+ fprintf(stderr, "ERROR! (expected " NETDATA_DOUBLE_FORMAT ")\n", v);
1508
ret = 1;
1509
}
1510
}
@@ -1742,7 +1754,7 @@ static int test_dbengine_check_metrics(RRDSET *st[CHARTS], RRDDIM *rd[CHARTS][DI
1754
time_t time_now, time_retrieved;
1755
int i, j, k, c, errors, update_every;
1756
collected_number last;
1745
- calculated_number value, expected;
1757
+ NETDATA_DOUBLE value, expected;
1758
SN_FLAGS nflags;
1759
struct rrddim_query_handle handle;
1760
size_t value_errors = 0, time_errors = 0;
@@ -1759,16 +1771,16 @@ static int test_dbengine_check_metrics(RRDSET *st[CHARTS], RRDDIM *rd[CHARTS][DI
1771
for (k = 0; k < QUERY_BATCH; ++k) {
1772
last = ((collected_number)i * DIMS) * REGION_POINTS[current_region] +
1773
j * REGION_POINTS[current_region] + c + k;
1762
- expected = unpack_storage_number(pack_storage_number((calculated_number)last, SN_DEFAULT_FLAGS));
1774
+ expected = unpack_storage_number(pack_storage_number((NETDATA_DOUBLE)last, SN_DEFAULT_FLAGS));
1775
1776
time_t end_time;
1777
value = rd[i][j]->state->query_ops.next_metric(&handle, &time_retrieved, &end_time, &nflags);
1778
1767
- same = (calculated_number_round(value) == calculated_number_round(expected)) ? 1 : 0;
1779
+ same = (roundndd(value) == roundndd(expected)) ? 1 : 0;
1780
if(!same) {
1781
if(!value_errors)
1770
- fprintf(stderr, " DB-engine unittest %s/%s: at %lu secs, expecting value "
1771
- CALCULATED_NUMBER_FORMAT ", found " CALCULATED_NUMBER_FORMAT ", ### E R R O R ###\n",
1782
+ fprintf(stderr, " DB-engine unittest %s/%s: at %lu secs, expecting value " NETDATA_DOUBLE_FORMAT
1783
+ ", found " NETDATA_DOUBLE_FORMAT ", ### E R R O R ###\n",
1784
st[i]->name, rd[i][j]->name, (unsigned long)time_now + k * update_every, expected, value);
1785
value_errors++;
1786
errors++;
@@ -1806,7 +1818,7 @@ static int test_dbengine_check_rrdr(RRDSET *st[CHARTS], RRDDIM *rd[CHARTS][DIMS]
1818
int i, j, errors, value_errors = 0, time_errors = 0;
1819
long c;
1820
collected_number last;
1809
- calculated_number value, expected;
1821
+ NETDATA_DOUBLE value, expected;
1822
1823
errors = 0;
1824
long points = (time_end - time_start) / update_every;
@@ -1825,18 +1837,18 @@ static int test_dbengine_check_rrdr(RRDSET *st[CHARTS], RRDDIM *rd[CHARTS][DIMS]
1837
1838
// for each dimension
1839
for (j = 0, d = r->st->dimensions ; d && j < r->d ; ++j, d = d->next) {
1828
- calculated_number *cn = &r->v[ c * r->d ];
1840
+ NETDATA_DOUBLE *cn = &r->v[ c * r->d ];
1841
value = cn[j];
1842
assert(rd[i][j] == d);
1843
1844
last = i * DIMS * REGION_POINTS[current_region] + j * REGION_POINTS[current_region] + c;
1833
- expected = unpack_storage_number(pack_storage_number((calculated_number)last, SN_DEFAULT_FLAGS));
1845
+ expected = unpack_storage_number(pack_storage_number((NETDATA_DOUBLE)last, SN_DEFAULT_FLAGS));
1846
1835
- same = (calculated_number_round(value) == calculated_number_round(expected)) ? 1 : 0;
1847
+ same = (roundndd(value) == roundndd(expected)) ? 1 : 0;
1848
if(!same) {
1849
if(value_errors < 10)
1838
- fprintf(stderr, " DB-engine unittest %s/%s: at %lu secs, expecting value "
1839
- CALCULATED_NUMBER_FORMAT ", RRDR found " CALCULATED_NUMBER_FORMAT ", ### E R R O R ###\n",
1850
+ fprintf(stderr, " DB-engine unittest %s/%s: at %lu secs, expecting value " NETDATA_DOUBLE_FORMAT
1851
+ ", RRDR found " NETDATA_DOUBLE_FORMAT ", ### E R R O R ###\n",
1852
st[i]->name, rd[i][j]->name, (unsigned long)time_now, expected, value);
1853
value_errors++;
1854
}
@@ -1959,18 +1971,18 @@ int test_dbengine(void)
1971
1972
// for each dimension
1973
for(j = 0, d = r->st->dimensions ; d && j < r->d ; ++j, d = d->next) {
1962
- calculated_number *cn = &r->v[ c * r->d ];
1963
- calculated_number value = cn[j];
1974
+ NETDATA_DOUBLE *cn = &r->v[ c * r->d ];
1975
+ NETDATA_DOUBLE value = cn[j];
1976
assert(rd[i][j] == d);
1977
1978
collected_number last = i * DIMS * REGION_POINTS[current_region] + j * REGION_POINTS[current_region] + c - point_offset + 1;
1967
- calculated_number expected = unpack_storage_number(pack_storage_number((calculated_number)last, SN_DEFAULT_FLAGS));
1979
+ NETDATA_DOUBLE expected = unpack_storage_number(pack_storage_number((NETDATA_DOUBLE)last, SN_DEFAULT_FLAGS));
1980
1969
- uint8_t same = (calculated_number_round(value) == calculated_number_round(expected)) ? 1 : 0;
1981
+ uint8_t same = (roundndd(value) == roundndd(expected)) ? 1 : 0;
1982
if(!same) {
1983
if(!value_errors)
1972
- fprintf(stderr, " DB-engine unittest %s/%s: at %lu secs, expecting value "
1973
- CALCULATED_NUMBER_FORMAT ", RRDR found " CALCULATED_NUMBER_FORMAT ", ### E R R O R ###\n",
1984
+ fprintf(stderr, " DB-engine unittest %s/%s: at %lu secs, expecting value " NETDATA_DOUBLE_FORMAT
1985
+ ", RRDR found " NETDATA_DOUBLE_FORMAT ", ### E R R O R ###\n",
1986
st[i]->name, rd[i][j]->name, (unsigned long)time_now, expected, value);
1987
value_errors++;
1988
}
@@ -2167,7 +2179,7 @@ static void query_dbengine_chart(void *arg)
2179
uint8_t same;
2180
time_t time_now, time_retrieved;
2181
collected_number generatedv;
2170
- calculated_number value, expected;
2182
+ NETDATA_DOUBLE value, expected;
2183
SN_FLAGS nflags;
2184
struct rrddim_query_handle handle;
2185
size_t value_errors = 0, time_errors = 0;
@@ -2200,12 +2212,12 @@ static void query_dbengine_chart(void *arg)
2212
++thread_info->queries_nr;
2213
for (time_now = time_after ; time_now <= time_before ; time_now += update_every) {
2214
generatedv = generate_dbengine_chart_value(i, j, time_now);
2203
- expected = unpack_storage_number(pack_storage_number((calculated_number) generatedv, SN_DEFAULT_FLAGS));
2215
+ expected = unpack_storage_number(pack_storage_number((NETDATA_DOUBLE) generatedv, SN_DEFAULT_FLAGS));
2216
2217
if (unlikely(rd->state->query_ops.is_finished(&handle))) {
2218
if (!thread_info->delete_old_data) { /* data validation only when we don't delete */
2207
- fprintf(stderr, " DB-engine stresstest %s/%s: at %lu secs, expecting value "
2208
- CALCULATED_NUMBER_FORMAT ", found data gap, ### E R R O R ###\n",
2219
+ fprintf(stderr, " DB-engine stresstest %s/%s: at %lu secs, expecting value " NETDATA_DOUBLE_FORMAT
2220
+ ", found data gap, ### E R R O R ###\n",
2221
st->name, rd->name, (unsigned long) time_now, expected);
2222
++thread_info->errors;
2223
}
@@ -2213,10 +2225,10 @@ static void query_dbengine_chart(void *arg)
2225
}
2226
time_t end_time;
2227
value = rd->state->query_ops.next_metric(&handle, &time_retrieved, &end_time, &nflags);
2216
- if (!calculated_number_isnumber(value)) {
2228
+ if (!netdata_double_isnumber(value)) {
2229
if (!thread_info->delete_old_data) { /* data validation only when we don't delete */
2218
- fprintf(stderr, " DB-engine stresstest %s/%s: at %lu secs, expecting value "
2219
- CALCULATED_NUMBER_FORMAT ", found data gap, ### E R R O R ###\n",
2230
+ fprintf(stderr, " DB-engine stresstest %s/%s: at %lu secs, expecting value " NETDATA_DOUBLE_FORMAT
2231
+ ", found data gap, ### E R R O R ###\n",
2232
st->name, rd->name, (unsigned long) time_now, expected);
2233
++thread_info->errors;
2234
}
@@ -2224,13 +2236,12 @@ static void query_dbengine_chart(void *arg)
2236
}
2237
++thread_info->queried_metrics_nr;
2238
2227
- same = (calculated_number_round(value) == calculated_number_round(expected)) ? 1 : 0;
2239
+ same = (roundndd(value) == roundndd(expected)) ? 1 : 0;
2240
if (!same) {
2241
if (!thread_info->delete_old_data) { /* data validation only when we don't delete */
2242
if(!value_errors)
2231
- fprintf(stderr, " DB-engine stresstest %s/%s: at %lu secs, expecting value "
2232
- CALCULATED_NUMBER_FORMAT ", found " CALCULATED_NUMBER_FORMAT
2233
- ", ### E R R O R ###\n",
2243
+ fprintf(stderr, " DB-engine stresstest %s/%s: at %lu secs, expecting value " NETDATA_DOUBLE_FORMAT
2244
+ ", found " NETDATA_DOUBLE_FORMAT ", ### E R R O R ###\n",
2245
st->name, rd->name, (unsigned long) time_now, expected, value);
2246
value_errors++;
2247
thread_info->errors++;
database/README.md
+17
-24
@@ -13,7 +13,7 @@ Netdata is fully capable of long-term metrics storage, at per-second granularity
13
traditional database. There is some amount of RAM dedicated to data caching and indexing and the rest of the data
14
reside compressed on disk. The number of history entries is not fixed in this case, but depends on the configured
15
disk space and the effective compression ratio of the data stored. This is the **only mode** that supports changing
16
- the data collection update frequency (`update_every`) **without losing** the previously stored metrics. For more
16
+ the data collection update frequency (`update every`) **without losing** the previously stored metrics. For more
17
details see [here](/database/engine/README.md).
18
19
2. `ram`, data are purely in memory. Data are never saved on disk. This mode uses `mmap()` and supports [KSM](#ksm).
@@ -32,15 +32,12 @@ Netdata is fully capable of long-term metrics storage, at per-second granularity
32
6. `alloc`, like `ram` but it uses `calloc()` and does not support [KSM](#ksm). This mode is the fallback for all
33
others except `none`.
34
35
-You can select the memory mode by editing `netdata.conf` and setting:
35
+You can select the database mode by editing `netdata.conf` and setting:
36
37
```conf
38
-[global]
38
+[db]
39
# dbengine (default), ram, save (the default if dbengine not available), map (swap like), none, alloc
40
- memory mode = dbengine
41
-
42
- # the directory where data are saved
43
- cache directory = /var/cache/netdata
40
+ mode = dbengine
41
```
42
43
## Running Netdata in embedded devices
@@ -49,26 +46,23 @@ Embedded devices usually have very limited RAM resources available.
46
47
There are 2 settings for you to tweak:
48
52
-1. `update every`, which controls the data collection frequency
53
-2. `history`, which controls the size of the database in RAM (except for `memory mode = dbengine`)
49
+1. `[db].update every`, which controls the data collection frequency
50
+2. `[db].retention`, which controls the size of the database in memory (except for `[db].mode = dbengine`)
51
55
-By default `update every = 1` and `history = 3600`. This gives you an hour of data with per second updates.
52
+By default `[db].update every = 1` and `[db].retention = 3600`. This gives you an hour of data with per second updates.
53
57
-If you set `update every = 2` and `history = 1800`, you will still have an hour of data, but collected once every 2
54
+If you set `[db].update every = 2` and `[db].retention = 1800`, you will still have an hour of data, but collected once every 2
55
seconds. This will **cut in half** both CPU and RAM resources consumed by Netdata. Of course experiment a bit. On very
59
-weak devices you might have to use `update every = 5` and `history = 720` (still 1 hour of data, but 1/5 of the CPU and
56
+weak devices you might have to use `[db].update every = 5` and `[db].retention = 720` (still 1 hour of data, but 1/5 of the CPU and
57
RAM resources).
58
59
You can also disable [data collection plugins](/collectors/README.md) you don't need. Disabling such plugins will also free both
60
CPU and RAM resources.
61
65
-## Running a dedicated central Netdata server
66
-
67
-Netdata allows streaming data between Netdata nodes. This allows us to have a central Netdata server that will maintain
68
-the entire database for all nodes, and will also run health checks/alarms for all nodes.
62
+## Running a dedicated parent Netdata server
63
70
-For this central Netdata, memory size can be a problem. Fortunately, Netdata supports several memory modes. **One
71
-interesting option** for this setup is `memory mode = map`.
64
+Netdata allows streaming data between Netdata nodes in real-time. This allows having one or more parent Netdata servers that will maintain
65
+the entire database for all the nodes that connect to them (their children), and will also run health checks/alarms for all these nodes.
66
67
### map
68
@@ -77,8 +71,7 @@ in memory, but the kernel automatically loads and saves memory pages from/to dis
71
72
**We suggest _not_ to use this mode on nodes that run other applications.** There will always be dirty memory to be
73
synced and this syncing process may influence the way other applications work. This mode however is useful when we need
80
-a central Netdata server that would normally need huge amounts of memory. Using memory mode `map` we can overcome all
81
-memory restrictions.
74
+a parent Netdata server that would normally need huge amounts of memory.
75
76
There are a few kernel options that provide finer control on the way this syncing works. But before explaining them, a
77
brief introduction of how Netdata database works is needed.
@@ -142,8 +135,8 @@ vm.dirty_ratio = 90
135
vm.dirty_writeback_centisecs = 0
136
```
137
145
-There is another memory mode to help overcome the memory size problem. What is **most interesting for this setup** is
146
-`memory mode = dbengine`.
138
+There is another mode to help overcome the memory size problem. What is **most interesting for this setup** is
139
+`[db].mode = dbengine`.
140
141
### dbengine
142
@@ -154,12 +147,12 @@ configured disk space and the effective compression ratio of the data stored.
147
148
We suggest to use **this** mode on nodes that also run other applications. The Database Engine uses direct I/O to avoid
149
polluting the OS filesystem caches and does not generate excessive I/O traffic so as to create the minimum possible
157
-interference with other applications. Using memory mode `dbengine` we can overcome most memory restrictions. For more
150
+interference with other applications. Using mode `dbengine` we can overcome most memory restrictions. For more
151
details see [here](/database/engine/README.md).
152
153
## KSM
154
162
-Netdata offers all its round robin database to kernel for deduplication (except for `memory mode = dbengine`).
155
+Netdata offers all its in-memory database to kernel for deduplication.
156
157
In the past KSM has been criticized for consuming a lot of CPU resources. Although this is true when KSM is used for
158
deduplicating certain applications, it is not true with netdata, since the Netdata memory is written very infrequently
database/engine/README.md
+32
-33
@@ -7,63 +7,62 @@ custom_edit_url: https://github.com/netdata/netdata/edit/master/database/engine/
7
# Database engine
8
9
The Database Engine works like a traditional database. It dedicates a certain amount of RAM to data caching and
10
-indexing, while the rest of the data resides compressed on disk. Unlike other [memory modes](/database/README.md), the
10
+indexing, while the rest of the data resides compressed on disk. Unlike other [database modes](/database/README.md), the
11
amount of historical metrics stored is based on the amount of disk space you allocate and the effective compression
12
ratio, not a fixed number of metrics collected.
13
14
By using both RAM and disk space, the database engine allows for long-term storage of per-second metrics inside of the
15
Agent itself.
16
17
-In addition, the database engine is the only memory mode that supports changing the data collection update frequency
18
-(`update_every`) without losing the metrics your Agent already gathered and stored.
17
+In addition, the dbengine is the only mode that supports changing the data collection update frequency
18
+(`update every`) without losing the metrics your Agent already gathered and stored.
19
20
## Configuration
21
22
-To use the database engine, open `netdata.conf` and set `memory mode` to `dbengine`.
22
+To use the database engine, open `netdata.conf` and set `[db].mode` to `dbengine`.
23
24
```conf
25
-[global]
26
- memory mode = dbengine
25
+[db]
26
+ mode = dbengine
27
```
28
29
-To configure the database engine, look for the `page cache size` and `dbengine multihost disk space` settings in the
30
-`[global]` section of your `netdata.conf`. The Agent ignores the `history` setting when using the database engine.
29
+To configure the database engine, look for the `page cache size MB` and `dbengine multihost disk space MB` settings in the
30
+`[db]` section of your `netdata.conf`. The Agent ignores the `[db].retention` setting when using the dbengine.
31
32
```conf
33
-[global]
34
- page cache size = 32
35
- dbengine multihost disk space = 256
33
+[db]
34
+ page cache size MB = 32
35
+ dbengine multihost disk space MB = 256
36
```
37
38
-The above values are the default values for Page Cache size and DB engine disk space quota. Both numbers are
39
-in **MiB**.
38
+The above values are the default values for Page Cache size and DB engine disk space quota.
39
41
-The `page cache size` option determines the amount of RAM in **MiB** dedicated to caching Netdata metric values. The
40
+The `page cache size MB` option determines the amount of RAM dedicated to caching Netdata metric values. The
41
actual page cache size will be slightly larger than this figure—see the [memory requirements](#memory-requirements)
42
section for details.
43
45
-The `dbengine multihost disk space` option determines the amount of disk space in **MiB** that is dedicated to storing
44
+The `dbengine multihost disk space MB` option determines the amount of disk space that is dedicated to storing
45
Netdata metric values and all related metadata describing them. You can use the [**database engine
46
calculator**](/docs/store/change-metrics-storage.md#calculate-the-system-resources-ram-disk-space-needed-to-store-metrics)
48
-to correctly set `dbengine multihost disk space` based on your metrics retention policy. The calculator gives an
47
+to correctly set `dbengine multihost disk space MB` based on your metrics retention policy. The calculator gives an
48
accurate estimate based on how many child nodes you have, how many metrics your Agent collects, and more.
49
50
### Legacy configuration
51
53
-The deprecated `dbengine disk space` option determines the amount of disk space in **MiB** that is dedicated to storing
52
+The deprecated `dbengine disk space MB` option determines the amount of disk space that is dedicated to storing
53
Netdata metric values per legacy database engine instance (see [details on the legacy mode](#legacy-mode) below).
54
55
```conf
57
-[global]
58
- dbengine disk space = 256
56
+[db]
57
+ dbengine disk space MB = 256
58
```
59
60
### Streaming metrics to the database engine
61
63
-When using the multihost database engine, all parent and child nodes share the same `page cache size` and `dbengine
64
-multihost disk space` in a single dbengine instance. The [**database engine
62
+When using the multihost database engine, all parent and child nodes share the same `page cache size MB` and `dbengine
63
+multihost disk space MB` in a single dbengine instance. The [**database engine
64
calculator**](/docs/store/change-metrics-storage.md#calculate-the-system-resources-ram-disk-space-needed-to-store-metrics)
66
-helps you properly set `page cache size` and `dbengine multihost disk space` on your parent node to allocate enough
65
+helps you properly set `page cache size MB` and `dbengine multihost disk space MB` on your parent node to allocate enough
66
resources based on your metrics retention policy and how many child nodes you have.
67
68
#### Legacy mode
@@ -72,8 +71,8 @@ _For Netdata Agents earlier than v1.23.2_, the Agent on the parent node uses one
71
another instance for every child node it receives metrics from. If you had four streaming nodes, you would have five
72
instances in total (`1 parent + 4 child nodes = 5 instances`).
73
75
-The Agent allocates resources for each instance separately using the `dbengine disk space` (**deprecated**) setting. If
76
-`dbengine disk space`(**deprecated**) is set to the default `256`, each instance is given 256 MiB in disk space, which
74
+The Agent allocates resources for each instance separately using the `dbengine disk space MB` (**deprecated**) setting. If
75
+`dbengine disk space MB`(**deprecated**) is set to the default `256`, each instance is given 256 MiB in disk space, which
76
means the total disk space required to store all instances is, roughly, `256 MiB * 1 parent * 4 child nodes = 1280 MiB`.
77
78
#### Backward compatibility
@@ -88,18 +87,18 @@ Agent.
87
88
##### Information
89
91
-For more information about setting `memory mode` on your nodes, in addition to other streaming configurations, see
90
+For more information about setting `[db].mode` on your nodes, in addition to other streaming configurations, see
91
[streaming](/streaming/README.md).
92
93
### Memory requirements
94
96
-Using memory mode `dbengine` we can overcome most memory restrictions and store a dataset that is much larger than the
95
+Using database mode `dbengine` we can overcome most memory restrictions and store a dataset that is much larger than the
96
available memory.
97
98
There are explicit memory requirements **per** DB engine **instance**:
99
100
- The total page cache memory footprint will be an additional `#dimensions-being-collected x 4096 x 2` bytes over what
102
- the user configured with `page cache size`.
101
+ the user configured with `page cache size MB`.
102
103
- an additional `#pages-on-disk x 4096 x 0.03` bytes of RAM are allocated for metadata.
104
@@ -132,7 +131,7 @@ Netdata allocates 25% of the available file descriptors to its Database Engine i
131
the file descriptors that are available to the Netdata service are accessible by dbengine instances. You should take
132
that into account when configuring your service or system-wide file descriptor limits. You can roughly estimate that the
133
Netdata service needs 2048 file descriptors for every 10 streaming child hosts when streaming is configured to use
135
-`memory mode = dbengine`.
134
+`[db].mode = dbengine`.
135
136
If for example one wants to allocate 65536 file descriptors to the Netdata service on a systemd system one needs to
137
override the Netdata service by running `sudo systemctl edit netdata` and creating a file with contents:
@@ -166,7 +165,7 @@ You can apply the settings by running `sysctl -p` or by rebooting.
165
166
## Files
167
169
-With the DB engine memory mode the metric data are stored in database files. These files are organized in pairs, the
168
+With the DB engine mode the metric data are stored in database files. These files are organized in pairs, the
169
datafiles and their corresponding journalfiles, e.g.:
170
171
```sh
@@ -232,10 +231,10 @@ so as to avoid all disk bottlenecks.
231
The reported numbers are the following:
232
233
| device | page cache | dataset | reads/sec | writes/sec |
235
-| :----: | :--------: | ------: | --------: | ---------: |
236
-| HDD | 64 MiB | 4.1 GiB | 813K | 18.0M |
237
-| SSD | 64 MiB | 9.8 GiB | 1.7M | 43.0M |
238
-| N/A | 16 GiB | 6.8 GiB | 118.2M | 30.2M |
234
+|:------:|:----------:|--------:|----------:|-----------:|
235
+| HDD | 64 MiB | 4.1 GiB | 813K | 18.0M |
236
+| SSD | 64 MiB | 9.8 GiB | 1.7M | 43.0M |
237
+| N/A | 16 GiB | 6.8 GiB | 118.2M | 30.2M |
238
239
where "reads/sec" is the number of metric data points being read from the database via its API per second and
240
"writes/sec" is the number of metric data points being written to the database per second.
database/engine/rrdengine.c
+5
-9
@@ -1074,16 +1074,12 @@ struct rrdeng_cmd rrdeng_deq_cmd(struct rrdengine_worker_config* wc)
1074
1075
static void load_configuration_dynamic(void)
1076
{
1077
- unsigned read_num;
1078
- static int printed_error = 0;
1079
-
1080
- read_num = (unsigned) config_get_number(CONFIG_SECTION_GLOBAL, "dbengine extent pages",
1081
- MAX_PAGES_PER_EXTENT);
1082
- if (read_num > 0 && read_num <= MAX_PAGES_PER_EXTENT) {
1077
+ unsigned read_num = (unsigned)config_get_number(CONFIG_SECTION_DB, "dbengine pages per extent", MAX_PAGES_PER_EXTENT);
1078
+ if (read_num > 0 && read_num <= MAX_PAGES_PER_EXTENT)
1079
pages_per_extent = read_num;
1084
- } else if (!printed_error) {
1085
- printed_error = 1;
1086
- error("Invalid dbengine extent pages %u given. Defaulting to %u.", read_num, pages_per_extent);
1080
+ else {
1081
+ error("Invalid dbengine pages per extent %u given. Using %u.", read_num, pages_per_extent);
1082
+ config_set_number(CONFIG_SECTION_DB, "dbengine pages per extent", pages_per_extent);
1083
}
1084
}
1085
database/engine/rrdengineapi.c
+3
-2
@@ -195,7 +195,7 @@ void rrdeng_store_metric_flush_current_page(RRDDIM *rd)
195
handle->descr = NULL;
196
}
197
198
-void rrdeng_store_metric_next(RRDDIM *rd, usec_t point_in_time, calculated_number n, SN_FLAGS flags)
198
+void rrdeng_store_metric_next(RRDDIM *rd, usec_t point_in_time, NETDATA_DOUBLE n, SN_FLAGS flags)
199
{
200
storage_number number = pack_storage_number(n, flags);
201
@@ -603,7 +603,8 @@ static int rrdeng_load_page_next(struct rrddim_query_handle *rrdimm_handle) {
603
// Returns the metric and sets its timestamp into current_time
604
// IT IS REQUIRED TO **ALWAYS** SET ALL RETURN VALUES (current_time, end_time, flags)
605
// IT IS REQUIRED TO **ALWAYS** KEEP TRACK OF TIME, EVEN OUTSIDE THE DATABASE BOUNDARIES
606
-calculated_number rrdeng_load_metric_next(struct rrddim_query_handle *rrdimm_handle, time_t *start_time, time_t *end_time, SN_FLAGS *flags) {
606
+NETDATA_DOUBLE
607
+rrdeng_load_metric_next(struct rrddim_query_handle *rrdimm_handle, time_t *start_time, time_t *end_time, SN_FLAGS *flags) {
608
struct rrdeng_query_handle *handle = (struct rrdeng_query_handle *)rrdimm_handle->handle;
609
610
struct rrdeng_page_descr *descr = handle->descr;
database/engine/rrdengineapi.h
+2
-2
@@ -42,14 +42,14 @@ extern void rrdeng_convert_legacy_uuid_to_multihost(char machine_guid[GUID_LEN +
42
extern void rrdeng_metric_init(RRDDIM *rd);
43
extern void rrdeng_store_metric_init(RRDDIM *rd);
44
extern void rrdeng_store_metric_flush_current_page(RRDDIM *rd);
45
-extern void rrdeng_store_metric_next(RRDDIM *rd, usec_t point_in_time, calculated_number number, SN_FLAGS flags);
45
+extern void rrdeng_store_metric_next(RRDDIM *rd, usec_t point_in_time, NETDATA_DOUBLE number, SN_FLAGS flags);
46
extern int rrdeng_store_metric_finalize(RRDDIM *rd);
47
extern unsigned
48
rrdeng_variable_step_boundaries(RRDSET *st, time_t start_time, time_t end_time,
49
struct rrdeng_region_info **region_info_arrayp, unsigned *max_intervalp, struct context_param *context_param_list);
50
extern void rrdeng_load_metric_init(RRDDIM *rd, struct rrddim_query_handle *rrdimm_handle,
51
time_t start_time, time_t end_time);
52
-extern calculated_number rrdeng_load_metric_next(struct rrddim_query_handle *rrdimm_handle, time_t *start_time, time_t *end_time, SN_FLAGS *flags);
52
+extern NETDATA_DOUBLE rrdeng_load_metric_next(struct rrddim_query_handle *rrdimm_handle, time_t *start_time, time_t *end_time, SN_FLAGS *flags);
53
extern int rrdeng_load_metric_is_finished(struct rrddim_query_handle *rrdimm_handle);
54
extern void rrdeng_load_metric_finalize(struct rrddim_query_handle *rrdimm_handle);
55
extern time_t rrdeng_metric_latest_time(RRDDIM *rd);
database/metric_correlations.c
+34
-32
@@ -9,7 +9,7 @@ int metric_correlations_version = 1;
9
METRIC_CORRELATIONS_METHOD default_metric_correlations_method = METRIC_CORRELATIONS_KS2;
10
11
typedef struct mc_stats {
12
- calculated_number max_base_high_ratio;
12
+ NETDATA_DOUBLE max_base_high_ratio;
13
size_t db_points;
14
size_t result_points;
15
size_t db_queries;
@@ -58,7 +58,7 @@ struct register_result {
58
const char *chart_id;
59
const char *context;
60
const char *dim_name;
61
- calculated_number value;
61
+ NETDATA_DOUBLE value;
62
};
63
64
static void register_result_insert_callback(const char *name, void *value, void *data) {
@@ -93,11 +93,11 @@ static void register_result_destroy(DICTIONARY *results) {
93
dictionary_destroy(results);
94
}
95
96
-static void register_result(DICTIONARY *results, RRDSET *st, RRDDIM *d, calculated_number value, RESULT_FLAGS flags, MC_STATS *stats) {
97
- if(!calculated_number_isnumber(value)) return;
96
+static void register_result(DICTIONARY *results, RRDSET *st, RRDDIM *d, NETDATA_DOUBLE value, RESULT_FLAGS flags, MC_STATS *stats) {
97
+ if(!netdata_double_isnumber(value)) return;
98
99
// make it positive
100
- calculated_number v = calculated_number_fabs(value);
100
+ NETDATA_DOUBLE v = fabsndd(value);
101
102
// no need to store zero scored values
103
if(v == 0.0) return;
@@ -186,7 +186,7 @@ static size_t registered_results_to_json(DICTIONARY *results, BUFFER *wb,
186
chart_dims = 0;
187
}
188
if (chart_dims) buffer_sprintf(wb, ",\n");
189
- buffer_sprintf(wb, "\t\t\t\t\"%s\": " CALCULATED_NUMBER_FORMAT, t->dim_name, t->value);
189
+ buffer_sprintf(wb, "\t\t\t\t\"%s\": " NETDATA_DOUBLE_FORMAT, t->dim_name, t->value);
190
chart_dims++;
191
total_dimensions++;
192
}
@@ -240,14 +240,14 @@ int compare_diffs(const void *left, const void *right) {
240
return (lt > rt) - (lt < rt);
241
}
242
243
-static size_t calculate_pairs_diff(DIFFS_NUMBERS *diffs, calculated_number *arr, size_t size) {
244
- calculated_number *last = &arr[size - 1];
243
+static size_t calculate_pairs_diff(DIFFS_NUMBERS *diffs, NETDATA_DOUBLE *arr, size_t size) {
244
+ NETDATA_DOUBLE *last = &arr[size - 1];
245
size_t added = 0;
246
247
while(last > arr) {
248
- calculated_number second = *last--;
249
- calculated_number first = *last;
250
- *diffs++ = (DIFFS_NUMBERS)((first - second) * (calculated_number)DOUBLE_TO_INT_MULTIPLIER);
248
+ NETDATA_DOUBLE second = *last--;
249
+ NETDATA_DOUBLE first = *last;
250
+ *diffs++ = (DIFFS_NUMBERS)((first - second) * (NETDATA_DOUBLE)DOUBLE_TO_INT_MULTIPLIER);
251
added++;
252
}
253
@@ -356,7 +356,9 @@ static double ks_2samp(DIFFS_NUMBERS baseline_diffs[], int base_size, DIFFS_NUMB
356
return KSfbar((int)en, d);
357
}
358
359
-static double kstwo(calculated_number baseline[], int baseline_points, calculated_number highlight[], int highlight_points, uint32_t base_shifts) {
359
+static double kstwo(
360
+ NETDATA_DOUBLE baseline[], int baseline_points,
361
+ NETDATA_DOUBLE highlight[], int highlight_points, uint32_t base_shifts) {
362
// -1 in size, since the calculate_pairs_diffs() returns one less point
363
DIFFS_NUMBERS baseline_diffs[baseline_points - 1];
364
DIFFS_NUMBERS highlight_diffs[highlight_points - 1];
@@ -469,14 +471,14 @@ static int rrdset_metric_correlations_ks2(RRDSET *st, DICTIONARY *results,
471
472
// copy the baseline points of the dimension to a contiguous array
473
// there is no need to check for empty values, since empty are already zero
472
- calculated_number baseline[base_points];
474
+ NETDATA_DOUBLE baseline[base_points];
475
for(int c = 0; c < base_points; c++)
476
baseline[c] = base_rrdr->v[ c * base_rrdr->d + i ];
477
478
// copy the highlight points of the dimension to a contiguous array
479
// there is no need to check for empty values, since empty values are already zero
480
// https://github.com/netdata/netdata/blob/6e3144683a73a2024d51425b20ecfd569034c858/web/api/queries/average/average.c#L41-L43
479
- calculated_number highlight[high_points];
481
+ NETDATA_DOUBLE highlight[high_points];
482
for(int c = 0; c < high_points; c++)
483
highlight[c] = high_rrdr->v[ c * high_rrdr->d + i ];
484
@@ -537,7 +539,7 @@ static int rrdset_metric_correlations_volume(RRDSET *st, DICTIONARY *results,
539
// dimensions, and we query a single dimension at a time.
540
541
stats->db_queries++;
540
- calculated_number baseline_average = NAN;
542
+ NETDATA_DOUBLE baseline_average = NAN;
543
uint8_t base_anomaly_rate = 0;
544
value_is_null = 1;
545
ret = rrdset2value_api_v1(st, NULL, &baseline_average, d->id, 1,
@@ -547,13 +549,13 @@ static int rrdset_metric_correlations_volume(RRDSET *st, DICTIONARY *results,
549
&stats->db_points, &stats->result_points,
550
&value_is_null, &base_anomaly_rate, 0);
551
550
- if(ret != HTTP_RESP_OK || value_is_null || !calculated_number_isnumber(baseline_average)) {
552
+ if(ret != HTTP_RESP_OK || value_is_null || !netdata_double_isnumber(baseline_average)) {
553
// this means no data for the baseline window, but we may have data for the highlighted one - assume zero
554
baseline_average = 0.0;
555
}
556
557
stats->db_queries++;
556
- calculated_number highlight_average = NAN;
558
+ NETDATA_DOUBLE highlight_average = NAN;
559
uint8_t high_anomaly_rate = 0;
560
value_is_null = 1;
561
ret = rrdset2value_api_v1(st, NULL, &highlight_average, d->id, 1,
@@ -563,7 +565,7 @@ static int rrdset_metric_correlations_volume(RRDSET *st, DICTIONARY *results,
565
&stats->db_points, &stats->result_points,
566
&value_is_null, &high_anomaly_rate, 0);
567
566
- if(ret != HTTP_RESP_OK || value_is_null || !calculated_number_isnumber(highlight_average)) {
568
+ if(ret != HTTP_RESP_OK || value_is_null || !netdata_double_isnumber(highlight_average)) {
569
// this means no data for the highlighted duration - so skip it
570
continue;
571
}
@@ -574,11 +576,11 @@ static int rrdset_metric_correlations_volume(RRDSET *st, DICTIONARY *results,
576
}
577
578
stats->db_queries++;
577
- calculated_number highlight_countif = NAN;
579
+ NETDATA_DOUBLE highlight_countif = NAN;
580
value_is_null = 1;
581
582
char highlighted_countif_options[50 + 1];
581
- snprintfz(highlighted_countif_options, 50, "%s" CALCULATED_NUMBER_FORMAT, highlight_average < baseline_average ? "<":">", baseline_average);
583
+ snprintfz(highlighted_countif_options, 50, "%s" NETDATA_DOUBLE_FORMAT, highlight_average < baseline_average ? "<":">", baseline_average);
584
585
ret = rrdset2value_api_v1(st, NULL, &highlight_countif, d->id, 1,
586
after, before,
@@ -588,7 +590,7 @@ static int rrdset_metric_correlations_volume(RRDSET *st, DICTIONARY *results,
590
&stats->db_points, &stats->result_points,
591
&value_is_null, NULL, 0);
592
591
- if(ret != HTTP_RESP_OK || value_is_null || !calculated_number_isnumber(highlight_countif)) {
593
+ if(ret != HTTP_RESP_OK || value_is_null || !netdata_double_isnumber(highlight_countif)) {
594
info("MC: highlighted countif query failed, but highlighted average worked - strange...");
595
continue;
596
}
@@ -599,7 +601,7 @@ static int rrdset_metric_correlations_volume(RRDSET *st, DICTIONARY *results,
601
highlight_countif = highlight_countif / 100.0; // countif returns 0 - 100.0
602
603
RESULT_FLAGS flags;
602
- calculated_number pcent = NAN;
604
+ NETDATA_DOUBLE pcent = NAN;
605
if(isgreater(baseline_average, 0.0) || isless(baseline_average, 0.0)) {
606
flags = RESULT_IS_BASE_HIGH_RATIO;
607
pcent = (highlight_average - baseline_average) / baseline_average * highlight_countif;
@@ -615,15 +617,15 @@ static int rrdset_metric_correlations_volume(RRDSET *st, DICTIONARY *results,
617
return correlated_dimensions;
618
}
619
618
-int compare_calculated_numbers(const void *left, const void *right) {
619
- calculated_number lt = *(calculated_number *)left;
620
- calculated_number rt = *(calculated_number *)right;
620
+int compare_netdata_doubles(const void *left, const void *right) {
621
+ NETDATA_DOUBLE lt = *(NETDATA_DOUBLE *)left;
622
+ NETDATA_DOUBLE rt = *(NETDATA_DOUBLE *)right;
623
624
// https://stackoverflow.com/a/3886497/1114110
625
return (lt > rt) - (lt < rt);
626
}
627
626
-static inline int binary_search_bigger_than_calculated_number(const calculated_number arr[], int left, int size, calculated_number K) {
628
+static inline int binary_search_bigger_than_netdata_double(const NETDATA_DOUBLE arr[], int left, int size, NETDATA_DOUBLE K) {
629
// binary search to find the index the smallest index
630
// of the first value in the array that is greater than K
631
@@ -655,7 +657,7 @@ static size_t spread_results_evenly(DICTIONARY *results, MC_STATS *stats) {
657
stats->max_base_high_ratio = 1.0;
658
659
// create an array of the right size and copy all the values in it
658
- calculated_number slots[dimensions];
660
+ NETDATA_DOUBLE slots[dimensions];
661
dimensions = 0;
662
dfe_start_read(results, t) {
663
if(t->flags & (RESULT_IS_PERCENTAGE_OF_TIME))
@@ -666,10 +668,10 @@ static size_t spread_results_evenly(DICTIONARY *results, MC_STATS *stats) {
668
dfe_done(t);
669
670
// sort the array with the values of all dimensions
669
- qsort(slots, dimensions, sizeof(calculated_number), compare_calculated_numbers);
671
+ qsort(slots, dimensions, sizeof(NETDATA_DOUBLE), compare_netdata_doubles);
672
673
// skip the duplicates in the sorted array
672
- calculated_number last_value = NAN;
674
+ NETDATA_DOUBLE last_value = NAN;
675
size_t unique_values = 0;
676
for(size_t i = 0; i < dimensions ;i++) {
677
if(likely(slots[i] != last_value))
@@ -681,11 +683,11 @@ static size_t spread_results_evenly(DICTIONARY *results, MC_STATS *stats) {
683
unique_values = dimensions;
684
685
// calculate the weight of each slot, using the number of unique values
684
- calculated_number slot_weight = 1.0 / (calculated_number)unique_values;
686
+ NETDATA_DOUBLE slot_weight = 1.0 / (NETDATA_DOUBLE)unique_values;
687
688
dfe_start_read(results, t) {
687
- int slot = binary_search_bigger_than_calculated_number(slots, 0, (int)unique_values, t->value);
688
- calculated_number v = slot * slot_weight;
689
+ int slot = binary_search_bigger_than_netdata_double(slots, 0, (int)unique_values, t->value);
690
+ NETDATA_DOUBLE v = slot * slot_weight;
691
if(unlikely(v > 1.0)) v = 1.0;
692
v = 1.0 - v;
693
t->value = v;
database/ram/rrddim_mem.c
+6
-5
@@ -6,12 +6,12 @@
6
// RRDDIM legacy data collection functions
7
8
void rrddim_collect_init(RRDDIM *rd) {
9
- rd->values[rd->rrdset->current_entry] = SN_EMPTY_SLOT;
9
+ rd->db[rd->rrdset->current_entry] = SN_EMPTY_SLOT;
10
rd->state->handle = calloc(1, sizeof(struct mem_collect_handle));
11
}
12
-void rrddim_collect_store_metric(RRDDIM *rd, usec_t point_in_time, calculated_number number, SN_FLAGS flags) {
12
+void rrddim_collect_store_metric(RRDDIM *rd, usec_t point_in_time, NETDATA_DOUBLE number, SN_FLAGS flags) {
13
(void)point_in_time;
14
- rd->values[rd->rrdset->current_entry] = pack_storage_number(number, flags);
14
+ rd->db[rd->rrdset->current_entry] = pack_storage_number(number, flags);
15
}
16
int rrddim_collect_finalize(RRDDIM *rd) {
17
free((struct mem_collect_handle*)rd->state->handle);
@@ -42,7 +42,8 @@ void rrddim_query_init(RRDDIM *rd, struct rrddim_query_handle *handle, time_t st
42
// Returns the metric and sets its timestamp into current_time
43
// IT IS REQUIRED TO **ALWAYS** SET ALL RETURN VALUES (current_time, end_time, flags)
44
// IT IS REQUIRED TO **ALWAYS** KEEP TRACK OF TIME, EVEN OUTSIDE THE DATABASE BOUNDARIES
45
-calculated_number rrddim_query_next_metric(struct rrddim_query_handle *handle, time_t *start_time, time_t *end_time, SN_FLAGS *flags) {
45
+NETDATA_DOUBLE
46
+rrddim_query_next_metric(struct rrddim_query_handle *handle, time_t *start_time, time_t *end_time, SN_FLAGS *flags) {
47
RRDDIM *rd = handle->rd;
48
struct mem_query_handle* h = (struct mem_query_handle*)handle->handle;
49
size_t entries = rd->rrdset->entries;
@@ -65,7 +66,7 @@ calculated_number rrddim_query_next_metric(struct rrddim_query_handle *handle, t
66
return NAN;
67
}
68
68
- storage_number n = rd->values[slot++];
69
+ storage_number n = rd->db[slot++];
70
if(unlikely(slot >= entries)) slot = 0;
71
72
h->slot = slot;
database/ram/rrddim_mem.h
+3
-2
@@ -20,11 +20,12 @@ struct mem_query_handle {
20
};
21
22
extern void rrddim_collect_init(RRDDIM *rd);
23
-extern void rrddim_collect_store_metric(RRDDIM *rd, usec_t point_in_time, calculated_number number, SN_FLAGS flags);
23
+extern void rrddim_collect_store_metric(RRDDIM *rd, usec_t point_in_time, NETDATA_DOUBLE number, SN_FLAGS flags);
24
extern int rrddim_collect_finalize(RRDDIM *rd);
25
26
extern void rrddim_query_init(RRDDIM *rd, struct rrddim_query_handle *handle, time_t start_time, time_t end_time);
27
-extern calculated_number rrddim_query_next_metric(struct rrddim_query_handle *handle, time_t *start_time, time_t *end_time, SN_FLAGS *flags);
27
+extern NETDATA_DOUBLE
28
+rrddim_query_next_metric(struct rrddim_query_handle *handle, time_t *start_time, time_t *end_time, SN_FLAGS *flags);
29
extern int rrddim_query_is_finished(struct rrddim_query_handle *handle);
30
extern void rrddim_query_finalize(struct rrddim_query_handle *handle);
31
extern time_t rrddim_query_latest_time(RRDDIM *rd);
database/rrd.h
+49
-45
@@ -74,9 +74,6 @@ extern time_t rrdset_free_obsolete_time;
74
75
#define RRD_ID_LENGTH_MAX 200
76
77
-#define RRDSET_MAGIC "NETDATA RRD SET FILE V019"
78
-#define RRDDIMENSION_MAGIC "NETDATA RRD DIMENSION FILE V019"
79
-
77
typedef long long total_number;
78
#define TOTAL_NUMBER_FORMAT "%lld"
79
@@ -237,52 +234,44 @@ struct rrddim {
234
// this is a pointer to the config structure
235
// since the config always has a higher priority
236
// (the user overwrites the name of the charts)
240
- // DO NOT FREE THIS - IT IS ALLOCATED IN CONFIG
241
-
242
- RRD_ALGORITHM algorithm; // the algorithm that is applied to add new collected values
243
- RRD_MEMORY_MODE rrd_memory_mode; // the memory mode for this dimension
244
-
245
- collected_number multiplier; // the multiplier of the collected values
246
- collected_number divisor; // the divider of the collected values
247
-
248
- uint32_t flags; // configuration flags for the dimension
249
-
250
- // ------------------------------------------------------------------------
251
- // members for temporary data we need for calculations
252
-
237
uint32_t hash; // a simple hash of the id, to speed up searching / indexing
238
// instead of strcmp() every item in the binary index
239
// we first compare the hashes
256
-
240
uint32_t hash_name; // a simple hash of the name
241
259
- char *cache_filename; // the filename we load/save from/to this set
260
-
261
- size_t collections_counter; // the number of times we added values to this rrdim
262
- struct rrddim_volatile *state; // volatile state that is not persistently stored
263
- size_t unused[8];
242
265
- collected_number collected_value_max; // the absolute maximum of the collected value
243
+ RRD_ALGORITHM algorithm; // the algorithm that is applied to add new collected values
244
+ RRD_MEMORY_MODE rrd_memory_mode; // the memory mode for this dimension
245
+ RRDDIM_FLAGS flags; // configuration flags for the dimension
246
247
unsigned int updated:1; // 1 when the dimension has been updated since the last processing
248
unsigned int exposed:1; // 1 when set what have sent this dimension to the central netdata
249
250
+ collected_number multiplier; // the multiplier of the collected values
251
+ collected_number divisor; // the divider of the collected values
252
+
253
+ // ------------------------------------------------------------------------
254
+ // members for temporary data we need for calculations
255
+
256
struct timeval last_collected_time; // when was this dimension last updated
257
// this is actual date time we updated the last_collected_value
258
// THIS IS DIFFERENT FROM THE SAME MEMBER OF RRDSET
259
274
- calculated_number calculated_value; // the current calculated value, after applying the algorithm - resets to zero after being used
275
- calculated_number last_calculated_value; // the last calculated value processed
260
+ struct rrddim_volatile *state; // volatile state that is not persistently stored
261
+ size_t collections_counter; // the number of times we added values to this rrdim
262
+ collected_number collected_value_max; // the absolute maximum of the collected value
263
277
- calculated_number last_stored_value; // the last value as stored in the database (after interpolation)
264
+ NETDATA_DOUBLE calculated_value; // the current calculated value, after applying the algorithm - resets to zero after being used
265
+ NETDATA_DOUBLE last_calculated_value; // the last calculated value processed
266
+ NETDATA_DOUBLE last_stored_value; // the last value as stored in the database (after interpolation)
267
268
collected_number collected_value; // the current value, as collected - resets to 0 after being used
269
collected_number last_collected_value; // the last value that was collected, after being processed
270
271
// the *_volume members are used to calculate the accuracy of the rounding done by the
272
// storage number - they are printed to debug.log when debug is enabled for a set.
284
- calculated_number collected_volume; // the sum of all collected values so far
285
- calculated_number stored_volume; // the sum of all stored values so far
273
+ NETDATA_DOUBLE collected_volume; // the sum of all collected values so far
274
+ NETDATA_DOUBLE stored_volume; // the sum of all stored values so far
275
276
struct rrddim *next; // linking of dimensions within the same data set
277
struct rrdset *rrdset;
@@ -296,18 +285,33 @@ struct rrddim {
285
286
int update_every; // every how many seconds is this updated
287
299
- size_t memsize; // the memory allocated for this dimension
300
-
301
- char magic[sizeof(RRDDIMENSION_MAGIC) + 1]; // a string to be saved, used to identify our data file
288
+ size_t memsize; // the memory allocated for this dimension (without RRDDIM)
289
290
struct rrddimvar *variables;
291
292
// ------------------------------------------------------------------------
293
// the values stored in this dimension, using our floating point numbers
294
308
- storage_number values[]; // the array of values - THIS HAS TO BE THE LAST MEMBER
295
+ void *rd_on_file; // pointer to the header written on disk
296
+ storage_number *db; // the array of values
297
};
298
299
+// returns the RRDDIM cache filename, or NULL if it does not exist
300
+extern const char *rrddim_cache_filename(RRDDIM *rd);
301
+
302
+// updated the header with the latest RRDDIM value, for memory mode MAP and SAVE
303
+extern void rrddim_memory_file_update(RRDDIM *rd);
304
+
305
+// free the memory file structures for memory mode MAP and SAVE
306
+extern void rrddim_memory_file_free(RRDDIM *rd);
307
+
308
+extern bool rrddim_memory_load_or_create_map_save(RRDSET *st, RRDDIM *rd, RRD_MEMORY_MODE memory_mode);
309
+
310
+// return the v019 header size of RRDDIM files
311
+extern size_t rrddim_memory_file_header_size(void);
312
+
313
+extern void rrddim_memory_file_save(RRDDIM *rd);
314
+
315
// ----------------------------------------------------------------------------
316
// engine-specific iterator state for dimension data collection
317
typedef struct storage_collect_handle STORAGE_COLLECT_HANDLE;
@@ -332,7 +336,7 @@ struct rrddim_collect_ops {
336
void (*init)(RRDDIM *rd);
337
338
// run this to store each metric into the database
335
- void (*store_metric)(RRDDIM *rd, usec_t point_in_time, calculated_number number, SN_FLAGS flags);
339
+ void (*store_metric)(RRDDIM *rd, usec_t point_in_time, NETDATA_DOUBLE number, SN_FLAGS flags);
340
341
// an finalization function to run after collection is over
342
// returns 1 if it's safe to delete the dimension
@@ -345,7 +349,7 @@ struct rrddim_query_ops {
349
void (*init)(RRDDIM *rd, struct rrddim_query_handle *handle, time_t start_time, time_t end_time);
350
351
// run this to load each metric number from the database
348
- calculated_number (*next_metric)(struct rrddim_query_handle *handle, time_t *current_time, time_t *end_time, SN_FLAGS *flags);
352
+ NETDATA_DOUBLE (*next_metric)(struct rrddim_query_handle *handle, time_t *current_time, time_t *end_time, SN_FLAGS *flags);
353
354
// run this to test if the series of next_metric() database queries is finished
355
int (*is_finished)(struct rrddim_query_handle *handle);
@@ -450,8 +454,6 @@ struct rrdset {
454
// since the config always has a higher priority
455
// (the user overwrites the name of the charts)
456
453
- void *unused_ptr; // Unused field (previously it held the config section of the chart)
454
-
457
char *type; // the type of graph RRD_TYPE_* (a category, for determining graphing options)
458
char *family; // grouping sets under the same family
459
char *title; // title shown to user
@@ -484,7 +486,6 @@ struct rrdset {
486
RRD_MEMORY_MODE rrd_memory_mode; // if set to 1, this is memory mapped
487
488
char *cache_dir; // the directory to store dimensions
487
- char cache_filename[FILENAME_MAX+1]; // the filename to store this set
489
490
netdata_rwlock_t rrdset_rwlock; // protects dimensions linked list
491
@@ -502,7 +503,6 @@ struct rrdset {
503
uuid_t *chart_uuid; // Store the global GUID for this chart
504
// this object.
505
struct rrdset_volatile *state; // volatile state that is not persistently stored
505
- size_t unused[3];
506
507
size_t rrddim_page_alignment; // keeps metric pages in alignment when using dbengine
508
@@ -527,8 +527,8 @@ struct rrdset {
527
// ------------------------------------------------------------------------
528
// local variables
529
530
- calculated_number green; // green threshold for this chart
531
- calculated_number red; // red threshold for this chart
530
+ NETDATA_DOUBLE green; // green threshold for this chart
531
+ NETDATA_DOUBLE red; // red threshold for this chart
532
533
avl_tree_lock rrdvar_root_index; // RRDVAR index for this chart
534
RRDSETVAR *variables; // RRDSETVAR linked list for this chart (one RRDSETVAR, many RRDVARs)
@@ -538,15 +538,13 @@ struct rrdset {
538
// members for checking the data when loading from disk
539
540
unsigned long memsize; // how much mem we have allocated for this (without dimensions)
541
-
542
- char magic[sizeof(RRDSET_MAGIC) + 1]; // our magic
541
+ void *st_on_file; // compatibility with V019 RRDSET files
542
543
// ------------------------------------------------------------------------
544
// the dimensions
545
546
avl_tree_lock dimensions_index; // the root of the dimensions index
547
RRDDIM *dimensions; // the actual data for every dimension
549
-
548
};
549
550
#define rrdset_rdlock(st) netdata_rwlock_rdlock(&((st)->rrdset_rwlock))
@@ -564,6 +562,12 @@ struct rrdset {
562
for((st) = (host)->rrdset_root, rrdhost_check_wrlock(host); st ; (st) = (st)->next)
563
564
565
+extern void rrdset_memory_file_save(RRDSET *st);
566
+extern void rrdset_memory_file_free(RRDSET *st);
567
+extern void rrdset_memory_file_update(RRDSET *st);
568
+extern const char *rrdset_cache_filename(RRDSET *st);
569
+extern bool rrdset_memory_load_or_create_map_save(RRDSET *st_on_file, RRD_MEMORY_MODE memory_mode);
570
+
571
// ----------------------------------------------------------------------------
572
// RRDHOST flags
573
// use this for configuration flags, not for state control
@@ -630,8 +634,8 @@ struct alarm_entry {
634
char *units;
635
char *info;
636
633
- calculated_number old_value;
634
- calculated_number new_value;
637
+ NETDATA_DOUBLE old_value;
638
+ NETDATA_DOUBLE new_value;
639
640
char *old_value_string;
641
char *new_value_string;
database/rrdcalc.c
+7
-3
@@ -57,12 +57,14 @@ static void rrdsetcalc_link(RRDSET *st, RRDCALC *rc) {
57
}
58
59
if(!isnan(rc->green) && isnan(st->green)) {
60
- debug(D_HEALTH, "Health alarm '%s.%s' green threshold set from " CALCULATED_NUMBER_FORMAT_AUTO " to " CALCULATED_NUMBER_FORMAT_AUTO ".", rc->rrdset->id, rc->name, rc->rrdset->green, rc->green);
60
+ debug(D_HEALTH, "Health alarm '%s.%s' green threshold set from " NETDATA_DOUBLE_FORMAT_AUTO
61
+ " to " NETDATA_DOUBLE_FORMAT_AUTO ".", rc->rrdset->id, rc->name, rc->rrdset->green, rc->green);
62
st->green = rc->green;
63
}
64
65
if(!isnan(rc->red) && isnan(st->red)) {
65
- debug(D_HEALTH, "Health alarm '%s.%s' red threshold set from " CALCULATED_NUMBER_FORMAT_AUTO " to " CALCULATED_NUMBER_FORMAT_AUTO ".", rc->rrdset->id, rc->name, rc->rrdset->red, rc->red);
66
+ debug(D_HEALTH, "Health alarm '%s.%s' red threshold set from " NETDATA_DOUBLE_FORMAT_AUTO " to " NETDATA_DOUBLE_FORMAT_AUTO
67
+ ".", rc->rrdset->id, rc->name, rc->rrdset->red, rc->red);
68
st->red = rc->red;
69
}
70
@@ -445,7 +447,9 @@ inline RRDCALC *rrdcalc_create_from_template(RRDHOST *host, RRDCALCTEMPLATE *rt,
447
error("Health alarm '%s.%s': failed to re-parse critical expression '%s'", chart, rt->name, rt->critical->source);
448
}
449
448
- debug(D_HEALTH, "Health runtime added alarm '%s.%s': exec '%s', recipient '%s', green " CALCULATED_NUMBER_FORMAT_AUTO ", red " CALCULATED_NUMBER_FORMAT_AUTO ", lookup: group %d, after %d, before %d, options %u, dimensions '%s', for each dimension '%s', update every %d, calculation '%s', warning '%s', critical '%s', source '%s', delay up %d, delay down %d, delay max %d, delay_multiplier %f, warn_repeat_every %u, crit_repeat_every %u",
450
+ debug(D_HEALTH, "Health runtime added alarm '%s.%s': exec '%s', recipient '%s', green " NETDATA_DOUBLE_FORMAT_AUTO
451
+ ", red " NETDATA_DOUBLE_FORMAT_AUTO
452
+ ", lookup: group %d, after %d, before %d, options %u, dimensions '%s', for each dimension '%s', update every %d, calculation '%s', warning '%s', critical '%s', source '%s', delay up %d, delay down %d, delay max %d, delay_multiplier %f, warn_repeat_every %u, crit_repeat_every %u",
453
(rc->chart)?rc->chart:"NOCHART",
454
rc->name,
455
(rc->exec)?rc->exec:"DEFAULT",
database/rrdcalc.h
+4
-4
@@ -63,8 +63,8 @@ struct rrdcalc {
63
int update_every; // update frequency for the alarm
64
65
// the red and green threshold of this alarm (to be set to the chart)
66
- calculated_number green;
67
- calculated_number red;
66
+ NETDATA_DOUBLE green;
67
+ NETDATA_DOUBLE red;
68
69
// ------------------------------------------------------------------------
70
// database lookup settings
@@ -112,8 +112,8 @@ struct rrdcalc {
112
RRDCALC_STATUS old_status; // the old status of the alarm
113
RRDCALC_STATUS status; // the current status of the alarm
114
115
- calculated_number value; // the current value of the alarm
116
- calculated_number old_value; // the previous value of the alarm
115
+ NETDATA_DOUBLE value; // the current value of the alarm
116
+ NETDATA_DOUBLE old_value; // the previous value of the alarm
117
118
uint32_t rrdcalc_flags; // check RRDCALC_FLAG_*
119
database/rrdcalctemplate.h
+2
-2
@@ -42,8 +42,8 @@ struct rrdcalctemplate {
42
int update_every; // update frequency for the alarm
43
44
// the red and green threshold of this alarm (to be set to the chart)
45
- calculated_number green;
46
- calculated_number red;
45
+ NETDATA_DOUBLE green;
46
+ NETDATA_DOUBLE red;
47
48
// ------------------------------------------------------------------------
49
// database lookup settings
database/rrddim.c
+215
-138
@@ -197,112 +197,15 @@ RRDDIM *rrddim_add_custom(RRDSET *st, const char *id, const char *name, collecte
197
rrdset_flag_set(st, RRDSET_FLAG_SYNC_CLOCK);
198
rrdset_flag_clear(st, RRDSET_FLAG_UPSTREAM_EXPOSED);
199
200
- char filename[FILENAME_MAX + 1];
201
- char fullfilename[FILENAME_MAX + 1];
202
-
203
- unsigned long size = sizeof(RRDDIM) + (st->entries * sizeof(storage_number));
204
-
205
- debug(D_RRD_CALLS, "Adding dimension '%s/%s'.", st->id, id);
206
-
207
- rrdset_strncpyz_name(filename, id, FILENAME_MAX);
208
- snprintfz(fullfilename, FILENAME_MAX, "%s/%s.db", st->cache_dir, filename);
209
-
210
- if(memory_mode == RRD_MEMORY_MODE_SAVE || memory_mode == RRD_MEMORY_MODE_MAP ||
211
- memory_mode == RRD_MEMORY_MODE_RAM) {
212
- rd = (RRDDIM *)netdata_mmap(
213
- (memory_mode == RRD_MEMORY_MODE_RAM) ? NULL : fullfilename,
214
- size,
215
- ((memory_mode == RRD_MEMORY_MODE_MAP) ? MAP_SHARED : MAP_PRIVATE),
216
- 1);
217
-
218
- if(likely(rd)) {
219
- // we have a file mapped for rd
220
-
221
- memset(&rd->avl, 0, sizeof(avl_t));
222
- rd->id = NULL;
223
- rd->name = NULL;
224
- rd->cache_filename = NULL;
225
- rd->variables = NULL;
226
- rd->next = NULL;
227
- rd->rrdset = NULL;
228
- rd->exposed = 0;
229
-
230
- struct timeval now;
231
- now_realtime_timeval(&now);
232
-
233
- if(memory_mode == RRD_MEMORY_MODE_RAM) {
234
- memset(rd, 0, size);
235
- }
236
- else {
237
- int reset = 0;
238
-
239
- if(strcmp(rd->magic, RRDDIMENSION_MAGIC) != 0) {
240
- info("Initializing file %s.", fullfilename);
241
- memset(rd, 0, size);
242
- reset = 1;
243
- }
244
- else if(rd->memsize != size) {
245
- error("File %s does not have the desired size, expected %lu but found %lu. Clearing it.", fullfilename, size, rd->memsize);
246
- memset(rd, 0, size);
247
- reset = 1;
248
- }
249
- else if(rd->update_every != st->update_every) {
250
- error("File %s does not have the same update frequency, expected %d but found %d. Clearing it.", fullfilename, st->update_every, rd->update_every);
251
- memset(rd, 0, size);
252
- reset = 1;
253
- }
254
- else if(dt_usec(&now, &rd->last_collected_time) > (rd->entries * rd->update_every * USEC_PER_SEC)) {
255
- info("File %s is too old (last collected %llu seconds ago, but the database is %ld seconds). Clearing it.", fullfilename, dt_usec(&now, &rd->last_collected_time) / USEC_PER_SEC, rd->entries * rd->update_every);
256
- memset(rd, 0, size);
257
- reset = 1;
258
- }
259
-
260
- if(!reset) {
261
- if(rd->algorithm != algorithm) {
262
- info("File %s does not have the expected algorithm (expected %u '%s', found %u '%s'). Previous values may be wrong.",
263
- fullfilename, algorithm, rrd_algorithm_name(algorithm), rd->algorithm, rrd_algorithm_name(rd->algorithm));
264
- }
265
-
266
- if(rd->multiplier != multiplier) {
267
- info("File %s does not have the expected multiplier (expected " COLLECTED_NUMBER_FORMAT ", found " COLLECTED_NUMBER_FORMAT "). Previous values may be wrong.", fullfilename, multiplier, rd->multiplier);
268
- }
269
-
270
- if(rd->divisor != divisor) {
271
- info("File %s does not have the expected divisor (expected " COLLECTED_NUMBER_FORMAT ", found " COLLECTED_NUMBER_FORMAT "). Previous values may be wrong.", fullfilename, divisor, rd->divisor);
272
- }
273
- }
274
- }
275
-
276
- // make sure we have the right memory mode
277
- // even if we cleared the memory
278
- rd->rrd_memory_mode = memory_mode;
279
- }
280
- }
281
-
282
- if(unlikely(!rd)) {
283
- // if we didn't manage to get a mmap'd dimension, just create one
284
- rd = callocz(1, size);
285
- if (memory_mode == RRD_MEMORY_MODE_DBENGINE)
286
- rd->rrd_memory_mode = RRD_MEMORY_MODE_DBENGINE;
287
- else
288
- rd->rrd_memory_mode = (memory_mode == RRD_MEMORY_MODE_NONE) ? RRD_MEMORY_MODE_NONE : RRD_MEMORY_MODE_ALLOC;
289
- }
290
- rd->memsize = size;
291
-
292
- strcpy(rd->magic, RRDDIMENSION_MAGIC);
293
-
200
+ rd = callocz(1, sizeof(RRDDIM));
201
rd->id = strdupz(id);
202
rd->hash = simple_hash(rd->id);
203
297
- rd->cache_filename = strdupz(fullfilename);
298
-
204
rd->name = (name && *name)?strdupz(name):strdupz(rd->id);
205
rd->hash_name = simple_hash(rd->name);
206
207
rd->algorithm = algorithm;
303
-
208
rd->multiplier = multiplier;
305
-
209
rd->divisor = divisor;
210
if(!rd->divisor) rd->divisor = 1;
211
@@ -311,23 +214,38 @@ RRDDIM *rrddim_add_custom(RRDSET *st, const char *id, const char *name, collecte
214
215
if(rrdset_flag_check(st, RRDSET_FLAG_STORE_FIRST))
216
rd->collections_counter = 1;
314
- else
315
- rd->collections_counter = 0;
316
-
317
- rd->updated = 0;
318
- rd->flags = 0x00000000;
319
-
320
- rd->calculated_value = 0;
321
- rd->last_calculated_value = 0;
322
- rd->collected_value = 0;
323
- rd->last_collected_value = 0;
324
- rd->collected_value_max = 0;
325
- rd->collected_volume = 0;
326
- rd->stored_volume = 0;
327
- rd->last_stored_value = 0;
328
- rd->last_collected_time.tv_sec = 0;
329
- rd->last_collected_time.tv_usec = 0;
217
+
218
rd->rrdset = st;
219
+
220
+ if(memory_mode == RRD_MEMORY_MODE_MAP || memory_mode == RRD_MEMORY_MODE_SAVE) {
221
+ if(!rrddim_memory_load_or_create_map_save(st, rd, memory_mode)) {
222
+ info("Failed to use memory mode %s for chart '%s', dimension '%s', falling back to ram", (memory_mode == RRD_MEMORY_MODE_MAP)?"map":"save", st->name, rd->name);
223
+ memory_mode = RRD_MEMORY_MODE_RAM;
224
+ }
225
+ }
226
+
227
+ if(memory_mode == RRD_MEMORY_MODE_RAM) {
228
+ size_t entries = st->entries;
229
+ if(!entries) entries = 5;
230
+
231
+ rd->db = netdata_mmap(NULL, entries * sizeof(storage_number), MAP_PRIVATE, 1);
232
+ if(!rd->db) {
233
+ info("Failed to use memory mode ram for chart '%s', dimension '%s', falling back to alloc", st->name, rd->name);
234
+ memory_mode = RRD_MEMORY_MODE_ALLOC;
235
+ }
236
+ else rd->memsize = entries * sizeof(storage_number);
237
+ }
238
+
239
+ if(memory_mode == RRD_MEMORY_MODE_ALLOC || memory_mode == RRD_MEMORY_MODE_NONE) {
240
+ size_t entries = st->entries;
241
+ if(entries < 5) entries = 5;
242
+
243
+ rd->db = callocz(entries, sizeof(storage_number));
244
+ rd->memsize = entries * sizeof(storage_number);
245
+ }
246
+
247
+ rd->rrd_memory_mode = memory_mode;
248
+
249
rd->state = callocz(1, sizeof(*rd->state));
250
#ifdef ENABLE_ACLK
251
rd->state->aclk_live_status = -1;
@@ -432,30 +350,21 @@ void rrddim_free(RRDSET *st, RRDDIM *rd)
350
// aclk_send_dimension_update(rd);
351
//#endif
352
435
- RRD_MEMORY_MODE rrd_memory_mode = rd->rrd_memory_mode;
436
- switch(rrd_memory_mode) {
437
- case RRD_MEMORY_MODE_SAVE:
438
- case RRD_MEMORY_MODE_MAP:
439
- case RRD_MEMORY_MODE_RAM:
440
- debug(D_RRD_CALLS, "Unmapping dimension '%s'.", rd->name);
441
- freez((void *)rd->id);
442
- freez((void *)rd->name);
443
- freez(rd->cache_filename);
444
- freez(rd->state);
445
- munmap(rd, rd->memsize);
446
- break;
447
-
448
- case RRD_MEMORY_MODE_ALLOC:
449
- case RRD_MEMORY_MODE_NONE:
450
- case RRD_MEMORY_MODE_DBENGINE:
451
- debug(D_RRD_CALLS, "Removing dimension '%s'.", rd->name);
452
- freez((void *)rd->id);
453
- freez((void *)rd->name);
454
- freez(rd->cache_filename);
455
- freez(rd->state);
456
- freez(rd);
457
- break;
353
+ freez((void *)rd->id);
354
+ freez((void *)rd->name);
355
+ freez(rd->state);
356
+
357
+ // this will free MEMORY_MODE_SAVE and MEMORY_MODE_MAP structures
358
+ rrddim_memory_file_free(rd);
359
+
360
+ if(rd->db) {
361
+ if(rd->rrd_memory_mode == RRD_MEMORY_MODE_RAM)
362
+ munmap(rd->db, rd->memsize);
363
+ else
364
+ freez(rd->db);
365
}
366
+
367
+ freez(rd);
368
}
369
370
@@ -529,7 +438,7 @@ inline collected_number rrddim_set_by_pointer(RRDSET *st __maybe_unused, RRDDIM
438
collected_number v = (value >= 0) ? value : -value;
439
if(unlikely(v > rd->collected_value_max)) rd->collected_value_max = v;
440
532
- // fprintf(stderr, "%s.%s %llu " COLLECTED_NUMBER_FORMAT " dt %0.6f" " rate " CALCULATED_NUMBER_FORMAT "\n", st->name, rd->name, st->usec_since_last_update, value, (float)((double)st->usec_since_last_update / (double)1000000), (calculated_number)((value - rd->last_collected_value) * (calculated_number)rd->multiplier / (calculated_number)rd->divisor * 1000000.0 / (calculated_number)st->usec_since_last_update));
441
+ // fprintf(stderr, "%s.%s %llu " COLLECTED_NUMBER_FORMAT " dt %0.6f" " rate " NETDATA_DOUBLE_FORMAT "\n", st->name, rd->name, st->usec_since_last_update, value, (float)((double)st->usec_since_last_update / (double)1000000), (NETDATA_DOUBLE)((value - rd->last_collected_value) * (NETDATA_DOUBLE)rd->multiplier / (NETDATA_DOUBLE)rd->divisor * 1000000.0 / (NETDATA_DOUBLE)st->usec_since_last_update));
442
443
return rd->last_collected_value;
444
}
@@ -544,3 +453,171 @@ collected_number rrddim_set(RRDSET *st, const char *id, collected_number value)
453
454
return rrddim_set_by_pointer(st, rd, value);
455
}
456
+
457
+
458
+// ----------------------------------------------------------------------------
459
+// compatibility layer for RRDDIM files v019
460
+
461
+#define RRDDIMENSION_MAGIC_V019 "NETDATA RRD DIMENSION FILE V019"
462
+
463
+struct avl_element_v019 {
464
+ void *avl_link[2];
465
+ signed char avl_balance;
466
+};
467
+
468
+struct rrddim_map_save_v019 {
469
+ struct avl_element_v019 avl; // ignored
470
+ void *id; // ignored
471
+ void *name; // ignored
472
+ uint32_t algorithm; // print warning on mismatch - update on load
473
+ uint32_t rrd_memory_mode; // ignored
474
+ long long multiplier; // print warning on mismatch - update on load
475
+ long long divisor; // print warning on mismatch - update on load
476
+ uint32_t flags; // ignored
477
+ uint32_t hash; // ignored
478
+ uint32_t hash_name; // ignored
479
+ void *cache_filename; // ignored - we use it to keep the filename to save back
480
+ size_t collections_counter; // ignored
481
+ void *state; // ignored
482
+ size_t unused[8]; // ignored
483
+ long long collected_value_max; // ignored
484
+ unsigned int updated:1; // ignored
485
+ unsigned int exposed:1; // ignored
486
+ struct timeval last_collected_time; // check to reset all - ignored after load
487
+ long double calculated_value; // ignored
488
+ long double last_calculated_value; // ignored
489
+ long double last_stored_value; // ignored
490
+ long long collected_value; // ignored
491
+ long long last_collected_value; // ignored
492
+ long double collected_volume; // ignored
493
+ long double stored_volume; // ignored
494
+ void *next; // ignored
495
+ void *rrdset; // ignored
496
+ long entries; // check to reset all - update on load
497
+ int update_every; // check to reset all - update on load
498
+ size_t memsize; // check to reset all - update on load
499
+ char magic[sizeof(RRDDIMENSION_MAGIC_V019) + 1];// check to reset all - update on load
500
+ void *variables; // ignored
501
+ storage_number values[]; // the array of values
502
+};
503
+
504
+size_t rrddim_memory_file_header_size(void) {
505
+ return sizeof(struct rrddim_map_save_v019);
506
+}
507
+
508
+void rrddim_memory_file_update(RRDDIM *rd) {
509
+ if(!rd->rd_on_file) return;
510
+ struct rrddim_map_save_v019 *rd_on_file = rd->rd_on_file;
511
+
512
+ rd_on_file->last_collected_time.tv_sec = rd->last_collected_time.tv_sec;
513
+ rd_on_file->last_collected_time.tv_usec = rd->last_collected_time.tv_usec;
514
+}
515
+
516
+void rrddim_memory_file_free(RRDDIM *rd) {
517
+ if(!rd->rd_on_file) return;
518
+
519
+ // needed for memory mode map, to save the latest state
520
+ rrddim_memory_file_update(rd);
521
+
522
+ struct rrddim_map_save_v019 *rd_on_file = rd->rd_on_file;
523
+ freez(rd_on_file->cache_filename);
524
+ munmap(rd_on_file, rd_on_file->memsize);
525
+
526
+ // remove the pointers from the RRDDIM
527
+ rd->rd_on_file = NULL;
528
+ rd->db = NULL;
529
+}
530
+
531
+const char *rrddim_cache_filename(RRDDIM *rd) {
532
+ if(!rd->rd_on_file) return NULL;
533
+ struct rrddim_map_save_v019 *rd_on_file = rd->rd_on_file;
534
+ return rd_on_file->cache_filename;
535
+}
536
+
537
+void rrddim_memory_file_save(RRDDIM *rd) {
538
+ if(!rd->rd_on_file) return;
539
+
540
+ rrddim_memory_file_update(rd);
541
+
542
+ struct rrddim_map_save_v019 *rd_on_file = rd->rd_on_file;
543
+ if(rd_on_file->rrd_memory_mode != RRD_MEMORY_MODE_SAVE) return;
544
+
545
+ memory_file_save(rd_on_file->cache_filename, rd_on_file, rd_on_file->memsize);
546
+}
547
+
548
+bool rrddim_memory_load_or_create_map_save(RRDSET *st, RRDDIM *rd, RRD_MEMORY_MODE memory_mode) {
549
+ if(memory_mode != RRD_MEMORY_MODE_SAVE && memory_mode != RRD_MEMORY_MODE_MAP)
550
+ return false;
551
+
552
+ struct rrddim_map_save_v019 *rd_on_file = NULL;
553
+
554
+ unsigned long size = sizeof(struct rrddim_map_save_v019) + (st->entries * sizeof(storage_number));
555
+
556
+ char filename[FILENAME_MAX + 1];
557
+ char fullfilename[FILENAME_MAX + 1];
558
+ rrdset_strncpyz_name(filename, rd->id, FILENAME_MAX);
559
+ snprintfz(fullfilename, FILENAME_MAX, "%s/%s.db", st->cache_dir, filename);
560
+
561
+ rd_on_file = (struct rrddim_map_save_v019 *)netdata_mmap(fullfilename, size,
562
+ ((memory_mode == RRD_MEMORY_MODE_MAP) ? MAP_SHARED : MAP_PRIVATE), 1);
563
+
564
+ if(unlikely(!rd_on_file)) return false;
565
+
566
+ struct timeval now;
567
+ now_realtime_timeval(&now);
568
+
569
+ int reset = 0;
570
+ if(strcmp(rd_on_file->magic, RRDDIMENSION_MAGIC_V019) != 0) {
571
+ info("Initializing file %s.", fullfilename);
572
+ memset(rd_on_file, 0, size);
573
+ reset = 1;
574
+ }
575
+ else if(rd_on_file->memsize != size) {
576
+ error("File %s does not have the desired size, expected %lu but found %lu. Clearing it.", fullfilename, size, rd_on_file->memsize);
577
+ memset(rd_on_file, 0, size);
578
+ reset = 1;
579
+ }
580
+ else if(rd_on_file->update_every != st->update_every) {
581
+ error("File %s does not have the same update frequency, expected %d but found %d. Clearing it.", fullfilename, st->update_every, rd_on_file->update_every);
582
+ memset(rd_on_file, 0, size);
583
+ reset = 1;
584
+ }
585
+ else if(dt_usec(&now, &rd_on_file->last_collected_time) > (rd_on_file->entries * rd_on_file->update_every * USEC_PER_SEC)) {
586
+ info("File %s is too old (last collected %llu seconds ago, but the database is %ld seconds). Clearing it.", fullfilename, dt_usec(&now, &rd_on_file->last_collected_time) / USEC_PER_SEC, rd_on_file->entries * rd_on_file->update_every);
587
+ memset(rd_on_file, 0, size);
588
+ reset = 1;
589
+ }
590
+
591
+ if(!reset) {
592
+ if(rd_on_file->algorithm != rd->algorithm)
593
+ info("File %s does not have the expected algorithm (expected %u '%s', found %u '%s'). Previous values may be wrong.",
594
+ fullfilename, rd->algorithm, rrd_algorithm_name(rd->algorithm), rd_on_file->algorithm, rrd_algorithm_name(rd_on_file->algorithm));
595
+
596
+ if(rd_on_file->multiplier != rd->multiplier)
597
+ info("File %s does not have the expected multiplier (expected " COLLECTED_NUMBER_FORMAT ", found " COLLECTED_NUMBER_FORMAT "). Previous values may be wrong.", fullfilename, rd->multiplier, rd_on_file->multiplier);
598
+
599
+ if(rd_on_file->divisor != rd->divisor)
600
+ info("File %s does not have the expected divisor (expected " COLLECTED_NUMBER_FORMAT ", found " COLLECTED_NUMBER_FORMAT "). Previous values may be wrong.", fullfilename, rd->divisor, rd_on_file->divisor);
601
+ }
602
+
603
+ // zero the entire header
604
+ memset(rd_on_file, 0, sizeof(struct rrddim_map_save_v019));
605
+
606
+ // set the important fields
607
+ strcpy(rd_on_file->magic, RRDDIMENSION_MAGIC_V019);
608
+ rd_on_file->algorithm = rd->algorithm;
609
+ rd_on_file->multiplier = rd->multiplier;
610
+ rd_on_file->divisor = rd->divisor;
611
+ rd_on_file->entries = st->entries;
612
+ rd_on_file->update_every = rd->update_every;
613
+ rd_on_file->memsize = size;
614
+ rd_on_file->rrd_memory_mode = memory_mode;
615
+ rd_on_file->cache_filename = strdupz(fullfilename);
616
+
617
+ rd->db = &rd_on_file->values[0];
618
+ rd->rd_on_file = rd_on_file;
619
+ rd->memsize = size;
620
+ rrddim_memory_file_update(rd);
621
+
622
+ return true;
623
+}
database/rrdhost.c
+10
-6
@@ -210,10 +210,10 @@ RRDHOST *rrdhost_create(const char *hostname,
210
avl_init_lock(&(host->rrdfamily_root_index), rrdfamily_compare);
211
avl_init_lock(&(host->rrdvar_root_index), rrdvar_compare);
212
213
- if(config_get_boolean(CONFIG_SECTION_GLOBAL, "delete obsolete charts files", 1))
213
+ if(config_get_boolean(CONFIG_SECTION_DB, "delete obsolete charts files", 1))
214
rrdhost_flag_set(host, RRDHOST_FLAG_DELETE_OBSOLETE_CHARTS);
215
216
- if(config_get_boolean(CONFIG_SECTION_GLOBAL, "delete orphan hosts files", 1) && !is_localhost)
216
+ if(config_get_boolean(CONFIG_SECTION_DB, "delete orphan hosts files", 1) && !is_localhost)
217
rrdhost_flag_set(host, RRDHOST_FLAG_DELETE_ORPHAN_HOST);
218
219
host->health_default_warn_repeat_every = config_get_duration(CONFIG_SECTION_HEALTH, "default repeat warning", "never");
@@ -689,17 +689,21 @@ restart_after_removal:
689
// RRDHOST global / startup initialization
690
691
int rrd_init(char *hostname, struct rrdhost_system_info *system_info) {
692
- rrdset_free_obsolete_time = config_get_number(CONFIG_SECTION_GLOBAL, "cleanup obsolete charts after seconds", rrdset_free_obsolete_time);
692
+ rrdset_free_obsolete_time = config_get_number(CONFIG_SECTION_DB, "cleanup obsolete charts after secs", rrdset_free_obsolete_time);
693
// Current chart locking and invalidation scheme doesn't prevent Netdata from segmentation faults if a short
694
// cleanup delay is set. Extensive stress tests showed that 10 seconds is quite a safe delay. Look at
695
// https://github.com/netdata/netdata/pull/11222#issuecomment-868367920 for more information.
696
if (rrdset_free_obsolete_time < 10) {
697
rrdset_free_obsolete_time = 10;
698
- info("The \"cleanup obsolete charts after seconds\" option was set to 10 seconds. A lower delay can potentially cause a segmentation fault.");
698
+ info("The \"cleanup obsolete charts after seconds\" option was set to 10 seconds.");
699
+ config_set_number(CONFIG_SECTION_DB, "cleanup obsolete charts after secs", rrdset_free_obsolete_time);
700
}
700
- gap_when_lost_iterations_above = (int)config_get_number(CONFIG_SECTION_GLOBAL, "gap when lost iterations above", gap_when_lost_iterations_above);
701
- if (gap_when_lost_iterations_above < 1)
701
+
702
+ gap_when_lost_iterations_above = (int)config_get_number(CONFIG_SECTION_DB, "gap when lost iterations above", gap_when_lost_iterations_above);
703
+ if (gap_when_lost_iterations_above < 1) {
704
gap_when_lost_iterations_above = 1;
705
+ config_set_number(CONFIG_SECTION_DB, "gap when lost iterations above", gap_when_lost_iterations_above);
706
+ }
707
708
if (unlikely(sql_init_database(DB_CHECK_NONE, 0))) {
709
if (default_rrd_memory_mode == RRD_MEMORY_MODE_DBENGINE)
database/rrdset.c
+355
-261
@@ -80,17 +80,9 @@ static inline RRDSET *rrdset_index_find_name(RRDHOST *host, const char *name, ui
80
tmp.name = name;
81
tmp.hash_name = (hash)?hash:simple_hash(tmp.name);
82
83
- // fprintf(stderr, "SEARCHING: %s\n", name);
83
result = avl_search_lock(&host->rrdset_root_index_name, (avl_t *) (&(tmp.avlname)));
85
- if(result) {
86
- RRDSET *st = rrdset_from_avlname(result);
87
- if(strcmp(st->magic, RRDSET_MAGIC) != 0)
88
- error("Search for RRDSET %s returned an invalid RRDSET %s (name %s)", name, st->id, st->name);
84
+ if(result) return rrdset_from_avlname(result);
85
90
- // fprintf(stderr, "FOUND: %s\n", name);
91
- return rrdset_from_avlname(result);
92
- }
93
- // fprintf(stderr, "NOT FOUND: %s\n", name);
86
return NULL;
87
}
88
@@ -294,20 +286,27 @@ void rrdset_reset(RRDSET *st) {
286
// RRDSET - helpers for rrdset_create()
287
288
inline long align_entries_to_pagesize(RRD_MEMORY_MODE mode, long entries) {
297
- if(unlikely(entries < 5)) entries = 5;
298
- if(unlikely(entries > RRD_HISTORY_ENTRIES_MAX)) entries = RRD_HISTORY_ENTRIES_MAX;
289
+ if(mode == RRD_MEMORY_MODE_DBENGINE) return 0;
290
+ if(mode == RRD_MEMORY_MODE_NONE) return 5;
291
+
292
+ if(entries < 5) entries = 5;
293
+ if(entries > RRD_HISTORY_ENTRIES_MAX) entries = RRD_HISTORY_ENTRIES_MAX;
294
+
295
+ if(mode == RRD_MEMORY_MODE_MAP || mode == RRD_MEMORY_MODE_SAVE || mode == RRD_MEMORY_MODE_RAM) {
296
+ long header_size = 0;
297
300
- if(unlikely(mode == RRD_MEMORY_MODE_NONE || mode == RRD_MEMORY_MODE_ALLOC))
301
- return entries;
298
+ if(mode == RRD_MEMORY_MODE_MAP || mode == RRD_MEMORY_MODE_SAVE)
299
+ header_size = (long)rrddim_memory_file_header_size();
300
303
- long page = (size_t)sysconf(_SC_PAGESIZE);
304
- long size = sizeof(RRDDIM) + entries * sizeof(storage_number);
305
- if(unlikely(size % page)) {
306
- size -= (size % page);
307
- size += page;
301
+ long page = (long)sysconf(_SC_PAGESIZE);
302
+ long size = (long)(header_size + entries * sizeof(storage_number));
303
+ if (unlikely(size % page)) {
304
+ size -= (size % page);
305
+ size += page;
306
309
- long n = (size - sizeof(RRDDIM)) / sizeof(storage_number);
310
- return n;
307
+ long n = (long)((size - header_size) / sizeof(storage_number));
308
+ return n;
309
+ }
310
}
311
312
return entries;
@@ -405,40 +404,18 @@ void rrdset_free(RRDSET *st) {
404
freez(st->state);
405
freez(st->chart_uuid);
406
408
- switch(st->rrd_memory_mode) {
409
- case RRD_MEMORY_MODE_SAVE:
410
- case RRD_MEMORY_MODE_MAP:
411
- case RRD_MEMORY_MODE_RAM:
412
- debug(D_RRD_CALLS, "Unmapping stats '%s'.", st->name);
413
- munmap(st, st->memsize);
414
- break;
415
-
416
- case RRD_MEMORY_MODE_ALLOC:
417
- case RRD_MEMORY_MODE_NONE:
418
- case RRD_MEMORY_MODE_DBENGINE:
419
- freez(st);
420
- break;
421
- }
422
-
407
+ rrdset_memory_file_free(st);
408
+ freez(st);
409
}
410
411
void rrdset_save(RRDSET *st) {
412
rrdset_check_rdlock(st);
413
428
- // info("Saving chart '%s' ('%s')", st->id, st->name);
429
-
430
- if(st->rrd_memory_mode == RRD_MEMORY_MODE_SAVE) {
431
- debug(D_RRD_STATS, "Saving stats '%s' to '%s'.", st->name, st->cache_filename);
432
- memory_file_save(st->cache_filename, st, st->memsize);
433
- }
414
+ rrdset_memory_file_save(st);
415
416
RRDDIM *rd;
436
- rrddim_foreach_read(rd, st) {
437
- if(likely(rd->rrd_memory_mode == RRD_MEMORY_MODE_SAVE)) {
438
- debug(D_RRD_STATS, "Saving dimension '%s' to '%s'.", rd->name, rd->cache_filename);
439
- memory_file_save(rd->cache_filename, rd, rd->memsize);
440
- }
441
- }
417
+ rrddim_foreach_read(rd, st)
418
+ rrddim_memory_file_save(rd);
419
}
420
421
void rrdset_delete(RRDSET *st) {
@@ -448,17 +425,23 @@ void rrdset_delete(RRDSET *st) {
425
info("Deleting chart '%s' ('%s') from disk...", st->id, st->name);
426
427
if(st->rrd_memory_mode == RRD_MEMORY_MODE_SAVE || st->rrd_memory_mode == RRD_MEMORY_MODE_MAP) {
451
- info("Deleting chart header file '%s'.", st->cache_filename);
452
- if(unlikely(unlink(st->cache_filename) == -1))
453
- error("Cannot delete chart header file '%s'", st->cache_filename);
428
+ const char *cache_filename = rrdset_cache_filename(st);
429
+ if(cache_filename) {
430
+ info("Deleting chart header file '%s'.", cache_filename);
431
+ if (unlikely(unlink(cache_filename) == -1))
432
+ error("Cannot delete chart header file '%s'", cache_filename);
433
+ }
434
+ else
435
+ error("Cannot find the cache filename of chart '%s'", st->id);
436
}
437
438
rrddim_foreach_read(rd, st) {
457
- if(likely(rd->rrd_memory_mode == RRD_MEMORY_MODE_SAVE || rd->rrd_memory_mode == RRD_MEMORY_MODE_MAP)) {
458
- info("Deleting dimension file '%s'.", rd->cache_filename);
459
- if(unlikely(unlink(rd->cache_filename) == -1))
460
- error("Cannot delete dimension file '%s'", rd->cache_filename);
461
- }
439
+ const char *cache_filename = rrddim_cache_filename(rd);
440
+ if(!cache_filename) continue;
441
+
442
+ info("Deleting dimension file '%s'.", cache_filename);
443
+ if(unlikely(unlink(cache_filename) == -1))
444
+ error("Cannot delete dimension file '%s'", cache_filename);
445
}
446
447
recursively_delete_dir(st->cache_dir, "left-over chart");
@@ -473,11 +456,11 @@ void rrdset_delete_obsolete_dimensions(RRDSET *st) {
456
457
rrddim_foreach_read(rd, st) {
458
if(rrddim_flag_check(rd, RRDDIM_FLAG_OBSOLETE)) {
476
- if(likely(rd->rrd_memory_mode == RRD_MEMORY_MODE_SAVE || rd->rrd_memory_mode == RRD_MEMORY_MODE_MAP)) {
477
- info("Deleting dimension file '%s'.", rd->cache_filename);
478
- if(unlikely(unlink(rd->cache_filename) == -1))
479
- error("Cannot delete dimension file '%s'", rd->cache_filename);
480
- }
459
+ const char *cache_filename = rrddim_cache_filename(rd);
460
+ if(!cache_filename) continue;
461
+ info("Deleting dimension file '%s'.", cache_filename);
462
+ if(unlikely(unlink(cache_filename) == -1))
463
+ error("Cannot delete dimension file '%s'", cache_filename);
464
}
465
}
466
}
@@ -699,8 +682,6 @@ RRDSET *rrdset_create_custom(
682
return st;
683
}
684
702
- char fullfilename[FILENAME_MAX + 1];
703
-
685
// ------------------------------------------------------------------------
686
// get the options from the config, we need to create it
687
@@ -708,126 +689,37 @@ RRDSET *rrdset_create_custom(
689
if (memory_mode != RRD_MEMORY_MODE_DBENGINE)
690
entries = align_entries_to_pagesize(memory_mode, history_entries);
691
711
- unsigned long size = sizeof(RRDSET);
692
char *cache_dir = rrdset_cache_dir(host, fullid);
693
714
- time_t now = now_realtime_sec();
715
-
694
// ------------------------------------------------------------------------
695
// load it or allocate it
696
697
debug(D_RRD_CALLS, "Creating RRD_STATS for '%s.%s'.", type, id);
698
721
- snprintfz(fullfilename, FILENAME_MAX, "%s/main.db", cache_dir);
722
- if(memory_mode == RRD_MEMORY_MODE_SAVE || memory_mode == RRD_MEMORY_MODE_MAP ||
723
- memory_mode == RRD_MEMORY_MODE_RAM) {
724
- st = (RRDSET *)netdata_mmap(
725
- (memory_mode == RRD_MEMORY_MODE_RAM) ? NULL : fullfilename,
726
- size,
727
- ((memory_mode == RRD_MEMORY_MODE_MAP) ? MAP_SHARED : MAP_PRIVATE),
728
- 0);
729
-
730
- if(st) {
731
- memset(&st->avl, 0, sizeof(avl_t));
732
- memset(&st->avlname, 0, sizeof(avl_t));
733
- memset(&st->rrdvar_root_index, 0, sizeof(avl_tree_lock));
734
- memset(&st->dimensions_index, 0, sizeof(avl_tree_lock));
735
- memset(&st->rrdset_rwlock, 0, sizeof(netdata_rwlock_t));
736
-
737
- st->name = NULL;
738
- st->type = NULL;
739
- st->family = NULL;
740
- st->title = NULL;
741
- st->units = NULL;
742
- st->context = NULL;
743
- st->cache_dir = NULL;
744
- st->plugin_name = NULL;
745
- st->module_name = NULL;
746
- st->dimensions = NULL;
747
- st->rrdfamily = NULL;
748
- st->rrdhost = NULL;
749
- st->next = NULL;
750
- st->variables = NULL;
751
- st->alarms = NULL;
752
- st->flags = 0x00000000;
753
- st->exporting_flags = NULL;
754
-
755
- if(memory_mode == RRD_MEMORY_MODE_RAM) {
756
- memset(st, 0, size);
757
- }
758
- else {
759
- if(strcmp(st->magic, RRDSET_MAGIC) != 0) {
760
- info("Initializing file %s.", fullfilename);
761
- memset(st, 0, size);
762
- }
763
- else if(strcmp(st->id, fullid) != 0) {
764
- error("File %s contents are not for chart %s. Clearing it.", fullfilename, fullid);
765
- // munmap(st, size);
766
- // st = NULL;
767
- memset(st, 0, size);
768
- }
769
- else if(st->memsize != size || st->entries != entries) {
770
- error("File %s does not have the desired size. Clearing it.", fullfilename);
771
- memset(st, 0, size);
772
- }
773
- else if(st->update_every != update_every) {
774
- error("File %s does not have the desired update frequency. Clearing it.", fullfilename);
775
- memset(st, 0, size);
776
- }
777
- else if((now - st->last_updated.tv_sec) > update_every * entries) {
778
- info("File %s is too old. Clearing it.", fullfilename);
779
- memset(st, 0, size);
780
- }
781
- else if(st->last_updated.tv_sec > now + update_every) {
782
- error("File %s refers to the future by %zd secs. Resetting it to now.", fullfilename, (ssize_t)(st->last_updated.tv_sec - now));
783
- st->last_updated.tv_sec = now;
784
- }
785
-
786
- // make sure the database is aligned
787
- if(st->last_updated.tv_sec) {
788
- st->update_every = update_every;
789
- last_updated_time_align(st);
790
- }
791
- }
792
-
793
- // make sure we have the right memory mode
794
- // even if we cleared the memory
795
- st->rrd_memory_mode = memory_mode;
796
- }
797
- }
798
-
799
- if(unlikely(!st)) {
800
- st = callocz(1, size);
801
- if (memory_mode == RRD_MEMORY_MODE_DBENGINE)
802
- st->rrd_memory_mode = RRD_MEMORY_MODE_DBENGINE;
803
- else
804
- st->rrd_memory_mode = (memory_mode == RRD_MEMORY_MODE_NONE) ? RRD_MEMORY_MODE_NONE : RRD_MEMORY_MODE_ALLOC;
805
- }
806
-
807
- st->plugin_name = plugin?strdupz(plugin):NULL;
808
- st->module_name = module?strdupz(module):NULL;
809
-
810
- st->rrdhost = host;
811
- st->memsize = size;
812
- st->entries = entries;
813
- st->update_every = update_every;
814
-
815
- if(st->current_entry >= st->entries) st->current_entry = 0;
816
-
817
- strcpy(st->cache_filename, fullfilename);
818
- strcpy(st->magic, RRDSET_MAGIC);
699
+ st = callocz(1, sizeof(RRDSET));
700
+ st->state = callocz(1, sizeof(*st->state));
701
702
strcpy(st->id, fullid);
703
st->hash = simple_hash(st->id);
704
705
+ st->rrdhost = host;
706
st->cache_dir = cache_dir;
707
+ st->entries = entries;
708
+ st->update_every = update_every;
709
825
- st->chart_type = chart_type;
826
- st->type = strdupz(type);
827
-
828
- st->state = callocz(1, sizeof(*st->state));
710
+ if(memory_mode == RRD_MEMORY_MODE_SAVE || memory_mode == RRD_MEMORY_MODE_MAP) {
711
+ if(!rrdset_memory_load_or_create_map_save(st, memory_mode)) {
712
+ info("Failed to use memory mode %s for chart '%s', falling back to ram", (memory_mode == RRD_MEMORY_MODE_MAP)?"map":"save", st->name);
713
+ memory_mode = RRD_MEMORY_MODE_RAM;
714
+ }
715
+ }
716
+ st->rrd_memory_mode = memory_mode;
717
830
- st->family = family ? strdupz(family) : strdupz(st->type);
718
+ st->plugin_name = plugin?strdupz(plugin):NULL;
719
+ st->module_name = module?strdupz(module):NULL;
720
+ st->chart_type = chart_type;
721
+ st->type = strdupz(type);
722
+ st->family = family ? strdupz(family) : strdupz(st->type);
723
json_fix_string(st->family);
724
725
st->state->is_ar_chart = strcmp(st->id, ML_ANOMALY_RATES_CHART_ID) == 0;
@@ -848,16 +740,8 @@ RRDSET *rrdset_create_custom(
740
st->green = NAN;
741
st->red = NAN;
742
851
- st->last_collected_time.tv_sec = 0;
852
- st->last_collected_time.tv_usec = 0;
853
- st->counter_done = 0;
854
- st->rrddim_page_alignment = 0;
855
-
743
st->gap_when_lost_iterations_above = (int) (gap_when_lost_iterations_above + 2);
744
858
- st->last_accessed_time = 0;
859
- st->upstream_resync_time = 0;
860
-
745
avl_init_lock(&st->dimensions_index, rrddim_compare);
746
avl_init_lock(&st->rrdvar_root_index, rrdvar_compare);
747
@@ -963,7 +847,8 @@ inline void rrdset_next_usec(RRDSET *st, usec_t microseconds) {
847
if(unlikely(since_last_usec < 0)) {
848
// oops! the database is in the future
849
#ifdef NETDATA_INTERNAL_CHECKS
966
- info("RRD database for chart '%s' on host '%s' is %0.5" LONG_DOUBLE_MODIFIER " secs in the future (counter #%zu, update #%zu). Adjusting it to current time.", st->id, st->rrdhost->hostname, (LONG_DOUBLE)-since_last_usec / USEC_PER_SEC, st->counter, st->counter_done);
850
+ info("RRD database for chart '%s' on host '%s' is %0.5" NETDATA_DOUBLE_MODIFIER
851
+ " secs in the future (counter #%zu, update #%zu). Adjusting it to current time.", st->id, st->rrdhost->hostname, (NETDATA_DOUBLE)-since_last_usec / USEC_PER_SEC, st->counter, st->counter_done);
852
#endif
853
854
st->last_collected_time.tv_sec = now.tv_sec - st->update_every;
@@ -982,7 +867,8 @@ inline void rrdset_next_usec(RRDSET *st, usec_t microseconds) {
867
else if(unlikely((usec_t)since_last_usec > (usec_t)(st->update_every * 5 * USEC_PER_SEC))) {
868
// oops! the database is too far behind
869
#ifdef NETDATA_INTERNAL_CHECKS
985
- info("RRD database for chart '%s' on host '%s' is %0.5" LONG_DOUBLE_MODIFIER " secs in the past (counter #%zu, update #%zu). Adjusting it to current time.", st->id, st->rrdhost->hostname, (LONG_DOUBLE)since_last_usec / USEC_PER_SEC, st->counter, st->counter_done);
870
+ info("RRD database for chart '%s' on host '%s' is %0.5" NETDATA_DOUBLE_MODIFIER
871
+ " secs in the past (counter #%zu, update #%zu). Adjusting it to current time.", st->id, st->rrdhost->hostname, (NETDATA_DOUBLE)since_last_usec / USEC_PER_SEC, st->counter, st->counter_done);
872
#endif
873
874
microseconds = (usec_t)since_last_usec;
@@ -1039,7 +925,7 @@ static inline usec_t rrdset_init_last_collected_time(RRDSET *st) {
925
usec_t last_collect_ut = st->last_collected_time.tv_sec * USEC_PER_SEC + st->last_collected_time.tv_usec;
926
927
#ifdef NETDATA_INTERNAL_CHECKS
1042
- rrdset_debug(st, "initialized last collected time to %0.3" LONG_DOUBLE_MODIFIER, (LONG_DOUBLE)last_collect_ut / USEC_PER_SEC);
928
+ rrdset_debug(st, "initialized last collected time to %0.3" NETDATA_DOUBLE_MODIFIER, (NETDATA_DOUBLE)last_collect_ut / USEC_PER_SEC);
929
#endif
930
931
return last_collect_ut;
@@ -1052,7 +938,7 @@ static inline usec_t rrdset_update_last_collected_time(RRDSET *st) {
938
st->last_collected_time.tv_usec = (suseconds_t) (ut % USEC_PER_SEC);
939
940
#ifdef NETDATA_INTERNAL_CHECKS
1055
- rrdset_debug(st, "updated last collected time to %0.3" LONG_DOUBLE_MODIFIER, (LONG_DOUBLE)last_collect_ut / USEC_PER_SEC);
941
+ rrdset_debug(st, "updated last collected time to %0.3" NETDATA_DOUBLE_MODIFIER, (NETDATA_DOUBLE)last_collect_ut / USEC_PER_SEC);
942
#endif
943
944
return last_collect_ut;
@@ -1071,7 +957,7 @@ static inline usec_t rrdset_init_last_updated_time(RRDSET *st) {
957
usec_t last_updated_ut = st->last_updated.tv_sec * USEC_PER_SEC + st->last_updated.tv_usec;
958
959
#ifdef NETDATA_INTERNAL_CHECKS
1074
- rrdset_debug(st, "initialized last updated time to %0.3" LONG_DOUBLE_MODIFIER, (LONG_DOUBLE)last_updated_ut / USEC_PER_SEC);
960
+ rrdset_debug(st, "initialized last updated time to %0.3" NETDATA_DOUBLE_MODIFIER, (NETDATA_DOUBLE)last_updated_ut / USEC_PER_SEC);
961
#endif
962
963
return last_updated_ut;
@@ -1109,8 +995,8 @@ static inline size_t rrdset_done_interpolate(
995
996
#ifdef NETDATA_INTERNAL_CHECKS
997
if(iterations < 0) { error("INTERNAL CHECK: %s: iterations calculation wrapped! first_ut = %llu, last_stored_ut = %llu, next_store_ut = %llu, now_collect_ut = %llu", st->name, first_ut, last_stored_ut, next_store_ut, now_collect_ut); }
1112
- rrdset_debug(st, "last_stored_ut = %0.3" LONG_DOUBLE_MODIFIER " (last updated time)", (LONG_DOUBLE)last_stored_ut/USEC_PER_SEC);
1113
- rrdset_debug(st, "next_store_ut = %0.3" LONG_DOUBLE_MODIFIER " (next interpolation point)", (LONG_DOUBLE)next_store_ut/USEC_PER_SEC);
998
+ rrdset_debug(st, "last_stored_ut = %0.3" NETDATA_DOUBLE_MODIFIER " (last updated time)", (NETDATA_DOUBLE)last_stored_ut/USEC_PER_SEC);
999
+ rrdset_debug(st, "next_store_ut = %0.3" NETDATA_DOUBLE_MODIFIER " (next interpolation point)", (NETDATA_DOUBLE)next_store_ut/USEC_PER_SEC);
1000
#endif
1001
1002
last_ut = next_store_ut;
@@ -1119,20 +1005,19 @@ static inline size_t rrdset_done_interpolate(
1005
if (rrddim_flag_check(rd, RRDDIM_FLAG_ARCHIVED))
1006
continue;
1007
1122
- calculated_number new_value;
1008
+ NETDATA_DOUBLE new_value;
1009
1010
switch(rd->algorithm) {
1011
case RRD_ALGORITHM_INCREMENTAL:
1126
- new_value = (calculated_number)
1012
+ new_value = (NETDATA_DOUBLE)
1013
( rd->calculated_value
1128
- * (calculated_number)(next_store_ut - last_collect_ut)
1129
- / (calculated_number)(now_collect_ut - last_collect_ut)
1014
+ * (NETDATA_DOUBLE)(next_store_ut - last_collect_ut)
1015
+ / (NETDATA_DOUBLE)(now_collect_ut - last_collect_ut)
1016
);
1017
1018
#ifdef NETDATA_INTERNAL_CHECKS
1133
- rrdset_debug(st, "%s: CALC2 INC "
1134
- CALCULATED_NUMBER_FORMAT " = "
1135
- CALCULATED_NUMBER_FORMAT
1019
+ rrdset_debug(st, "%s: CALC2 INC " NETDATA_DOUBLE_FORMAT " = "
1020
+ NETDATA_DOUBLE_FORMAT
1021
" * (%llu - %llu)"
1022
" / (%llu - %llu)"
1023
, rd->name
@@ -1146,18 +1031,18 @@ static inline size_t rrdset_done_interpolate(
1031
rd->calculated_value -= new_value;
1032
new_value += rd->last_calculated_value;
1033
rd->last_calculated_value = 0;
1149
- new_value /= (calculated_number)st->update_every;
1034
+ new_value /= (NETDATA_DOUBLE)st->update_every;
1035
1036
if(unlikely(next_store_ut - last_stored_ut < update_every_ut)) {
1037
1038
#ifdef NETDATA_INTERNAL_CHECKS
1154
- rrdset_debug(st, "%s: COLLECTION POINT IS SHORT " CALCULATED_NUMBER_FORMAT " - EXTRAPOLATING",
1039
+ rrdset_debug(st, "%s: COLLECTION POINT IS SHORT " NETDATA_DOUBLE_FORMAT " - EXTRAPOLATING",
1040
rd->name
1156
- , (calculated_number)(next_store_ut - last_stored_ut)
1041
+ , (NETDATA_DOUBLE)(next_store_ut - last_stored_ut)
1042
);
1043
#endif
1044
1160
- new_value = new_value * (calculated_number)(st->update_every * USEC_PER_SEC) / (calculated_number)(next_store_ut - last_stored_ut);
1045
+ new_value = new_value * (NETDATA_DOUBLE)(st->update_every * USEC_PER_SEC) / (NETDATA_DOUBLE)(next_store_ut - last_stored_ut);
1046
}
1047
break;
1048
@@ -1176,21 +1061,19 @@ static inline size_t rrdset_done_interpolate(
1061
// we have missed an update
1062
// interpolate in the middle values
1063
1179
- new_value = (calculated_number)
1064
+ new_value = (NETDATA_DOUBLE)
1065
( ( (rd->calculated_value - rd->last_calculated_value)
1181
- * (calculated_number)(next_store_ut - last_collect_ut)
1182
- / (calculated_number)(now_collect_ut - last_collect_ut)
1066
+ * (NETDATA_DOUBLE)(next_store_ut - last_collect_ut)
1067
+ / (NETDATA_DOUBLE)(now_collect_ut - last_collect_ut)
1068
)
1069
+ rd->last_calculated_value
1070
);
1071
1072
#ifdef NETDATA_INTERNAL_CHECKS
1188
- rrdset_debug(st, "%s: CALC2 DEF "
1189
- CALCULATED_NUMBER_FORMAT " = ((("
1190
- "(" CALCULATED_NUMBER_FORMAT " - " CALCULATED_NUMBER_FORMAT ")"
1073
+ rrdset_debug(st, "%s: CALC2 DEF " NETDATA_DOUBLE_FORMAT " = ((("
1074
+ "(" NETDATA_DOUBLE_FORMAT " - " NETDATA_DOUBLE_FORMAT ")"
1075
" * %llu"
1192
- " / %llu) + " CALCULATED_NUMBER_FORMAT
1193
- , rd->name
1076
+ " / %llu) + " NETDATA_DOUBLE_FORMAT, rd->name
1077
, new_value
1078
, rd->calculated_value, rd->last_calculated_value
1079
, (next_store_ut - first_ut)
@@ -1271,7 +1154,7 @@ static inline void rrdset_done_fill_the_gap(RRDSET *st) {
1154
long current_entry = st->current_entry;
1155
1156
for(c = 0; c < entries && next_store_ut <= now_collect_ut ; next_store_ut += update_every_ut, c++) {
1274
- rd->values[current_entry] = SN_EMPTY_SLOT;
1157
+ rd->db[current_entry] = SN_EMPTY_SLOT;
1158
current_entry = ((current_entry + 1) >= entries) ? 0 : current_entry + 1;
1159
1160
#ifdef NETDATA_INTERNAL_CHECKS
@@ -1332,7 +1215,8 @@ void rrdset_done(RRDSET *st) {
1215
// check if the chart has a long time to be updated
1216
if(unlikely(st->usec_since_last_update > st->entries * update_every_ut &&
1217
st->rrd_memory_mode != RRD_MEMORY_MODE_DBENGINE && st->rrd_memory_mode != RRD_MEMORY_MODE_NONE)) {
1335
- info("host '%s', chart %s: took too long to be updated (counter #%zu, update #%zu, %0.3" LONG_DOUBLE_MODIFIER " secs). Resetting it.", st->rrdhost->hostname, st->name, st->counter, st->counter_done, (LONG_DOUBLE)st->usec_since_last_update / USEC_PER_SEC);
1218
+ info("host '%s', chart %s: took too long to be updated (counter #%zu, update #%zu, %0.3" NETDATA_DOUBLE_MODIFIER
1219
+ " secs). Resetting it.", st->rrdhost->hostname, st->name, st->counter, st->counter_done, (NETDATA_DOUBLE)st->usec_since_last_update / USEC_PER_SEC);
1220
rrdset_reset(st);
1221
st->usec_since_last_update = update_every_ut;
1222
store_this_entry = 0;
@@ -1459,6 +1343,7 @@ void rrdset_done(RRDSET *st) {
1343
#endif
1344
}
1345
}
1346
+
1347
after_first_database_work:
1348
st->counter_done++;
1349
@@ -1469,10 +1354,10 @@ after_first_database_work:
1354
}
1355
1356
#ifdef NETDATA_INTERNAL_CHECKS
1472
- rrdset_debug(st, "last_collect_ut = %0.3" LONG_DOUBLE_MODIFIER " (last collection time)", (LONG_DOUBLE)last_collect_ut/USEC_PER_SEC);
1473
- rrdset_debug(st, "now_collect_ut = %0.3" LONG_DOUBLE_MODIFIER " (current collection time)", (LONG_DOUBLE)now_collect_ut/USEC_PER_SEC);
1474
- rrdset_debug(st, "last_stored_ut = %0.3" LONG_DOUBLE_MODIFIER " (last updated time)", (LONG_DOUBLE)last_stored_ut/USEC_PER_SEC);
1475
- rrdset_debug(st, "next_store_ut = %0.3" LONG_DOUBLE_MODIFIER " (next interpolation point)", (LONG_DOUBLE)next_store_ut/USEC_PER_SEC);
1357
+ rrdset_debug(st, "last_collect_ut = %0.3" NETDATA_DOUBLE_MODIFIER " (last collection time)", (NETDATA_DOUBLE)last_collect_ut/USEC_PER_SEC);
1358
+ rrdset_debug(st, "now_collect_ut = %0.3" NETDATA_DOUBLE_MODIFIER " (current collection time)", (NETDATA_DOUBLE)now_collect_ut/USEC_PER_SEC);
1359
+ rrdset_debug(st, "last_stored_ut = %0.3" NETDATA_DOUBLE_MODIFIER " (last updated time)", (NETDATA_DOUBLE)last_stored_ut/USEC_PER_SEC);
1360
+ rrdset_debug(st, "next_store_ut = %0.3" NETDATA_DOUBLE_MODIFIER " (next interpolation point)", (NETDATA_DOUBLE)next_store_ut/USEC_PER_SEC);
1361
#endif
1362
1363
// calculate totals and count the dimensions
@@ -1481,7 +1366,9 @@ after_first_database_work:
1366
rrddim_foreach_read(rd, st) {
1367
if (rrddim_flag_check(rd, RRDDIM_FLAG_ARCHIVED))
1368
continue;
1369
+
1370
dimensions++;
1371
+
1372
if(likely(rd->updated))
1373
st->collected_total += rd->collected_value;
1374
}
@@ -1509,9 +1396,8 @@ after_first_database_work:
1396
rrdset_debug(st, "%s: START "
1397
" last_collected_value = " COLLECTED_NUMBER_FORMAT
1398
" collected_value = " COLLECTED_NUMBER_FORMAT
1512
- " last_calculated_value = " CALCULATED_NUMBER_FORMAT
1513
- " calculated_value = " CALCULATED_NUMBER_FORMAT
1514
- , rd->name
1399
+ " last_calculated_value = " NETDATA_DOUBLE_FORMAT
1400
+ " calculated_value = " NETDATA_DOUBLE_FORMAT, rd->name
1401
, rd->last_collected_value
1402
, rd->collected_value
1403
, rd->last_calculated_value
@@ -1521,21 +1407,19 @@ after_first_database_work:
1407
1408
switch(rd->algorithm) {
1409
case RRD_ALGORITHM_ABSOLUTE:
1524
- rd->calculated_value = (calculated_number)rd->collected_value
1525
- * (calculated_number)rd->multiplier
1526
- / (calculated_number)rd->divisor;
1410
+ rd->calculated_value = (NETDATA_DOUBLE)rd->collected_value
1411
+ * (NETDATA_DOUBLE)rd->multiplier
1412
+ / (NETDATA_DOUBLE)rd->divisor;
1413
1414
#ifdef NETDATA_INTERNAL_CHECKS
1529
- rrdset_debug(st, "%s: CALC ABS/ABS-NO-IN "
1530
- CALCULATED_NUMBER_FORMAT " = "
1415
+ rrdset_debug(st, "%s: CALC ABS/ABS-NO-IN " NETDATA_DOUBLE_FORMAT " = "
1416
COLLECTED_NUMBER_FORMAT
1532
- " * " CALCULATED_NUMBER_FORMAT
1533
- " / " CALCULATED_NUMBER_FORMAT
1534
- , rd->name
1417
+ " * " NETDATA_DOUBLE_FORMAT
1418
+ " / " NETDATA_DOUBLE_FORMAT, rd->name
1419
, rd->calculated_value
1420
, rd->collected_value
1537
- , (calculated_number)rd->multiplier
1538
- , (calculated_number)rd->divisor
1421
+ , (NETDATA_DOUBLE)rd->multiplier
1422
+ , (NETDATA_DOUBLE)rd->divisor
1423
);
1424
#endif
1425
@@ -1548,13 +1432,12 @@ after_first_database_work:
1432
// the percentage of the current value
1433
// over the total of all dimensions
1434
rd->calculated_value =
1551
- (calculated_number)100
1552
- * (calculated_number)rd->collected_value
1553
- / (calculated_number)st->collected_total;
1435
+ (NETDATA_DOUBLE)100
1436
+ * (NETDATA_DOUBLE)rd->collected_value
1437
+ / (NETDATA_DOUBLE)st->collected_total;
1438
1439
#ifdef NETDATA_INTERNAL_CHECKS
1556
- rrdset_debug(st, "%s: CALC PCENT-ROW "
1557
- CALCULATED_NUMBER_FORMAT " = 100"
1440
+ rrdset_debug(st, "%s: CALC PCENT-ROW " NETDATA_DOUBLE_FORMAT " = 100"
1441
" * " COLLECTED_NUMBER_FORMAT
1442
" / " COLLECTED_NUMBER_FORMAT
1443
, rd->name
@@ -1605,34 +1488,32 @@ after_first_database_work:
1488
// TODO: remember recent history of rates and compare with current rate to reduce this chance.
1489
if (delta < max_acceptable_rate) {
1490
rd->calculated_value +=
1608
- (calculated_number) delta
1609
- * (calculated_number) rd->multiplier
1610
- / (calculated_number) rd->divisor;
1491
+ (NETDATA_DOUBLE) delta
1492
+ * (NETDATA_DOUBLE) rd->multiplier
1493
+ / (NETDATA_DOUBLE) rd->divisor;
1494
} else {
1495
// This is a reset. Any overflow with a rate greater than MAX_INCREMENTAL_PERCENT_RATE will also
1496
// be detected as a reset instead.
1614
- rd->calculated_value += (calculated_number)0;
1497
+ rd->calculated_value += (NETDATA_DOUBLE)0;
1498
}
1499
}
1500
else {
1501
rd->calculated_value +=
1619
- (calculated_number) (rd->collected_value - rd->last_collected_value)
1620
- * (calculated_number) rd->multiplier
1621
- / (calculated_number) rd->divisor;
1502
+ (NETDATA_DOUBLE) (rd->collected_value - rd->last_collected_value)
1503
+ * (NETDATA_DOUBLE) rd->multiplier
1504
+ / (NETDATA_DOUBLE) rd->divisor;
1505
}
1506
1507
#ifdef NETDATA_INTERNAL_CHECKS
1625
- rrdset_debug(st, "%s: CALC INC PRE "
1626
- CALCULATED_NUMBER_FORMAT " = ("
1508
+ rrdset_debug(st, "%s: CALC INC PRE " NETDATA_DOUBLE_FORMAT " = ("
1509
COLLECTED_NUMBER_FORMAT " - " COLLECTED_NUMBER_FORMAT
1510
")"
1629
- " * " CALCULATED_NUMBER_FORMAT
1630
- " / " CALCULATED_NUMBER_FORMAT
1631
- , rd->name
1511
+ " * " NETDATA_DOUBLE_FORMAT
1512
+ " / " NETDATA_DOUBLE_FORMAT, rd->name
1513
, rd->calculated_value
1514
, rd->collected_value, rd->last_collected_value
1634
- , (calculated_number)rd->multiplier
1635
- , (calculated_number)rd->divisor
1515
+ , (NETDATA_DOUBLE)rd->multiplier
1516
+ , (NETDATA_DOUBLE)rd->divisor
1517
);
1518
#endif
1519
@@ -1665,13 +1546,12 @@ after_first_database_work:
1546
rd->calculated_value = 0;
1547
else
1548
rd->calculated_value =
1668
- (calculated_number)100
1669
- * (calculated_number)(rd->collected_value - rd->last_collected_value)
1670
- / (calculated_number)(st->collected_total - st->last_collected_total);
1549
+ (NETDATA_DOUBLE)100
1550
+ * (NETDATA_DOUBLE)(rd->collected_value - rd->last_collected_value)
1551
+ / (NETDATA_DOUBLE)(st->collected_total - st->last_collected_total);
1552
1553
#ifdef NETDATA_INTERNAL_CHECKS
1673
- rrdset_debug(st, "%s: CALC PCENT-DIFF "
1674
- CALCULATED_NUMBER_FORMAT " = 100"
1554
+ rrdset_debug(st, "%s: CALC PCENT-DIFF " NETDATA_DOUBLE_FORMAT " = 100"
1555
" * (" COLLECTED_NUMBER_FORMAT " - " COLLECTED_NUMBER_FORMAT ")"
1556
" / (" COLLECTED_NUMBER_FORMAT " - " COLLECTED_NUMBER_FORMAT ")"
1557
, rd->name
@@ -1689,8 +1569,7 @@ after_first_database_work:
1569
rd->calculated_value = 0;
1570
1571
#ifdef NETDATA_INTERNAL_CHECKS
1692
- rrdset_debug(st, "%s: CALC "
1693
- CALCULATED_NUMBER_FORMAT " = 0"
1572
+ rrdset_debug(st, "%s: CALC " NETDATA_DOUBLE_FORMAT " = 0"
1573
, rd->name
1574
, rd->calculated_value
1575
);
@@ -1703,9 +1582,8 @@ after_first_database_work:
1582
rrdset_debug(st, "%s: PHASE2 "
1583
" last_collected_value = " COLLECTED_NUMBER_FORMAT
1584
" collected_value = " COLLECTED_NUMBER_FORMAT
1706
- " last_calculated_value = " CALCULATED_NUMBER_FORMAT
1707
- " calculated_value = " CALCULATED_NUMBER_FORMAT
1708
- , rd->name
1585
+ " last_calculated_value = " NETDATA_DOUBLE_FORMAT
1586
+ " calculated_value = " NETDATA_DOUBLE_FORMAT, rd->name
1587
, rd->last_collected_value
1588
, rd->collected_value
1589
, rd->last_calculated_value
@@ -1765,7 +1643,8 @@ after_second_database_work:
1643
case RRD_ALGORITHM_INCREMENTAL:
1644
if(unlikely(!first_entry)) {
1645
#ifdef NETDATA_INTERNAL_CHECKS
1768
- rrdset_debug(st, "%s: setting last_calculated_value (old: " CALCULATED_NUMBER_FORMAT ") to last_calculated_value (new: " CALCULATED_NUMBER_FORMAT ")", rd->name, rd->last_calculated_value + rd->calculated_value, rd->calculated_value);
1646
+ rrdset_debug(st, "%s: setting last_calculated_value (old: " NETDATA_DOUBLE_FORMAT
1647
+ ") to last_calculated_value (new: " NETDATA_DOUBLE_FORMAT ")", rd->name, rd->last_calculated_value + rd->calculated_value, rd->calculated_value);
1648
#endif
1649
1650
rd->last_calculated_value += rd->calculated_value;
@@ -1781,7 +1660,8 @@ after_second_database_work:
1660
case RRD_ALGORITHM_PCENT_OVER_ROW_TOTAL:
1661
case RRD_ALGORITHM_PCENT_OVER_DIFF_TOTAL:
1662
#ifdef NETDATA_INTERNAL_CHECKS
1784
- rrdset_debug(st, "%s: setting last_calculated_value (old: " CALCULATED_NUMBER_FORMAT ") to last_calculated_value (new: " CALCULATED_NUMBER_FORMAT ")", rd->name, rd->last_calculated_value, rd->calculated_value);
1663
+ rrdset_debug(st, "%s: setting last_calculated_value (old: " NETDATA_DOUBLE_FORMAT
1664
+ ") to last_calculated_value (new: " NETDATA_DOUBLE_FORMAT ")", rd->name, rd->last_calculated_value, rd->calculated_value);
1665
#endif
1666
1667
rd->last_calculated_value = rd->calculated_value;
@@ -1796,9 +1676,8 @@ after_second_database_work:
1676
rrdset_debug(st, "%s: END "
1677
" last_collected_value = " COLLECTED_NUMBER_FORMAT
1678
" collected_value = " COLLECTED_NUMBER_FORMAT
1799
- " last_calculated_value = " CALCULATED_NUMBER_FORMAT
1800
- " calculated_value = " CALCULATED_NUMBER_FORMAT
1801
- , rd->name
1679
+ " last_calculated_value = " NETDATA_DOUBLE_FORMAT
1680
+ " calculated_value = " NETDATA_DOUBLE_FORMAT, rd->name
1681
, rd->last_collected_value
1682
, rd->collected_value
1683
, rd->last_calculated_value
@@ -1811,15 +1690,24 @@ after_second_database_work:
1690
// ALL DONE ABOUT THE DATA UPDATE
1691
// --------------------------------------------------------------------
1692
1814
- // find if there are any obsolete dimensions
1815
- time_t now = now_realtime_sec();
1693
+ if(unlikely(st->rrd_memory_mode == RRD_MEMORY_MODE_MAP)) {
1694
+ // update the memory mapped files with the latest values
1695
1696
+ rrdset_memory_file_update(st);
1697
+ rrddim_foreach_read(rd, st) {
1698
+ rrddim_memory_file_update(rd);
1699
+ }
1700
+ }
1701
+
1702
+ // find if there are any obsolete dimensions
1703
if(unlikely(rrdset_flag_check(st, RRDSET_FLAG_OBSOLETE_DIMENSIONS))) {
1704
rrddim_foreach_read(rd, st)
1705
if(unlikely(rrddim_flag_check(rd, RRDDIM_FLAG_OBSOLETE)))
1706
break;
1707
1708
if(unlikely(rd)) {
1709
+ time_t now = now_realtime_sec();
1710
+
1711
RRDDIM *last;
1712
// there is a dimension to free
1713
// upgrade our read lock to a write lock
@@ -1831,10 +1719,11 @@ after_second_database_work:
1719
&& (rd->last_collected_time.tv_sec + rrdset_free_obsolete_time < now))) {
1720
info("Removing obsolete dimension '%s' (%s) of '%s' (%s).", rd->name, rd->id, st->name, st->id);
1721
1834
- if(likely(rd->rrd_memory_mode == RRD_MEMORY_MODE_SAVE || rd->rrd_memory_mode == RRD_MEMORY_MODE_MAP)) {
1835
- info("Deleting dimension file '%s'.", rd->cache_filename);
1836
- if(unlikely(unlink(rd->cache_filename) == -1))
1837
- error("Cannot delete dimension file '%s'", rd->cache_filename);
1722
+ const char *cache_filename = rrddim_cache_filename(rd);
1723
+ if(cache_filename) {
1724
+ info("Deleting dimension file '%s'.", cache_filename);
1725
+ if (unlikely(unlink(cache_filename) == -1))
1726
+ error("Cannot delete dimension file '%s'", cache_filename);
1727
}
1728
1729
#ifdef ENABLE_DBENGINE
@@ -1885,3 +1774,208 @@ after_second_database_work:
1774
1775
netdata_thread_enable_cancelability();
1776
}
1777
+
1778
+
1779
+// ----------------------------------------------------------------------------
1780
+// compatibility layer for RRDSET files v019
1781
+
1782
+#define RRDSET_MAGIC_V019 "NETDATA RRD SET FILE V019"
1783
+#define RRD_ID_LENGTH_MAX_V019 200
1784
+
1785
+struct avl_element_v019 {
1786
+ void *avl_link[2];
1787
+ signed char avl_balance;
1788
+};
1789
+struct avl_tree_type_v019 {
1790
+ void *root;
1791
+ int (*compar)(void *a, void *b);
1792
+};
1793
+struct avl_tree_lock_v019 {
1794
+ struct avl_tree_type_v019 avl_tree;
1795
+ pthread_rwlock_t rwlock;
1796
+};
1797
+struct rrdset_map_save_v019 {
1798
+ struct avl_element_v019 avl; // ignored
1799
+ struct avl_element_v019 avlname; // ignored
1800
+ char id[RRD_ID_LENGTH_MAX_V019 + 1]; // check to reset all - update on load
1801
+ void *name; // ignored
1802
+ void *unused_ptr; // ignored
1803
+ void *type; // ignored
1804
+ void *family; // ignored
1805
+ void *title; // ignored
1806
+ void *units; // ignored
1807
+ void *context; // ignored
1808
+ uint32_t hash_context; // ignored
1809
+ uint32_t chart_type; // ignored
1810
+ int update_every; // check to reset all - update on load
1811
+ long entries; // check to reset all - update on load
1812
+ long current_entry; // NEEDS TO BE UPDATED - FIXED ON LOAD
1813
+ uint32_t flags; // ignored
1814
+ void *exporting_flags; // ignored
1815
+ int gap_when_lost_iterations_above; // ignored
1816
+ long priority; // ignored
1817
+ uint32_t rrd_memory_mode; // ignored
1818
+ void *cache_dir; // ignored
1819
+ char cache_filename[FILENAME_MAX+1]; // ignored - update on load
1820
+ pthread_rwlock_t rrdset_rwlock; // ignored
1821
+ size_t counter; // NEEDS TO BE UPDATED - maintained on load
1822
+ size_t counter_done; // ignored
1823
+ union { //
1824
+ time_t last_accessed_time; // ignored
1825
+ time_t last_entry_t; // ignored
1826
+ }; //
1827
+ time_t upstream_resync_time; // ignored
1828
+ void *plugin_name; // ignored
1829
+ void *module_name; // ignored
1830
+ void *chart_uuid; // ignored
1831
+ void *state; // ignored
1832
+ size_t unused[3]; // ignored
1833
+ size_t rrddim_page_alignment; // ignored
1834
+ uint32_t hash; // ignored
1835
+ uint32_t hash_name; // ignored
1836
+ usec_t usec_since_last_update; // NEEDS TO BE UPDATED - maintained on load
1837
+ struct timeval last_updated; // NEEDS TO BE UPDATED - check to reset all - fixed on load
1838
+ struct timeval last_collected_time; // ignored
1839
+ long long collected_total; // NEEDS TO BE UPDATED - maintained on load
1840
+ long long last_collected_total; // NEEDS TO BE UPDATED - maintained on load
1841
+ void *rrdfamily; // ignored
1842
+ void *rrdhost; // ignored
1843
+ void *next; // ignored
1844
+ long double green; // ignored
1845
+ long double red; // ignored
1846
+ struct avl_tree_lock_v019 rrdvar_root_index; // ignored
1847
+ void *variables; // ignored
1848
+ void *alarms; // ignored
1849
+ unsigned long memsize; // check to reset all - update on load
1850
+ char magic[sizeof(RRDSET_MAGIC_V019) + 1]; // check to reset all - update on load
1851
+ struct avl_tree_lock_v019 dimensions_index; // ignored
1852
+ void *dimensions; // ignored
1853
+};
1854
+
1855
+void rrdset_memory_file_update(RRDSET *st) {
1856
+ if(!st->st_on_file) return;
1857
+ struct rrdset_map_save_v019 *st_on_file = st->st_on_file;
1858
+
1859
+ st_on_file->current_entry = st->current_entry;
1860
+ st_on_file->counter = st->counter;
1861
+ st_on_file->usec_since_last_update = st->usec_since_last_update;
1862
+ st_on_file->last_updated.tv_sec = st->last_updated.tv_sec;
1863
+ st_on_file->last_updated.tv_usec = st->last_updated.tv_usec;
1864
+ st_on_file->collected_total = st->collected_total;
1865
+ st_on_file->last_collected_total = st->last_collected_total;
1866
+}
1867
+
1868
+const char *rrdset_cache_filename(RRDSET *st) {
1869
+ if(!st->st_on_file) return NULL;
1870
+ struct rrdset_map_save_v019 *st_on_file = st->st_on_file;
1871
+ return st_on_file->cache_filename;
1872
+}
1873
+
1874
+void rrdset_memory_file_free(RRDSET *st) {
1875
+ if(!st->st_on_file) return;
1876
+
1877
+ // needed for memory mode map, to save the latest state
1878
+ rrdset_memory_file_update(st);
1879
+
1880
+ struct rrdset_map_save_v019 *st_on_file = st->st_on_file;
1881
+ munmap(st_on_file, st_on_file->memsize);
1882
+
1883
+ // remove the pointers from the RRDDIM
1884
+ st->st_on_file = NULL;
1885
+}
1886
+
1887
+void rrdset_memory_file_save(RRDSET *st) {
1888
+ if(!st->st_on_file) return;
1889
+
1890
+ rrdset_memory_file_update(st);
1891
+
1892
+ struct rrdset_map_save_v019 *st_on_file = st->st_on_file;
1893
+ if(st_on_file->rrd_memory_mode != RRD_MEMORY_MODE_SAVE) return;
1894
+
1895
+ memory_file_save(st_on_file->cache_filename, st->st_on_file, st_on_file->memsize);
1896
+}
1897
+
1898
+bool rrdset_memory_load_or_create_map_save(RRDSET *st, RRD_MEMORY_MODE memory_mode) {
1899
+ if(memory_mode != RRD_MEMORY_MODE_SAVE && memory_mode != RRD_MEMORY_MODE_MAP)
1900
+ return false;
1901
+
1902
+ char fullfilename[FILENAME_MAX + 1];
1903
+ snprintfz(fullfilename, FILENAME_MAX, "%s/main.db", st->cache_dir);
1904
+
1905
+ unsigned long size = sizeof(struct rrdset_map_save_v019);
1906
+ struct rrdset_map_save_v019 *st_on_file = (struct rrdset_map_save_v019 *)netdata_mmap(
1907
+ fullfilename, size,
1908
+ ((memory_mode == RRD_MEMORY_MODE_MAP) ? MAP_SHARED : MAP_PRIVATE),
1909
+ 0);
1910
+
1911
+ if(!st_on_file) return false;
1912
+
1913
+ time_t now = now_realtime_sec();
1914
+
1915
+ if(strcmp(st_on_file->magic, RRDSET_MAGIC_V019) != 0) {
1916
+ info("Initializing file '%s'.", fullfilename);
1917
+ memset(st_on_file, 0, size);
1918
+ }
1919
+ else if(strncmp(st_on_file->id, st->id, RRD_ID_LENGTH_MAX_V019) != 0) {
1920
+ error("File '%s' contents are not for chart '%s'. Clearing it.", fullfilename, st->id);
1921
+ memset(st_on_file, 0, size);
1922
+ }
1923
+ else if(st_on_file->memsize != size || st_on_file->entries != st->entries) {
1924
+ error("File '%s' does not have the desired size. Clearing it.", fullfilename);
1925
+ memset(st_on_file, 0, size);
1926
+ }
1927
+ else if(st_on_file->update_every != st->update_every) {
1928
+ error("File '%s' does not have the desired granularity. Clearing it.", fullfilename);
1929
+ memset(st_on_file, 0, size);
1930
+ }
1931
+ else if((now - st_on_file->last_updated.tv_sec) > st->update_every * st->entries) {
1932
+ info("File '%s' is too old. Clearing it.", fullfilename);
1933
+ memset(st_on_file, 0, size);
1934
+ }
1935
+ else if(st_on_file->last_updated.tv_sec > now + st->update_every) {
1936
+ error("File '%s' refers to the future by %zd secs. Resetting it to now.", fullfilename, (ssize_t)(st_on_file->last_updated.tv_sec - now));
1937
+ st_on_file->last_updated.tv_sec = now;
1938
+ }
1939
+
1940
+ if(st_on_file->current_entry >= st_on_file->entries)
1941
+ st_on_file->current_entry = 0;
1942
+
1943
+ // make sure the database is aligned
1944
+ bool align_last_updated = false;
1945
+ if(st_on_file->last_updated.tv_sec) {
1946
+ st_on_file->update_every = st->update_every;
1947
+ align_last_updated = true;
1948
+ }
1949
+
1950
+ // copy the useful values to st
1951
+ st->current_entry = st_on_file->current_entry;
1952
+ st->counter = st_on_file->counter;
1953
+ st->usec_since_last_update = st_on_file->usec_since_last_update;
1954
+ st->last_updated.tv_sec = st_on_file->last_updated.tv_sec;
1955
+ st->last_updated.tv_usec = st_on_file->last_updated.tv_usec;
1956
+ st->collected_total = st_on_file->collected_total;
1957
+ st->last_collected_total = st_on_file->last_collected_total;
1958
+
1959
+ // link it to st
1960
+ st->st_on_file = st_on_file;
1961
+
1962
+ // clear everything
1963
+ memset(st_on_file, 0, size);
1964
+
1965
+ // set the values we need
1966
+ strncpyz(st_on_file->id, st->id, RRD_ID_LENGTH_MAX_V019 + 1);
1967
+ strcpy(st_on_file->cache_filename, fullfilename);
1968
+ strcpy(st_on_file->magic, RRDSET_MAGIC_V019);
1969
+ st_on_file->memsize = size;
1970
+ st_on_file->entries = st->entries;
1971
+ st_on_file->update_every = st->update_every;
1972
+ st_on_file->rrd_memory_mode = memory_mode;
1973
+
1974
+ if(align_last_updated)
1975
+ last_updated_time_align(st);
1976
+
1977
+ // copy the useful values back to st_on_file
1978
+ rrdset_memory_file_update(st);
1979
+
1980
+ return true;
1981
+}
database/rrdsetvar.c
+5
-4
@@ -163,7 +163,7 @@ RRDSETVAR *rrdsetvar_custom_chart_variable_create(RRDSET *st, const char *name)
163
164
// not found, allocate one
165
166
- calculated_number *v = mallocz(sizeof(calculated_number));
166
+ NETDATA_DOUBLE *v = mallocz(sizeof(NETDATA_DOUBLE));
167
*v = NAN;
168
169
rs = rrdsetvar_create(st, n, RRDVAR_TYPE_CALCULATED, v, RRDVAR_OPTION_ALLOCATED|RRDVAR_OPTION_CUSTOM_CHART_VAR);
@@ -173,12 +173,13 @@ RRDSETVAR *rrdsetvar_custom_chart_variable_create(RRDSET *st, const char *name)
173
return rs;
174
}
175
176
-void rrdsetvar_custom_chart_variable_set(RRDSETVAR *rs, calculated_number value) {
176
+void rrdsetvar_custom_chart_variable_set(RRDSETVAR *rs, NETDATA_DOUBLE value) {
177
if(rs->type != RRDVAR_TYPE_CALCULATED || !(rs->options & RRDVAR_OPTION_CUSTOM_CHART_VAR) || !(rs->options & RRDVAR_OPTION_ALLOCATED)) {
178
- error("RRDSETVAR: requested to set variable '%s' of chart '%s' on host '%s' to value " CALCULATED_NUMBER_FORMAT " but the variable is not a custom chart one.", rs->variable, rs->rrdset->id, rs->rrdset->rrdhost->hostname, value);
178
+ error("RRDSETVAR: requested to set variable '%s' of chart '%s' on host '%s' to value " NETDATA_DOUBLE_FORMAT
179
+ " but the variable is not a custom chart one.", rs->variable, rs->rrdset->id, rs->rrdset->rrdhost->hostname, value);
180
}
181
else {
181
- calculated_number *v = rs->value;
182
+ NETDATA_DOUBLE *v = rs->value;
183
if(*v != value) {
184
*v = value;
185
database/rrdsetvar.h
+1
-1
@@ -35,7 +35,7 @@ struct rrdsetvar {
35
};
36
37
extern RRDSETVAR *rrdsetvar_custom_chart_variable_create(RRDSET *st, const char *name);
38
-extern void rrdsetvar_custom_chart_variable_set(RRDSETVAR *rv, calculated_number value);
38
+extern void rrdsetvar_custom_chart_variable_set(RRDSETVAR *rv, NETDATA_DOUBLE value);
39
40
extern void rrdsetvar_rename_all(RRDSET *st);
41
extern RRDSETVAR *rrdsetvar_create(RRDSET *st, const char *variable, RRDVAR_TYPE type, void *value, RRDVAR_OPTIONS options);
database/rrdvar.c
+10
-10
@@ -133,7 +133,7 @@ inline int rrdvar_callback_for_all_host_variables(RRDHOST *host, int (*callback)
133
}
134
135
static RRDVAR *rrdvar_custom_variable_create(const char *scope, avl_tree_lock *tree_lock, const char *name) {
136
- calculated_number *v = callocz(1, sizeof(calculated_number));
136
+ NETDATA_DOUBLE *v = callocz(1, sizeof(NETDATA_DOUBLE));
137
*v = NAN;
138
139
RRDVAR *rv = rrdvar_create_and_index(scope, tree_lock, name, RRDVAR_TYPE_CALCULATED, RRDVAR_OPTION_CUSTOM_HOST_VAR|RRDVAR_OPTION_ALLOCATED, v);
@@ -158,11 +158,11 @@ RRDVAR *rrdvar_custom_host_variable_create(RRDHOST *host, const char *name) {
158
return rrdvar_custom_variable_create("host", &host->rrdvar_root_index, name);
159
}
160
161
-void rrdvar_custom_host_variable_set(RRDHOST *host, RRDVAR *rv, calculated_number value) {
161
+void rrdvar_custom_host_variable_set(RRDHOST *host, RRDVAR *rv, NETDATA_DOUBLE value) {
162
if(rv->type != RRDVAR_TYPE_CALCULATED || !(rv->options & RRDVAR_OPTION_CUSTOM_HOST_VAR) || !(rv->options & RRDVAR_OPTION_ALLOCATED))
163
- error("requested to set variable '%s' to value " CALCULATED_NUMBER_FORMAT " but the variable is not a custom one.", rv->name, value);
163
+ error("requested to set variable '%s' to value " NETDATA_DOUBLE_FORMAT " but the variable is not a custom one.", rv->name, value);
164
else {
165
- calculated_number *v = rv->value;
165
+ NETDATA_DOUBLE *v = rv->value;
166
if(*v != value) {
167
*v = value;
168
@@ -181,10 +181,10 @@ int foreach_host_variable_callback(RRDHOST *host, int (*callback)(RRDVAR * /*rv*
181
// ----------------------------------------------------------------------------
182
// RRDVAR lookup
183
184
-calculated_number rrdvar2number(RRDVAR *rv) {
184
+NETDATA_DOUBLE rrdvar2number(RRDVAR *rv) {
185
switch(rv->type) {
186
case RRDVAR_TYPE_CALCULATED: {
187
- calculated_number *n = (calculated_number *)rv->value;
187
+ NETDATA_DOUBLE *n = (NETDATA_DOUBLE *)rv->value;
188
return *n;
189
}
190
@@ -209,12 +209,12 @@ calculated_number rrdvar2number(RRDVAR *rv) {
209
}
210
211
default:
212
- error("I don't know how to convert RRDVAR type %u to calculated_number", rv->type);
212
+ error("I don't know how to convert RRDVAR type %u to NETDATA_DOUBLE", rv->type);
213
return NAN;
214
}
215
}
216
217
-int health_variable_lookup(const char *variable, uint32_t hash, RRDCALC *rc, calculated_number *result) {
217
+int health_variable_lookup(const char *variable, uint32_t hash, RRDCALC *rc, NETDATA_DOUBLE *result) {
218
RRDSET *st = rc->rrdset;
219
if(!st) return 0;
220
@@ -254,13 +254,13 @@ struct variable2json_helper {
254
static int single_variable2json(void *entry, void *data) {
255
struct variable2json_helper *helper = (struct variable2json_helper *)data;
256
RRDVAR *rv = (RRDVAR *)entry;
257
- calculated_number value = rrdvar2number(rv);
257
+ NETDATA_DOUBLE value = rrdvar2number(rv);
258
259
if (helper->options == RRDVAR_OPTION_DEFAULT || rv->options & helper->options) {
260
if(unlikely(isnan(value) || isinf(value)))
261
buffer_sprintf(helper->buf, "%s\n\t\t\"%s\": null", helper->counter?",":"", rv->name);
262
else
263
- buffer_sprintf(helper->buf, "%s\n\t\t\"%s\": %0.5" LONG_DOUBLE_MODIFIER, helper->counter?",":"", rv->name, (LONG_DOUBLE)value);
263
+ buffer_sprintf(helper->buf, "%s\n\t\t\"%s\": %0.5" NETDATA_DOUBLE_MODIFIER, helper->counter?",":"", rv->name, (NETDATA_DOUBLE)value);
264
265
helper->counter++;
266
}
database/rrdvar.h
+2
-2
@@ -52,13 +52,13 @@ extern int rrdvar_fix_name(char *variable);
52
#include "rrd.h"
53
54
extern RRDVAR *rrdvar_custom_host_variable_create(RRDHOST *host, const char *name);
55
-extern void rrdvar_custom_host_variable_set(RRDHOST *host, RRDVAR *rv, calculated_number value);
55
+extern void rrdvar_custom_host_variable_set(RRDHOST *host, RRDVAR *rv, NETDATA_DOUBLE value);
56
extern int foreach_host_variable_callback(RRDHOST *host, int (*callback)(RRDVAR *rv, void *data), void *data);
57
extern void rrdvar_free_remaining_variables(RRDHOST *host, avl_tree_lock *tree_lock);
58
59
extern int rrdvar_callback_for_all_host_variables(RRDHOST *host, int (*callback)(void *rrdvar, void *data), void *data);
60
61
-extern calculated_number rrdvar2number(RRDVAR *rv);
61
+extern NETDATA_DOUBLE rrdvar2number(RRDVAR *rv);
62
63
extern RRDVAR *rrdvar_create_and_index(const char *scope, avl_tree_lock *tree, const char *name, RRDVAR_TYPE type, RRDVAR_OPTIONS options, void *value);
64
extern void rrdvar_free(RRDHOST *host, avl_tree_lock *tree, RRDVAR *rv);
database/sqlite/sqlite_aclk_alert.c
+4
-4
@@ -336,8 +336,8 @@ void aclk_push_alert_event(struct aclk_database_worker_config *wc, struct aclk_d
336
strdupz((char *)format_value_and_unit(
337
old_value_string, 100, sqlite3_column_double(res, 24), (char *)sqlite3_column_text(res, 17), -1));
338
339
- alarm_log.value = (calculated_number) sqlite3_column_double(res, 23);
340
- alarm_log.old_value = (calculated_number) sqlite3_column_double(res, 24);
339
+ alarm_log.value = (NETDATA_DOUBLE) sqlite3_column_double(res, 23);
340
+ alarm_log.old_value = (NETDATA_DOUBLE) sqlite3_column_double(res, 24);
341
342
alarm_log.updated = (sqlite3_column_int64(res, 8) & HEALTH_ENTRY_FLAG_UPDATED) ? 1 : 0;
343
alarm_log.rendered_info = sqlite3_column_type(res, 18) == SQLITE_NULL ?
@@ -868,8 +868,8 @@ void health_alarm_entry2proto_nolock(struct alarm_log_entry *alarm_log, ALARM_EN
868
alarm_log->value_string = strdupz(ae->new_value_string);
869
alarm_log->old_value_string = strdupz(ae->old_value_string);
870
871
- alarm_log->value = (!isnan(ae->new_value)) ? (calculated_number)ae->new_value : 0;
872
- alarm_log->old_value = (!isnan(ae->old_value)) ? (calculated_number)ae->old_value : 0;
871
+ alarm_log->value = (!isnan(ae->new_value)) ? (NETDATA_DOUBLE)ae->new_value : 0;
872
+ alarm_log->old_value = (!isnan(ae->old_value)) ? (NETDATA_DOUBLE)ae->old_value : 0;
873
874
alarm_log->updated = (ae->flags & HEALTH_ENTRY_FLAG_UPDATED) ? 1 : 0;
875
alarm_log->rendered_info = ae->info ? strdupz(ae->info) : strdupz((char *)"");
database/sqlite/sqlite_health.c
+2
-2
@@ -751,8 +751,8 @@ void sql_health_alarm_log_load(RRDHOST *host) {
751
ae->old_status = (RRDCALC_STATUS)sqlite3_column_int(res, 23);
752
ae->delay = (int) sqlite3_column_int(res, 24);
753
754
- ae->new_value = (calculated_number) sqlite3_column_double(res, 25);
755
- ae->old_value = (calculated_number) sqlite3_column_double(res, 26);
754
+ ae->new_value = (NETDATA_DOUBLE) sqlite3_column_double(res, 25);
755
+ ae->old_value = (NETDATA_DOUBLE) sqlite3_column_double(res, 26);
756
757
ae->last_repeat = last_repeat;
758
docs/guides/longer-metrics-storage.md
+22
-32
@@ -25,14 +25,14 @@ available disk space for long-term metrics storage. This feature of the database
25
larger dataset than your system's available RAM.
26
27
The database engine is currently the default method of storing metrics, but if you're not sure which database you're
28
-using, check out your `netdata.conf` file and look for the `memory mode` setting:
28
+using, check out your `netdata.conf` file and look for the `[db].mode` setting:
29
30
```conf
31
-[global]
32
- memory mode = dbengine
31
+[db]
32
+ mode = dbengine
33
```
34
35
-If `memory mode` is set to anything but `dbengine`, change it and restart Netdata using the standard command for
35
+If `[db].mode` is set to anything but `dbengine`, change it and restart Netdata using the standard command for
36
restarting services on your system. You're now using the database engine!
37
38
What makes the database engine efficient? While it's structured like a traditional database, the database engine splits
@@ -43,22 +43,22 @@ When the Netdata dashboard queries for historical metrics, the database engine w
43
return relevant metrics for visualization in charts.
44
45
Now, given that the database engine uses _both_ RAM and disk, there are two other settings to consider: `page cache
46
-size` and `dbengine multihost disk space`.
46
+size MB` and `dbengine multihost disk space MB`.
47
48
```conf
49
-[global]
50
- page cache size = 32
51
- dbengine multihost disk space = 256
49
+[db]
50
+ page cache size MB = 32
51
+ dbengine multihost disk space MB = 256
52
```
53
54
-`page cache size` sets the maximum amount of RAM (in MiB) the database engine will use for caching and indexing.
55
-`dbengine multihost disk space` sets the maximum disk space (again, in MiB) the database engine will use for storing
56
-compressed metrics. The default settings retain about two day's worth of metrics on a system collecting 2,000 metrics
54
+`[db].page cache size MB` sets the maximum amount of RAM the database engine will use for caching and indexing.
55
+`[db].dbengine multihost disk space MB` sets the maximum disk space the database engine will use for storing
56
+compressed metrics. The default settings retain about four day's worth of metrics on a system collecting 2,000 metrics
57
every second.
58
59
[**See our database engine
60
calculator**](/docs/store/change-metrics-storage.md#calculate-the-system-resources-ram-disk-space-needed-to-store-metrics)
61
-to help you correctly set `dbengine multihost disk space` based on your needs. The calculator gives an accurate estimate
61
+to help you correctly set `[db].dbengine multihost disk space MB` based on your needs. The calculator gives an accurate estimate
62
based on how many child nodes you have, how many metrics your Agent collects, and more.
63
64
With the database engine active, you can back up your `/var/cache/netdata/dbengine/` folder to another location for
@@ -72,26 +72,26 @@ aren't ready to make the move.
72
In previous versions, Netdata used a round-robin database to store 1 hour of per-second metrics.
73
74
To see if you're still using this database, or if you would like to switch to it, open your `netdata.conf` file and see
75
-if `memory mode` option is set to `save`.
75
+if `[db].mode` option is set to `save`.
76
77
```conf
78
-[global]
79
- memory mode = save
78
+[db]
79
+ mode = save
80
```
81
82
-If `memory mode` is set to `save`, then you're using the round-robin database. If so, the `history` option is set to
82
+If `[db].mode` is set to `save`, then you're using the round-robin database. If so, the `[db].retention` option is set to
83
`3600`, which is the equivalent to 3,600 seconds, or one hour.
84
85
-To increase your historical metrics, you can increase `history` to the number of seconds you'd like to store:
85
+To increase your historical metrics, you can increase `[db].retention` to the number of seconds you'd like to store:
86
87
```conf
88
-[global]
88
+[db]
89
# 2 hours = 2 * 60 * 60 = 7200 seconds
90
- history = 7200
90
+ retention = 7200
91
# 4 hours = 4 * 60 * 60 = 14440 seconds
92
- history = 14440
92
+ retention = 14440
93
# 24 hours = 24 * 60 * 60 = 86400 seconds
94
- history = 86400
94
+ retention = 86400
95
```
96
97
And so on.
@@ -105,20 +105,10 @@ dashboard and look at the bottom-right corner of the interface. You'll find a se
105
On this desktop system, using a Ryzen 5 1600 and 16GB of RAM, the round-robin databases uses 25 MB of RAM to store just
106
over an hour's worth of data for nearly 2,000 metrics.
107
108
-To increase the `history` option, you need to edit your `netdata.conf` file and increase the `history` setting. In most
109
-installations, you'll find it at `/etc/netdata/netdata.conf`, but some operating systems place it at
110
-`/opt/netdata/etc/netdata/netdata.conf`.
111
-
112
-Use `/etc/netdata/edit-config netdata.conf`, or your favorite text editor, to replace `3600` with the number of seconds
113
-you'd like to store.
114
-
108
You should base this number on two things: How much history you need for your use case, and how much RAM you're willing
109
to dedicate to Netdata.
110
118
-> Take care when you change the `history` option on production systems. Netdata is configured to stop its process if
119
-> your system starts running out of RAM, but you can never be too careful. Out of memory situations are very bad.
120
-
121
-How much RAM will a longer history use? Let's use a little math.
111
+How much RAM will a longer retention use? Let's use a little math.
112
113
The round-robin database needs 4 bytes for every value Netdata collects. If Netdata collects metrics every second,
114
that's 4 bytes, per second, per metric.
exporting/exporting_engine.h
+2
-1
@@ -269,7 +269,8 @@ int rrdset_is_exportable(struct instance *instance, RRDSET *st);
269
270
extern EXPORTING_OPTIONS exporting_parse_data_source(const char *source, EXPORTING_OPTIONS exporting_options);
271
272
-calculated_number exporting_calculate_value_from_stored_data(
272
+NETDATA_DOUBLE
273
+exporting_calculate_value_from_stored_data(
274
struct instance *instance,
275
RRDDIM *rd,
276
time_t *last_timestamp);
exporting/graphite/graphite.c
+2
-2
@@ -173,14 +173,14 @@ int format_dimension_stored_graphite_plaintext(struct instance *instance, RRDDIM
173
RRD_ID_LENGTH_MAX);
174
175
time_t last_t;
176
- calculated_number value = exporting_calculate_value_from_stored_data(instance, rd, &last_t);
176
+ NETDATA_DOUBLE value = exporting_calculate_value_from_stored_data(instance, rd, &last_t);
177
178
if(isnan(value))
179
return 0;
180
181
buffer_sprintf(
182
instance->buffer,
183
- "%s.%s.%s.%s%s%s%s " CALCULATED_NUMBER_FORMAT " %llu\n",
183
+ "%s.%s.%s.%s%s%s%s " NETDATA_DOUBLE_FORMAT " %llu\n",
184
instance->config.prefix,
185
(host == localhost) ? instance->config.hostname : host->hostname,
186
chart_name,
exporting/json/json.c
+2
-2
@@ -224,7 +224,7 @@ int format_dimension_stored_json_plaintext(struct instance *instance, RRDDIM *rd
224
RRDHOST *host = st->rrdhost;
225
226
time_t last_t;
227
- calculated_number value = exporting_calculate_value_from_stored_data(instance, rd, &last_t);
227
+ NETDATA_DOUBLE value = exporting_calculate_value_from_stored_data(instance, rd, &last_t);
228
229
if(isnan(value))
230
return 0;
@@ -265,7 +265,7 @@ int format_dimension_stored_json_plaintext(struct instance *instance, RRDDIM *rd
265
266
"\"id\":\"%s\","
267
"\"name\":\"%s\","
268
- "\"value\":" CALCULATED_NUMBER_FORMAT ","
268
+ "\"value\":" NETDATA_DOUBLE_FORMAT ","
269
270
"\"timestamp\": %llu}",
271
exporting/opentsdb/opentsdb.c
+4
-4
@@ -225,14 +225,14 @@ int format_dimension_stored_opentsdb_telnet(struct instance *instance, RRDDIM *r
225
RRD_ID_LENGTH_MAX);
226
227
time_t last_t;
228
- calculated_number value = exporting_calculate_value_from_stored_data(instance, rd, &last_t);
228
+ NETDATA_DOUBLE value = exporting_calculate_value_from_stored_data(instance, rd, &last_t);
229
230
if(isnan(value))
231
return 0;
232
233
buffer_sprintf(
234
instance->buffer,
235
- "put %s.%s.%s %llu " CALCULATED_NUMBER_FORMAT " host=%s%s%s%s\n",
235
+ "put %s.%s.%s %llu " NETDATA_DOUBLE_FORMAT " host=%s%s%s%s\n",
236
instance->config.prefix,
237
chart_name,
238
dimension_name,
@@ -368,7 +368,7 @@ int format_dimension_stored_opentsdb_http(struct instance *instance, RRDDIM *rd)
368
RRD_ID_LENGTH_MAX);
369
370
time_t last_t;
371
- calculated_number value = exporting_calculate_value_from_stored_data(instance, rd, &last_t);
371
+ NETDATA_DOUBLE value = exporting_calculate_value_from_stored_data(instance, rd, &last_t);
372
373
if(isnan(value))
374
return 0;
@@ -381,7 +381,7 @@ int format_dimension_stored_opentsdb_http(struct instance *instance, RRDDIM *rd)
381
"{"
382
"\"metric\":\"%s.%s.%s\","
383
"\"timestamp\":%llu,"
384
- "\"value\":"CALCULATED_NUMBER_FORMAT","
384
+ "\"value\":" NETDATA_DOUBLE_FORMAT ","
385
"\"tags\":{"
386
"\"host\":\"%s%s%s\"%s"
387
"}"
exporting/process_data.c
+5
-5
@@ -64,7 +64,7 @@ int mark_scheduled_instances(struct engine *engine)
64
* @param last_timestamp the timestamp that should be reported to the exporting connector instance.
65
* @return Returns the value, calculated over the given period.
66
*/
67
-calculated_number exporting_calculate_value_from_stored_data(
67
+NETDATA_DOUBLE exporting_calculate_value_from_stored_data(
68
struct instance *instance,
69
RRDDIM *rd,
70
time_t *last_timestamp)
@@ -123,15 +123,15 @@ calculated_number exporting_calculate_value_from_stored_data(
123
*last_timestamp = before;
124
125
size_t counter = 0;
126
- calculated_number sum = 0;
127
- calculated_number value;
126
+ NETDATA_DOUBLE sum = 0;
127
+ NETDATA_DOUBLE value;
128
129
for (rd->state->query_ops.init(rd, &handle, after, before); !rd->state->query_ops.is_finished(&handle);) {
130
time_t curr_t, end_t;
131
SN_FLAGS flags;
132
value = rd->state->query_ops.next_metric(&handle, &curr_t, &end_t, &flags);
133
134
- if (unlikely(!calculated_number_isnumber(value))) {
134
+ if (unlikely(!netdata_double_isnumber(value))) {
135
// not collected
136
continue;
137
}
@@ -156,7 +156,7 @@ calculated_number exporting_calculate_value_from_stored_data(
156
if (unlikely(EXPORTING_OPTIONS_DATA_SOURCE(instance->config.options) == EXPORTING_SOURCE_DATA_SUM))
157
return sum;
158
159
- return sum / (calculated_number)counter;
159
+ return sum / (NETDATA_DOUBLE)counter;
160
}
161
162
/**
exporting/prometheus/prometheus.c
+9
-9
@@ -362,7 +362,7 @@ static int print_host_variables(RRDVAR *rv, void *data)
362
}
363
}
364
365
- calculated_number value = rrdvar2number(rv);
365
+ NETDATA_DOUBLE value = rrdvar2number(rv);
366
if (isnan(value) || isinf(value)) {
367
if (opts->output_options & PROMETHEUS_OUTPUT_HELP)
368
buffer_sprintf(
@@ -383,7 +383,7 @@ static int print_host_variables(RRDVAR *rv, void *data)
383
if (opts->output_options & PROMETHEUS_OUTPUT_TIMESTAMPS)
384
buffer_sprintf(
385
opts->wb,
386
- "%s_%s%s%s%s " CALCULATED_NUMBER_FORMAT " %llu\n",
386
+ "%s_%s%s%s%s " NETDATA_DOUBLE_FORMAT " %llu\n",
387
opts->prefix,
388
opts->name,
389
label_pre,
@@ -394,7 +394,7 @@ static int print_host_variables(RRDVAR *rv, void *data)
394
else
395
buffer_sprintf(
396
opts->wb,
397
- "%s_%s%s%s%s " CALCULATED_NUMBER_FORMAT "\n",
397
+ "%s_%s%s%s%s " NETDATA_DOUBLE_FORMAT "\n",
398
opts->prefix,
399
opts->name,
400
label_pre,
@@ -483,9 +483,9 @@ static void generate_as_collected_prom_metric(BUFFER *wb, struct gen_parameters
483
if (prometheus_collector)
484
buffer_sprintf(
485
wb,
486
- CALCULATED_NUMBER_FORMAT,
487
- (calculated_number)p->rd->last_collected_value * (calculated_number)p->rd->multiplier /
488
- (calculated_number)p->rd->divisor);
486
+ NETDATA_DOUBLE_FORMAT,
487
+ (NETDATA_DOUBLE)p->rd->last_collected_value * (NETDATA_DOUBLE)p->rd->multiplier /
488
+ (NETDATA_DOUBLE)p->rd->divisor);
489
else
490
buffer_sprintf(wb, COLLECTED_NUMBER_FORMAT, p->rd->last_collected_value);
491
@@ -732,7 +732,7 @@ static void rrd_stats_api_v1_charts_allmetrics_prometheus(
732
733
time_t first_time = instance->after;
734
time_t last_time = instance->before;
735
- calculated_number value = exporting_calculate_value_from_stored_data(instance, rd, &last_time);
735
+ NETDATA_DOUBLE value = exporting_calculate_value_from_stored_data(instance, rd, &last_time);
736
737
if (!isnan(value) && !isinf(value)) {
738
if (EXPORTING_OPTIONS_DATA_SOURCE(exporting_options) == EXPORTING_SOURCE_DATA_AVERAGE)
@@ -764,7 +764,7 @@ static void rrd_stats_api_v1_charts_allmetrics_prometheus(
764
if (output_options & PROMETHEUS_OUTPUT_TIMESTAMPS)
765
buffer_sprintf(
766
wb,
767
- "%s_%s%s%s{chart=\"%s\",family=\"%s\",dimension=\"%s\"%s} " CALCULATED_NUMBER_FORMAT
767
+ "%s_%s%s%s{chart=\"%s\",family=\"%s\",dimension=\"%s\"%s} " NETDATA_DOUBLE_FORMAT
768
" %llu\n",
769
prefix,
770
context,
@@ -779,7 +779,7 @@ static void rrd_stats_api_v1_charts_allmetrics_prometheus(
779
else
780
buffer_sprintf(
781
wb,
782
- "%s_%s%s%s{chart=\"%s\",family=\"%s\",dimension=\"%s\"%s} " CALCULATED_NUMBER_FORMAT
782
+ "%s_%s%s%s{chart=\"%s\",family=\"%s\",dimension=\"%s\"%s} " NETDATA_DOUBLE_FORMAT
783
"\n",
784
prefix,
785
context,
exporting/prometheus/remote_write/remote_write.c
+1
-1
@@ -294,7 +294,7 @@ int format_dimension_prometheus_remote_write(struct instance *instance, RRDDIM *
294
// we need average or sum of the data
295
296
time_t last_t = instance->before;
297
- calculated_number value = exporting_calculate_value_from_stored_data(instance, rd, &last_t);
297
+ NETDATA_DOUBLE value = exporting_calculate_value_from_stored_data(instance, rd, &last_t);
298
299
if (!isnan(value) && !isinf(value)) {
300
if (EXPORTING_OPTIONS_DATA_SOURCE(instance->config.options) == EXPORTING_SOURCE_DATA_AVERAGE)
exporting/tests/exporting_doubles.c
+3
-3
@@ -52,11 +52,11 @@ int __wrap_mark_scheduled_instances(struct engine *engine)
52
return mock_type(int);
53
}
54
55
-calculated_number __real_exporting_calculate_value_from_stored_data(
55
+NETDATA_DOUBLE __real_exporting_calculate_value_from_stored_data(
56
struct instance *instance,
57
RRDDIM *rd,
58
time_t *last_timestamp);
59
-calculated_number __wrap_exporting_calculate_value_from_stored_data(
59
+NETDATA_DOUBLE __wrap_exporting_calculate_value_from_stored_data(
60
struct instance *instance,
61
RRDDIM *rd,
62
time_t *last_timestamp)
@@ -67,7 +67,7 @@ calculated_number __wrap_exporting_calculate_value_from_stored_data(
67
*last_timestamp = 15052;
68
69
function_called();
70
- return mock_type(calculated_number);
70
+ return mock_type(NETDATA_DOUBLE);
71
}
72
73
int __real_prepare_buffers(struct engine *engine);
exporting/tests/netdata_doubles.c
+3
-3
@@ -177,7 +177,7 @@ const char *rrd_memory_mode_name(RRD_MEMORY_MODE id)
177
return RRD_MEMORY_MODE_NONE_NAME;
178
}
179
180
-calculated_number rrdvar2number(RRDVAR *rv)
180
+NETDATA_DOUBLE rrdvar2number(RRDVAR *rv)
181
{
182
(void)rv;
183
return 0;
@@ -230,7 +230,7 @@ int __mock_rrddim_query_is_finished(struct rrddim_query_handle *handle)
230
return mock_type(int);
231
}
232
233
-calculated_number __mock_rrddim_query_next_metric(struct rrddim_query_handle *handle, time_t *start_time, time_t *end_time, SN_FLAGS *flags)
233
+NETDATA_DOUBLE __mock_rrddim_query_next_metric(struct rrddim_query_handle *handle, time_t *start_time, time_t *end_time, SN_FLAGS *flags)
234
{
235
(void)handle;
236
(void)start_time;
@@ -239,7 +239,7 @@ calculated_number __mock_rrddim_query_next_metric(struct rrddim_query_handle *ha
239
240
241
function_called();
242
- return mock_type(calculated_number);
242
+ return mock_type(NETDATA_DOUBLE);
243
}
244
245
void __mock_rrddim_query_finalize(struct rrddim_query_handle *handle)
exporting/tests/test_exporting_engine.h
+3
-3
@@ -61,7 +61,7 @@ time_t __mock_rrddim_query_oldest_time(RRDDIM *rd);
61
time_t __mock_rrddim_query_latest_time(RRDDIM *rd);
62
void __mock_rrddim_query_init(RRDDIM *rd, struct rrddim_query_handle *handle, time_t start_time, time_t end_time);
63
int __mock_rrddim_query_is_finished(struct rrddim_query_handle *handle);
64
-calculated_number __mock_rrddim_query_next_metric(struct rrddim_query_handle *handle, time_t *start_time, time_t *end_time, SN_FLAGS *flags);
64
+NETDATA_DOUBLE __mock_rrddim_query_next_metric(struct rrddim_query_handle *handle, time_t *start_time, time_t *end_time, SN_FLAGS *flags);
65
void __mock_rrddim_query_finalize(struct rrddim_query_handle *handle);
66
67
// -----------------------------------------------------------------------
@@ -88,11 +88,11 @@ int __wrap_init_connectors(struct engine *engine);
88
int __real_mark_scheduled_instances(struct engine *engine);
89
int __wrap_mark_scheduled_instances(struct engine *engine);
90
91
-calculated_number __real_exporting_calculate_value_from_stored_data(
91
+NETDATA_DOUBLE __real_exporting_calculate_value_from_stored_data(
92
struct instance *instance,
93
RRDDIM *rd,
94
time_t *last_timestamp);
95
-calculated_number __wrap_exporting_calculate_value_from_stored_data(
95
+NETDATA_DOUBLE __wrap_exporting_calculate_value_from_stored_data(
96
struct instance *instance,
97
RRDDIM *rd,
98
time_t *last_timestamp);
health/health.c
+9
-8
@@ -238,7 +238,7 @@ void health_reload(void) {
238
// ----------------------------------------------------------------------------
239
// health main thread and friends
240
241
-static inline RRDCALC_STATUS rrdcalc_value2status(calculated_number n) {
241
+static inline RRDCALC_STATUS rrdcalc_value2status(NETDATA_DOUBLE n) {
242
if(isnan(n) || isinf(n)) return RRDCALC_STATUS_UNDEFINED;
243
if(n) return RRDCALC_STATUS_RAISED;
244
return RRDCALC_STATUS_CLEAR;
@@ -346,7 +346,9 @@ static inline void health_alarm_execute(RRDHOST *host, ALARM_ENTRY *ae) {
346
347
char *edit_command = ae->source ? health_edit_command_from_source(ae->source) : strdupz("UNKNOWN=0=UNKNOWN");
348
349
- snprintfz(command_to_run, ALARM_EXEC_COMMAND_LENGTH, "exec %s '%s' '%s' '%u' '%u' '%u' '%lu' '%s' '%s' '%s' '%s' '%s' '" CALCULATED_NUMBER_FORMAT_ZERO "' '" CALCULATED_NUMBER_FORMAT_ZERO "' '%s' '%u' '%u' '%s' '%s' '%s' '%s' '%s' '%s' '%d' '%d' '%s' '%s' '%s' '%s' '%s'",
349
+ snprintfz(command_to_run, ALARM_EXEC_COMMAND_LENGTH, "exec %s '%s' '%s' '%u' '%u' '%u' '%lu' '%s' '%s' '%s' '%s' '%s' '" NETDATA_DOUBLE_FORMAT_ZERO
350
+ "' '" NETDATA_DOUBLE_FORMAT_ZERO
351
+ "' '%s' '%u' '%u' '%s' '%s' '%s' '%s' '%s' '%s' '%d' '%d' '%s' '%s' '%s' '%s' '%s'",
352
exec,
353
recipient,
354
host->registry_hostname,
@@ -411,7 +413,7 @@ static inline void health_alarm_wait_for_execution(ALARM_ENTRY *ae) {
413
}
414
415
static inline void health_process_notifications(RRDHOST *host, ALARM_ENTRY *ae) {
414
- debug(D_HEALTH, "Health alarm '%s.%s' = " CALCULATED_NUMBER_FORMAT_AUTO " - changed status from %s to %s",
416
+ debug(D_HEALTH, "Health alarm '%s.%s' = " NETDATA_DOUBLE_FORMAT_AUTO " - changed status from %s to %s",
417
ae->chart?ae->chart:"NOCHART", ae->name,
418
ae->new_value,
419
rrdcalc_status2string(ae->old_status),
@@ -892,8 +894,7 @@ void *health_main(void *ptr) {
894
} else
895
rc->rrdcalc_flags &= ~RRDCALC_FLAG_DB_NAN;
896
895
- debug(D_HEALTH, "Health on host '%s', alarm '%s.%s': database lookup gave value "
896
- CALCULATED_NUMBER_FORMAT, host->hostname, rc->chart ? rc->chart : "NOCHART", rc->name,
897
+ debug(D_HEALTH, "Health on host '%s', alarm '%s.%s': database lookup gave value " NETDATA_DOUBLE_FORMAT, host->hostname, rc->chart ? rc->chart : "NOCHART", rc->name,
898
rc->value
899
);
900
}
@@ -917,7 +918,7 @@ void *health_main(void *ptr) {
918
rc->rrdcalc_flags &= ~RRDCALC_FLAG_CALC_ERROR;
919
920
debug(D_HEALTH, "Health on host '%s', alarm '%s.%s': expression '%s' gave value "
920
- CALCULATED_NUMBER_FORMAT
921
+ NETDATA_DOUBLE_FORMAT
922
": %s (source: %s)", host->hostname, rc->chart ? rc->chart : "NOCHART", rc->name,
923
rc->calculation->parsed_as, rc->calculation->result,
924
buffer_tostring(rc->calculation->error_msg), rc->source
@@ -966,7 +967,7 @@ void *health_main(void *ptr) {
967
} else {
968
rc->rrdcalc_flags &= ~RRDCALC_FLAG_WARN_ERROR;
969
debug(D_HEALTH, "Health on host '%s', alarm '%s.%s': warning expression gave value "
969
- CALCULATED_NUMBER_FORMAT
970
+ NETDATA_DOUBLE_FORMAT
971
": %s (source: %s)", host->hostname, rc->chart ? rc->chart : "NOCHART",
972
rc->name, rc->warning->result, buffer_tostring(rc->warning->error_msg), rc->source
973
);
@@ -992,7 +993,7 @@ void *health_main(void *ptr) {
993
} else {
994
rc->rrdcalc_flags &= ~RRDCALC_FLAG_CRIT_ERROR;
995
debug(D_HEALTH, "Health on host '%s', alarm '%s.%s': critical expression gave value "
995
- CALCULATED_NUMBER_FORMAT
996
+ NETDATA_DOUBLE_FORMAT
997
": %s (source: %s)", host->hostname, rc->chart ? rc->chart : "NOCHART",
998
rc->name, rc->critical->result, buffer_tostring(rc->critical->error_msg),
999
rc->source
health/health.h
+3
-3
@@ -35,7 +35,7 @@ extern void health_init(void);
35
36
extern void health_reload(void);
37
38
-extern int health_variable_lookup(const char *variable, uint32_t hash, RRDCALC *rc, calculated_number *result);
38
+extern int health_variable_lookup(const char *variable, uint32_t hash, RRDCALC *rc, NETDATA_DOUBLE *result);
39
extern void health_aggregate_alarms(RRDHOST *host, BUFFER *wb, BUFFER* context, RRDCALC_STATUS status);
40
extern void health_alarms2json(RRDHOST *host, BUFFER *wb, int all);
41
extern void health_alarms_values2json(RRDHOST *host, BUFFER *wb, int all);
@@ -63,8 +63,8 @@ extern ALARM_ENTRY* health_create_alarm_entry(
63
const char *exec,
64
const char *recipient,
65
time_t duration,
66
- calculated_number old_value,
67
- calculated_number new_value,
66
+ NETDATA_DOUBLE old_value,
67
+ NETDATA_DOUBLE new_value,
68
RRDCALC_STATUS old_status,
69
RRDCALC_STATUS new_status,
70
const char *source,
health/health_config.c
+10
-6
@@ -54,7 +54,9 @@ static inline int rrdcalc_add_alarm_from_config(RRDHOST *host, RRDCALC *rc) {
54
55
rc->id = rrdcalc_get_unique_id(host, rc->chart, rc->name, &rc->next_event_id);
56
57
- debug(D_HEALTH, "Health configuration adding alarm '%s.%s' (%u): exec '%s', recipient '%s', green " CALCULATED_NUMBER_FORMAT_AUTO ", red " CALCULATED_NUMBER_FORMAT_AUTO ", lookup: group %d, after %d, before %d, options %u, dimensions '%s', for each dimension '%s', update every %d, calculation '%s', warning '%s', critical '%s', source '%s', delay up %d, delay down %d, delay max %d, delay_multiplier %f, warn_repeat_every %u, crit_repeat_every %u",
57
+ debug(D_HEALTH, "Health configuration adding alarm '%s.%s' (%u): exec '%s', recipient '%s', green " NETDATA_DOUBLE_FORMAT_AUTO
58
+ ", red " NETDATA_DOUBLE_FORMAT_AUTO
59
+ ", lookup: group %d, after %d, before %d, options %u, dimensions '%s', for each dimension '%s', update every %d, calculation '%s', warning '%s', critical '%s', source '%s', delay up %d, delay down %d, delay max %d, delay_multiplier %f, warn_repeat_every %u, crit_repeat_every %u",
60
rc->chart?rc->chart:"NOCHART",
61
rc->name,
62
rc->id,
@@ -141,7 +143,9 @@ static inline int rrdcalctemplate_add_template_from_config(RRDHOST *host, RRDCAL
143
}
144
}
145
144
- debug(D_HEALTH, "Health configuration adding template '%s': context '%s', exec '%s', recipient '%s', green " CALCULATED_NUMBER_FORMAT_AUTO ", red " CALCULATED_NUMBER_FORMAT_AUTO ", lookup: group %d, after %d, before %d, options %u, dimensions '%s', for each dimension '%s', update every %d, calculation '%s', warning '%s', critical '%s', source '%s', delay up %d, delay down %d, delay max %d, delay_multiplier %f, warn_repeat_every %u, crit_repeat_every %u",
146
+ debug(D_HEALTH, "Health configuration adding template '%s': context '%s', exec '%s', recipient '%s', green " NETDATA_DOUBLE_FORMAT_AUTO
147
+ ", red " NETDATA_DOUBLE_FORMAT_AUTO
148
+ ", lookup: group %d, after %d, before %d, options %u, dimensions '%s', for each dimension '%s', update every %d, calculation '%s', warning '%s', critical '%s', source '%s', delay up %d, delay down %d, delay max %d, delay_multiplier %f, warn_repeat_every %u, crit_repeat_every %u",
149
rt->name,
150
(rt->context)?rt->context:"NONE",
151
(rt->exec)?rt->exec:"DEFAULT",
@@ -848,7 +852,7 @@ static int health_readfile(const char *filename, void *data) {
852
else if(hash == hash_green && !strcasecmp(key, HEALTH_GREEN_KEY)) {
853
alert_cfg->green = strdupz(value);
854
char *e;
851
- rc->green = str2ld(value, &e);
855
+ rc->green = str2ndd(value, &e);
856
if(e && *e) {
857
error("Health configuration at line %zu of file '%s' for alarm '%s' at key '%s' leaves this string unmatched: '%s'.",
858
line, filename, rc->name, key, e);
@@ -857,7 +861,7 @@ static int health_readfile(const char *filename, void *data) {
861
else if(hash == hash_red && !strcasecmp(key, HEALTH_RED_KEY)) {
862
alert_cfg->red = strdupz(value);
863
char *e;
860
- rc->red = str2ld(value, &e);
864
+ rc->red = str2ndd(value, &e);
865
if(e && *e) {
866
error("Health configuration at line %zu of file '%s' for alarm '%s' at key '%s' leaves this string unmatched: '%s'.",
867
line, filename, rc->name, key, e);
@@ -1097,7 +1101,7 @@ static int health_readfile(const char *filename, void *data) {
1101
else if(hash == hash_green && !strcasecmp(key, HEALTH_GREEN_KEY)) {
1102
alert_cfg->green = strdupz(value);
1103
char *e;
1100
- rt->green = str2ld(value, &e);
1104
+ rt->green = str2ndd(value, &e);
1105
if(e && *e) {
1106
error("Health configuration at line %zu of file '%s' for template '%s' at key '%s' leaves this string unmatched: '%s'.",
1107
line, filename, rt->name, key, e);
@@ -1106,7 +1110,7 @@ static int health_readfile(const char *filename, void *data) {
1110
else if(hash == hash_red && !strcasecmp(key, HEALTH_RED_KEY)) {
1111
alert_cfg->red = strdupz(value);
1112
char *e;
1109
- rt->red = str2ld(value, &e);
1113
+ rt->red = str2ndd(value, &e);
1114
if(e && *e) {
1115
error("Health configuration at line %zu of file '%s' for template '%s' at key '%s' leaves this string unmatched: '%s'.",
1116
line, filename, rt->name, key, e);
health/health_log.c
+3
-3
@@ -98,7 +98,7 @@ inline void health_alarm_log_save(RRDHOST *host, ALARM_ENTRY *ae) {
98
"\t%08x\t%08x\t%08x"
99
"\t%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s"
100
"\t%d\t%d\t%d\t%d"
101
- "\t" CALCULATED_NUMBER_FORMAT_AUTO "\t" CALCULATED_NUMBER_FORMAT_AUTO
101
+ "\t" NETDATA_DOUBLE_FORMAT_AUTO "\t" NETDATA_DOUBLE_FORMAT_AUTO
102
"\t%016"PRIx64""
103
"\t%s\t%s\t%s"
104
"\n"
@@ -457,8 +457,8 @@ inline ALARM_ENTRY* health_create_alarm_entry(
457
const char *exec,
458
const char *recipient,
459
time_t duration,
460
- calculated_number old_value,
461
- calculated_number new_value,
460
+ NETDATA_DOUBLE old_value,
461
+ NETDATA_DOUBLE new_value,
462
RRDCALC_STATUS old_status,
463
RRDCALC_STATUS new_status,
464
const char *source,
libnetdata/buffer/buffer.c
+4
-4
@@ -65,9 +65,9 @@ void buffer_char_replace(BUFFER *wb, char from, char to)
65
}
66
67
// This trick seems to give an 80% speed increase in 32bit systems
68
-// print_calculated_number_llu_r() will just print the digits up to the
68
+// print_number_llu_r() will just print the digits up to the
69
// point the remaining value fits in 32 bits, and then calls
70
-// print_calculated_number_lu_r() to print the rest with 32 bit arithmetic.
70
+// print_number_lu_r() to print the rest with 32 bit arithmetic.
71
72
inline char *print_number_lu_r(char *str, unsigned long uvalue) {
73
char *wstr = str;
@@ -299,7 +299,7 @@ void buffer_sprintf(BUFFER *wb, const char *fmt, ...)
299
}
300
301
302
-void buffer_rrd_value(BUFFER *wb, calculated_number value)
302
+void buffer_rrd_value(BUFFER *wb, NETDATA_DOUBLE value)
303
{
304
buffer_need_bytes(wb, 50);
305
@@ -308,7 +308,7 @@ void buffer_rrd_value(BUFFER *wb, calculated_number value)
308
return;
309
}
310
else
311
- wb->len += print_calculated_number(&wb->buffer[wb->len], value);
311
+ wb->len += print_netdata_double(&wb->buffer[wb->len], value);
312
313
// terminate it
314
buffer_need_bytes(wb, 1);
libnetdata/buffer/buffer.h
+1
-1
@@ -56,7 +56,7 @@ extern void buffer_reset(BUFFER *wb);
56
57
extern void buffer_strcat(BUFFER *wb, const char *txt);
58
extern void buffer_fast_strcat(BUFFER *wb, const char *txt, size_t len);
59
-extern void buffer_rrd_value(BUFFER *wb, calculated_number value);
59
+extern void buffer_rrd_value(BUFFER *wb, NETDATA_DOUBLE value);
60
61
extern void buffer_date(BUFFER *wb, int year, int month, int day, int hours, int minutes, int seconds);
62
extern void buffer_jsdate(BUFFER *wb, int year, int month, int day, int hours, int minutes, int seconds);
libnetdata/clocks/clocks.c
+1
-1
@@ -393,7 +393,7 @@ static inline collected_number read_proc_uptime(char *filename) {
393
return 0;
394
}
395
396
- return (collected_number)(strtold(procfile_lineword(read_proc_uptime_ff, 0, 0), NULL) * 1000.0);
396
+ return (collected_number)(strtondd(procfile_lineword(read_proc_uptime_ff, 0, 0), NULL) * 1000.0);
397
}
398
399
inline collected_number uptime_msec(char *filename){
libnetdata/config/appconfig.c
+24
-23
@@ -462,15 +462,15 @@ long long appconfig_get_number(struct config *root, const char *section, const c
462
return strtoll(s, NULL, 0);
463
}
464
465
-LONG_DOUBLE appconfig_get_float(struct config *root, const char *section, const char *name, LONG_DOUBLE value)
465
+NETDATA_DOUBLE appconfig_get_float(struct config *root, const char *section, const char *name, NETDATA_DOUBLE value)
466
{
467
char buffer[100], *s;
468
- sprintf(buffer, "%0.5" LONG_DOUBLE_MODIFIER, value);
468
+ sprintf(buffer, "%0.5" NETDATA_DOUBLE_MODIFIER, value);
469
470
s = appconfig_get(root, section, name, buffer);
471
if(!s) return value;
472
473
- return str2ld(s, NULL);
473
+ return str2ndd(s, NULL);
474
}
475
476
static inline int appconfig_test_boolean_value(char *s) {
@@ -588,10 +588,10 @@ long long appconfig_set_number(struct config *root, const char *section, const c
588
return value;
589
}
590
591
-LONG_DOUBLE appconfig_set_float(struct config *root, const char *section, const char *name, LONG_DOUBLE value)
591
+NETDATA_DOUBLE appconfig_set_float(struct config *root, const char *section, const char *name, NETDATA_DOUBLE value)
592
{
593
char buffer[100];
594
- sprintf(buffer, "%0.5" LONG_DOUBLE_MODIFIER, value);
594
+ sprintf(buffer, "%0.5" NETDATA_DOUBLE_MODIFIER, value);
595
596
appconfig_set(root, section, name, buffer);
597
@@ -831,26 +831,27 @@ void appconfig_generate(struct config *root, BUFFER *wb, int only_changed)
831
"#\n"
832
"\n# global netdata configuration\n");
833
834
- for(i = 0; i <= 15 ;i++) {
834
+ for(i = 0; i <= 16 ;i++) {
835
appconfig_wrlock(root);
836
for(co = root->first_section; co ; co = co->next) {
837
if(!strcmp(co->name, CONFIG_SECTION_GLOBAL)) pri = 0;
838
- else if(!strcmp(co->name, CONFIG_SECTION_DIRECTORIES)) pri = 1;
839
- else if(!strcmp(co->name, CONFIG_SECTION_LOGS)) pri = 2;
840
- else if(!strcmp(co->name, CONFIG_SECTION_ENV_VARS)) pri = 3;
841
- else if(!strcmp(co->name, CONFIG_SECTION_HOST_LABEL)) pri = 4;
842
- else if(!strcmp(co->name, CONFIG_SECTION_SQLITE)) pri = 5;
843
- else if(!strcmp(co->name, CONFIG_SECTION_CLOUD)) pri = 6;
844
- else if(!strcmp(co->name, CONFIG_SECTION_ML)) pri = 7;
845
- else if(!strcmp(co->name, CONFIG_SECTION_HEALTH)) pri = 8;
846
- else if(!strcmp(co->name, CONFIG_SECTION_WEB)) pri = 9;
847
- // by default, new sections will get pri = 10 (set at the end, below)
848
- else if(!strcmp(co->name, CONFIG_SECTION_REGISTRY)) pri = 11;
849
- else if(!strcmp(co->name, CONFIG_SECTION_GLOBAL_STATISTICS)) pri = 12;
850
- else if(!strcmp(co->name, CONFIG_SECTION_PLUGINS)) pri = 13;
851
- else if(!strcmp(co->name, CONFIG_SECTION_STATSD)) pri = 14;
852
- else if(!strncmp(co->name, "plugin:", 7)) pri = 15; // << change the loop too if you change this
853
- else pri = 10; // this is used for any new (currently unknown) sections
838
+ else if(!strcmp(co->name, CONFIG_SECTION_DB)) pri = 1;
839
+ else if(!strcmp(co->name, CONFIG_SECTION_DIRECTORIES)) pri = 2;
840
+ else if(!strcmp(co->name, CONFIG_SECTION_LOGS)) pri = 3;
841
+ else if(!strcmp(co->name, CONFIG_SECTION_ENV_VARS)) pri = 4;
842
+ else if(!strcmp(co->name, CONFIG_SECTION_HOST_LABEL)) pri = 5;
843
+ else if(!strcmp(co->name, CONFIG_SECTION_SQLITE)) pri = 6;
844
+ else if(!strcmp(co->name, CONFIG_SECTION_CLOUD)) pri = 7;
845
+ else if(!strcmp(co->name, CONFIG_SECTION_ML)) pri = 8;
846
+ else if(!strcmp(co->name, CONFIG_SECTION_HEALTH)) pri = 9;
847
+ else if(!strcmp(co->name, CONFIG_SECTION_WEB)) pri = 10;
848
+ // by default, new sections will get pri = 11 (set at the end, below)
849
+ else if(!strcmp(co->name, CONFIG_SECTION_REGISTRY)) pri = 12;
850
+ else if(!strcmp(co->name, CONFIG_SECTION_GLOBAL_STATISTICS)) pri = 13;
851
+ else if(!strcmp(co->name, CONFIG_SECTION_PLUGINS)) pri = 14;
852
+ else if(!strcmp(co->name, CONFIG_SECTION_STATSD)) pri = 15;
853
+ else if(!strncmp(co->name, "plugin:", 7)) pri = 16; // << change the loop too if you change this
854
+ else pri = 11; // this is used for any new (currently unknown) sections
855
856
if(i == pri) {
857
int loaded = 0;
@@ -916,7 +917,7 @@ int config_parse_duration(const char* string, int* result) {
917
if(!(isdigit(*string) || *string == '+' || *string == '-')) goto fallback;
918
919
char *e = NULL;
919
- calculated_number n = str2ld(string, &e);
920
+ NETDATA_DOUBLE n = str2ndd(string, &e);
921
if(e && *e) {
922
switch (*e) {
923
case 'Y':
libnetdata/config/appconfig.h
+4
-2
@@ -100,6 +100,8 @@
100
#define CONFIG_SECTION_HOST_LABEL "host labels"
101
#define EXPORTING_CONF "exporting.conf"
102
#define CONFIG_SECTION_GLOBAL_STATISTICS "global statistics"
103
+#define CONFIG_SECTION_DB "db"
104
+
105
106
// these are used to limit the configuration names and values lengths
107
// they are not enforced by config.c functions (they will strdup() all strings, no matter of their length)
@@ -168,7 +170,7 @@ extern void config_section_unlock(struct section *co);
170
extern char *appconfig_get_by_section(struct section *co, const char *name, const char *default_value);
171
extern char *appconfig_get(struct config *root, const char *section, const char *name, const char *default_value);
172
extern long long appconfig_get_number(struct config *root, const char *section, const char *name, long long value);
171
-extern LONG_DOUBLE appconfig_get_float(struct config *root, const char *section, const char *name, LONG_DOUBLE value);
173
+extern NETDATA_DOUBLE appconfig_get_float(struct config *root, const char *section, const char *name, NETDATA_DOUBLE value);
174
extern int appconfig_get_boolean_by_section(struct section *co, const char *name, int value);
175
extern int appconfig_get_boolean(struct config *root, const char *section, const char *name, int value);
176
extern int appconfig_get_boolean_ondemand(struct config *root, const char *section, const char *name, int value);
@@ -177,7 +179,7 @@ extern int appconfig_get_duration(struct config *root, const char *section, cons
179
extern const char *appconfig_set(struct config *root, const char *section, const char *name, const char *value);
180
extern const char *appconfig_set_default(struct config *root, const char *section, const char *name, const char *value);
181
extern long long appconfig_set_number(struct config *root, const char *section, const char *name, long long value);
180
-extern LONG_DOUBLE appconfig_set_float(struct config *root, const char *section, const char *name, LONG_DOUBLE value);
182
+extern NETDATA_DOUBLE appconfig_set_float(struct config *root, const char *section, const char *name, NETDATA_DOUBLE value);
183
extern int appconfig_set_boolean(struct config *root, const char *section, const char *name, int value);
184
185
extern int appconfig_exists(struct config *root, const char *section, const char *name);
libnetdata/eval/eval.c
+56
-56
@@ -9,7 +9,7 @@ typedef struct eval_value {
9
int type;
10
11
union {
12
- calculated_number number;
12
+ NETDATA_DOUBLE number;
13
EVAL_VARIABLE *variable;
14
struct eval_node *expression;
15
};
@@ -54,16 +54,16 @@ typedef struct eval_node {
54
static inline void eval_node_free(EVAL_NODE *op);
55
static inline EVAL_NODE *parse_full_expression(const char **string, int *error);
56
static inline EVAL_NODE *parse_one_full_operand(const char **string, int *error);
57
-static inline calculated_number eval_node(EVAL_EXPRESSION *exp, EVAL_NODE *op, int *error);
57
+static inline NETDATA_DOUBLE eval_node(EVAL_EXPRESSION *exp, EVAL_NODE *op, int *error);
58
static inline void print_parsed_as_node(BUFFER *out, EVAL_NODE *op, int *error);
59
-static inline void print_parsed_as_constant(BUFFER *out, calculated_number n);
59
+static inline void print_parsed_as_constant(BUFFER *out, NETDATA_DOUBLE n);
60
61
// ----------------------------------------------------------------------------
62
// evaluation of expressions
63
64
-static inline calculated_number eval_variable(EVAL_EXPRESSION *exp, EVAL_VARIABLE *v, int *error) {
64
+static inline NETDATA_DOUBLE eval_variable(EVAL_EXPRESSION *exp, EVAL_VARIABLE *v, int *error) {
65
static uint32_t this_hash = 0, now_hash = 0, after_hash = 0, before_hash = 0, status_hash = 0, removed_hash = 0, uninitialized_hash = 0, undefined_hash = 0, clear_hash = 0, warning_hash = 0, critical_hash = 0;
66
- calculated_number n;
66
+ NETDATA_DOUBLE n;
67
68
if(unlikely(this_hash == 0)) {
69
this_hash = simple_hash("this");
@@ -179,8 +179,8 @@ static inline calculated_number eval_variable(EVAL_EXPRESSION *exp, EVAL_VARIABL
179
return NAN;
180
}
181
182
-static inline calculated_number eval_value(EVAL_EXPRESSION *exp, EVAL_VALUE *v, int *error) {
183
- calculated_number n;
182
+static inline NETDATA_DOUBLE eval_value(EVAL_EXPRESSION *exp, EVAL_VALUE *v, int *error) {
183
+ NETDATA_DOUBLE n;
184
185
switch(v->type) {
186
case EVAL_VALUE_EXPRESSION:
@@ -204,101 +204,101 @@ static inline calculated_number eval_value(EVAL_EXPRESSION *exp, EVAL_VALUE *v,
204
return n;
205
}
206
207
-static inline int is_true(calculated_number n) {
207
+static inline int is_true(NETDATA_DOUBLE n) {
208
if(isnan(n)) return 0;
209
if(isinf(n)) return 1;
210
if(n == 0) return 0;
211
return 1;
212
}
213
214
-calculated_number eval_and(EVAL_EXPRESSION *exp, EVAL_NODE *op, int *error) {
214
+NETDATA_DOUBLE eval_and(EVAL_EXPRESSION *exp, EVAL_NODE *op, int *error) {
215
return is_true(eval_value(exp, &op->ops[0], error)) && is_true(eval_value(exp, &op->ops[1], error));
216
}
217
-calculated_number eval_or(EVAL_EXPRESSION *exp, EVAL_NODE *op, int *error) {
217
+NETDATA_DOUBLE eval_or(EVAL_EXPRESSION *exp, EVAL_NODE *op, int *error) {
218
return is_true(eval_value(exp, &op->ops[0], error)) || is_true(eval_value(exp, &op->ops[1], error));
219
}
220
-calculated_number eval_greater_than_or_equal(EVAL_EXPRESSION *exp, EVAL_NODE *op, int *error) {
221
- calculated_number n1 = eval_value(exp, &op->ops[0], error);
222
- calculated_number n2 = eval_value(exp, &op->ops[1], error);
220
+NETDATA_DOUBLE eval_greater_than_or_equal(EVAL_EXPRESSION *exp, EVAL_NODE *op, int *error) {
221
+ NETDATA_DOUBLE n1 = eval_value(exp, &op->ops[0], error);
222
+ NETDATA_DOUBLE n2 = eval_value(exp, &op->ops[1], error);
223
return isgreaterequal(n1, n2);
224
}
225
-calculated_number eval_less_than_or_equal(EVAL_EXPRESSION *exp, EVAL_NODE *op, int *error) {
226
- calculated_number n1 = eval_value(exp, &op->ops[0], error);
227
- calculated_number n2 = eval_value(exp, &op->ops[1], error);
225
+NETDATA_DOUBLE eval_less_than_or_equal(EVAL_EXPRESSION *exp, EVAL_NODE *op, int *error) {
226
+ NETDATA_DOUBLE n1 = eval_value(exp, &op->ops[0], error);
227
+ NETDATA_DOUBLE n2 = eval_value(exp, &op->ops[1], error);
228
return islessequal(n1, n2);
229
}
230
-calculated_number eval_equal(EVAL_EXPRESSION *exp, EVAL_NODE *op, int *error) {
231
- calculated_number n1 = eval_value(exp, &op->ops[0], error);
232
- calculated_number n2 = eval_value(exp, &op->ops[1], error);
230
+NETDATA_DOUBLE eval_equal(EVAL_EXPRESSION *exp, EVAL_NODE *op, int *error) {
231
+ NETDATA_DOUBLE n1 = eval_value(exp, &op->ops[0], error);
232
+ NETDATA_DOUBLE n2 = eval_value(exp, &op->ops[1], error);
233
if(isnan(n1) && isnan(n2)) return 1;
234
if(isinf(n1) && isinf(n2)) return 1;
235
if(isnan(n1) || isnan(n2)) return 0;
236
if(isinf(n1) || isinf(n2)) return 0;
237
- return calculated_number_equal(n1, n2);
237
+ return considered_equal_ndd(n1, n2);
238
}
239
-calculated_number eval_not_equal(EVAL_EXPRESSION *exp, EVAL_NODE *op, int *error) {
239
+NETDATA_DOUBLE eval_not_equal(EVAL_EXPRESSION *exp, EVAL_NODE *op, int *error) {
240
return !eval_equal(exp, op, error);
241
}
242
-calculated_number eval_less(EVAL_EXPRESSION *exp, EVAL_NODE *op, int *error) {
243
- calculated_number n1 = eval_value(exp, &op->ops[0], error);
244
- calculated_number n2 = eval_value(exp, &op->ops[1], error);
242
+NETDATA_DOUBLE eval_less(EVAL_EXPRESSION *exp, EVAL_NODE *op, int *error) {
243
+ NETDATA_DOUBLE n1 = eval_value(exp, &op->ops[0], error);
244
+ NETDATA_DOUBLE n2 = eval_value(exp, &op->ops[1], error);
245
return isless(n1, n2);
246
}
247
-calculated_number eval_greater(EVAL_EXPRESSION *exp, EVAL_NODE *op, int *error) {
248
- calculated_number n1 = eval_value(exp, &op->ops[0], error);
249
- calculated_number n2 = eval_value(exp, &op->ops[1], error);
247
+NETDATA_DOUBLE eval_greater(EVAL_EXPRESSION *exp, EVAL_NODE *op, int *error) {
248
+ NETDATA_DOUBLE n1 = eval_value(exp, &op->ops[0], error);
249
+ NETDATA_DOUBLE n2 = eval_value(exp, &op->ops[1], error);
250
return isgreater(n1, n2);
251
}
252
-calculated_number eval_plus(EVAL_EXPRESSION *exp, EVAL_NODE *op, int *error) {
253
- calculated_number n1 = eval_value(exp, &op->ops[0], error);
254
- calculated_number n2 = eval_value(exp, &op->ops[1], error);
252
+NETDATA_DOUBLE eval_plus(EVAL_EXPRESSION *exp, EVAL_NODE *op, int *error) {
253
+ NETDATA_DOUBLE n1 = eval_value(exp, &op->ops[0], error);
254
+ NETDATA_DOUBLE n2 = eval_value(exp, &op->ops[1], error);
255
if(isnan(n1) || isnan(n2)) return NAN;
256
if(isinf(n1) || isinf(n2)) return INFINITY;
257
return n1 + n2;
258
}
259
-calculated_number eval_minus(EVAL_EXPRESSION *exp, EVAL_NODE *op, int *error) {
260
- calculated_number n1 = eval_value(exp, &op->ops[0], error);
261
- calculated_number n2 = eval_value(exp, &op->ops[1], error);
259
+NETDATA_DOUBLE eval_minus(EVAL_EXPRESSION *exp, EVAL_NODE *op, int *error) {
260
+ NETDATA_DOUBLE n1 = eval_value(exp, &op->ops[0], error);
261
+ NETDATA_DOUBLE n2 = eval_value(exp, &op->ops[1], error);
262
if(isnan(n1) || isnan(n2)) return NAN;
263
if(isinf(n1) || isinf(n2)) return INFINITY;
264
return n1 - n2;
265
}
266
-calculated_number eval_multiply(EVAL_EXPRESSION *exp, EVAL_NODE *op, int *error) {
267
- calculated_number n1 = eval_value(exp, &op->ops[0], error);
268
- calculated_number n2 = eval_value(exp, &op->ops[1], error);
266
+NETDATA_DOUBLE eval_multiply(EVAL_EXPRESSION *exp, EVAL_NODE *op, int *error) {
267
+ NETDATA_DOUBLE n1 = eval_value(exp, &op->ops[0], error);
268
+ NETDATA_DOUBLE n2 = eval_value(exp, &op->ops[1], error);
269
if(isnan(n1) || isnan(n2)) return NAN;
270
if(isinf(n1) || isinf(n2)) return INFINITY;
271
return n1 * n2;
272
}
273
-calculated_number eval_divide(EVAL_EXPRESSION *exp, EVAL_NODE *op, int *error) {
274
- calculated_number n1 = eval_value(exp, &op->ops[0], error);
275
- calculated_number n2 = eval_value(exp, &op->ops[1], error);
273
+NETDATA_DOUBLE eval_divide(EVAL_EXPRESSION *exp, EVAL_NODE *op, int *error) {
274
+ NETDATA_DOUBLE n1 = eval_value(exp, &op->ops[0], error);
275
+ NETDATA_DOUBLE n2 = eval_value(exp, &op->ops[1], error);
276
if(isnan(n1) || isnan(n2)) return NAN;
277
if(isinf(n1) || isinf(n2)) return INFINITY;
278
return n1 / n2;
279
}
280
-calculated_number eval_nop(EVAL_EXPRESSION *exp, EVAL_NODE *op, int *error) {
280
+NETDATA_DOUBLE eval_nop(EVAL_EXPRESSION *exp, EVAL_NODE *op, int *error) {
281
return eval_value(exp, &op->ops[0], error);
282
}
283
-calculated_number eval_not(EVAL_EXPRESSION *exp, EVAL_NODE *op, int *error) {
283
+NETDATA_DOUBLE eval_not(EVAL_EXPRESSION *exp, EVAL_NODE *op, int *error) {
284
return !is_true(eval_value(exp, &op->ops[0], error));
285
}
286
-calculated_number eval_sign_plus(EVAL_EXPRESSION *exp, EVAL_NODE *op, int *error) {
286
+NETDATA_DOUBLE eval_sign_plus(EVAL_EXPRESSION *exp, EVAL_NODE *op, int *error) {
287
return eval_value(exp, &op->ops[0], error);
288
}
289
-calculated_number eval_sign_minus(EVAL_EXPRESSION *exp, EVAL_NODE *op, int *error) {
290
- calculated_number n1 = eval_value(exp, &op->ops[0], error);
289
+NETDATA_DOUBLE eval_sign_minus(EVAL_EXPRESSION *exp, EVAL_NODE *op, int *error) {
290
+ NETDATA_DOUBLE n1 = eval_value(exp, &op->ops[0], error);
291
if(isnan(n1)) return NAN;
292
if(isinf(n1)) return INFINITY;
293
return -n1;
294
}
295
-calculated_number eval_abs(EVAL_EXPRESSION *exp, EVAL_NODE *op, int *error) {
296
- calculated_number n1 = eval_value(exp, &op->ops[0], error);
295
+NETDATA_DOUBLE eval_abs(EVAL_EXPRESSION *exp, EVAL_NODE *op, int *error) {
296
+ NETDATA_DOUBLE n1 = eval_value(exp, &op->ops[0], error);
297
if(isnan(n1)) return NAN;
298
if(isinf(n1)) return INFINITY;
299
return ABS(n1);
300
}
301
-calculated_number eval_if_then_else(EVAL_EXPRESSION *exp, EVAL_NODE *op, int *error) {
301
+NETDATA_DOUBLE eval_if_then_else(EVAL_EXPRESSION *exp, EVAL_NODE *op, int *error) {
302
if(is_true(eval_value(exp, &op->ops[0], error)))
303
return eval_value(exp, &op->ops[1], error);
304
else
@@ -310,7 +310,7 @@ static struct operator {
310
char precedence;
311
char parameters;
312
char isfunction;
313
- calculated_number (*eval)(EVAL_EXPRESSION *exp, EVAL_NODE *op, int *error);
313
+ NETDATA_DOUBLE (*eval)(EVAL_EXPRESSION *exp, EVAL_NODE *op, int *error);
314
} operators[256] = {
315
// this is a random access array
316
// we always access it with a known EVAL_OPERATOR_X
@@ -341,13 +341,13 @@ static struct operator {
341
342
#define eval_precedence(operator) (operators[(unsigned char)(operator)].precedence)
343
344
-static inline calculated_number eval_node(EVAL_EXPRESSION *exp, EVAL_NODE *op, int *error) {
344
+static inline NETDATA_DOUBLE eval_node(EVAL_EXPRESSION *exp, EVAL_NODE *op, int *error) {
345
if(unlikely(op->count != operators[op->operator].parameters)) {
346
*error = EVAL_ERROR_INVALID_NUMBER_OF_OPERANDS;
347
return 0;
348
}
349
350
- calculated_number n = operators[op->operator].eval(exp, op, error);
350
+ NETDATA_DOUBLE n = operators[op->operator].eval(exp, op, error);
351
352
return n;
353
}
@@ -360,7 +360,7 @@ static inline void print_parsed_as_variable(BUFFER *out, EVAL_VARIABLE *v, int *
360
buffer_sprintf(out, "${%s}", v->name);
361
}
362
363
-static inline void print_parsed_as_constant(BUFFER *out, calculated_number n) {
363
+static inline void print_parsed_as_constant(BUFFER *out, NETDATA_DOUBLE n) {
364
if(unlikely(isnan(n))) {
365
buffer_strcat(out, "nan");
366
return;
@@ -372,7 +372,7 @@ static inline void print_parsed_as_constant(BUFFER *out, calculated_number n) {
372
}
373
374
char b[100+1], *s;
375
- snprintfz(b, 100, CALCULATED_NUMBER_FORMAT, n);
375
+ snprintfz(b, 100, NETDATA_DOUBLE_FORMAT, n);
376
377
s = &b[strlen(b) - 1];
378
while(s > b && *s == '0') {
@@ -737,9 +737,9 @@ static inline int parse_variable(const char **string, char *buffer, size_t len)
737
return 0;
738
}
739
740
-static inline int parse_constant(const char **string, calculated_number *number) {
740
+static inline int parse_constant(const char **string, NETDATA_DOUBLE *number) {
741
char *end = NULL;
742
- calculated_number n = str2ld(*string, &end);
742
+ NETDATA_DOUBLE n = str2ndd(*string, &end);
743
if(unlikely(!end || *string == end)) {
744
*number = 0;
745
return 0;
@@ -845,7 +845,7 @@ static inline void eval_node_set_value_to_node(EVAL_NODE *op, int pos, EVAL_NODE
845
op->ops[pos].expression = value;
846
}
847
848
-static inline void eval_node_set_value_to_constant(EVAL_NODE *op, int pos, calculated_number value) {
848
+static inline void eval_node_set_value_to_constant(EVAL_NODE *op, int pos, NETDATA_DOUBLE value) {
849
if(pos >= op->count)
850
fatal("Invalid request to set position %d of OPERAND that has only %d values", pos + 1, op->count + 1);
851
@@ -911,7 +911,7 @@ static inline EVAL_NODE *parse_next_operand_given_its_operator(const char **stri
911
static inline EVAL_NODE *parse_one_full_operand(const char **string, int *error) {
912
char variable_buffer[EVAL_MAX_VARIABLE_NAME_LENGTH + 1];
913
EVAL_NODE *op1 = NULL;
914
- calculated_number number;
914
+ NETDATA_DOUBLE number;
915
916
*error = EVAL_ERROR_OK;
917
libnetdata/eval/eval.h
+3
-3
@@ -28,11 +28,11 @@ typedef struct eval_expression {
28
const char *parsed_as;
29
30
RRDCALC_STATUS *status;
31
- calculated_number *myself;
31
+ NETDATA_DOUBLE *myself;
32
time_t *after;
33
time_t *before;
34
35
- calculated_number result;
35
+ NETDATA_DOUBLE result;
36
37
int error;
38
BUFFER *error_msg;
@@ -83,6 +83,6 @@ extern const char *expression_strerror(int error);
83
// 2 = FAILED, the error message is in: buffer_tostring(expression->error_msg)
84
extern int expression_evaluate(EVAL_EXPRESSION *expression);
85
86
-extern int health_variable_lookup(const char *variable, uint32_t hash, struct rrdcalc *rc, calculated_number *result);
86
+extern int health_variable_lookup(const char *variable, uint32_t hash, struct rrdcalc *rc, NETDATA_DOUBLE *result);
87
88
#endif //NETDATA_EVAL_H
libnetdata/inlined.h
-71
@@ -151,77 +151,6 @@ static inline long long str2ll(const char *s, char **endptr) {
151
return n;
152
}
153
154
-static inline long double str2ld(const char *s, char **endptr) {
155
- int negative = 0;
156
- const char *start = s;
157
- unsigned long long integer_part = 0;
158
- unsigned long decimal_part = 0;
159
- size_t decimal_digits = 0;
160
-
161
- switch(*s) {
162
- case '-':
163
- s++;
164
- negative = 1;
165
- break;
166
-
167
- case '+':
168
- s++;
169
- break;
170
-
171
- case 'n':
172
- if(s[1] == 'a' && s[2] == 'n') {
173
- if(endptr) *endptr = (char *)&s[3];
174
- return NAN;
175
- }
176
- break;
177
-
178
- case 'i':
179
- if(s[1] == 'n' && s[2] == 'f') {
180
- if(endptr) *endptr = (char *)&s[3];
181
- return INFINITY;
182
- }
183
- break;
184
-
185
- default:
186
- break;
187
- }
188
-
189
- while (*s >= '0' && *s <= '9') {
190
- integer_part = (integer_part * 10) + (*s - '0');
191
- s++;
192
- }
193
-
194
- if(unlikely(*s == '.')) {
195
- decimal_part = 0;
196
- s++;
197
-
198
- while (*s >= '0' && *s <= '9') {
199
- decimal_part = (decimal_part * 10) + (*s - '0');
200
- s++;
201
- decimal_digits++;
202
- }
203
- }
204
-
205
- if(unlikely(*s == 'e' || *s == 'E'))
206
- return strtold(start, endptr);
207
-
208
- if(unlikely(endptr))
209
- *endptr = (char *)s;
210
-
211
- if(unlikely(negative)) {
212
- if(unlikely(decimal_digits))
213
- return -((long double)integer_part + (long double)decimal_part / powl(10.0, decimal_digits));
214
- else
215
- return -((long double)integer_part);
216
- }
217
- else {
218
- if(unlikely(decimal_digits))
219
- return (long double)integer_part + (long double)decimal_part / powl(10.0, decimal_digits);
220
- else
221
- return (long double)integer_part;
222
- }
223
-}
224
-
154
static inline char *strncpyz(char *dst, const char *src, size_t n) {
155
char *p = dst;
156
libnetdata/json/json.c
+2
-2
@@ -111,7 +111,7 @@ int json_callback_print(JSON_ENTRY *e)
111
break;
112
113
case JSON_NUMBER:
114
- sprintf(txt,"%Lf", e->data.number);
114
+ sprintf(txt, NETDATA_DOUBLE_FORMAT_AUTO, e->data.number);
115
buffer_strcat(wb,txt);
116
117
break;
@@ -168,7 +168,7 @@ static inline void json_jsonc_set_integer(JSON_ENTRY *e, char *key, int64_t valu
168
e->type = JSON_NUMBER;
169
memcpy(e->name, key, len);
170
e->name[len] = 0;
171
- e->data.number = value;
171
+ e->data.number = (NETDATA_DOUBLE)value;
172
}
173
174
/**
libnetdata/json/json.h
+5
-5
@@ -31,12 +31,12 @@ typedef struct json_entry {
31
char name[JSON_NAME_LEN + 1];
32
char fullname[JSON_FULLNAME_LEN + 1];
33
union {
34
- char *string; // type == JSON_STRING
35
- long double number; // type == JSON_NUMBER
36
- int boolean; // type == JSON_BOOLEAN
37
- size_t items; // type == JSON_ARRAY
34
+ char *string; // type == JSON_STRING
35
+ NETDATA_DOUBLE number; // type == JSON_NUMBER
36
+ int boolean; // type == JSON_BOOLEAN
37
+ size_t items; // type == JSON_ARRAY
38
} data;
39
- size_t pos; // the position of this item in its parent
39
+ size_t pos; // the position of this item in its parent
40
41
char *original_string;
42
libnetdata/required_dummies.h
+1
-1
@@ -23,7 +23,7 @@ void signals_unblock(void){};
23
void signals_reset(void){};
24
25
// callback required by eval()
26
-int health_variable_lookup(const char *variable, uint32_t hash, struct rrdcalc *rc, calculated_number *result)
26
+int health_variable_lookup(const char *variable, uint32_t hash, struct rrdcalc *rc, NETDATA_DOUBLE *result)
27
{
28
(void)variable;
29
(void)hash;
libnetdata/statistical/statistical.c
+94
-86
@@ -2,28 +2,28 @@
2
3
#include "../libnetdata.h"
4
5
-LONG_DOUBLE default_single_exponential_smoothing_alpha = 0.1;
5
+NETDATA_DOUBLE default_single_exponential_smoothing_alpha = 0.1;
6
7
-void log_series_to_stderr(LONG_DOUBLE *series, size_t entries, calculated_number result, const char *msg) {
8
- const LONG_DOUBLE *value, *end = &series[entries];
7
+void log_series_to_stderr(NETDATA_DOUBLE *series, size_t entries, NETDATA_DOUBLE result, const char *msg) {
8
+ const NETDATA_DOUBLE *value, *end = &series[entries];
9
10
fprintf(stderr, "%s of %zu entries [ ", msg, entries);
11
for(value = series; value < end ;value++) {
12
if(value != series) fprintf(stderr, ", ");
13
- fprintf(stderr, "%" LONG_DOUBLE_MODIFIER, *value);
13
+ fprintf(stderr, "%" NETDATA_DOUBLE_MODIFIER, *value);
14
}
15
- fprintf(stderr, " ] results in " CALCULATED_NUMBER_FORMAT "\n", result);
15
+ fprintf(stderr, " ] results in " NETDATA_DOUBLE_FORMAT "\n", result);
16
}
17
18
// --------------------------------------------------------------------------------------------------------------------
19
20
-inline LONG_DOUBLE sum_and_count(const LONG_DOUBLE *series, size_t entries, size_t *count) {
21
- const LONG_DOUBLE *value, *end = &series[entries];
22
- LONG_DOUBLE sum = 0;
20
+inline NETDATA_DOUBLE sum_and_count(const NETDATA_DOUBLE *series, size_t entries, size_t *count) {
21
+ const NETDATA_DOUBLE *value, *end = &series[entries];
22
+ NETDATA_DOUBLE sum = 0;
23
size_t c = 0;
24
25
for(value = series; value < end ; value++) {
26
- if(calculated_number_isnumber(*value)) {
26
+ if(netdata_double_isnumber(*value)) {
27
sum += *value;
28
c++;
29
}
@@ -35,42 +35,42 @@ inline LONG_DOUBLE sum_and_count(const LONG_DOUBLE *series, size_t entries, size
35
return sum;
36
}
37
38
-inline LONG_DOUBLE sum(const LONG_DOUBLE *series, size_t entries) {
38
+inline NETDATA_DOUBLE sum(const NETDATA_DOUBLE *series, size_t entries) {
39
return sum_and_count(series, entries, NULL);
40
}
41
42
-inline LONG_DOUBLE average(const LONG_DOUBLE *series, size_t entries) {
42
+inline NETDATA_DOUBLE average(const NETDATA_DOUBLE *series, size_t entries) {
43
size_t count = 0;
44
- LONG_DOUBLE sum = sum_and_count(series, entries, &count);
44
+ NETDATA_DOUBLE sum = sum_and_count(series, entries, &count);
45
46
if(unlikely(!count)) return NAN;
47
- return sum / (LONG_DOUBLE)count;
47
+ return sum / (NETDATA_DOUBLE)count;
48
}
49
50
// --------------------------------------------------------------------------------------------------------------------
51
52
-LONG_DOUBLE moving_average(const LONG_DOUBLE *series, size_t entries, size_t period) {
52
+NETDATA_DOUBLE moving_average(const NETDATA_DOUBLE *series, size_t entries, size_t period) {
53
if(unlikely(period <= 0))
54
return 0.0;
55
56
size_t i, count;
57
- LONG_DOUBLE sum = 0, avg = 0;
58
- LONG_DOUBLE p[period];
57
+ NETDATA_DOUBLE sum = 0, avg = 0;
58
+ NETDATA_DOUBLE p[period];
59
60
for(count = 0; count < period ; count++)
61
p[count] = 0.0;
62
63
for(i = 0, count = 0; i < entries; i++) {
64
- LONG_DOUBLE value = series[i];
65
- if(unlikely(!calculated_number_isnumber(value))) continue;
64
+ NETDATA_DOUBLE value = series[i];
65
+ if(unlikely(!netdata_double_isnumber(value))) continue;
66
67
if(unlikely(count < period)) {
68
sum += value;
69
- avg = (count == period - 1) ? sum / (LONG_DOUBLE)period : 0;
69
+ avg = (count == period - 1) ? sum / (NETDATA_DOUBLE)period : 0;
70
}
71
else {
72
sum = sum - p[count % period] + value;
73
- avg = sum / (LONG_DOUBLE)period;
73
+ avg = sum / (NETDATA_DOUBLE)period;
74
}
75
76
p[count % period] = value;
@@ -83,8 +83,8 @@ LONG_DOUBLE moving_average(const LONG_DOUBLE *series, size_t entries, size_t per
83
// --------------------------------------------------------------------------------------------------------------------
84
85
static int qsort_compare(const void *a, const void *b) {
86
- LONG_DOUBLE *p1 = (LONG_DOUBLE *)a, *p2 = (LONG_DOUBLE *)b;
87
- LONG_DOUBLE n1 = *p1, n2 = *p2;
86
+ NETDATA_DOUBLE *p1 = (NETDATA_DOUBLE *)a, *p2 = (NETDATA_DOUBLE *)b;
87
+ NETDATA_DOUBLE n1 = *p1, n2 = *p2;
88
89
if(unlikely(isnan(n1) || isnan(n2))) {
90
if(isnan(n1) && !isnan(n2)) return -1;
@@ -102,22 +102,22 @@ static int qsort_compare(const void *a, const void *b) {
102
return 0;
103
}
104
105
-inline void sort_series(LONG_DOUBLE *series, size_t entries) {
106
- qsort(series, entries, sizeof(LONG_DOUBLE), qsort_compare);
105
+inline void sort_series(NETDATA_DOUBLE *series, size_t entries) {
106
+ qsort(series, entries, sizeof(NETDATA_DOUBLE), qsort_compare);
107
}
108
109
-inline LONG_DOUBLE *copy_series(const LONG_DOUBLE *series, size_t entries) {
110
- LONG_DOUBLE *copy = mallocz(sizeof(LONG_DOUBLE) * entries);
111
- memcpy(copy, series, sizeof(LONG_DOUBLE) * entries);
109
+inline NETDATA_DOUBLE *copy_series(const NETDATA_DOUBLE *series, size_t entries) {
110
+ NETDATA_DOUBLE *copy = mallocz(sizeof(NETDATA_DOUBLE) * entries);
111
+ memcpy(copy, series, sizeof(NETDATA_DOUBLE) * entries);
112
return copy;
113
}
114
115
-LONG_DOUBLE median_on_sorted_series(const LONG_DOUBLE *series, size_t entries) {
115
+NETDATA_DOUBLE median_on_sorted_series(const NETDATA_DOUBLE *series, size_t entries) {
116
if(unlikely(entries == 0)) return NAN;
117
if(unlikely(entries == 1)) return series[0];
118
if(unlikely(entries == 2)) return (series[0] + series[1]) / 2;
119
120
- LONG_DOUBLE average;
120
+ NETDATA_DOUBLE average;
121
if(entries % 2 == 0) {
122
size_t m = entries / 2;
123
average = (series[m] + series[m + 1]) / 2;
@@ -129,17 +129,17 @@ LONG_DOUBLE median_on_sorted_series(const LONG_DOUBLE *series, size_t entries) {
129
return average;
130
}
131
132
-LONG_DOUBLE median(const LONG_DOUBLE *series, size_t entries) {
132
+NETDATA_DOUBLE median(const NETDATA_DOUBLE *series, size_t entries) {
133
if(unlikely(entries == 0)) return NAN;
134
if(unlikely(entries == 1)) return series[0];
135
136
if(unlikely(entries == 2))
137
return (series[0] + series[1]) / 2;
138
139
- LONG_DOUBLE *copy = copy_series(series, entries);
139
+ NETDATA_DOUBLE *copy = copy_series(series, entries);
140
sort_series(copy, entries);
141
142
- LONG_DOUBLE avg = median_on_sorted_series(copy, entries);
142
+ NETDATA_DOUBLE avg = median_on_sorted_series(copy, entries);
143
144
freez(copy);
145
return avg;
@@ -147,18 +147,18 @@ LONG_DOUBLE median(const LONG_DOUBLE *series, size_t entries) {
147
148
// --------------------------------------------------------------------------------------------------------------------
149
150
-LONG_DOUBLE moving_median(const LONG_DOUBLE *series, size_t entries, size_t period) {
150
+NETDATA_DOUBLE moving_median(const NETDATA_DOUBLE *series, size_t entries, size_t period) {
151
if(entries <= period)
152
return median(series, entries);
153
154
- LONG_DOUBLE *data = copy_series(series, entries);
154
+ NETDATA_DOUBLE *data = copy_series(series, entries);
155
156
size_t i;
157
for(i = period; i < entries; i++) {
158
data[i - period] = median(&series[i - period], period);
159
}
160
161
- LONG_DOUBLE avg = median(data, entries - period);
161
+ NETDATA_DOUBLE avg = median(data, entries - period);
162
freez(data);
163
return avg;
164
}
@@ -166,17 +166,17 @@ LONG_DOUBLE moving_median(const LONG_DOUBLE *series, size_t entries, size_t peri
166
// --------------------------------------------------------------------------------------------------------------------
167
168
// http://stackoverflow.com/a/15150143/4525767
169
-LONG_DOUBLE running_median_estimate(const LONG_DOUBLE *series, size_t entries) {
170
- LONG_DOUBLE median = 0.0f;
171
- LONG_DOUBLE average = 0.0f;
169
+NETDATA_DOUBLE running_median_estimate(const NETDATA_DOUBLE *series, size_t entries) {
170
+ NETDATA_DOUBLE median = 0.0f;
171
+ NETDATA_DOUBLE average = 0.0f;
172
size_t i;
173
174
for(i = 0; i < entries ; i++) {
175
- LONG_DOUBLE value = series[i];
176
- if(unlikely(!calculated_number_isnumber(value))) continue;
175
+ NETDATA_DOUBLE value = series[i];
176
+ if(unlikely(!netdata_double_isnumber(value))) continue;
177
178
average += ( value - average ) * 0.1f; // rough running average.
179
- median += copysignl( average * 0.01, value - median );
179
+ median += copysignndd( average * 0.01, value - median );
180
}
181
182
return median;
@@ -184,16 +184,16 @@ LONG_DOUBLE running_median_estimate(const LONG_DOUBLE *series, size_t entries) {
184
185
// --------------------------------------------------------------------------------------------------------------------
186
187
-LONG_DOUBLE standard_deviation(const LONG_DOUBLE *series, size_t entries) {
187
+NETDATA_DOUBLE standard_deviation(const NETDATA_DOUBLE *series, size_t entries) {
188
if(unlikely(entries == 0)) return NAN;
189
if(unlikely(entries == 1)) return series[0];
190
191
- const LONG_DOUBLE *value, *end = &series[entries];
191
+ const NETDATA_DOUBLE *value, *end = &series[entries];
192
size_t count;
193
- LONG_DOUBLE sum;
193
+ NETDATA_DOUBLE sum;
194
195
for(count = 0, sum = 0, value = series ; value < end ;value++) {
196
- if(likely(calculated_number_isnumber(*value))) {
196
+ if(likely(netdata_double_isnumber(*value))) {
197
count++;
198
sum += *value;
199
}
@@ -202,55 +202,55 @@ LONG_DOUBLE standard_deviation(const LONG_DOUBLE *series, size_t entries) {
202
if(unlikely(count == 0)) return NAN;
203
if(unlikely(count == 1)) return sum;
204
205
- LONG_DOUBLE average = sum / (LONG_DOUBLE)count;
205
+ NETDATA_DOUBLE average = sum / (NETDATA_DOUBLE)count;
206
207
for(count = 0, sum = 0, value = series ; value < end ;value++) {
208
- if(calculated_number_isnumber(*value)) {
208
+ if(netdata_double_isnumber(*value)) {
209
count++;
210
- sum += powl(*value - average, 2);
210
+ sum += powndd(*value - average, 2);
211
}
212
}
213
214
if(unlikely(count == 0)) return NAN;
215
if(unlikely(count == 1)) return average;
216
217
- LONG_DOUBLE variance = sum / (LONG_DOUBLE)(count); // remove -1 from count to have a population stddev
218
- LONG_DOUBLE stddev = sqrtl(variance);
217
+ NETDATA_DOUBLE variance = sum / (NETDATA_DOUBLE)(count); // remove -1 from count to have a population stddev
218
+ NETDATA_DOUBLE stddev = sqrtndd(variance);
219
return stddev;
220
}
221
222
// --------------------------------------------------------------------------------------------------------------------
223
224
-LONG_DOUBLE single_exponential_smoothing(const LONG_DOUBLE *series, size_t entries, LONG_DOUBLE alpha) {
224
+NETDATA_DOUBLE single_exponential_smoothing(const NETDATA_DOUBLE *series, size_t entries, NETDATA_DOUBLE alpha) {
225
if(unlikely(entries == 0))
226
return NAN;
227
228
if(unlikely(isnan(alpha)))
229
alpha = default_single_exponential_smoothing_alpha;
230
231
- const LONG_DOUBLE *value = series, *end = &series[entries];
232
- LONG_DOUBLE level = (1.0 - alpha) * (*value);
231
+ const NETDATA_DOUBLE *value = series, *end = &series[entries];
232
+ NETDATA_DOUBLE level = (1.0 - alpha) * (*value);
233
234
for(value++ ; value < end; value++) {
235
- if(likely(calculated_number_isnumber(*value)))
235
+ if(likely(netdata_double_isnumber(*value)))
236
level = alpha * (*value) + (1.0 - alpha) * level;
237
}
238
239
return level;
240
}
241
242
-LONG_DOUBLE single_exponential_smoothing_reverse(const LONG_DOUBLE *series, size_t entries, LONG_DOUBLE alpha) {
242
+NETDATA_DOUBLE single_exponential_smoothing_reverse(const NETDATA_DOUBLE *series, size_t entries, NETDATA_DOUBLE alpha) {
243
if(unlikely(entries == 0))
244
return NAN;
245
246
if(unlikely(isnan(alpha)))
247
alpha = default_single_exponential_smoothing_alpha;
248
249
- const LONG_DOUBLE *value = &series[entries -1];
250
- LONG_DOUBLE level = (1.0 - alpha) * (*value);
249
+ const NETDATA_DOUBLE *value = &series[entries -1];
250
+ NETDATA_DOUBLE level = (1.0 - alpha) * (*value);
251
252
for(value++ ; value >= series; value--) {
253
- if(likely(calculated_number_isnumber(*value)))
253
+ if(likely(netdata_double_isnumber(*value)))
254
level = alpha * (*value) + (1.0 - alpha) * level;
255
}
256
@@ -260,11 +260,14 @@ LONG_DOUBLE single_exponential_smoothing_reverse(const LONG_DOUBLE *series, size
260
// --------------------------------------------------------------------------------------------------------------------
261
262
// http://grisha.org/blog/2016/02/16/triple-exponential-smoothing-forecasting-part-ii/
263
-LONG_DOUBLE double_exponential_smoothing(const LONG_DOUBLE *series, size_t entries, LONG_DOUBLE alpha, LONG_DOUBLE beta, LONG_DOUBLE *forecast) {
263
+NETDATA_DOUBLE double_exponential_smoothing(const NETDATA_DOUBLE *series, size_t entries,
264
+ NETDATA_DOUBLE alpha,
265
+ NETDATA_DOUBLE beta,
266
+ NETDATA_DOUBLE *forecast) {
267
if(unlikely(entries == 0))
268
return NAN;
269
267
- LONG_DOUBLE level, trend;
270
+ NETDATA_DOUBLE level, trend;
271
272
if(unlikely(isnan(alpha)))
273
alpha = 0.3;
@@ -279,11 +282,10 @@ LONG_DOUBLE double_exponential_smoothing(const LONG_DOUBLE *series, size_t entri
282
else
283
trend = 0;
284
282
- const LONG_DOUBLE *value = series;
285
+ const NETDATA_DOUBLE *value = series;
286
for(value++ ; value >= series; value--) {
284
- if(likely(calculated_number_isnumber(*value))) {
285
-
286
- LONG_DOUBLE last_level = level;
287
+ if(likely(netdata_double_isnumber(*value))) {
288
+ NETDATA_DOUBLE last_level = level;
289
level = alpha * *value + (1.0 - alpha) * (level + trend);
290
trend = beta * (level - last_level) + (1.0 - beta) * trend;
291
@@ -320,24 +322,26 @@ LONG_DOUBLE double_exponential_smoothing(const LONG_DOUBLE *series, size_t entri
322
* s[t] = γ (Y[t] / a[t]) + (1-γ) s[t-p]
323
*/
324
static int __HoltWinters(
323
- const LONG_DOUBLE *series,
325
+ const NETDATA_DOUBLE *series,
326
int entries, // start_time + h
327
326
- LONG_DOUBLE alpha, // alpha parameter of Holt-Winters Filter.
327
- LONG_DOUBLE beta, // beta parameter of Holt-Winters Filter. If set to 0, the function will do exponential smoothing.
328
- LONG_DOUBLE gamma, // gamma parameter used for the seasonal component. If set to 0, an non-seasonal model is fitted.
328
+ NETDATA_DOUBLE alpha, // alpha parameter of Holt-Winters Filter.
329
+ NETDATA_DOUBLE
330
+ beta, // beta parameter of Holt-Winters Filter. If set to 0, the function will do exponential smoothing.
331
+ NETDATA_DOUBLE
332
+ gamma, // gamma parameter used for the seasonal component. If set to 0, an non-seasonal model is fitted.
333
334
const int *seasonal,
335
const int *period,
332
- const LONG_DOUBLE *a, // Start value for level (a[0]).
333
- const LONG_DOUBLE *b, // Start value for trend (b[0]).
334
- LONG_DOUBLE *s, // Vector of start values for the seasonal component (s_1[0] ... s_p[0])
336
+ const NETDATA_DOUBLE *a, // Start value for level (a[0]).
337
+ const NETDATA_DOUBLE *b, // Start value for trend (b[0]).
338
+ NETDATA_DOUBLE *s, // Vector of start values for the seasonal component (s_1[0] ... s_p[0])
339
340
/* return values */
337
- LONG_DOUBLE *SSE, // The final sum of squared errors achieved in optimizing
338
- LONG_DOUBLE *level, // Estimated values for the level component (size entries - t + 2)
339
- LONG_DOUBLE *trend, // Estimated values for the trend component (size entries - t + 2)
340
- LONG_DOUBLE *season // Estimated values for the seasonal component (size entries - t + 2)
341
+ NETDATA_DOUBLE *SSE, // The final sum of squared errors achieved in optimizing
342
+ NETDATA_DOUBLE *level, // Estimated values for the level component (size entries - t + 2)
343
+ NETDATA_DOUBLE *trend, // Estimated values for the trend component (size entries - t + 2)
344
+ NETDATA_DOUBLE *season // Estimated values for the seasonal component (size entries - t + 2)
345
)
346
{
347
if(unlikely(entries < 4))
@@ -345,13 +349,13 @@ static int __HoltWinters(
349
350
int start_time = 2;
351
348
- LONG_DOUBLE res = 0, xhat = 0, stmp = 0;
352
+ NETDATA_DOUBLE res = 0, xhat = 0, stmp = 0;
353
int i, i0, s0;
354
355
/* copy start values to the beginning of the vectors */
356
level[0] = *a;
357
if(beta > 0) trend[0] = *b;
354
- if(gamma > 0) memcpy(season, s, *period * sizeof(LONG_DOUBLE));
358
+ if(gamma > 0) memcpy(season, s, *period * sizeof(NETDATA_DOUBLE));
359
360
for(i = start_time - 1; i < entries; i++) {
361
/* indices for period i */
@@ -397,7 +401,11 @@ static int __HoltWinters(
401
return 1;
402
}
403
400
-LONG_DOUBLE holtwinters(const LONG_DOUBLE *series, size_t entries, LONG_DOUBLE alpha, LONG_DOUBLE beta, LONG_DOUBLE gamma, LONG_DOUBLE *forecast) {
404
+NETDATA_DOUBLE holtwinters(const NETDATA_DOUBLE *series, size_t entries,
405
+ NETDATA_DOUBLE alpha,
406
+ NETDATA_DOUBLE beta,
407
+ NETDATA_DOUBLE gamma,
408
+ NETDATA_DOUBLE *forecast) {
409
if(unlikely(isnan(alpha)))
410
alpha = 0.3;
411
@@ -409,15 +417,15 @@ LONG_DOUBLE holtwinters(const LONG_DOUBLE *series, size_t entries, LONG_DOUBLE a
417
418
int seasonal = 0;
419
int period = 0;
412
- LONG_DOUBLE a0 = series[0];
413
- LONG_DOUBLE b0 = 0;
414
- LONG_DOUBLE s[] = {};
420
+ NETDATA_DOUBLE a0 = series[0];
421
+ NETDATA_DOUBLE b0 = 0;
422
+ NETDATA_DOUBLE s[] = {};
423
416
- LONG_DOUBLE errors = 0.0;
424
+ NETDATA_DOUBLE errors = 0.0;
425
size_t nb_computations = entries;
418
- LONG_DOUBLE *estimated_level = callocz(nb_computations, sizeof(LONG_DOUBLE));
419
- LONG_DOUBLE *estimated_trend = callocz(nb_computations, sizeof(LONG_DOUBLE));
420
- LONG_DOUBLE *estimated_season = callocz(nb_computations, sizeof(LONG_DOUBLE));
426
+ NETDATA_DOUBLE *estimated_level = callocz(nb_computations, sizeof(NETDATA_DOUBLE));
427
+ NETDATA_DOUBLE *estimated_trend = callocz(nb_computations, sizeof(NETDATA_DOUBLE));
428
+ NETDATA_DOUBLE *estimated_season = callocz(nb_computations, sizeof(NETDATA_DOUBLE));
429
430
int ret = __HoltWinters(
431
series,
@@ -436,7 +444,7 @@ LONG_DOUBLE holtwinters(const LONG_DOUBLE *series, size_t entries, LONG_DOUBLE a
444
estimated_season
445
);
446
439
- LONG_DOUBLE value = estimated_level[nb_computations - 1];
447
+ NETDATA_DOUBLE value = estimated_level[nb_computations - 1];
448
449
if(forecast)
450
*forecast = 0.0;
libnetdata/statistical/statistical.h
+24
-16
@@ -5,22 +5,30 @@
5
6
#include "../libnetdata.h"
7
8
-extern void log_series_to_stderr(LONG_DOUBLE *series, size_t entries, calculated_number result, const char *msg);
8
+extern void log_series_to_stderr(NETDATA_DOUBLE *series, size_t entries, NETDATA_DOUBLE result, const char *msg);
9
10
-extern LONG_DOUBLE average(const LONG_DOUBLE *series, size_t entries);
11
-extern LONG_DOUBLE moving_average(const LONG_DOUBLE *series, size_t entries, size_t period);
12
-extern LONG_DOUBLE median(const LONG_DOUBLE *series, size_t entries);
13
-extern LONG_DOUBLE moving_median(const LONG_DOUBLE *series, size_t entries, size_t period);
14
-extern LONG_DOUBLE running_median_estimate(const LONG_DOUBLE *series, size_t entries);
15
-extern LONG_DOUBLE standard_deviation(const LONG_DOUBLE *series, size_t entries);
16
-extern LONG_DOUBLE single_exponential_smoothing(const LONG_DOUBLE *series, size_t entries, LONG_DOUBLE alpha);
17
-extern LONG_DOUBLE single_exponential_smoothing_reverse(const LONG_DOUBLE *series, size_t entries, LONG_DOUBLE alpha);
18
-extern LONG_DOUBLE double_exponential_smoothing(const LONG_DOUBLE *series, size_t entries, LONG_DOUBLE alpha, LONG_DOUBLE beta, LONG_DOUBLE *forecast);
19
-extern LONG_DOUBLE holtwinters(const LONG_DOUBLE *series, size_t entries, LONG_DOUBLE alpha, LONG_DOUBLE beta, LONG_DOUBLE gamma, LONG_DOUBLE *forecast);
20
-extern LONG_DOUBLE sum_and_count(const LONG_DOUBLE *series, size_t entries, size_t *count);
21
-extern LONG_DOUBLE sum(const LONG_DOUBLE *series, size_t entries);
22
-extern LONG_DOUBLE median_on_sorted_series(const LONG_DOUBLE *series, size_t entries);
23
-extern LONG_DOUBLE *copy_series(const LONG_DOUBLE *series, size_t entries);
24
-extern void sort_series(LONG_DOUBLE *series, size_t entries);
10
+extern NETDATA_DOUBLE average(const NETDATA_DOUBLE *series, size_t entries);
11
+extern NETDATA_DOUBLE moving_average(const NETDATA_DOUBLE *series, size_t entries, size_t period);
12
+extern NETDATA_DOUBLE median(const NETDATA_DOUBLE *series, size_t entries);
13
+extern NETDATA_DOUBLE moving_median(const NETDATA_DOUBLE *series, size_t entries, size_t period);
14
+extern NETDATA_DOUBLE running_median_estimate(const NETDATA_DOUBLE *series, size_t entries);
15
+extern NETDATA_DOUBLE standard_deviation(const NETDATA_DOUBLE *series, size_t entries);
16
+extern NETDATA_DOUBLE single_exponential_smoothing(const NETDATA_DOUBLE *series, size_t entries, NETDATA_DOUBLE alpha);
17
+extern NETDATA_DOUBLE
18
+single_exponential_smoothing_reverse(const NETDATA_DOUBLE *series, size_t entries, NETDATA_DOUBLE alpha);
19
+extern NETDATA_DOUBLE double_exponential_smoothing(const NETDATA_DOUBLE *series, size_t entries,
20
+ NETDATA_DOUBLE alpha,
21
+ NETDATA_DOUBLE beta,
22
+ NETDATA_DOUBLE *forecast);
23
+extern NETDATA_DOUBLE holtwinters(const NETDATA_DOUBLE *series, size_t entries,
24
+ NETDATA_DOUBLE alpha,
25
+ NETDATA_DOUBLE beta,
26
+ NETDATA_DOUBLE gamma,
27
+ NETDATA_DOUBLE *forecast);
28
+extern NETDATA_DOUBLE sum_and_count(const NETDATA_DOUBLE *series, size_t entries, size_t *count);
29
+extern NETDATA_DOUBLE sum(const NETDATA_DOUBLE *series, size_t entries);
30
+extern NETDATA_DOUBLE median_on_sorted_series(const NETDATA_DOUBLE *series, size_t entries);
31
+extern NETDATA_DOUBLE *copy_series(const NETDATA_DOUBLE *series, size_t entries);
32
+extern void sort_series(NETDATA_DOUBLE *series, size_t entries);
33
34
#endif //NETDATA_STATISTICAL_H
libnetdata/storage_number/storage_number.c
+17
-17
@@ -2,7 +2,7 @@
2
3
#include "../libnetdata.h"
4
5
-storage_number pack_storage_number(calculated_number value, SN_FLAGS flags) {
5
+storage_number pack_storage_number(NETDATA_DOUBLE value, SN_FLAGS flags) {
6
// bit 32 = sign 0:positive, 1:negative
7
// bit 31 = 0:divide, 1:multiply
8
// bit 30, 29, 28 = (multiplier or divider) 0-7 (8 total)
@@ -19,7 +19,7 @@ storage_number pack_storage_number(calculated_number value, SN_FLAGS flags) {
19
goto RET_SN;
20
21
int m = 0;
22
- calculated_number n = value, factor = 10;
22
+ NETDATA_DOUBLE n = value, factor = 10;
23
24
// if the value is negative
25
// add the sign bit and make it positive
@@ -36,7 +36,7 @@ storage_number pack_storage_number(calculated_number value, SN_FLAGS flags) {
36
// make its integer part fit in 0x00ffffff
37
// by dividing it by 10 up to 7 times
38
// and increasing the multiplier
39
- while(m < 7 && n > (calculated_number)0x00ffffff) {
39
+ while(m < 7 && n > (NETDATA_DOUBLE)0x00ffffff) {
40
n /= factor;
41
m++;
42
}
@@ -46,9 +46,9 @@ storage_number pack_storage_number(calculated_number value, SN_FLAGS flags) {
46
// so we add a multiplier to unpack it
47
r += (1 << 30) + (m << 27); // the multiplier m
48
49
- if(n > (calculated_number)0x00ffffff) {
49
+ if(n > (NETDATA_DOUBLE)0x00ffffff) {
50
#ifdef NETDATA_INTERNAL_CHECKS
51
- error("Number " CALCULATED_NUMBER_FORMAT " is too big.", value);
51
+ error("Number " NETDATA_DOUBLE_FORMAT " is too big.", value);
52
#endif
53
r += 0x00ffffff;
54
goto RET_SN;
@@ -60,12 +60,12 @@ storage_number pack_storage_number(calculated_number value, SN_FLAGS flags) {
60
// while the value is below 0x0019999e we can
61
// multiply it by 10, up to 7 times, increasing
62
// the multiplier
63
- while(m < 7 && n < (calculated_number)0x0019999e) {
63
+ while(m < 7 && n < (NETDATA_DOUBLE)0x0019999e) {
64
n *= 10;
65
m++;
66
}
67
68
- if (unlikely(n > (calculated_number) (0x00ffffff))) {
68
+ if (unlikely(n > (NETDATA_DOUBLE) (0x00ffffff))) {
69
n /= 10;
70
m--;
71
}
@@ -90,7 +90,7 @@ RET_SN:
90
}
91
92
// Lookup table to make storage number unpacking efficient.
93
-calculated_number unpack_storage_number_lut10x[4 * 8];
93
+NETDATA_DOUBLE unpack_storage_number_lut10x[4 * 8];
94
95
__attribute__((constructor)) void initialize_lut(void) {
96
// The lookup table is partitioned in 4 subtables based on the
@@ -107,7 +107,7 @@ __attribute__((constructor)) void initialize_lut(void) {
107
}
108
109
/*
110
-int print_calculated_number(char *str, calculated_number value)
110
+int print_netdata_double(char *str, NETDATA_DOUBLE value)
111
{
112
char *wstr = str;
113
@@ -117,9 +117,9 @@ int print_calculated_number(char *str, calculated_number value)
117
#ifdef STORAGE_WITH_MATH
118
// without llrintl() there are rounding problems
119
// for example 0.9 becomes 0.89
120
- unsigned long long uvalue = (unsigned long long int) llrintl(value * (calculated_number)100000);
120
+ unsigned long long uvalue = (unsigned long long int) llrintl(value * (NETDATA_DOUBLE)100000);
121
#else
122
- unsigned long long uvalue = value * (calculated_number)100000;
122
+ unsigned long long uvalue = value * (NETDATA_DOUBLE)100000;
123
#endif
124
125
wstr = print_number_llu_r_smart(str, uvalue);
@@ -163,8 +163,8 @@ int print_calculated_number(char *str, calculated_number value)
163
}
164
*/
165
166
-int print_calculated_number(char *str, calculated_number value) {
167
- // info("printing number " CALCULATED_NUMBER_FORMAT, value);
166
+int print_netdata_double(char *str, NETDATA_DOUBLE value) {
167
+ // info("printing number " NETDATA_DOUBLE_FORMAT, value);
168
char integral_str[50], fractional_str[50];
169
170
char *wstr = str;
@@ -174,22 +174,22 @@ int print_calculated_number(char *str, calculated_number value) {
174
value = -value;
175
}
176
177
- calculated_number integral, fractional;
177
+ NETDATA_DOUBLE integral, fractional;
178
179
#ifdef STORAGE_WITH_MATH
180
- fractional = calculated_number_modf(value, &integral) * 10000000.0;
180
+ fractional = modfndd(value, &integral) * 10000000.0;
181
#else
182
fractional = ((unsigned long long)(value * 10000000ULL) % 10000000ULL);
183
#endif
184
185
unsigned long long integral_int = (unsigned long long)integral;
186
- unsigned long long fractional_int = (unsigned long long)calculated_number_llrint(fractional);
186
+ unsigned long long fractional_int = (unsigned long long)llrintndd(fractional);
187
if(unlikely(fractional_int >= 10000000)) {
188
integral_int += 1;
189
fractional_int -= 10000000;
190
}
191
192
- // info("integral " CALCULATED_NUMBER_FORMAT " (%llu), fractional " CALCULATED_NUMBER_FORMAT " (%llu)", integral, integral_int, fractional, fractional_int);
192
+ // info("integral " NETDATA_DOUBLE_FORMAT " (%llu), fractional " NETDATA_DOUBLE_FORMAT " (%llu)", integral, integral_int, fractional, fractional_int);
193
194
char *istre;
195
if(unlikely(integral_int == 0)) {
libnetdata/storage_number/storage_number.h
+121
-58
@@ -6,68 +6,60 @@
6
#include <math.h>
7
#include "../libnetdata.h"
8
9
-#ifdef NETDATA_WITHOUT_LONG_DOUBLE
10
-
11
-#define powl pow
12
-#define modfl modf
13
-#define llrintl llrint
14
-#define roundl round
15
-#define sqrtl sqrt
16
-#define copysignl copysign
17
-#define strtold strtod
18
-
19
-typedef double calculated_number;
20
-#define CALCULATED_NUMBER_FORMAT "%0.7f"
21
-#define CALCULATED_NUMBER_FORMAT_ZERO "%0.0f"
22
-#define CALCULATED_NUMBER_FORMAT_AUTO "%f"
23
-
24
-#define LONG_DOUBLE_MODIFIER "f"
25
-typedef double LONG_DOUBLE;
26
-
27
-#define CALCULATED_NUMBER_MAX DBL_MAX
28
-
29
-#else // NETDATA_WITHOUT_LONG_DOUBLE
30
-
31
-typedef long double calculated_number;
32
-#define CALCULATED_NUMBER_FORMAT "%0.7Lf"
33
-#define CALCULATED_NUMBER_FORMAT_ZERO "%0.0Lf"
34
-#define CALCULATED_NUMBER_FORMAT_AUTO "%Lf"
35
-
36
-#define LONG_DOUBLE_MODIFIER "Lf"
37
-typedef long double LONG_DOUBLE;
38
-
39
-#define CALCULATED_NUMBER_MAX LDBL_MAX
40
-
41
-#endif // NETDATA_WITHOUT_LONG_DOUBLE
42
-
43
-//typedef long long calculated_number;
44
-//#define CALCULATED_NUMBER_FORMAT "%lld"
9
+#ifdef NETDATA_WITH_LONG_DOUBLE
10
+
11
+typedef long double NETDATA_DOUBLE;
12
+#define NETDATA_DOUBLE_FORMAT "%0.7Lf"
13
+#define NETDATA_DOUBLE_FORMAT_ZERO "%0.0Lf"
14
+#define NETDATA_DOUBLE_FORMAT_AUTO "%Lf"
15
+#define NETDATA_DOUBLE_MODIFIER "Lf"
16
+
17
+#define NETDATA_DOUBLE_MAX LDBL_MAX
18
+
19
+#define strtondd(s, endptr) strtold(s, endptr)
20
+#define powndd(x, y) powl(x, y)
21
+#define llrintndd(x) llrintl(x)
22
+#define roundndd(x) roundl(x)
23
+#define sqrtndd(x) sqrtl(x)
24
+#define copysignndd(x, y) copysignl(x, y)
25
+#define modfndd(x, y) modfl(x, y)
26
+#define fabsndd(x) fabsl(x)
27
+
28
+#else // NETDATA_WITH_LONG_DOUBLE
29
+
30
+typedef double NETDATA_DOUBLE;
31
+#define NETDATA_DOUBLE_FORMAT "%0.7f"
32
+#define NETDATA_DOUBLE_FORMAT_ZERO "%0.0f"
33
+#define NETDATA_DOUBLE_FORMAT_AUTO "%f"
34
+#define NETDATA_DOUBLE_MODIFIER "f"
35
+
36
+#define NETDATA_DOUBLE_MAX DBL_MAX
37
+
38
+#define strtondd(s, endptr) strtod(s, endptr)
39
+#define powndd(x, y) pow(x, y)
40
+#define llrintndd(x) llrint(x)
41
+#define roundndd(x) round(x)
42
+#define sqrtndd(x) sqrt(x)
43
+#define copysignndd(x, y) copysign(x, y)
44
+#define modfndd(x, y) modf(x, y)
45
+#define fabsndd(x) fabs(x)
46
+
47
+#endif // NETDATA_WITH_LONG_DOUBLE
48
49
typedef long long collected_number;
50
#define COLLECTED_NUMBER_FORMAT "%lld"
51
49
-/*
50
-typedef long double collected_number;
51
-#define COLLECTED_NUMBER_FORMAT "%0.7Lf"
52
-*/
53
-
54
-#define calculated_number_modf(x, y) modfl(x, y)
55
-#define calculated_number_llrint(x) llrintl(x)
56
-#define calculated_number_round(x) roundl(x)
57
-#define calculated_number_fabs(x) fabsl(x)
58
-#define calculated_number_pow(x, y) powl(x, y)
59
-#define calculated_number_epsilon (calculated_number)0.0000001
60
-
61
-#define calculated_number_equal(a, b) (calculated_number_fabs((a) - (b)) < calculated_number_epsilon)
52
+#define epsilonndd (NETDATA_DOUBLE)0.0000001
53
+#define considered_equal_ndd(a, b) (fabsndd((a) - (b)) < epsilonndd)
54
55
#if defined(HAVE_ISFINITE) || defined(isfinite)
56
// The isfinite() macro shall determine whether its argument has a
57
// finite value (zero, subnormal, or normal, and not infinite or NaN).
66
-#define calculated_number_isnumber(a) (isfinite(a))
58
+#define netdata_double_isnumber(a) (isfinite(a))
59
#elif defined(HAVE_FINITE) || defined(finite)
68
-#define calculated_number_isnumber(a) (finite(a))
60
+#define netdata_double_isnumber(a) (finite(a))
61
#else
70
-#define calculated_number_isnumber(a) (fpclassify(a) != FP_NAN && fpclassify(a) != FP_INFINITE)
62
+#define netdata_double_isnumber(a) (fpclassify(a) != FP_NAN && fpclassify(a) != FP_INFINITE)
63
#endif
64
65
typedef uint32_t storage_number;
@@ -95,10 +87,10 @@ typedef enum {
87
#define does_storage_number_exist(value) (((storage_number) (value)) != SN_EMPTY_SLOT)
88
#define did_storage_number_reset(value) ((((storage_number) (value)) & SN_EXISTS_RESET) != 0)
89
98
-storage_number pack_storage_number(calculated_number value, SN_FLAGS flags);
99
-static inline calculated_number unpack_storage_number(storage_number value) __attribute__((const));
90
+storage_number pack_storage_number(NETDATA_DOUBLE value, SN_FLAGS flags);
91
+static inline NETDATA_DOUBLE unpack_storage_number(storage_number value) __attribute__((const));
92
101
-int print_calculated_number(char *str, calculated_number value);
93
+int print_netdata_double(char *str, NETDATA_DOUBLE value);
94
95
// sign div/mul <--- multiplier / divider ---> 10/100 RESET EXISTS VALUE
96
#define STORAGE_NUMBER_POSITIVE_MAX_RAW (storage_number)( (0 << 31) | (1 << 30) | (1 << 29) | (1 << 28) | (1<<27) | (1 << 26) | (0 << 25) | (1 << 24) | 0x00ffffff )
@@ -115,8 +107,8 @@ int print_calculated_number(char *str, calculated_number value);
107
#define MAX_INCREMENTAL_PERCENT_RATE 10
108
109
118
-static inline calculated_number unpack_storage_number(storage_number value) {
119
- extern calculated_number unpack_storage_number_lut10x[4 * 8];
110
+static inline NETDATA_DOUBLE unpack_storage_number(storage_number value) {
111
+ extern NETDATA_DOUBLE unpack_storage_number_lut10x[4 * 8];
112
113
if(unlikely(value == SN_EMPTY_SLOT))
114
return NAN;
@@ -145,11 +137,82 @@ static inline calculated_number unpack_storage_number(storage_number value) {
137
// bit 24 to bit 1 = the value, so remove all other bits
138
value ^= value & ((1<<31)|(1<<30)|(1<<29)|(1<<28)|(1<<27)|(1<<26)|(1<<25)|(1<<24));
139
148
- calculated_number n = value;
140
+ NETDATA_DOUBLE n = value;
141
142
// fprintf(stderr, "UNPACK: %08X, sign = %d, exp = %d, mul = %d, factor = %d, n = " CALCULATED_NUMBER_FORMAT "\n", value, sign, exp, mul, factor, n);
143
144
return sign * unpack_storage_number_lut10x[(factor * 16) + (exp * 8) + mul] * n;
145
}
146
147
+static inline NETDATA_DOUBLE str2ndd(const char *s, char **endptr) {
148
+ int negative = 0;
149
+ const char *start = s;
150
+ unsigned long long integer_part = 0;
151
+ unsigned long decimal_part = 0;
152
+ size_t decimal_digits = 0;
153
+
154
+ switch(*s) {
155
+ case '-':
156
+ s++;
157
+ negative = 1;
158
+ break;
159
+
160
+ case '+':
161
+ s++;
162
+ break;
163
+
164
+ case 'n':
165
+ if(s[1] == 'a' && s[2] == 'n') {
166
+ if(endptr) *endptr = (char *)&s[3];
167
+ return NAN;
168
+ }
169
+ break;
170
+
171
+ case 'i':
172
+ if(s[1] == 'n' && s[2] == 'f') {
173
+ if(endptr) *endptr = (char *)&s[3];
174
+ return INFINITY;
175
+ }
176
+ break;
177
+
178
+ default:
179
+ break;
180
+ }
181
+
182
+ while (*s >= '0' && *s <= '9') {
183
+ integer_part = (integer_part * 10) + (*s - '0');
184
+ s++;
185
+ }
186
+
187
+ if(unlikely(*s == '.')) {
188
+ decimal_part = 0;
189
+ s++;
190
+
191
+ while (*s >= '0' && *s <= '9') {
192
+ decimal_part = (decimal_part * 10) + (*s - '0');
193
+ s++;
194
+ decimal_digits++;
195
+ }
196
+ }
197
+
198
+ if(unlikely(*s == 'e' || *s == 'E'))
199
+ return strtondd(start, endptr);
200
+
201
+ if(unlikely(endptr))
202
+ *endptr = (char *)s;
203
+
204
+ if(unlikely(negative)) {
205
+ if(unlikely(decimal_digits))
206
+ return -((NETDATA_DOUBLE)integer_part + (NETDATA_DOUBLE)decimal_part / powndd(10.0, decimal_digits));
207
+ else
208
+ return -((NETDATA_DOUBLE)integer_part);
209
+ }
210
+ else {
211
+ if(unlikely(decimal_digits))
212
+ return (NETDATA_DOUBLE)integer_part + (NETDATA_DOUBLE)decimal_part / powndd(10.0, decimal_digits);
213
+ else
214
+ return (NETDATA_DOUBLE)integer_part;
215
+ }
216
+}
217
+
218
#endif /* NETDATA_STORAGE_NUMBER_H */
libnetdata/storage_number/tests/test_storage_number.c
+10
-10
@@ -11,34 +11,34 @@ static void test_number_printing(void **state)
11
12
char value[50];
13
14
- print_calculated_number(value, 0);
14
+ print_netdata_double(value, 0);
15
assert_string_equal(value, "0");
16
17
- print_calculated_number(value, 0.0000001);
17
+ print_netdata_double(value, 0.0000001);
18
assert_string_equal(value, "0.0000001");
19
20
- print_calculated_number(value, 0.00000009);
20
+ print_netdata_double(value, 0.00000009);
21
assert_string_equal(value, "0.0000001");
22
23
- print_calculated_number(value, 0.000000001);
23
+ print_netdata_double(value, 0.000000001);
24
assert_string_equal(value, "0");
25
26
- print_calculated_number(value, 99.99999999999999999);
26
+ print_netdata_double(value, 99.99999999999999999);
27
assert_string_equal(value, "100");
28
29
- print_calculated_number(value, -99.99999999999999999);
29
+ print_netdata_double(value, -99.99999999999999999);
30
assert_string_equal(value, "-100");
31
32
- print_calculated_number(value, 123.4567890123456789);
32
+ print_netdata_double(value, 123.4567890123456789);
33
assert_string_equal(value, "123.456789");
34
35
- print_calculated_number(value, 9999.9999999);
35
+ print_netdata_double(value, 9999.9999999);
36
assert_string_equal(value, "9999.9999999");
37
38
- print_calculated_number(value, -9999.9999999);
38
+ print_netdata_double(value, -9999.9999999);
39
assert_string_equal(value, "-9999.9999999");
40
41
- print_calculated_number(value, unpack_storage_number(pack_storage_number(16.777218L, SN_DEFAULT_FLAGS)));
41
+ print_netdata_double(value, unpack_storage_number(pack_storage_number(16.777218L, SN_DEFAULT_FLAGS)));
42
assert_string_equal(value, "16.77722");
43
}
44
libnetdata/tests/test_str2ld.c
+2
-2
@@ -24,8 +24,8 @@ static void test_str2ld(void **state)
24
25
for (int i = 0; values[i]; i++) {
26
char *e_mine = "hello", *e_sys = "world";
27
- LONG_DOUBLE mine = str2ld(values[i], &e_mine);
28
- LONG_DOUBLE sys = strtold(values[i], &e_sys);
27
+ NETDATA_DOUBLE mine = str2ndd(values[i], &e_mine);
28
+ NETDATA_DOUBLE sys = strtondd(values[i], &e_sys);
29
30
if (isnan(mine))
31
assert_true(isnan(sys));
ml/Dimension.cc
+1
-1
@@ -42,7 +42,7 @@ TrainableDimension::getCalculatedNumbers() {
42
auto P = Q.nextMetric();
43
CalculatedNumber Value = P.second;
44
45
- if (calculated_number_isnumber(Value)) {
45
+ if (netdata_double_isnumber(Value)) {
46
CNs[Idx] = Value;
47
LastValue = CNs[Idx];
48
CollectedValues++;
ml/ml.cc
+2
-2
@@ -186,10 +186,10 @@ void ml_process_rrdr(RRDR *R, int MaxAnomalyRates) {
186
if (MaxAnomalyRates < 1 || MaxAnomalyRates >= R->d)
187
return;
188
189
- calculated_number *CNs = R->v;
189
+ NETDATA_DOUBLE *CNs = R->v;
190
RRDR_DIMENSION_FLAGS *DimFlags = R->od;
191
192
- std::vector<std::pair<calculated_number, int>> V;
192
+ std::vector<std::pair<NETDATA_DOUBLE, int>> V;
193
194
V.reserve(R->d);
195
for (int Idx = 0; Idx != R->d; Idx++)
parser/parser.h
+1
-1
@@ -28,7 +28,7 @@ typedef struct pluginsd_action {
28
29
PARSER_RC (*flush_action)(void *user, RRDSET *st);
30
PARSER_RC (*disable_action)(void *user);
31
- PARSER_RC (*variable_action)(void *user, RRDHOST *host, RRDSET *st, char *name, int global, calculated_number value);
31
+ PARSER_RC (*variable_action)(void *user, RRDHOST *host, RRDSET *st, char *name, int global, NETDATA_DOUBLE value);
32
PARSER_RC (*label_action)(void *user, char *key, char *value, RRDLABEL_SRC source);
33
PARSER_RC (*overwrite_action)(void *user, RRDHOST *host, DICTIONARY *new_labels);
34
PARSER_RC (*clabel_action)(void *user, char *key, char *value, RRDLABEL_SRC source);
streaming/rrdpush.c
+7
-6
@@ -75,7 +75,8 @@ int rrdpush_init() {
75
default_rrdpush_destination = appconfig_get(&stream_config, CONFIG_SECTION_STREAM, "destination", "");
76
default_rrdpush_api_key = appconfig_get(&stream_config, CONFIG_SECTION_STREAM, "api key", "");
77
default_rrdpush_send_charts_matching = appconfig_get(&stream_config, CONFIG_SECTION_STREAM, "send charts matching", "*");
78
- rrdhost_free_orphan_time = config_get_number(CONFIG_SECTION_GLOBAL, "cleanup orphan hosts after seconds", rrdhost_free_orphan_time);
78
+ rrdhost_free_orphan_time = config_get_number(CONFIG_SECTION_DB, "cleanup orphan hosts after secs", rrdhost_free_orphan_time);
79
+
80
#ifdef ENABLE_COMPRESSION
81
default_compression_enabled = (unsigned int)appconfig_get_boolean(&stream_config, CONFIG_SECTION_STREAM,
82
"enable compression", default_compression_enabled);
@@ -97,10 +98,10 @@ int rrdpush_init() {
98
}
99
}
100
100
- char *invalid_certificate = appconfig_get(&stream_config, CONFIG_SECTION_STREAM, "ssl skip certificate verification", "no");
101
+ bool invalid_certificate = appconfig_get_boolean(&stream_config, CONFIG_SECTION_STREAM, "ssl skip certificate verification", CONFIG_BOOLEAN_NO);
102
102
- if ( !strcmp(invalid_certificate,"yes")){
103
- if (netdata_validate_server == NETDATA_SSL_VALID_CERTIFICATE){
103
+ if(invalid_certificate == CONFIG_BOOLEAN_YES){
104
+ if(netdata_validate_server == NETDATA_SSL_VALID_CERTIFICATE){
105
info("Netdata is configured to accept invalid SSL certificate.");
106
netdata_validate_server = NETDATA_SSL_INVALID_CERTIFICATE;
107
}
@@ -272,11 +273,11 @@ static inline void rrdpush_send_chart_definition_nolock(RRDSET *st) {
273
RRDSETVAR *rs;
274
for(rs = st->variables; rs ;rs = rs->next) {
275
if(unlikely(rs->type == RRDVAR_TYPE_CALCULATED && rs->options & RRDVAR_OPTION_CUSTOM_CHART_VAR)) {
275
- calculated_number *value = (calculated_number *) rs->value;
276
+ NETDATA_DOUBLE *value = (NETDATA_DOUBLE *) rs->value;
277
278
buffer_sprintf(
279
host->sender->build
279
- , "VARIABLE CHART %s = " CALCULATED_NUMBER_FORMAT "\n"
280
+ , "VARIABLE CHART %s = " NETDATA_DOUBLE_FORMAT "\n"
281
, rs->variable
282
, *value
283
);
streaming/sender.c
+3
-3
@@ -89,16 +89,16 @@ static inline void rrdpush_sender_thread_close_socket(RRDHOST *host) {
89
}
90
91
static inline void rrdpush_sender_add_host_variable_to_buffer_nolock(RRDHOST *host, RRDVAR *rv) {
92
- calculated_number *value = (calculated_number *)rv->value;
92
+ NETDATA_DOUBLE *value = (NETDATA_DOUBLE *)rv->value;
93
94
buffer_sprintf(
95
host->sender->build
96
- , "VARIABLE HOST %s = " CALCULATED_NUMBER_FORMAT "\n"
96
+ , "VARIABLE HOST %s = " NETDATA_DOUBLE_FORMAT "\n"
97
, rv->name
98
, *value
99
);
100
101
- debug(D_STREAM, "RRDVAR pushed HOST VARIABLE %s = " CALCULATED_NUMBER_FORMAT, rv->name, *value);
101
+ debug(D_STREAM, "RRDVAR pushed HOST VARIABLE %s = " NETDATA_DOUBLE_FORMAT, rv->name, *value);
102
}
103
104
void rrdpush_sender_send_this_host_variable_now(RRDHOST *host, RRDVAR *rv) {
tests/profile/test-eval.c
+5
-5
@@ -58,9 +58,9 @@ void print_node(EVAL_NODE *op, int level) {
58
while(i--) print_value(&op->ops[i], level + 1);
59
}
60
61
-calculated_number evaluate(EVAL_NODE *op, int depth);
61
+NETDATA_DOUBLE evaluate(EVAL_NODE *op, int depth);
62
63
-calculated_number evaluate_value(EVAL_VALUE *v, int depth) {
63
+NETDATA_DOUBLE evaluate_value(EVAL_VALUE *v, int depth) {
64
switch(v->type) {
65
case EVAL_VALUE_NUMBER:
66
return v->number;
@@ -80,8 +80,8 @@ void print_depth(int depth) {
80
while(depth--) printf(" ");
81
}
82
83
-calculated_number evaluate(EVAL_NODE *op, int depth) {
84
- calculated_number n1, n2, r;
83
+NETDATA_DOUBLE evaluate(EVAL_NODE *op, int depth) {
84
+ NETDATA_DOUBLE n1, n2, r;
85
86
switch(op->operator) {
87
case EVAL_OPERATOR_SIGN_PLUS:
@@ -249,7 +249,7 @@ void print_expression(EVAL_NODE *op, const char *failed_at, int error) {
249
evaluate(op, 0);
250
251
int error;
252
- calculated_number ret = expression_evaluate(op, &error);
252
+ NETDATA_DOUBLE ret = expression_evaluate(op, &error);
253
printf("\ninternal evaluator:\nSTATUS: %d, RESULT = %Lf\n", error, ret);
254
255
expression_free(op);
web/api/badges/web_buffer_svg.c
+21
-18
@@ -249,7 +249,8 @@ cleanup:
249
return len - i;
250
}
251
252
-static inline char *format_value_with_precision_and_unit(char *value_string, size_t value_string_len, calculated_number value, const char *units, int precision) {
252
+static inline char *format_value_with_precision_and_unit(char *value_string, size_t value_string_len,
253
+ NETDATA_DOUBLE value, const char *units, int precision) {
254
if(unlikely(isnan(value) || isinf(value)))
255
value = 0.0;
256
@@ -260,23 +261,23 @@ static inline char *format_value_with_precision_and_unit(char *value_string, siz
261
if(precision < 0) {
262
int len, lstop = 0, trim_zeros = 1;
263
263
- calculated_number abs = value;
264
+ NETDATA_DOUBLE abs = value;
265
if(isless(value, 0)) {
266
lstop = 1;
266
- abs = calculated_number_fabs(value);
267
+ abs = fabsndd(value);
268
}
269
270
if(isgreaterequal(abs, 1000)) {
270
- len = snprintfz(value_string, value_string_len, "%0.0" LONG_DOUBLE_MODIFIER, (LONG_DOUBLE) value);
271
+ len = snprintfz(value_string, value_string_len, "%0.0" NETDATA_DOUBLE_MODIFIER, (NETDATA_DOUBLE) value);
272
trim_zeros = 0;
273
}
273
- else if(isgreaterequal(abs, 10)) len = snprintfz(value_string, value_string_len, "%0.1" LONG_DOUBLE_MODIFIER, (LONG_DOUBLE) value);
274
- else if(isgreaterequal(abs, 1)) len = snprintfz(value_string, value_string_len, "%0.2" LONG_DOUBLE_MODIFIER, (LONG_DOUBLE) value);
275
- else if(isgreaterequal(abs, 0.1)) len = snprintfz(value_string, value_string_len, "%0.2" LONG_DOUBLE_MODIFIER, (LONG_DOUBLE) value);
276
- else if(isgreaterequal(abs, 0.01)) len = snprintfz(value_string, value_string_len, "%0.4" LONG_DOUBLE_MODIFIER, (LONG_DOUBLE) value);
277
- else if(isgreaterequal(abs, 0.001)) len = snprintfz(value_string, value_string_len, "%0.5" LONG_DOUBLE_MODIFIER, (LONG_DOUBLE) value);
278
- else if(isgreaterequal(abs, 0.0001)) len = snprintfz(value_string, value_string_len, "%0.6" LONG_DOUBLE_MODIFIER, (LONG_DOUBLE) value);
279
- else len = snprintfz(value_string, value_string_len, "%0.7" LONG_DOUBLE_MODIFIER, (LONG_DOUBLE) value);
274
+ else if(isgreaterequal(abs, 10)) len = snprintfz(value_string, value_string_len, "%0.1" NETDATA_DOUBLE_MODIFIER, (NETDATA_DOUBLE) value);
275
+ else if(isgreaterequal(abs, 1)) len = snprintfz(value_string, value_string_len, "%0.2" NETDATA_DOUBLE_MODIFIER, (NETDATA_DOUBLE) value);
276
+ else if(isgreaterequal(abs, 0.1)) len = snprintfz(value_string, value_string_len, "%0.2" NETDATA_DOUBLE_MODIFIER, (NETDATA_DOUBLE) value);
277
+ else if(isgreaterequal(abs, 0.01)) len = snprintfz(value_string, value_string_len, "%0.4" NETDATA_DOUBLE_MODIFIER, (NETDATA_DOUBLE) value);
278
+ else if(isgreaterequal(abs, 0.001)) len = snprintfz(value_string, value_string_len, "%0.5" NETDATA_DOUBLE_MODIFIER, (NETDATA_DOUBLE) value);
279
+ else if(isgreaterequal(abs, 0.0001)) len = snprintfz(value_string, value_string_len, "%0.6" NETDATA_DOUBLE_MODIFIER, (NETDATA_DOUBLE) value);
280
+ else len = snprintfz(value_string, value_string_len, "%0.7" NETDATA_DOUBLE_MODIFIER, (NETDATA_DOUBLE) value);
281
282
if(unlikely(trim_zeros)) {
283
int l;
@@ -303,7 +304,7 @@ static inline char *format_value_with_precision_and_unit(char *value_string, siz
304
}
305
else {
306
if(precision > 50) precision = 50;
306
- snprintfz(value_string, value_string_len, "%0.*" LONG_DOUBLE_MODIFIER "%s%s", precision, (LONG_DOUBLE) value, separator, units);
307
+ snprintfz(value_string, value_string_len, "%0.*" NETDATA_DOUBLE_MODIFIER "%s%s", precision, (NETDATA_DOUBLE) value, separator, units);
308
}
309
310
return value_string;
@@ -359,7 +360,8 @@ static struct units_formatter {
360
{ NULL, 0, UNITS_FORMAT_NONE }
361
};
362
362
-inline char *format_value_and_unit(char *value_string, size_t value_string_len, calculated_number value, const char *units, int precision) {
363
+inline char *format_value_and_unit(char *value_string, size_t value_string_len,
364
+ NETDATA_DOUBLE value, const char *units, int precision) {
365
static int max = -1;
366
int i;
367
@@ -555,7 +557,7 @@ typedef enum color_comparison {
557
COLOR_COMPARE_GREATEREQUAL,
558
} BADGE_COLOR_COMPARISON;
559
558
-static inline void calc_colorz(const char *color, char *final, size_t len, calculated_number value) {
560
+static inline void calc_colorz(const char *color, char *final, size_t len, NETDATA_DOUBLE value) {
561
if(isnan(value) || isinf(value))
562
value = NAN;
563
@@ -642,7 +644,7 @@ static inline void calc_colorz(const char *color, char *final, size_t len, calcu
644
*dc = '\0';
645
if(dv) {
646
*dv = '\0';
645
- calculated_number v;
647
+ NETDATA_DOUBLE v;
648
649
if(!*value_buffer || !strcmp(value_buffer, "null")) {
650
v = NAN;
@@ -732,7 +734,8 @@ static const char *parse_color_argument(const char *arg, const char *def)
734
return color_map(arg, def);
735
}
736
735
-void buffer_svg(BUFFER *wb, const char *label, calculated_number value, const char *units, const char *label_color, const char *value_color, int precision, int scale, uint32_t options, int fixed_width_lbl, int fixed_width_val, const char* text_color_lbl, const char* text_color_val) {
737
+void buffer_svg(BUFFER *wb, const char *label,
738
+ NETDATA_DOUBLE value, const char *units, const char *label_color, const char *value_color, int precision, int scale, uint32_t options, int fixed_width_lbl, int fixed_width_val, const char* text_color_lbl, const char* text_color_val) {
739
char value_color_buffer[COLOR_STRING_SIZE + 1]
740
, value_string[VALUE_STRING_SIZE + 1]
741
, label_escaped[LABEL_STRING_SIZE + 1]
@@ -750,7 +753,7 @@ void buffer_svg(BUFFER *wb, const char *label, calculated_number value, const ch
753
value_color = (isnan(value) || isinf(value))?"999":"4c1";
754
755
calc_colorz(value_color, value_color_buffer, COLOR_STRING_SIZE, value);
753
- format_value_and_unit(value_string, VALUE_STRING_SIZE, (options & RRDR_OPTION_DISPLAY_ABS)?calculated_number_fabs(value):value, units, precision);
756
+ format_value_and_unit(value_string, VALUE_STRING_SIZE, (options & RRDR_OPTION_DISPLAY_ABS)? fabsndd(value):value, units, precision);
757
758
if(fixed_width_lbl <= 0 || fixed_width_val <= 0) {
759
label_width = verdana11_width(label, font_size) + (BADGE_HORIZONTAL_PADDING * 2);
@@ -1098,7 +1101,7 @@ int web_client_api_request_v1_badge(RRDHOST *host, struct web_client *w, char *u
1101
else {
1102
time_t latest_timestamp = 0;
1103
int value_is_null = 1;
1101
- calculated_number n = NAN;
1104
+ NETDATA_DOUBLE n = NAN;
1105
ret = HTTP_RESP_INTERNAL_SERVER_ERROR;
1106
1107
// if the collected value is too old, don't calculate its value
web/api/badges/web_buffer_svg.h
+4
-2
@@ -6,8 +6,10 @@
6
#include "libnetdata/libnetdata.h"
7
#include "web/server/web_client.h"
8
9
-extern void buffer_svg(BUFFER *wb, const char *label, calculated_number value, const char *units, const char *label_color, const char *value_color, int precision, int scale, uint32_t options, int fixed_width_lbl, int fixed_width_val, const char* text_color_lbl, const char* text_color_val);
10
-extern char *format_value_and_unit(char *value_string, size_t value_string_len, calculated_number value, const char *units, int precision);
9
+extern void buffer_svg(BUFFER *wb, const char *label,
10
+ NETDATA_DOUBLE value, const char *units, const char *label_color, const char *value_color, int precision, int scale, uint32_t options, int fixed_width_lbl, int fixed_width_val, const char* text_color_lbl, const char* text_color_val);
11
+extern char *format_value_and_unit(char *value_string, size_t value_string_len,
12
+ NETDATA_DOUBLE value, const char *units, int precision);
13
14
extern int web_client_api_request_v1_badge(struct rrdhost *host, struct web_client *w, char *url);
15
web/api/exporters/shell/allmetrics_shell.c
+10
-10
@@ -33,7 +33,7 @@ void rrd_stats_api_v1_charts_allmetrics_shell(RRDHOST *host, const char *filter_
33
if (filter && !simple_pattern_matches(filter, st->name))
34
continue;
35
36
- calculated_number total = 0.0;
36
+ NETDATA_DOUBLE total = 0.0;
37
char chart[SHELL_ELEMENT_MAX + 1];
38
shell_name_copy(chart, st->name?st->name:st->id, SHELL_ELEMENT_MAX);
39
@@ -48,21 +48,21 @@ void rrd_stats_api_v1_charts_allmetrics_shell(RRDHOST *host, const char *filter_
48
char dimension[SHELL_ELEMENT_MAX + 1];
49
shell_name_copy(dimension, rd->name?rd->name:rd->id, SHELL_ELEMENT_MAX);
50
51
- calculated_number n = rd->last_stored_value;
51
+ NETDATA_DOUBLE n = rd->last_stored_value;
52
53
if(isnan(n) || isinf(n))
54
buffer_sprintf(wb, "NETDATA_%s_%s=\"\" # %s\n", chart, dimension, st->units);
55
else {
56
if(rd->multiplier < 0 || rd->divisor < 0) n = -n;
57
- n = calculated_number_round(n);
57
+ n = roundndd(n);
58
if(!rrddim_flag_check(rd, RRDDIM_FLAG_HIDDEN)) total += n;
59
- buffer_sprintf(wb, "NETDATA_%s_%s=\"" CALCULATED_NUMBER_FORMAT_ZERO "\" # %s\n", chart, dimension, n, st->units);
59
+ buffer_sprintf(wb, "NETDATA_%s_%s=\"" NETDATA_DOUBLE_FORMAT_ZERO "\" # %s\n", chart, dimension, n, st->units);
60
}
61
}
62
}
63
64
- total = calculated_number_round(total);
65
- buffer_sprintf(wb, "NETDATA_%s_VISIBLETOTAL=\"" CALCULATED_NUMBER_FORMAT_ZERO "\" # %s\n", chart, total, st->units);
64
+ total = roundndd(total);
65
+ buffer_sprintf(wb, "NETDATA_%s_VISIBLETOTAL=\"" NETDATA_DOUBLE_FORMAT_ZERO "\" # %s\n", chart, total, st->units);
66
rrdset_unlock(st);
67
}
68
}
@@ -79,13 +79,13 @@ void rrd_stats_api_v1_charts_allmetrics_shell(RRDHOST *host, const char *filter_
79
char alarm[SHELL_ELEMENT_MAX + 1];
80
shell_name_copy(alarm, rc->name, SHELL_ELEMENT_MAX);
81
82
- calculated_number n = rc->value;
82
+ NETDATA_DOUBLE n = rc->value;
83
84
if(isnan(n) || isinf(n))
85
buffer_sprintf(wb, "NETDATA_ALARM_%s_%s_VALUE=\"\" # %s\n", chart, alarm, rc->units);
86
else {
87
- n = calculated_number_round(n);
88
- buffer_sprintf(wb, "NETDATA_ALARM_%s_%s_VALUE=\"" CALCULATED_NUMBER_FORMAT_ZERO "\" # %s\n", chart, alarm, n, rc->units);
87
+ n = roundndd(n);
88
+ buffer_sprintf(wb, "NETDATA_ALARM_%s_%s_VALUE=\"" NETDATA_DOUBLE_FORMAT_ZERO "\" # %s\n", chart, alarm, n, rc->units);
89
}
90
91
buffer_sprintf(wb, "NETDATA_ALARM_%s_%s_STATUS=\"%s\"\n", chart, alarm, rrdcalc_status2string(rc->status));
@@ -154,7 +154,7 @@ void rrd_stats_api_v1_charts_allmetrics_json(RRDHOST *host, const char *filter_s
154
if(isnan(rd->last_stored_value))
155
buffer_strcat(wb, "null");
156
else
157
- buffer_sprintf(wb, CALCULATED_NUMBER_FORMAT, rd->last_stored_value);
157
+ buffer_sprintf(wb, NETDATA_DOUBLE_FORMAT, rd->last_stored_value);
158
159
buffer_strcat(wb, "\n\t\t\t}");
160
web/api/formatters/csv/csv.c
+5
-5
@@ -63,9 +63,9 @@ void rrdr2csv(RRDR *r, BUFFER *wb, uint32_t format, RRDR_OPTIONS options, const
63
}
64
65
// for each line in the array
66
- calculated_number total = 1;
66
+ NETDATA_DOUBLE total = 1;
67
for(i = start; i != end ;i += step) {
68
- calculated_number *cn = &r->v[ i * r->d ];
68
+ NETDATA_DOUBLE *cn = &r->v[ i * r->d ];
69
RRDR_VALUE_FLAGS *co = &r->o[ i * r->d ];
70
71
buffer_strcat(wb, betweenlines);
@@ -75,7 +75,7 @@ void rrdr2csv(RRDR *r, BUFFER *wb, uint32_t format, RRDR_OPTIONS options, const
75
76
if((options & RRDR_OPTION_SECONDS) || (options & RRDR_OPTION_MILLISECONDS)) {
77
// print the timestamp of the line
78
- buffer_rrd_value(wb, (calculated_number)now);
78
+ buffer_rrd_value(wb, (NETDATA_DOUBLE)now);
79
// in ms
80
if(options & RRDR_OPTION_MILLISECONDS) buffer_strcat(wb, "000");
81
}
@@ -90,7 +90,7 @@ void rrdr2csv(RRDR *r, BUFFER *wb, uint32_t format, RRDR_OPTIONS options, const
90
if(unlikely(options & RRDR_OPTION_PERCENTAGE)) {
91
total = 0;
92
for(c = 0, d = temp_rd?temp_rd:r->st->dimensions; d && c < r->d ;c++, d = d->next) {
93
- calculated_number n = cn[c];
93
+ NETDATA_DOUBLE n = cn[c];
94
95
if(likely((options & RRDR_OPTION_ABSOLUTE) && n < 0))
96
n = -n;
@@ -109,7 +109,7 @@ void rrdr2csv(RRDR *r, BUFFER *wb, uint32_t format, RRDR_OPTIONS options, const
109
110
buffer_strcat(wb, separator);
111
112
- calculated_number n = cn[c];
112
+ NETDATA_DOUBLE n = cn[c];
113
114
if(co[c] & RRDR_VALUE_EMPTY) {
115
if(options & RRDR_OPTION_NULL2ZERO)
web/api/formatters/json/json.c
+7
-7
@@ -158,9 +158,9 @@ void rrdr2json(RRDR *r, BUFFER *wb, RRDR_OPTIONS options, int datatable, struct
158
);
159
160
// for each line in the array
161
- calculated_number total = 1;
161
+ NETDATA_DOUBLE total = 1;
162
for(i = start; i != end ;i += step) {
163
- calculated_number *cn = &r->v[ i * r->d ];
163
+ NETDATA_DOUBLE *cn = &r->v[ i * r->d ];
164
RRDR_VALUE_FLAGS *co = &r->o[ i * r->d ];
165
uint8_t *ar = &r->ar[ i * r->d ];
166
@@ -210,7 +210,7 @@ void rrdr2json(RRDR *r, BUFFER *wb, RRDR_OPTIONS options, int datatable, struct
210
if(unlikely( options & RRDR_OPTION_OBJECTSROWS ))
211
buffer_fast_strcat(wb, object_rows_time, object_rows_time_len);
212
213
- buffer_rrd_value(wb, (calculated_number)r->t[i]);
213
+ buffer_rrd_value(wb, (NETDATA_DOUBLE)r->t[i]);
214
215
// in ms
216
if(unlikely(options & RRDR_OPTION_MILLISECONDS))
@@ -223,9 +223,9 @@ void rrdr2json(RRDR *r, BUFFER *wb, RRDR_OPTIONS options, int datatable, struct
223
if(unlikely(options & RRDR_OPTION_PERCENTAGE)) {
224
total = 0;
225
for(c = 0, rd = temp_rd?temp_rd:r->st->dimensions; rd && c < r->d ;c++, rd = rd->next) {
226
- calculated_number n;
226
+ NETDATA_DOUBLE n;
227
if(unlikely(options & RRDR_OPTION_INTERNAL_AR))
228
- n = (calculated_number)ar[c] / 2.0; // rrdr stores anomaly rates 0 - 200
228
+ n = (NETDATA_DOUBLE)ar[c] / 2.0; // rrdr stores anomaly rates 0 - 200
229
else
230
n = cn[c];
231
@@ -244,9 +244,9 @@ void rrdr2json(RRDR *r, BUFFER *wb, RRDR_OPTIONS options, int datatable, struct
244
if(unlikely(r->od[c] & RRDR_DIMENSION_HIDDEN)) continue;
245
if(unlikely((options & RRDR_OPTION_NONZERO) && !(r->od[c] & RRDR_DIMENSION_NONZERO))) continue;
246
247
- calculated_number n;
247
+ NETDATA_DOUBLE n;
248
if(unlikely(options & RRDR_OPTION_INTERNAL_AR))
249
- n = (calculated_number)ar[c] / 2.0; // rrdr stores anomaly rates 0 - 200
249
+ n = (NETDATA_DOUBLE)ar[c] / 2.0; // rrdr stores anomaly rates 0 - 200
250
else
251
n = cn[c];
252
web/api/formatters/json_wrapper.c
+6
-6
@@ -257,7 +257,7 @@ void rrdr_json_wrapper_begin(RRDR *r, BUFFER *wb, uint32_t format, RRDR_OPTIONS
257
if(i) buffer_strcat(wb, ", ");
258
i++;
259
260
- calculated_number value = rd->last_stored_value;
260
+ NETDATA_DOUBLE value = rd->last_stored_value;
261
if (NAN == value)
262
buffer_strcat(wb, "null");
263
else
@@ -282,13 +282,13 @@ void rrdr_json_wrapper_begin(RRDR *r, BUFFER *wb, uint32_t format, RRDR_OPTIONS
282
283
i = 0;
284
if(rows) {
285
- calculated_number total = 1;
285
+ NETDATA_DOUBLE total = 1;
286
287
if(unlikely(options & RRDR_OPTION_PERCENTAGE)) {
288
total = 0;
289
for(c = 0, rd = temp_rd?temp_rd:r->st->dimensions; rd && c < r->d ;c++, rd = rd->next) {
290
- calculated_number *cn = &r->v[ (rrdr_rows(r) - 1) * r->d ];
291
- calculated_number n = cn[c];
290
+ NETDATA_DOUBLE *cn = &r->v[ (rrdr_rows(r) - 1) * r->d ];
291
+ NETDATA_DOUBLE n = cn[c];
292
293
if(likely((options & RRDR_OPTION_ABSOLUTE) && n < 0))
294
n = -n;
@@ -306,9 +306,9 @@ void rrdr_json_wrapper_begin(RRDR *r, BUFFER *wb, uint32_t format, RRDR_OPTIONS
306
if(i) buffer_strcat(wb, ", ");
307
i++;
308
309
- calculated_number *cn = &r->v[ (rrdr_rows(r) - 1) * r->d ];
309
+ NETDATA_DOUBLE *cn = &r->v[ (rrdr_rows(r) - 1) * r->d ];
310
RRDR_VALUE_FLAGS *co = &r->o[ (rrdr_rows(r) - 1) * r->d ];
311
- calculated_number n = cn[c];
311
+ NETDATA_DOUBLE n = cn[c];
312
313
if(co[c] & RRDR_VALUE_EMPTY) {
314
if(options & RRDR_OPTION_NULL2ZERO)
web/api/formatters/rrd2json.c
+2
-2
@@ -86,7 +86,7 @@ void build_context_param_list(ONEWAYALLOC *owa, struct context_param **param_lis
86
(*param_list)->last_entry_t = MAX((*param_list)->last_entry_t, rrdset_last_entry_t_nolock(st));
87
88
rrddim_foreach_read(rd1, st) {
89
- RRDDIM *rd = onewayalloc_memdupz(owa, rd1, rd1->memsize);
89
+ RRDDIM *rd = onewayalloc_memdupz(owa, rd1, sizeof(RRDDIM));
90
rd->id = onewayalloc_strdupz(owa, rd1->id);
91
rd->name = onewayalloc_strdupz(owa, rd1->name);
92
rd->state = onewayalloc_memdupz(owa, rd1->state, sizeof(*rd->state));
@@ -152,7 +152,7 @@ void rrdr_buffer_print_format(BUFFER *wb, uint32_t format) {
152
int rrdset2value_api_v1(
153
RRDSET *st
154
, BUFFER *wb
155
- , calculated_number *n
155
+ , NETDATA_DOUBLE *n
156
, const char *dimensions
157
, long points
158
, long long after
web/api/formatters/rrd2json.h
+3
-3
@@ -67,8 +67,8 @@ extern void rrdr_buffer_print_format(BUFFER *wb, uint32_t format);
67
extern int rrdset2anything_api_v1(
68
ONEWAYALLOC *owa
69
, RRDSET *st
70
- ,
71
- QUERY_PARAMS *query_params, BUFFER *dimensions
70
+ , QUERY_PARAMS *query_params
71
+ , BUFFER *dimensions
72
, uint32_t format
73
, long points
74
, long long after
@@ -83,7 +83,7 @@ extern int rrdset2anything_api_v1(
83
extern int rrdset2value_api_v1(
84
RRDSET *st
85
, BUFFER *wb
86
- , calculated_number *n
86
+ , NETDATA_DOUBLE *n
87
, const char *dimensions
88
, long points
89
, long long after
web/api/formatters/rrdset2json.c
+2
-2
@@ -85,14 +85,14 @@ void rrdset2json(RRDSET *st, BUFFER *wb, size_t *dimensions_count, size_t *memor
85
"\t\t\t\"dimensions\": {\n",
86
st->update_every);
87
88
- unsigned long memory = st->memsize;
88
+ unsigned long memory = sizeof(RRDSET) + st->memsize;
89
90
size_t dimensions = 0;
91
RRDDIM *rd;
92
rrddim_foreach_read(rd, st) {
93
if(rrddim_flag_check(rd, RRDDIM_FLAG_HIDDEN) || rrddim_flag_check(rd, RRDDIM_FLAG_OBSOLETE)) continue;
94
95
- memory += rd->memsize;
95
+ memory += sizeof(RRDDIM) + rd->memsize;
96
97
if (dimensions)
98
buffer_strcat(wb, ",\n\t\t\t\t\"");
web/api/formatters/ssv/ssv.c
+1
-1
@@ -17,7 +17,7 @@ void rrdr2ssv(RRDR *r, BUFFER *wb, RRDR_OPTIONS options, const char *prefix, con
17
// for each line in the array
18
for(i = start; i != end ;i += step) {
19
int all_values_are_null = 0;
20
- calculated_number v = rrdr2value(r, i, options, &all_values_are_null, NULL, temp_rd);
20
+ NETDATA_DOUBLE v = rrdr2value(r, i, options, &all_values_are_null, NULL, temp_rd);
21
22
if(likely(i != start)) {
23
if(r->min > v) r->min = v;
web/api/formatters/value/value.c
+7
-6
@@ -3,28 +3,29 @@
3
#include "value.h"
4
5
6
-inline calculated_number rrdr2value(RRDR *r, long i, RRDR_OPTIONS options, int *all_values_are_null, uint8_t *anomaly_rate, RRDDIM *temp_rd) {
6
+inline NETDATA_DOUBLE
7
+rrdr2value(RRDR *r, long i, RRDR_OPTIONS options, int *all_values_are_null, uint8_t *anomaly_rate, RRDDIM *temp_rd) {
8
if (r->st_needs_lock)
9
rrdset_check_rdlock(r->st);
10
11
long c;
12
RRDDIM *d;
13
13
- calculated_number *cn = &r->v[ i * r->d ];
14
+ NETDATA_DOUBLE *cn = &r->v[ i * r->d ];
15
RRDR_VALUE_FLAGS *co = &r->o[ i * r->d ];
16
uint8_t *ar = &r->ar[ i * r->d ];
17
17
- calculated_number sum = 0, min = 0, max = 0, v;
18
+ NETDATA_DOUBLE sum = 0, min = 0, max = 0, v;
19
int all_null = 1, init = 1;
20
20
- calculated_number total = 1;
21
+ NETDATA_DOUBLE total = 1;
22
size_t total_anomaly_rate = 0;
23
24
int set_min_max = 0;
25
if(unlikely(options & RRDR_OPTION_PERCENTAGE)) {
26
total = 0;
27
for (c = 0, d = temp_rd ? temp_rd : r->st->dimensions; d && c < r->d; c++, d = d->next) {
27
- calculated_number n = cn[c];
28
+ NETDATA_DOUBLE n = cn[c];
29
30
if(likely((options & RRDR_OPTION_ABSOLUTE) && n < 0))
31
n = -n;
@@ -41,7 +42,7 @@ inline calculated_number rrdr2value(RRDR *r, long i, RRDR_OPTIONS options, int *
42
if(unlikely(r->od[c] & RRDR_DIMENSION_HIDDEN)) continue;
43
if(unlikely((options & RRDR_OPTION_NONZERO) && !(r->od[c] & RRDR_DIMENSION_NONZERO))) continue;
44
44
- calculated_number n = cn[c];
45
+ NETDATA_DOUBLE n = cn[c];
46
47
if(likely((options & RRDR_OPTION_ABSOLUTE) && n < 0))
48
n = -n;
web/api/formatters/value/value.h
+2
-1
@@ -5,6 +5,7 @@
5
6
#include "../rrd2json.h"
7
8
-extern calculated_number rrdr2value(RRDR *r, long i, RRDR_OPTIONS options, int *all_values_are_null, uint8_t *anomaly_rate, RRDDIM *temp_rd);
8
+extern NETDATA_DOUBLE
9
+rrdr2value(RRDR *r, long i, RRDR_OPTIONS options, int *all_values_are_null, uint8_t *anomaly_rate, RRDDIM *temp_rd);
10
11
#endif //NETDATA_API_FORMATTER_VALUE_H
web/api/queries/average/average.c
+4
-4
@@ -6,7 +6,7 @@
6
// average
7
8
struct grouping_average {
9
- calculated_number sum;
9
+ NETDATA_DOUBLE sum;
10
size_t count;
11
};
12
@@ -27,16 +27,16 @@ void grouping_free_average(RRDR *r) {
27
r->internal.grouping_data = NULL;
28
}
29
30
-void grouping_add_average(RRDR *r, calculated_number value) {
30
+void grouping_add_average(RRDR *r, NETDATA_DOUBLE value) {
31
struct grouping_average *g = (struct grouping_average *)r->internal.grouping_data;
32
g->sum += value;
33
g->count++;
34
}
35
36
-calculated_number grouping_flush_average(RRDR *r, RRDR_VALUE_FLAGS *rrdr_value_options_ptr) {
36
+NETDATA_DOUBLE grouping_flush_average(RRDR *r, RRDR_VALUE_FLAGS *rrdr_value_options_ptr) {
37
struct grouping_average *g = (struct grouping_average *)r->internal.grouping_data;
38
39
- calculated_number value;
39
+ NETDATA_DOUBLE value;
40
41
if(unlikely(!g->count)) {
42
value = 0.0;
web/api/queries/average/average.h
+2
-2
@@ -9,7 +9,7 @@
9
extern void grouping_create_average(RRDR *r, const char *options __maybe_unused);
10
extern void grouping_reset_average(RRDR *r);
11
extern void grouping_free_average(RRDR *r);
12
-extern void grouping_add_average(RRDR *r, calculated_number value);
13
-extern calculated_number grouping_flush_average(RRDR *r, RRDR_VALUE_FLAGS *rrdr_value_options_ptr);
12
+extern void grouping_add_average(RRDR *r, NETDATA_DOUBLE value);
13
+extern NETDATA_DOUBLE grouping_flush_average(RRDR *r, RRDR_VALUE_FLAGS *rrdr_value_options_ptr);
14
15
#endif //NETDATA_API_QUERY_AVERAGE_H
web/api/queries/countif/countif.c
+13
-13
@@ -6,33 +6,33 @@
6
// countif
7
8
struct grouping_countif {
9
- size_t (*comparison)(calculated_number, calculated_number);
10
- calculated_number target;
9
+ size_t (*comparison)(NETDATA_DOUBLE, NETDATA_DOUBLE);
10
+ NETDATA_DOUBLE target;
11
size_t count;
12
size_t matched;
13
};
14
15
-static size_t countif_equal(calculated_number v, calculated_number target) {
15
+static size_t countif_equal(NETDATA_DOUBLE v, NETDATA_DOUBLE target) {
16
return (v == target);
17
}
18
19
-static size_t countif_notequal(calculated_number v, calculated_number target) {
19
+static size_t countif_notequal(NETDATA_DOUBLE v, NETDATA_DOUBLE target) {
20
return (v != target);
21
}
22
23
-static size_t countif_less(calculated_number v, calculated_number target) {
23
+static size_t countif_less(NETDATA_DOUBLE v, NETDATA_DOUBLE target) {
24
return (v < target);
25
}
26
27
-static size_t countif_lessequal(calculated_number v, calculated_number target) {
27
+static size_t countif_lessequal(NETDATA_DOUBLE v, NETDATA_DOUBLE target) {
28
return (v <= target);
29
}
30
31
-static size_t countif_greater(calculated_number v, calculated_number target) {
31
+static size_t countif_greater(NETDATA_DOUBLE v, NETDATA_DOUBLE target) {
32
return (v > target);
33
}
34
35
-static size_t countif_greaterequal(calculated_number v, calculated_number target) {
35
+static size_t countif_greaterequal(NETDATA_DOUBLE v, NETDATA_DOUBLE target) {
36
return (v >= target);
37
}
38
@@ -89,7 +89,7 @@ void grouping_create_countif(RRDR *r, const char *options __maybe_unused) {
89
// skip everything up to the first digit
90
while(isspace(*options)) options++;
91
92
- g->target = str2ld(options, NULL);
92
+ g->target = str2ndd(options, NULL);
93
}
94
else {
95
g->target = 0.0;
@@ -110,23 +110,23 @@ void grouping_free_countif(RRDR *r) {
110
r->internal.grouping_data = NULL;
111
}
112
113
-void grouping_add_countif(RRDR *r, calculated_number value) {
113
+void grouping_add_countif(RRDR *r, NETDATA_DOUBLE value) {
114
struct grouping_countif *g = (struct grouping_countif *)r->internal.grouping_data;
115
g->matched += g->comparison(value, g->target);
116
g->count++;
117
}
118
119
-calculated_number grouping_flush_countif(RRDR *r, RRDR_VALUE_FLAGS *rrdr_value_options_ptr) {
119
+NETDATA_DOUBLE grouping_flush_countif(RRDR *r, RRDR_VALUE_FLAGS *rrdr_value_options_ptr) {
120
struct grouping_countif *g = (struct grouping_countif *)r->internal.grouping_data;
121
122
- calculated_number value;
122
+ NETDATA_DOUBLE value;
123
124
if(unlikely(!g->count)) {
125
value = 0.0;
126
*rrdr_value_options_ptr |= RRDR_VALUE_EMPTY;
127
}
128
else {
129
- value = (calculated_number)g->matched * 100 / (calculated_number)g->count;
129
+ value = (NETDATA_DOUBLE)g->matched * 100 / (NETDATA_DOUBLE)g->count;
130
}
131
132
g->matched = 0;
web/api/queries/countif/countif.h
+2
-2
@@ -9,7 +9,7 @@
9
extern void grouping_create_countif(RRDR *r, const char *options __maybe_unused);
10
extern void grouping_reset_countif(RRDR *r);
11
extern void grouping_free_countif(RRDR *r);
12
-extern void grouping_add_countif(RRDR *r, calculated_number value);
13
-extern calculated_number grouping_flush_countif(RRDR *r, RRDR_VALUE_FLAGS *rrdr_value_options_ptr);
12
+extern void grouping_add_countif(RRDR *r, NETDATA_DOUBLE value);
13
+extern NETDATA_DOUBLE grouping_flush_countif(RRDR *r, RRDR_VALUE_FLAGS *rrdr_value_options_ptr);
14
15
#endif //NETDATA_API_QUERY_COUNTIF_H
web/api/queries/des/des.c
+12
-12
@@ -8,13 +8,13 @@
8
// single exponential smoothing
9
10
struct grouping_des {
11
- calculated_number alpha;
12
- calculated_number alpha_other;
13
- calculated_number beta;
14
- calculated_number beta_other;
11
+ NETDATA_DOUBLE alpha;
12
+ NETDATA_DOUBLE alpha_other;
13
+ NETDATA_DOUBLE beta;
14
+ NETDATA_DOUBLE beta_other;
15
16
- calculated_number level;
17
- calculated_number trend;
16
+ NETDATA_DOUBLE level;
17
+ NETDATA_DOUBLE trend;
18
19
size_t count;
20
};
@@ -31,10 +31,10 @@ void grouping_init_des(void) {
31
}
32
}
33
34
-static inline calculated_number window(RRDR *r, struct grouping_des *g) {
34
+static inline NETDATA_DOUBLE window(RRDR *r, struct grouping_des *g) {
35
(void)g;
36
37
- calculated_number points;
37
+ NETDATA_DOUBLE points;
38
if(r->group == 1) {
39
// provide a running DES
40
points = r->internal.points_wanted;
@@ -96,7 +96,7 @@ void grouping_free_des(RRDR *r) {
96
r->internal.grouping_data = NULL;
97
}
98
99
-void grouping_add_des(RRDR *r, calculated_number value) {
99
+void grouping_add_des(RRDR *r, NETDATA_DOUBLE value) {
100
struct grouping_des *g = (struct grouping_des *)r->internal.grouping_data;
101
102
if(likely(g->count > 0)) {
@@ -109,7 +109,7 @@ void grouping_add_des(RRDR *r, calculated_number value) {
109
}
110
111
// for the values, except the first
112
- calculated_number last_level = g->level;
112
+ NETDATA_DOUBLE last_level = g->level;
113
g->level = (g->alpha * value) + (g->alpha_other * (g->level + g->trend));
114
g->trend = (g->beta * (g->level - last_level)) + (g->beta_other * g->trend);
115
}
@@ -123,10 +123,10 @@ void grouping_add_des(RRDR *r, calculated_number value) {
123
//fprintf(stderr, "value: " CALCULATED_NUMBER_FORMAT ", level: " CALCULATED_NUMBER_FORMAT ", trend: " CALCULATED_NUMBER_FORMAT "\n", value, g->level, g->trend);
124
}
125
126
-calculated_number grouping_flush_des(RRDR *r, RRDR_VALUE_FLAGS *rrdr_value_options_ptr) {
126
+NETDATA_DOUBLE grouping_flush_des(RRDR *r, RRDR_VALUE_FLAGS *rrdr_value_options_ptr) {
127
struct grouping_des *g = (struct grouping_des *)r->internal.grouping_data;
128
129
- if(unlikely(!g->count || !calculated_number_isnumber(g->level))) {
129
+ if(unlikely(!g->count || !netdata_double_isnumber(g->level))) {
130
*rrdr_value_options_ptr |= RRDR_VALUE_EMPTY;
131
return 0.0;
132
}
web/api/queries/des/des.h
+2
-2
@@ -11,7 +11,7 @@ extern void grouping_init_des(void);
11
extern void grouping_create_des(RRDR *r, const char *options __maybe_unused);
12
extern void grouping_reset_des(RRDR *r);
13
extern void grouping_free_des(RRDR *r);
14
-extern void grouping_add_des(RRDR *r, calculated_number value);
15
-extern calculated_number grouping_flush_des(RRDR *r, RRDR_VALUE_FLAGS *rrdr_value_options_ptr);
14
+extern void grouping_add_des(RRDR *r, NETDATA_DOUBLE value);
15
+extern NETDATA_DOUBLE grouping_flush_des(RRDR *r, RRDR_VALUE_FLAGS *rrdr_value_options_ptr);
16
17
#endif //NETDATA_API_QUERIES_DES_H
web/api/queries/incremental_sum/incremental_sum.c
+5
-5
@@ -6,8 +6,8 @@
6
// incremental sum
7
8
struct grouping_incremental_sum {
9
- calculated_number first;
10
- calculated_number last;
9
+ NETDATA_DOUBLE first;
10
+ NETDATA_DOUBLE last;
11
size_t count;
12
};
13
@@ -29,7 +29,7 @@ void grouping_free_incremental_sum(RRDR *r) {
29
r->internal.grouping_data = NULL;
30
}
31
32
-void grouping_add_incremental_sum(RRDR *r, calculated_number value) {
32
+void grouping_add_incremental_sum(RRDR *r, NETDATA_DOUBLE value) {
33
struct grouping_incremental_sum *g = (struct grouping_incremental_sum *)r->internal.grouping_data;
34
35
if(unlikely(!g->count)) {
@@ -42,10 +42,10 @@ void grouping_add_incremental_sum(RRDR *r, calculated_number value) {
42
}
43
}
44
45
-calculated_number grouping_flush_incremental_sum(RRDR *r, RRDR_VALUE_FLAGS *rrdr_value_options_ptr) {
45
+NETDATA_DOUBLE grouping_flush_incremental_sum(RRDR *r, RRDR_VALUE_FLAGS *rrdr_value_options_ptr) {
46
struct grouping_incremental_sum *g = (struct grouping_incremental_sum *)r->internal.grouping_data;
47
48
- calculated_number value;
48
+ NETDATA_DOUBLE value;
49
50
if(unlikely(!g->count)) {
51
value = 0.0;
web/api/queries/incremental_sum/incremental_sum.h
+2
-2
@@ -9,7 +9,7 @@
9
extern void grouping_create_incremental_sum(RRDR *r, const char *options __maybe_unused);
10
extern void grouping_reset_incremental_sum(RRDR *r);
11
extern void grouping_free_incremental_sum(RRDR *r);
12
-extern void grouping_add_incremental_sum(RRDR *r, calculated_number value);
13
-extern calculated_number grouping_flush_incremental_sum(RRDR *r, RRDR_VALUE_FLAGS *rrdr_value_options_ptr);
12
+extern void grouping_add_incremental_sum(RRDR *r, NETDATA_DOUBLE value);
13
+extern NETDATA_DOUBLE grouping_flush_incremental_sum(RRDR *r, RRDR_VALUE_FLAGS *rrdr_value_options_ptr);
14
15
#endif //NETDATA_API_QUERY_INCREMENTAL_SUM_H
web/api/queries/max/max.c
+5
-5
@@ -6,7 +6,7 @@
6
// max
7
8
struct grouping_max {
9
- calculated_number max;
9
+ NETDATA_DOUBLE max;
10
size_t count;
11
};
12
@@ -27,19 +27,19 @@ void grouping_free_max(RRDR *r) {
27
r->internal.grouping_data = NULL;
28
}
29
30
-void grouping_add_max(RRDR *r, calculated_number value) {
30
+void grouping_add_max(RRDR *r, NETDATA_DOUBLE value) {
31
struct grouping_max *g = (struct grouping_max *)r->internal.grouping_data;
32
33
- if(!g->count || calculated_number_fabs(value) > calculated_number_fabs(g->max)) {
33
+ if(!g->count || fabsndd(value) > fabsndd(g->max)) {
34
g->max = value;
35
g->count++;
36
}
37
}
38
39
-calculated_number grouping_flush_max(RRDR *r, RRDR_VALUE_FLAGS *rrdr_value_options_ptr) {
39
+NETDATA_DOUBLE grouping_flush_max(RRDR *r, RRDR_VALUE_FLAGS *rrdr_value_options_ptr) {
40
struct grouping_max *g = (struct grouping_max *)r->internal.grouping_data;
41
42
- calculated_number value;
42
+ NETDATA_DOUBLE value;
43
44
if(unlikely(!g->count)) {
45
value = 0.0;
web/api/queries/max/max.h
+2
-2
@@ -9,7 +9,7 @@
9
extern void grouping_create_max(RRDR *r, const char *options __maybe_unused);
10
extern void grouping_reset_max(RRDR *r);
11
extern void grouping_free_max(RRDR *r);
12
-extern void grouping_add_max(RRDR *r, calculated_number value);
13
-extern calculated_number grouping_flush_max(RRDR *r, RRDR_VALUE_FLAGS *rrdr_value_options_ptr);
12
+extern void grouping_add_max(RRDR *r, NETDATA_DOUBLE value);
13
+extern NETDATA_DOUBLE grouping_flush_max(RRDR *r, RRDR_VALUE_FLAGS *rrdr_value_options_ptr);
14
15
#endif //NETDATA_API_QUERY_MAX_H
web/api/queries/median/median.c
+9
-9
@@ -10,14 +10,14 @@ struct grouping_median {
10
size_t series_size;
11
size_t next_pos;
12
13
- LONG_DOUBLE series[];
13
+ NETDATA_DOUBLE series[];
14
};
15
16
void grouping_create_median(RRDR *r, const char *options __maybe_unused) {
17
long entries = r->group;
18
if(entries < 0) entries = 0;
19
20
- struct grouping_median *g = (struct grouping_median *)callocz(1, sizeof(struct grouping_median) + entries * sizeof(LONG_DOUBLE));
20
+ struct grouping_median *g = (struct grouping_median *)callocz(1, sizeof(struct grouping_median) + entries * sizeof(NETDATA_DOUBLE));
21
g->series_size = (size_t)entries;
22
23
r->internal.grouping_data = g;
@@ -35,20 +35,20 @@ void grouping_free_median(RRDR *r) {
35
r->internal.grouping_data = NULL;
36
}
37
38
-void grouping_add_median(RRDR *r, calculated_number value) {
38
+void grouping_add_median(RRDR *r, NETDATA_DOUBLE value) {
39
struct grouping_median *g = (struct grouping_median *)r->internal.grouping_data;
40
41
if(unlikely(g->next_pos >= g->series_size)) {
42
error("INTERNAL ERROR: median buffer overflow on chart '%s' - next_pos = %zu, series_size = %zu, r->group = %ld.", r->st->name, g->next_pos, g->series_size, r->group);
43
}
44
else
45
- g->series[g->next_pos++] = (LONG_DOUBLE)value;
45
+ g->series[g->next_pos++] = (NETDATA_DOUBLE)value;
46
}
47
48
-calculated_number grouping_flush_median(RRDR *r, RRDR_VALUE_FLAGS *rrdr_value_options_ptr) {
48
+NETDATA_DOUBLE grouping_flush_median(RRDR *r, RRDR_VALUE_FLAGS *rrdr_value_options_ptr) {
49
struct grouping_median *g = (struct grouping_median *)r->internal.grouping_data;
50
51
- calculated_number value;
51
+ NETDATA_DOUBLE value;
52
53
if(unlikely(!g->next_pos)) {
54
value = 0.0;
@@ -57,12 +57,12 @@ calculated_number grouping_flush_median(RRDR *r, RRDR_VALUE_FLAGS *rrdr_value_op
57
else {
58
if(g->next_pos > 1) {
59
sort_series(g->series, g->next_pos);
60
- value = (calculated_number)median_on_sorted_series(g->series, g->next_pos);
60
+ value = (NETDATA_DOUBLE)median_on_sorted_series(g->series, g->next_pos);
61
}
62
else
63
- value = (calculated_number)g->series[0];
63
+ value = (NETDATA_DOUBLE)g->series[0];
64
65
- if(!calculated_number_isnumber(value)) {
65
+ if(!netdata_double_isnumber(value)) {
66
value = 0.0;
67
*rrdr_value_options_ptr |= RRDR_VALUE_EMPTY;
68
}
web/api/queries/median/median.h
+2
-2
@@ -9,7 +9,7 @@
9
extern void grouping_create_median(RRDR *r, const char *options __maybe_unused);
10
extern void grouping_reset_median(RRDR *r);
11
extern void grouping_free_median(RRDR *r);
12
-extern void grouping_add_median(RRDR *r, calculated_number value);
13
-extern calculated_number grouping_flush_median(RRDR *r, RRDR_VALUE_FLAGS *rrdr_value_options_ptr);
12
+extern void grouping_add_median(RRDR *r, NETDATA_DOUBLE value);
13
+extern NETDATA_DOUBLE grouping_flush_median(RRDR *r, RRDR_VALUE_FLAGS *rrdr_value_options_ptr);
14
15
#endif //NETDATA_API_QUERIES_MEDIAN_H
web/api/queries/min/min.c
+5
-5
@@ -6,7 +6,7 @@
6
// min
7
8
struct grouping_min {
9
- calculated_number min;
9
+ NETDATA_DOUBLE min;
10
size_t count;
11
};
12
@@ -27,19 +27,19 @@ void grouping_free_min(RRDR *r) {
27
r->internal.grouping_data = NULL;
28
}
29
30
-void grouping_add_min(RRDR *r, calculated_number value) {
30
+void grouping_add_min(RRDR *r, NETDATA_DOUBLE value) {
31
struct grouping_min *g = (struct grouping_min *)r->internal.grouping_data;
32
33
- if(!g->count || calculated_number_fabs(value) < calculated_number_fabs(g->min)) {
33
+ if(!g->count || fabsndd(value) < fabsndd(g->min)) {
34
g->min = value;
35
g->count++;
36
}
37
}
38
39
-calculated_number grouping_flush_min(RRDR *r, RRDR_VALUE_FLAGS *rrdr_value_options_ptr) {
39
+NETDATA_DOUBLE grouping_flush_min(RRDR *r, RRDR_VALUE_FLAGS *rrdr_value_options_ptr) {
40
struct grouping_min *g = (struct grouping_min *)r->internal.grouping_data;
41
42
- calculated_number value;
42
+ NETDATA_DOUBLE value;
43
44
if(unlikely(!g->count)) {
45
value = 0.0;
web/api/queries/min/min.h
+2
-2
@@ -9,7 +9,7 @@
9
extern void grouping_create_min(RRDR *r, const char *options __maybe_unused);
10
extern void grouping_reset_min(RRDR *r);
11
extern void grouping_free_min(RRDR *r);
12
-extern void grouping_add_min(RRDR *r, calculated_number value);
13
-extern calculated_number grouping_flush_min(RRDR *r, RRDR_VALUE_FLAGS *rrdr_value_options_ptr);
12
+extern void grouping_add_min(RRDR *r, NETDATA_DOUBLE value);
13
+extern NETDATA_DOUBLE grouping_flush_min(RRDR *r, RRDR_VALUE_FLAGS *rrdr_value_options_ptr);
14
15
#endif //NETDATA_API_QUERY_MIN_H
web/api/queries/query.c
+16
-17
@@ -41,7 +41,7 @@ static struct {
41
42
// Add a single value into the calculation.
43
// The module may decide to cache it, or use it in the fly.
44
- void (*add)(struct rrdresult *r, calculated_number value);
44
+ void (*add)(struct rrdresult *r, NETDATA_DOUBLE value);
45
46
// Generate a single result for the values added so far.
47
// More values and points may be requested later.
@@ -49,7 +49,7 @@ static struct {
49
// when flushing it (so for a few modules it may be better to
50
// continue after a flush as if nothing changed, for others a
51
// cleanup of the internal structures may be required).
52
- calculated_number (*flush)(struct rrdresult *r, RRDR_VALUE_FLAGS *rrdr_value_options_ptr);
52
+ NETDATA_DOUBLE (*flush)(struct rrdresult *r, RRDR_VALUE_FLAGS *rrdr_value_options_ptr);
53
} api_v1_data_groups[] = {
54
{.name = "average",
55
.hash = 0,
@@ -399,7 +399,7 @@ static inline RRDR_VALUE_FLAGS *UNUSED_FUNCTION(rrdr_line_options)(RRDR *r, long
399
return &r->o[ rrdr_line * r->d ];
400
}
401
402
-static inline calculated_number *UNUSED_FUNCTION(rrdr_line_values)(RRDR *r, long rrdr_line) {
402
+static inline NETDATA_DOUBLE *UNUSED_FUNCTION(rrdr_line_values)(RRDR *r, long rrdr_line) {
403
return &r->v[ rrdr_line * r->d ];
404
}
405
@@ -454,21 +454,21 @@ static inline void rrd2rrdr_do_dimension(
454
455
struct rrddim_query_handle handle;
456
457
- calculated_number min = r->min, max = r->max;
457
+ NETDATA_DOUBLE min = r->min, max = r->max;
458
size_t db_points_read = 0;
459
460
// cache the function pointers we need in the loop
461
- calculated_number (*next_metric)(struct rrddim_query_handle *handle, time_t *current_time, time_t *end_time, SN_FLAGS *flags) = rd->state->query_ops.next_metric;
462
- void (*grouping_add)(struct rrdresult *r, calculated_number value) = r->internal.grouping_add;
463
- calculated_number (*grouping_flush)(struct rrdresult *r, RRDR_VALUE_FLAGS *rrdr_value_options_ptr) = r->internal.grouping_flush;
461
+ NETDATA_DOUBLE (*next_metric)(struct rrddim_query_handle *handle, time_t *current_time, time_t *end_time, SN_FLAGS *flags) = rd->state->query_ops.next_metric;
462
+ void (*grouping_add)(struct rrdresult *r, NETDATA_DOUBLE value) = r->internal.grouping_add;
463
+ NETDATA_DOUBLE (*grouping_flush)(struct rrdresult *r, RRDR_VALUE_FLAGS *rrdr_value_options_ptr) = r->internal.grouping_flush;
464
465
- calculated_number last_point_value;
465
+ NETDATA_DOUBLE last_point_value;
466
SN_FLAGS last_point_flags;
467
time_t last_point_start_time;
468
time_t last_point_end_time;
469
size_t last_point_anomaly;
470
471
- calculated_number new_point_value = NAN;
471
+ NETDATA_DOUBLE new_point_value = NAN;
472
SN_FLAGS new_point_flags = SN_EMPTY_SLOT;
473
time_t new_point_start_time = 0;
474
time_t new_point_end_time = 0;
@@ -496,11 +496,11 @@ static inline void rrd2rrdr_do_dimension(
496
// fetch the new point
497
new_point_value = next_metric(&handle, &new_point_start_time, &new_point_end_time, &new_point_flags);
498
499
- if(likely(calculated_number_isnumber(new_point_value))) {
499
+ if(likely(netdata_double_isnumber(new_point_value))) {
500
new_point_anomaly = (new_point_flags & SN_ANOMALY_BIT) ? 0 : 100;
501
502
if(unlikely(options & RRDR_OPTION_ANOMALY_BIT))
503
- new_point_value = (calculated_number)new_point_anomaly;
503
+ new_point_value = (NETDATA_DOUBLE)new_point_anomaly;
504
}
505
else {
506
new_point_flags = SN_EMPTY_SLOT;
@@ -551,8 +551,7 @@ static inline void rrd2rrdr_do_dimension(
551
552
size_t iterations = 0;
553
for ( ; now <= new_point_end_time && points_added < points_wanted; now += dt, iterations++) {
554
-
555
- calculated_number current_point_value;
554
+ NETDATA_DOUBLE current_point_value;
555
SN_FLAGS current_point_flags;
556
size_t current_point_anomaly;
557
//time_t current_point_start_time;
@@ -583,7 +582,7 @@ static inline void rrd2rrdr_do_dimension(
582
//current_point_end_time = now;
583
}
584
586
- if(likely(calculated_number_isnumber(current_point_value))) {
585
+ if(likely(netdata_double_isnumber(current_point_value))) {
586
if(likely(current_point_value != 0.0))
587
group_points_non_zero++;
588
@@ -615,7 +614,7 @@ static inline void rrd2rrdr_do_dimension(
614
*rrdr_value_options_ptr = group_value_flags;
615
616
// store the group value
618
- calculated_number group_value = grouping_flush(r, rrdr_value_options_ptr);
617
+ NETDATA_DOUBLE group_value = grouping_flush(r, rrdr_value_options_ptr);
618
r->v[rrdr_o_v_index] = group_value;
619
620
// we only store uint8_t anomaly rates,
@@ -856,7 +855,7 @@ static RRDR *rrd2rrdr_do_chart(
855
group++;
856
857
// resampling_time_requested enforces a certain grouping multiple
859
- calculated_number resampling_divisor = 1.0;
858
+ NETDATA_DOUBLE resampling_divisor = 1.0;
859
long resampling_group = 1;
860
if(unlikely(resampling_time_requested > update_every)) {
861
if (unlikely(resampling_time_requested > duration)) {
@@ -900,7 +899,7 @@ static RRDR *rrd2rrdr_do_chart(
899
if(unlikely(group % resampling_group)) group += resampling_group - (group % resampling_group); // make sure group is multiple of resampling_group
900
901
//resampling_divisor = group / resampling_group;
903
- resampling_divisor = (calculated_number)(group * update_every) / (calculated_number)resampling_time_requested;
902
+ resampling_divisor = (NETDATA_DOUBLE)(group * update_every) / (NETDATA_DOUBLE)resampling_time_requested;
903
}
904
905
// now that we have group,
web/api/queries/rrdr.c
+3
-3
@@ -30,7 +30,7 @@ static void rrdr_dump(RRDR *r)
30
31
// for each line in the array
32
for(i = 0; i < r->rows ;i++) {
33
- calculated_number *cn = &r->v[ i * r->d ];
33
+ NETDATA_DOUBLE *cn = &r->v[ i * r->d ];
34
RRDR_DIMENSION_FLAGS *co = &r->o[ i * r->d ];
35
36
// print the id and the timestamp of the line
@@ -44,7 +44,7 @@ static void rrdr_dump(RRDR *r)
44
if(co[c] & RRDR_EMPTY)
45
fprintf(stderr, "null ");
46
else
47
- fprintf(stderr, CALCULATED_NUMBER_FORMAT " %s%s%s%s "
47
+ fprintf(stderr, NETDATA_DOUBLE_FORMAT " %s%s%s%s "
48
, cn[c]
49
, (co[c] & RRDR_EMPTY)?"E":" "
50
, (co[c] & RRDR_RESET)?"R":" "
@@ -124,7 +124,7 @@ RRDR *rrdr_create(ONEWAYALLOC *owa, struct rrdset *st, long n, struct context_pa
124
r->n = n;
125
126
r->t = onewayalloc_callocz(owa, (size_t)n, sizeof(time_t));
127
- r->v = onewayalloc_mallocz(owa, n * r->d * sizeof(calculated_number));
127
+ r->v = onewayalloc_mallocz(owa, n * r->d * sizeof(NETDATA_DOUBLE));
128
r->o = onewayalloc_mallocz(owa, n * r->d * sizeof(RRDR_VALUE_FLAGS));
129
r->ar = onewayalloc_mallocz(owa, n * r->d * sizeof(uint8_t));
130
r->od = onewayalloc_mallocz(owa, r->d * sizeof(RRDR_DIMENSION_FLAGS));
web/api/queries/rrdr.h
+6
-6
@@ -67,15 +67,15 @@ typedef struct rrdresult {
67
RRDR_DIMENSION_FLAGS *od; // the options for the dimensions
68
69
time_t *t; // array of n timestamps
70
- calculated_number *v; // array n x d values
70
+ NETDATA_DOUBLE *v; // array n x d values
71
RRDR_VALUE_FLAGS *o; // array n x d options for each value returned
72
uint8_t *ar; // array n x d of anomaly rates (0 - 200)
73
74
long group; // how many collected values were grouped for each row
75
int update_every; // what is the suggested update frequency in seconds
76
77
- calculated_number min;
78
- calculated_number max;
77
+ NETDATA_DOUBLE min;
78
+ NETDATA_DOUBLE max;
79
80
time_t before;
81
time_t after;
@@ -87,13 +87,13 @@ typedef struct rrdresult {
87
struct {
88
long points_wanted;
89
long resampling_group;
90
- calculated_number resampling_divisor;
90
+ NETDATA_DOUBLE resampling_divisor;
91
92
void (*grouping_create)(struct rrdresult *r, const char *options);
93
void (*grouping_reset)(struct rrdresult *r);
94
void (*grouping_free)(struct rrdresult *r);
95
- void (*grouping_add)(struct rrdresult *r, calculated_number value);
96
- calculated_number (*grouping_flush)(struct rrdresult *r, RRDR_VALUE_FLAGS *rrdr_value_options_ptr);
95
+ void (*grouping_add)(struct rrdresult *r, NETDATA_DOUBLE value);
96
+ NETDATA_DOUBLE (*grouping_flush)(struct rrdresult *r, RRDR_VALUE_FLAGS *rrdr_value_options_ptr);
97
void *grouping_data;
98
99
#ifdef NETDATA_INTERNAL_CHECKS
web/api/queries/ses/ses.c
+8
-8
@@ -7,9 +7,9 @@
7
// single exponential smoothing
8
9
struct grouping_ses {
10
- calculated_number alpha;
11
- calculated_number alpha_other;
12
- calculated_number level;
10
+ NETDATA_DOUBLE alpha;
11
+ NETDATA_DOUBLE alpha_other;
12
+ NETDATA_DOUBLE level;
13
size_t count;
14
};
15
@@ -25,10 +25,10 @@ void grouping_init_ses(void) {
25
}
26
}
27
28
-static inline calculated_number window(RRDR *r, struct grouping_ses *g) {
28
+static inline NETDATA_DOUBLE window(RRDR *r, struct grouping_ses *g) {
29
(void)g;
30
31
- calculated_number points;
31
+ NETDATA_DOUBLE points;
32
if(r->group == 1) {
33
// provide a running DES
34
points = r->internal.points_wanted;
@@ -68,7 +68,7 @@ void grouping_free_ses(RRDR *r) {
68
r->internal.grouping_data = NULL;
69
}
70
71
-void grouping_add_ses(RRDR *r, calculated_number value) {
71
+void grouping_add_ses(RRDR *r, NETDATA_DOUBLE value) {
72
struct grouping_ses *g = (struct grouping_ses *)r->internal.grouping_data;
73
74
if(unlikely(!g->count))
@@ -78,10 +78,10 @@ void grouping_add_ses(RRDR *r, calculated_number value) {
78
g->count++;
79
}
80
81
-calculated_number grouping_flush_ses(RRDR *r, RRDR_VALUE_FLAGS *rrdr_value_options_ptr) {
81
+NETDATA_DOUBLE grouping_flush_ses(RRDR *r, RRDR_VALUE_FLAGS *rrdr_value_options_ptr) {
82
struct grouping_ses *g = (struct grouping_ses *)r->internal.grouping_data;
83
84
- if(unlikely(!g->count || !calculated_number_isnumber(g->level))) {
84
+ if(unlikely(!g->count || !netdata_double_isnumber(g->level))) {
85
*rrdr_value_options_ptr |= RRDR_VALUE_EMPTY;
86
return 0.0;
87
}
web/api/queries/ses/ses.h
+2
-2
@@ -11,7 +11,7 @@ extern void grouping_init_ses(void);
11
extern void grouping_create_ses(RRDR *r, const char *options __maybe_unused);
12
extern void grouping_reset_ses(RRDR *r);
13
extern void grouping_free_ses(RRDR *r);
14
-extern void grouping_add_ses(RRDR *r, calculated_number value);
15
-extern calculated_number grouping_flush_ses(RRDR *r, RRDR_VALUE_FLAGS *rrdr_value_options_ptr);
14
+extern void grouping_add_ses(RRDR *r, NETDATA_DOUBLE value);
15
+extern NETDATA_DOUBLE grouping_flush_ses(RRDR *r, RRDR_VALUE_FLAGS *rrdr_value_options_ptr);
16
17
#endif //NETDATA_API_QUERIES_SES_H
web/api/queries/stddev/stddev.c
+17
-17
@@ -11,7 +11,7 @@
11
12
struct grouping_stddev {
13
long count;
14
- calculated_number m_oldM, m_newM, m_oldS, m_newS;
14
+ NETDATA_DOUBLE m_oldM, m_newM, m_oldS, m_newS;
15
};
16
17
void grouping_create_stddev(RRDR *r, const char *options __maybe_unused) {
@@ -30,7 +30,7 @@ void grouping_free_stddev(RRDR *r) {
30
r->internal.grouping_data = NULL;
31
}
32
33
-void grouping_add_stddev(RRDR *r, calculated_number value) {
33
+void grouping_add_stddev(RRDR *r, NETDATA_DOUBLE value) {
34
struct grouping_stddev *g = (struct grouping_stddev *)r->internal.grouping_data;
35
36
g->count++;
@@ -50,26 +50,26 @@ void grouping_add_stddev(RRDR *r, calculated_number value) {
50
}
51
}
52
53
-static inline calculated_number mean(struct grouping_stddev *g) {
53
+static inline NETDATA_DOUBLE mean(struct grouping_stddev *g) {
54
return (g->count > 0) ? g->m_newM : 0.0;
55
}
56
57
-static inline calculated_number variance(struct grouping_stddev *g) {
57
+static inline NETDATA_DOUBLE variance(struct grouping_stddev *g) {
58
return ( (g->count > 1) ? g->m_newS/(g->count - 1) : 0.0 );
59
}
60
-static inline calculated_number stddev(struct grouping_stddev *g) {
61
- return sqrtl(variance(g));
60
+static inline NETDATA_DOUBLE stddev(struct grouping_stddev *g) {
61
+ return sqrtndd(variance(g));
62
}
63
64
-calculated_number grouping_flush_stddev(RRDR *r, RRDR_VALUE_FLAGS *rrdr_value_options_ptr) {
64
+NETDATA_DOUBLE grouping_flush_stddev(RRDR *r, RRDR_VALUE_FLAGS *rrdr_value_options_ptr) {
65
struct grouping_stddev *g = (struct grouping_stddev *)r->internal.grouping_data;
66
67
- calculated_number value;
67
+ NETDATA_DOUBLE value;
68
69
if(likely(g->count > 1)) {
70
value = stddev(g);
71
72
- if(!calculated_number_isnumber(value)) {
72
+ if(!netdata_double_isnumber(value)) {
73
value = 0.0;
74
*rrdr_value_options_ptr |= RRDR_VALUE_EMPTY;
75
}
@@ -88,16 +88,16 @@ calculated_number grouping_flush_stddev(RRDR *r, RRDR_VALUE_FLAGS *rrdr_value_op
88
}
89
90
// https://en.wikipedia.org/wiki/Coefficient_of_variation
91
-calculated_number grouping_flush_coefficient_of_variation(RRDR *r, RRDR_VALUE_FLAGS *rrdr_value_options_ptr) {
91
+NETDATA_DOUBLE grouping_flush_coefficient_of_variation(RRDR *r, RRDR_VALUE_FLAGS *rrdr_value_options_ptr) {
92
struct grouping_stddev *g = (struct grouping_stddev *)r->internal.grouping_data;
93
94
- calculated_number value;
94
+ NETDATA_DOUBLE value;
95
96
if(likely(g->count > 1)) {
97
- calculated_number m = mean(g);
97
+ NETDATA_DOUBLE m = mean(g);
98
value = 100.0 * stddev(g) / ((m < 0)? -m : m);
99
100
- if(unlikely(!calculated_number_isnumber(value))) {
100
+ if(unlikely(!netdata_double_isnumber(value))) {
101
value = 0.0;
102
*rrdr_value_options_ptr |= RRDR_VALUE_EMPTY;
103
}
@@ -121,10 +121,10 @@ calculated_number grouping_flush_coefficient_of_variation(RRDR *r, RRDR_VALUE_FL
121
/*
122
* Mean = average
123
*
124
-calculated_number grouping_flush_mean(RRDR *r, RRDR_VALUE_FLAGS *rrdr_value_options_ptr) {
124
+NETDATA_DOUBLE grouping_flush_mean(RRDR *r, RRDR_VALUE_FLAGS *rrdr_value_options_ptr) {
125
struct grouping_stddev *g = (struct grouping_stddev *)r->internal.grouping_data;
126
127
- calculated_number value;
127
+ NETDATA_DOUBLE value;
128
129
if(unlikely(!g->count)) {
130
value = 0.0;
@@ -148,10 +148,10 @@ calculated_number grouping_flush_mean(RRDR *r, RRDR_VALUE_FLAGS *rrdr_value_opti
148
/*
149
* It is not advised to use this version of variance directly
150
*
151
-calculated_number grouping_flush_variance(RRDR *r, RRDR_VALUE_FLAGS *rrdr_value_options_ptr) {
151
+NETDATA_DOUBLE grouping_flush_variance(RRDR *r, RRDR_VALUE_FLAGS *rrdr_value_options_ptr) {
152
struct grouping_stddev *g = (struct grouping_stddev *)r->internal.grouping_data;
153
154
- calculated_number value;
154
+ NETDATA_DOUBLE value;
155
156
if(unlikely(!g->count)) {
157
value = 0.0;
web/api/queries/stddev/stddev.h
+5
-5
@@ -9,10 +9,10 @@
9
extern void grouping_create_stddev(RRDR *r, const char *options __maybe_unused);
10
extern void grouping_reset_stddev(RRDR *r);
11
extern void grouping_free_stddev(RRDR *r);
12
-extern void grouping_add_stddev(RRDR *r, calculated_number value);
13
-extern calculated_number grouping_flush_stddev(RRDR *r, RRDR_VALUE_FLAGS *rrdr_value_options_ptr);
14
-extern calculated_number grouping_flush_coefficient_of_variation(RRDR *r, RRDR_VALUE_FLAGS *rrdr_value_options_ptr);
15
-// extern calculated_number grouping_flush_mean(RRDR *r, RRDR_VALUE_FLAGS *rrdr_value_options_ptr);
16
-// extern calculated_number grouping_flush_variance(RRDR *r, RRDR_VALUE_FLAGS *rrdr_value_options_ptr);
12
+extern void grouping_add_stddev(RRDR *r, NETDATA_DOUBLE value);
13
+extern NETDATA_DOUBLE grouping_flush_stddev(RRDR *r, RRDR_VALUE_FLAGS *rrdr_value_options_ptr);
14
+extern NETDATA_DOUBLE grouping_flush_coefficient_of_variation(RRDR *r, RRDR_VALUE_FLAGS *rrdr_value_options_ptr);
15
+// extern NETDATA_DOUBLE grouping_flush_mean(RRDR *r, RRDR_VALUE_FLAGS *rrdr_value_options_ptr);
16
+// extern NETDATA_DOUBLE grouping_flush_variance(RRDR *r, RRDR_VALUE_FLAGS *rrdr_value_options_ptr);
17
18
#endif //NETDATA_API_QUERIES_STDDEV_H
web/api/queries/sum/sum.c
+4
-4
@@ -6,7 +6,7 @@
6
// sum
7
8
struct grouping_sum {
9
- calculated_number sum;
9
+ NETDATA_DOUBLE sum;
10
size_t count;
11
};
12
@@ -27,16 +27,16 @@ void grouping_free_sum(RRDR *r) {
27
r->internal.grouping_data = NULL;
28
}
29
30
-void grouping_add_sum(RRDR *r, calculated_number value) {
30
+void grouping_add_sum(RRDR *r, NETDATA_DOUBLE value) {
31
struct grouping_sum *g = (struct grouping_sum *)r->internal.grouping_data;
32
g->sum += value;
33
g->count++;
34
}
35
36
-calculated_number grouping_flush_sum(RRDR *r, RRDR_VALUE_FLAGS *rrdr_value_options_ptr) {
36
+NETDATA_DOUBLE grouping_flush_sum(RRDR *r, RRDR_VALUE_FLAGS *rrdr_value_options_ptr) {
37
struct grouping_sum *g = (struct grouping_sum *)r->internal.grouping_data;
38
39
- calculated_number value;
39
+ NETDATA_DOUBLE value;
40
41
if(unlikely(!g->count)) {
42
value = 0.0;
web/api/queries/sum/sum.h
+2
-2
@@ -9,7 +9,7 @@
9
extern void grouping_create_sum(RRDR *r, const char *options __maybe_unused);
10
extern void grouping_reset_sum(RRDR *r);
11
extern void grouping_free_sum(RRDR *r);
12
-extern void grouping_add_sum(RRDR *r, calculated_number value);
13
-extern calculated_number grouping_flush_sum(RRDR *r, RRDR_VALUE_FLAGS *rrdr_value_options_ptr);
12
+extern void grouping_add_sum(RRDR *r, NETDATA_DOUBLE value);
13
+extern NETDATA_DOUBLE grouping_flush_sum(RRDR *r, RRDR_VALUE_FLAGS *rrdr_value_options_ptr);
14
15
#endif //NETDATA_API_QUERY_SUM_H