int rrd_update_every = UPDATE_EVERY;
int rrd_default_history_entries = RRD_DEFAULT_HISTORY_ENTRIES;
-int rrd_memory_mode = RRD_MEMORY_MODE_SAVE;
+RRD_MEMORY_MODE rrd_memory_mode = RRD_MEMORY_MODE_SAVE;
static int rrdset_compare(void* a, void* b);
static int rrdset_compare_name(void* a, void* b);
void rrdhost_init(char *hostname) {
localhost.hostname = hostname;
localhost.health_log.next_log_id =
- localhost.health_log.next_alarm_id = time(NULL);
+ localhost.health_log.next_alarm_id = now_realtime_sec();
}
void rrdhost_rwlock(RRDHOST *host) {
return (RRDFAMILY *)avl_search_lock(&(host->rrdfamily_root_index), (avl *) &tmp);
}
-RRDFAMILY *rrdfamily_create(const char *id) {
- RRDFAMILY *rc = rrdfamily_index_find(&localhost, id, 0);
+RRDFAMILY *rrdfamily_create(RRDHOST *host, const char *id) {
+ RRDFAMILY *rc = rrdfamily_index_find(host, id, 0);
if(!rc) {
rc = callocz(1, sizeof(RRDFAMILY));
// initialize the variables index
avl_init_lock(&rc->variables_root_index, rrdvar_compare);
- RRDFAMILY *ret = rrdfamily_index_add(&localhost, rc);
+ RRDFAMILY *ret = rrdfamily_index_add(host, rc);
if(ret != rc)
- fatal("INTERNAL ERROR: Expected to INSERT RRDFAMILY '%s' into index, but inserted '%s'.", rc->family, (ret)?ret->family:"NONE");
+ fatal("RRDFAMILY: INTERNAL ERROR: Expected to INSERT RRDFAMILY '%s' into index, but inserted '%s'.", rc->family, (ret)?ret->family:"NONE");
}
rc->use_count++;
return rc;
}
-void rrdfamily_free(RRDFAMILY *rc) {
+void rrdfamily_free(RRDHOST *host, RRDFAMILY *rc) {
rc->use_count--;
if(!rc->use_count) {
- RRDFAMILY *ret = rrdfamily_index_del(&localhost, rc);
+ RRDFAMILY *ret = rrdfamily_index_del(host, rc);
if(ret != rc)
- fatal("INTERNAL ERROR: Expected to DELETE RRDFAMILY '%s' from index, but deleted '%s'.", rc->family, (ret)?ret->family:"NONE");
+ fatal("RRDFAMILY: INTERNAL ERROR: Expected to DELETE RRDFAMILY '%s' from index, but deleted '%s'.", rc->family, (ret)?ret->family:"NONE");
if(rc->variables_root_index.avl_tree.root != NULL)
- fatal("INTERNAL ERROR: Variables index of RRDFAMILY '%s' that is freed, is not empty.", rc->family);
+ fatal("RRDFAMILY: INTERNAL ERROR: Variables index of RRDFAMILY '%s' that is freed, is not empty.", rc->family);
freez((void *)rc->family);
freez(rc);
else return strcmp(((RRDDIM *)a)->id, ((RRDDIM *)b)->id);
}
-#define rrddim_index_add(st, rd) avl_insert_lock(&((st)->dimensions_index), (avl *)(rd))
-#define rrddim_index_del(st,rd ) avl_remove_lock(&((st)->dimensions_index), (avl *)(rd))
+#define rrddim_index_add(st, rd) (RRDDIM *)avl_insert_lock(&((st)->dimensions_index), (avl *)(rd))
+#define rrddim_index_del(st,rd ) (RRDDIM *)avl_remove_lock(&((st)->dimensions_index), (avl *)(rd))
static RRDDIM *rrddim_index_find(RRDSET *st, const char *id, uint32_t hash) {
- RRDDIM tmp;
- strncpyz(tmp.id, id, RRD_ID_LENGTH_MAX);
- tmp.hash = (hash)?hash:simple_hash(tmp.id);
-
+ RRDDIM tmp = {
+ .id = id,
+ .hash = (hash)?hash:simple_hash(id)
+ };
return (RRDDIM *)avl_search_lock(&(st->dimensions_index), (avl *) &tmp);
}
// ----------------------------------------------------------------------------
// chart types
-int rrdset_type_id(const char *name)
-{
- if(unlikely(strcmp(name, RRDSET_TYPE_AREA_NAME) == 0)) return RRDSET_TYPE_AREA;
- else if(unlikely(strcmp(name, RRDSET_TYPE_STACKED_NAME) == 0)) return RRDSET_TYPE_STACKED;
- else if(unlikely(strcmp(name, RRDSET_TYPE_LINE_NAME) == 0)) return RRDSET_TYPE_LINE;
- return RRDSET_TYPE_LINE;
-}
+inline RRDSET_TYPE rrdset_type_id(const char *name) {
+ if(unlikely(strcmp(name, RRDSET_TYPE_AREA_NAME) == 0))
+ return RRDSET_TYPE_AREA;
-const char *rrdset_type_name(int chart_type)
-{
- static char line[] = RRDSET_TYPE_LINE_NAME;
- static char area[] = RRDSET_TYPE_AREA_NAME;
- static char stacked[] = RRDSET_TYPE_STACKED_NAME;
+ else if(unlikely(strcmp(name, RRDSET_TYPE_STACKED_NAME) == 0))
+ return RRDSET_TYPE_STACKED;
+ else // if(unlikely(strcmp(name, RRDSET_TYPE_LINE_NAME) == 0))
+ return RRDSET_TYPE_LINE;
+}
+
+const char *rrdset_type_name(RRDSET_TYPE chart_type) {
switch(chart_type) {
case RRDSET_TYPE_LINE:
- return line;
+ default:
+ return RRDSET_TYPE_LINE_NAME;
case RRDSET_TYPE_AREA:
- return area;
+ return RRDSET_TYPE_AREA_NAME;
case RRDSET_TYPE_STACKED:
- return stacked;
+ return RRDSET_TYPE_STACKED_NAME;
}
- return line;
}
// ----------------------------------------------------------------------------
// load / save
-const char *rrd_memory_mode_name(int id)
-{
- static const char ram[] = RRD_MEMORY_MODE_RAM_NAME;
- static const char map[] = RRD_MEMORY_MODE_MAP_NAME;
- static const char save[] = RRD_MEMORY_MODE_SAVE_NAME;
-
+inline const char *rrd_memory_mode_name(RRD_MEMORY_MODE id) {
switch(id) {
case RRD_MEMORY_MODE_RAM:
- return ram;
+ return RRD_MEMORY_MODE_RAM_NAME;
case RRD_MEMORY_MODE_MAP:
- return map;
+ return RRD_MEMORY_MODE_MAP_NAME;
case RRD_MEMORY_MODE_SAVE:
default:
- return save;
+ return RRD_MEMORY_MODE_SAVE_NAME;
}
-
- return save;
}
int rrd_memory_mode_id(const char *name)
// ----------------------------------------------------------------------------
// algorithms types
-int rrddim_algorithm_id(const char *name)
+RRDDIM_ALGORITHM rrddim_algorithm_id(const char *name)
{
- if(strcmp(name, RRDDIM_INCREMENTAL_NAME) == 0) return RRDDIM_INCREMENTAL;
- if(strcmp(name, RRDDIM_ABSOLUTE_NAME) == 0) return RRDDIM_ABSOLUTE;
- if(strcmp(name, RRDDIM_PCENT_OVER_ROW_TOTAL_NAME) == 0) return RRDDIM_PCENT_OVER_ROW_TOTAL;
- if(strcmp(name, RRDDIM_PCENT_OVER_DIFF_TOTAL_NAME) == 0) return RRDDIM_PCENT_OVER_DIFF_TOTAL;
- return RRDDIM_ABSOLUTE;
+ if(strcmp(name, RRDDIM_ALGORITHM_INCREMENTAL_NAME) == 0)
+ return RRDDIM_ALGORITHM_INCREMENTAL;
+
+ else if(strcmp(name, RRDDIM_ALGORITHM_ABSOLUTE_NAME) == 0)
+ return RRDDIM_ALGORITHM_ABSOLUTE;
+
+ else if(strcmp(name, RRDDIM_ALGORITHM_PCENT_OVER_ROW_TOTAL_NAME) == 0)
+ return RRDDIM_ALGORITHM_PCENT_OVER_ROW_TOTAL;
+
+ else if(strcmp(name, RRDDIM_ALGORITHM_PCENT_OVER_DIFF_TOTAL_NAME) == 0)
+ return RRDDIM_ALGORITHM_PCENT_OVER_DIFF_TOTAL;
+
+ else
+ return RRDDIM_ALGORITHM_ABSOLUTE;
}
-const char *rrddim_algorithm_name(int chart_type)
+const char *rrddim_algorithm_name(RRDDIM_ALGORITHM algorithm)
{
- static char absolute[] = RRDDIM_ABSOLUTE_NAME;
- static char incremental[] = RRDDIM_INCREMENTAL_NAME;
- static char percentage_of_absolute_row[] = RRDDIM_PCENT_OVER_ROW_TOTAL_NAME;
- static char percentage_of_incremental_row[] = RRDDIM_PCENT_OVER_DIFF_TOTAL_NAME;
-
- switch(chart_type) {
- case RRDDIM_ABSOLUTE:
- return absolute;
+ switch(algorithm) {
+ case RRDDIM_ALGORITHM_ABSOLUTE:
+ default:
+ return RRDDIM_ALGORITHM_ABSOLUTE_NAME;
- case RRDDIM_INCREMENTAL:
- return incremental;
+ case RRDDIM_ALGORITHM_INCREMENTAL:
+ return RRDDIM_ALGORITHM_INCREMENTAL_NAME;
- case RRDDIM_PCENT_OVER_ROW_TOTAL:
- return percentage_of_absolute_row;
+ case RRDDIM_ALGORITHM_PCENT_OVER_ROW_TOTAL:
+ return RRDDIM_ALGORITHM_PCENT_OVER_ROW_TOTAL_NAME;
- case RRDDIM_PCENT_OVER_DIFF_TOTAL:
- return percentage_of_incremental_row;
+ case RRDDIM_ALGORITHM_PCENT_OVER_DIFF_TOTAL:
+ return RRDDIM_ALGORITHM_PCENT_OVER_DIFF_TOTAL_NAME;
}
- return absolute;
}
// ----------------------------------------------------------------------------
rrdset_strncpyz_name(b, n, CONFIG_MAX_VALUE);
if(st->name) {
- rrdset_index_del_name(&localhost, st);
+ rrdset_index_del_name(st->rrdhost, st);
st->name = config_set_default(st->id, "name", b);
st->hash_name = simple_hash(st->name);
rrdsetvar_rename_all(st);
rrddimvar_rename_all(rd);
pthread_rwlock_unlock(&st->rwlock);
- rrdset_index_add_name(&localhost, st);
+ if(unlikely(rrdset_index_add_name(st->rrdhost, st) != st))
+ error("RRDSET: INTERNAL ERROR: attempted to index duplicate chart name '%s'", st->name);
}
// ----------------------------------------------------------------------------
{
char *ret = NULL;
- static char *cache_dir = NULL;
- if(!cache_dir) {
- cache_dir = config_get("global", "cache directory", CACHE_DIR);
- int r = mkdir(cache_dir, 0755);
- if(r != 0 && errno != EEXIST)
- error("Cannot create directory '%s'", cache_dir);
- }
-
char b[FILENAME_MAX + 1];
char n[FILENAME_MAX + 1];
rrdset_strncpyz_name(b, id, FILENAME_MAX);
- snprintfz(n, FILENAME_MAX, "%s/%s", cache_dir, b);
+ snprintfz(n, FILENAME_MAX, "%s/%s", netdata_configured_cache_dir, b);
ret = config_get(id, "cache directory", n);
if(rrd_memory_mode == RRD_MEMORY_MODE_MAP || rrd_memory_mode == RRD_MEMORY_MODE_SAVE) {
memset(rd->values, 0, rd->entries * sizeof(storage_number));
}
}
-static long align_entries_to_pagesize(long entries) {
+static inline long align_entries_to_pagesize(long entries) {
if(entries < 5) entries = 5;
if(entries > RRD_HISTORY_ENTRIES_MAX) entries = RRD_HISTORY_ENTRIES_MAX;
#endif
}
-RRDSET *rrdset_create(const char *type, const char *id, const char *name, const char *family, const char *context, const char *title, const char *units, long priority, int update_every, int chart_type)
-{
+static inline void timeval_align(struct timeval *tv, int update_every) {
+ tv->tv_sec -= tv->tv_sec % update_every;
+ tv->tv_usec = 500000;
+}
+
+RRDSET *rrdset_create(const char *type, const char *id, const char *name, const char *family, const char *context, const char *title, const char *units, long priority, int update_every, int chart_type) {
+ RRDHOST *host = &localhost;
+
if(!type || !type[0]) {
fatal("Cannot create rrd stats without a type.");
return NULL;
snprintfz(fullid, RRD_ID_LENGTH_MAX, "%s.%s", type, id);
- RRDSET *st = rrdset_find(fullid);
+ RRDSET *st = rrdset_find(host, fullid);
if(st) {
- error("Cannot create rrd stats for '%s', it already exists.", fullid);
+ debug(D_RRD_CALLS, "RRDSET '%s', already exists.", fullid);
return st;
}
error("File %s does not have the desired update frequency. Clearing it.", fullfilename);
memset(st, 0, size);
}
- else if((time(NULL) - st->last_updated.tv_sec) > update_every * entries) {
+ else if((now_realtime_sec() - st->last_updated.tv_sec) > update_every * entries) {
errno = 0;
error("File %s is too old. Clearing it.", fullfilename);
memset(st, 0, size);
}
+
+ // make sure the database is aligned
+ if(st->last_updated.tv_sec)
+ timeval_align(&st->last_updated, update_every);
}
if(st) {
st->mapped = rrd_memory_mode;
st->variables = NULL;
st->alarms = NULL;
+ memset(&st->rwlock, 0, sizeof(pthread_rwlock_t));
+ memset(&st->avl, 0, sizeof(avl));
+ memset(&st->avlname, 0, sizeof(avl));
+ memset(&st->variables_root_index, 0, sizeof(avl_tree_lock));
+ memset(&st->dimensions_index, 0, sizeof(avl_tree_lock));
}
else {
st = callocz(1, size);
st->mapped = RRD_MEMORY_MODE_RAM;
}
+ st->rrdhost = host;
st->memsize = size;
st->entries = entries;
st->update_every = update_every;
avl_init_lock(&st->variables_root_index, rrdvar_compare);
pthread_rwlock_init(&st->rwlock, NULL);
- rrdhost_rwlock(&localhost);
+ rrdhost_rwlock(host);
if(name && *name) rrdset_set_name(st, name);
else rrdset_set_name(st, id);
{
char varvalue[CONFIG_MAX_VALUE + 1];
+ char varvalue2[CONFIG_MAX_VALUE + 1];
snprintfz(varvalue, CONFIG_MAX_VALUE, "%s (%s)", title?title:"", st->name);
- st->title = config_get(st->id, "title", varvalue);
+ json_escape_string(varvalue2, varvalue, sizeof(varvalue2));
+ st->title = config_get(st->id, "title", varvalue2);
}
- st->rrdfamily = rrdfamily_create(st->family);
- st->rrdhost = &localhost;
+ st->rrdfamily = rrdfamily_create(host, st->family);
- st->next = localhost.rrdset_root;
- localhost.rrdset_root = st;
+ st->next = host->rrdset_root;
+ host->rrdset_root = st;
if(health_enabled) {
rrdsetvar_create(st, "last_collected_t", RRDVAR_TYPE_TIME_T, &st->last_collected_time.tv_sec, 0);
rrdsetvar_create(st, "update_every", RRDVAR_TYPE_INT, &st->update_every, 0);
}
- rrdset_index_add(&localhost, st);
+ if(unlikely(rrdset_index_add(host, st) != st))
+ error("RRDSET: INTERNAL ERROR: attempt to index duplicate chart '%s'", st->id);
rrdsetcalc_link_matching(st);
rrdcalctemplate_link_matching(st);
- rrdhost_unlock(&localhost);
+ rrdhost_unlock(host);
return(st);
}
-RRDDIM *rrddim_add(RRDSET *st, const char *id, const char *name, long multiplier, long divisor, int algorithm)
+RRDDIM *rrddim_add(RRDSET *st, const char *id, const char *name, collected_number multiplier, collected_number divisor, RRDDIM_ALGORITHM algorithm)
{
+ RRDDIM *rd = rrddim_find(st, id);
+ if(rd) {
+ debug(D_RRD_CALLS, "Cannot create rrd dimension '%s/%s', it already exists.", st->id, name?name:"<NONAME>");
+ return rd;
+ }
+
char filename[FILENAME_MAX + 1];
char fullfilename[FILENAME_MAX + 1];
char varname[CONFIG_MAX_NAME + 1];
- RRDDIM *rd = NULL;
unsigned long size = sizeof(RRDDIM) + (st->entries * sizeof(storage_number));
debug(D_RRD_CALLS, "Adding dimension '%s/%s'.", st->id, id);
rrdset_strncpyz_name(filename, id, FILENAME_MAX);
snprintfz(fullfilename, FILENAME_MAX, "%s/%s.db", st->cache_dir, filename);
- if(rrd_memory_mode != RRD_MEMORY_MODE_RAM) rd = (RRDDIM *)mymmap(fullfilename, size, ((rrd_memory_mode == RRD_MEMORY_MODE_MAP)?MAP_SHARED:MAP_PRIVATE), 1);
- if(rd) {
- struct timeval now;
- gettimeofday(&now, NULL);
- if(strcmp(rd->magic, RRDDIMENSION_MAGIC) != 0) {
- errno = 0;
- info("Initializing file %s.", fullfilename);
- memset(rd, 0, size);
- }
- else if(rd->memsize != size) {
- errno = 0;
- error("File %s does not have the desired size. Clearing it.", fullfilename);
- memset(rd, 0, size);
- }
- else if(rd->multiplier != multiplier) {
- errno = 0;
- error("File %s does not have the same multiplier. Clearing it.", fullfilename);
- memset(rd, 0, size);
- }
- else if(rd->divisor != divisor) {
- errno = 0;
- error("File %s does not have the same divisor. Clearing it.", fullfilename);
- memset(rd, 0, size);
- }
- else if(rd->algorithm != algorithm) {
- errno = 0;
- error("File %s does not have the same algorithm. Clearing it.", fullfilename);
- memset(rd, 0, size);
- }
- else if(rd->update_every != st->update_every) {
- errno = 0;
- error("File %s does not have the same refresh frequency. Clearing it.", fullfilename);
- memset(rd, 0, size);
- }
- else if(usec_dt(&now, &rd->last_collected_time) > (rd->entries * rd->update_every * 1000000ULL)) {
- errno = 0;
- error("File %s is too old. Clearing it.", fullfilename);
- memset(rd, 0, size);
- }
- else if(strcmp(rd->id, id) != 0) {
- errno = 0;
- error("File %s contents are not for dimension %s. Clearing it.", fullfilename, id);
- // munmap(rd, size);
- // rd = NULL;
- memset(rd, 0, size);
+ if(rrd_memory_mode != RRD_MEMORY_MODE_RAM) {
+ rd = (RRDDIM *) mymmap(fullfilename, size, ((rrd_memory_mode == RRD_MEMORY_MODE_MAP) ? MAP_SHARED : MAP_PRIVATE), 1);
+ if(rd) {
+ // we have a file mapped for rd
+
+ rd->id = NULL;
+ rd->name = NULL;
+ rd->cache_filename = NULL;
+ rd->memory_mode = rrd_memory_mode;
+ rd->flags = 0x00000000;
+ rd->variables = NULL;
+ rd->next = NULL;
+ rd->rrdset = NULL;
+ memset(&rd->avl, 0, sizeof(avl));
+
+ struct timeval now;
+ now_realtime_timeval(&now);
+
+ if(strcmp(rd->magic, RRDDIMENSION_MAGIC) != 0) {
+ errno = 0;
+ info("Initializing file %s.", fullfilename);
+ memset(rd, 0, size);
+ }
+ else if(rd->memsize != size) {
+ errno = 0;
+ error("File %s does not have the desired size. Clearing it.", fullfilename);
+ memset(rd, 0, size);
+ }
+ else if(rd->multiplier != multiplier) {
+ errno = 0;
+ error("File %s does not have the same multiplier. Clearing it.", fullfilename);
+ memset(rd, 0, size);
+ }
+ else if(rd->divisor != divisor) {
+ errno = 0;
+ error("File %s does not have the same divisor. Clearing it.", fullfilename);
+ memset(rd, 0, size);
+ }
+ else if(rd->update_every != st->update_every) {
+ errno = 0;
+ error("File %s does not have the same refresh frequency. Clearing it.", fullfilename);
+ memset(rd, 0, size);
+ }
+ else if(dt_usec(&now, &rd->last_collected_time) > (rd->entries * rd->update_every * USEC_PER_SEC)) {
+ errno = 0;
+ error("File %s is too old. Clearing it.", fullfilename);
+ memset(rd, 0, size);
+ }
+
+ if(rd->algorithm && rd->algorithm != algorithm)
+ error("File %s does not have the expected algorithm (expected %u '%s', found %u '%s'). Previous values may be wrong."
+ , fullfilename, algorithm, rrddim_algorithm_name(algorithm), rd->algorithm,
+ rrddim_algorithm_name(rd->algorithm));
}
}
- if(rd) {
- // we have a file mapped for rd
- rd->mapped = rrd_memory_mode;
- rd->flags = 0x00000000;
- rd->variables = NULL;
- rd->next = NULL;
- rd->name = NULL;
- }
- else {
+ if(unlikely(!rd)) {
// if we didn't manage to get a mmap'd dimension, just create one
-
rd = callocz(1, size);
- rd->mapped = RRD_MEMORY_MODE_RAM;
+ rd->memory_mode = RRD_MEMORY_MODE_RAM;
}
+
rd->memsize = size;
strcpy(rd->magic, RRDDIMENSION_MAGIC);
- strcpy(rd->cache_filename, fullfilename);
- strncpyz(rd->id, id, RRD_ID_LENGTH_MAX);
+
+ rd->id = strdupz(id);
rd->hash = simple_hash(rd->id);
+ rd->cache_filename = strdupz(fullfilename);
+
snprintfz(varname, CONFIG_MAX_NAME, "dim %s name", rd->id);
rd->name = config_get(st->id, varname, (name && *name)?name:rd->id);
+ rd->hash_name = simple_hash(rd->name);
snprintfz(varname, CONFIG_MAX_NAME, "dim %s algorithm", rd->id);
rd->algorithm = rrddim_algorithm_id(config_get(st->id, varname, rrddim_algorithm_name(algorithm)));
// prevent incremental calculation spikes
rd->counter = 0;
- rd->updated = 0;
+ rrddim_flag_clear(rd, RRDDIM_FLAG_UPDATED);
rd->calculated_value = 0;
rd->last_calculated_value = 0;
rd->collected_value = 0;
pthread_rwlock_unlock(&st->rwlock);
- rrddim_index_add(st, rd);
+ if(unlikely(rrddim_index_add(st, rd) != rd))
+ error("RRDDIM: INTERNAL ERROR: attempt to index duplicate dimension '%s' on chart '%s'", rd->id, st->id);
return(rd);
}
void rrddim_set_name(RRDSET *st, RRDDIM *rd, const char *name)
{
- if(unlikely(rd->name && !strcmp(rd->name, name)))
+ if(unlikely(!strcmp(rd->name, name)))
return;
debug(D_RRD_CALLS, "rrddim_set_name() from %s.%s to %s.%s", st->name, rd->name, st->name, name);
char varname[CONFIG_MAX_NAME + 1];
snprintfz(varname, CONFIG_MAX_NAME, "dim %s name", rd->id);
rd->name = config_set_default(st->id, varname, name);
+ rd->hash_name = simple_hash(rd->name);
rrddimvar_rename_all(rd);
}
while(rd->variables)
rrddimvar_free(rd->variables);
- rrddim_index_del(st, rd);
+ if(unlikely(rrddim_index_del(st, rd) != rd))
+ error("RRDDIM: INTERNAL ERROR: attempt to remove from index dimension '%s' on chart '%s', removed a different dimension.", rd->id, st->id);
// free(rd->annotations);
- if(rd->mapped == RRD_MEMORY_MODE_SAVE) {
- debug(D_RRD_CALLS, "Saving dimension '%s' to '%s'.", rd->name, rd->cache_filename);
- savememory(rd->cache_filename, rd, rd->memsize);
- debug(D_RRD_CALLS, "Unmapping dimension '%s'.", rd->name);
- munmap(rd, rd->memsize);
- }
- else if(rd->mapped == RRD_MEMORY_MODE_MAP) {
- debug(D_RRD_CALLS, "Unmapping dimension '%s'.", rd->name);
- munmap(rd, rd->memsize);
- }
- else {
- debug(D_RRD_CALLS, "Removing dimension '%s'.", rd->name);
- freez(rd);
+ switch(rd->memory_mode) {
+ case RRD_MEMORY_MODE_SAVE:
+ debug(D_RRD_CALLS, "Saving dimension '%s' to '%s'.", rd->name, rd->cache_filename);
+ savememory(rd->cache_filename, rd, rd->memsize);
+ // continue to map mode - no break;
+
+ case RRD_MEMORY_MODE_MAP:
+ debug(D_RRD_CALLS, "Unmapping dimension '%s'.", rd->name);
+ freez((void *)rd->id);
+ freez(rd->cache_filename);
+ munmap(rd, rd->memsize);
+ break;
+
+ case RRD_MEMORY_MODE_RAM:
+ debug(D_RRD_CALLS, "Removing dimension '%s'.", rd->name);
+ freez((void *)rd->id);
+ freez(rd->cache_filename);
+ freez(rd);
+ break;
}
}
while(st->dimensions)
rrddim_free(st, st->dimensions);
- rrdset_index_del(&localhost, st);
+ if(unlikely(rrdset_index_del(&localhost, st) != st))
+ error("RRDSET: INTERNAL ERROR: attempt to remove from index chart '%s', removed a different chart.", st->id);
+
+ rrdset_index_del_name(&localhost, st);
st->rrdfamily->use_count--;
if(!st->rrdfamily->use_count)
- rrdfamily_free(st->rrdfamily);
+ rrdfamily_free(&localhost, st->rrdfamily);
pthread_rwlock_unlock(&st->rwlock);
- if(st->mapped == RRD_MEMORY_MODE_SAVE) {
- debug(D_RRD_CALLS, "Saving stats '%s' to '%s'.", st->name, st->cache_filename);
- savememory(st->cache_filename, st, st->memsize);
-
- debug(D_RRD_CALLS, "Unmapping stats '%s'.", st->name);
- munmap(st, st->memsize);
- }
- else if(st->mapped == RRD_MEMORY_MODE_MAP) {
+ if(st->mapped == RRD_MEMORY_MODE_SAVE || st->mapped == RRD_MEMORY_MODE_MAP) {
debug(D_RRD_CALLS, "Unmapping stats '%s'.", st->name);
munmap(st, st->memsize);
}
RRDSET *st;
RRDDIM *rd;
+ // we get an write lock
+ // to ensure only one thread is saving the database
rrdhost_rwlock(&localhost);
+
for(st = localhost.rrdset_root; st ; st = st->next) {
- pthread_rwlock_wrlock(&st->rwlock);
+ pthread_rwlock_rdlock(&st->rwlock);
if(st->mapped == RRD_MEMORY_MODE_SAVE) {
debug(D_RRD_CALLS, "Saving stats '%s' to '%s'.", st->name, st->cache_filename);
}
for(rd = st->dimensions; rd ; rd = rd->next) {
- if(likely(rd->mapped == RRD_MEMORY_MODE_SAVE)) {
+ if(likely(rd->memory_mode == RRD_MEMORY_MODE_SAVE)) {
debug(D_RRD_CALLS, "Saving dimension '%s' to '%s'.", rd->name, rd->cache_filename);
savememory(rd->cache_filename, rd, rd->memsize);
}
pthread_rwlock_unlock(&st->rwlock);
}
+
rrdhost_unlock(&localhost);
}
-RRDSET *rrdset_find(const char *id)
-{
- debug(D_RRD_CALLS, "rrdset_find() for chart %s", id);
-
- RRDSET *st = rrdset_index_find(&localhost, id, 0);
+RRDSET *rrdset_find(RRDHOST *host, const char *id) {
+ debug(D_RRD_CALLS, "rrdset_find() for chart '%s' in host '%s'", id, host->hostname);
+ RRDSET *st = rrdset_index_find(host, id, 0);
return(st);
}
-RRDSET *rrdset_find_bytype(const char *type, const char *id)
+RRDSET *rrdset_find_bytype(RRDHOST *host, const char *type, const char *id)
{
- debug(D_RRD_CALLS, "rrdset_find_bytype() for chart %s.%s", type, id);
+ debug(D_RRD_CALLS, "rrdset_find_bytype() for chart '%s.%s' in host '%s'", type, id, host->hostname);
char buf[RRD_ID_LENGTH_MAX + 1];
-
strncpyz(buf, type, RRD_ID_LENGTH_MAX - 1);
strcat(buf, ".");
int len = (int) strlen(buf);
strncpyz(&buf[len], id, (size_t) (RRD_ID_LENGTH_MAX - len));
- return(rrdset_find(buf));
+ return(rrdset_find(host, buf));
}
-RRDSET *rrdset_find_byname(const char *name)
-{
- debug(D_RRD_CALLS, "rrdset_find_byname() for chart %s", name);
-
- RRDSET *st = rrdset_index_find_name(&localhost, name, 0);
+RRDSET *rrdset_find_byname(RRDHOST *host, const char *name) {
+ debug(D_RRD_CALLS, "rrdset_find_byname() for chart '%s' in host '%s'", name, host->hostname);
+ RRDSET *st = rrdset_index_find_name(host, name, 0);
return(st);
}
return 1;
}
- rd->flags |= RRDDIM_FLAG_HIDDEN;
+ rrddim_flag_set(rd, RRDDIM_FLAG_HIDDEN);
return 0;
}
-int rrddim_unhide(RRDSET *st, const char *id)
-{
+int rrddim_unhide(RRDSET *st, const char *id) {
debug(D_RRD_CALLS, "rrddim_unhide() for chart %s, dimension %s", st->name, id);
RRDDIM *rd = rrddim_find(st, id);
return 1;
}
- if(rd->flags & RRDDIM_FLAG_HIDDEN) rd->flags ^= RRDDIM_FLAG_HIDDEN;
+ rrddim_flag_clear(rd, RRDDIM_FLAG_HIDDEN);
return 0;
}
{
debug(D_RRD_CALLS, "rrddim_set_by_pointer() for chart %s, dimension %s, value " COLLECTED_NUMBER_FORMAT, st->name, rd->name, value);
- gettimeofday(&rd->last_collected_time, NULL);
+ now_realtime_timeval(&rd->last_collected_time);
rd->collected_value = value;
- rd->updated = 1;
+ rrddim_flag_set(rd, RRDDIM_FLAG_UPDATED);
rd->counter++;
// 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));
return rrddim_set_by_pointer(st, rd, value);
}
-void rrdset_next_usec_unfiltered(RRDSET *st, unsigned long long microseconds)
+void rrdset_next_usec_unfiltered(RRDSET *st, usec_t microseconds)
{
if(unlikely(!st->last_collected_time.tv_sec || !microseconds)) {
// the first entry
- microseconds = st->update_every * 1000000ULL;
+ microseconds = st->update_every * USEC_PER_SEC;
}
st->usec_since_last_update = microseconds;
}
-void rrdset_next_usec(RRDSET *st, unsigned long long microseconds)
+void rrdset_next_usec(RRDSET *st, usec_t microseconds)
{
struct timeval now;
- gettimeofday(&now, NULL);
+ now_realtime_timeval(&now);
if(unlikely(!st->last_collected_time.tv_sec)) {
// the first entry
- microseconds = st->update_every * 1000000ULL;
+ microseconds = st->update_every * USEC_PER_SEC;
}
else if(unlikely(!microseconds)) {
// no dt given by the plugin
- microseconds = usec_dt(&now, &st->last_collected_time);
+ microseconds = dt_usec(&now, &st->last_collected_time);
}
else {
// microseconds has the time since the last collection
- unsigned long long now_usec = timeval_usec(&now);
- unsigned long long last_usec = timeval_usec(&st->last_collected_time);
- unsigned long long since_last_usec = usec_dt(&now, &st->last_collected_time);
+#ifdef NETDATA_INTERNAL_CHECKS
+ usec_t now_usec = timeval_usec(&now);
+ usec_t last_usec = timeval_usec(&st->last_collected_time);
+#endif
+ usec_t since_last_usec = dt_usec(&now, &st->last_collected_time);
// verify the microseconds given is good
if(unlikely(microseconds > since_last_usec)) {
st->usec_since_last_update = microseconds;
}
-unsigned long long rrdset_done(RRDSET *st)
+usec_t rrdset_done(RRDSET *st)
{
if(unlikely(netdata_exit)) return 0;
unsigned int
stored_entries = 0; // the number of entries we have stored in the db, during this call to rrdset_done()
- unsigned long long
+ usec_t
last_collect_ut, // the timestamp in microseconds, of the last collected value
now_collect_ut, // the timestamp in microseconds, of this collected value (this is NOW)
last_stored_ut, // the timestamp in microseconds, of the last stored entry in the db
next_store_ut, // the timestamp in microseconds, of the next entry to store in the db
- update_every_ut = st->update_every * 1000000ULL; // st->update_every in microseconds
+ update_every_ut = st->update_every * USEC_PER_SEC; // st->update_every in microseconds
if(unlikely(pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &pthreadoldcancelstate) != 0))
error("Cannot set pthread cancel state to DISABLE.");
// check if the chart has a long time to be updated
if(unlikely(st->usec_since_last_update > st->entries * update_every_ut)) {
- info("%s: took too long to be updated (%0.3Lf secs). Reseting it.", st->name, (long double)(st->usec_since_last_update / 1000000.0));
+ info("%s: took too long to be updated (%0.3Lf secs). Resetting it.", st->name, (long double)(st->usec_since_last_update / 1000000.0));
rrdset_reset(st);
st->usec_since_last_update = update_every_ut;
first_entry = 1;
if(unlikely(!st->last_collected_time.tv_sec)) {
// it is the first entry
// set the last_collected_time to now
- gettimeofday(&st->last_collected_time, NULL);
- last_collect_ut = st->last_collected_time.tv_sec * 1000000ULL + st->last_collected_time.tv_usec - update_every_ut;
+ now_realtime_timeval(&st->last_collected_time);
+ timeval_align(&st->last_collected_time, st->update_every);
+
+ last_collect_ut = st->last_collected_time.tv_sec * USEC_PER_SEC + st->last_collected_time.tv_usec - update_every_ut;
// the first entry should not be stored
store_this_entry = 0;
else {
// it is not the first entry
// calculate the proper last_collected_time, using usec_since_last_update
- last_collect_ut = st->last_collected_time.tv_sec * 1000000ULL + st->last_collected_time.tv_usec;
- unsigned long long ut = last_collect_ut + st->usec_since_last_update;
- st->last_collected_time.tv_sec = (time_t) (ut / 1000000ULL);
- st->last_collected_time.tv_usec = (suseconds_t) (ut % 1000000ULL);
+ last_collect_ut = st->last_collected_time.tv_sec * USEC_PER_SEC + st->last_collected_time.tv_usec;
+ usec_t ut = last_collect_ut + st->usec_since_last_update;
+ st->last_collected_time.tv_sec = (time_t) (ut / USEC_PER_SEC);
+ st->last_collected_time.tv_usec = (suseconds_t) (ut % USEC_PER_SEC);
}
// if this set has not been updated in the past
if(unlikely(!st->last_updated.tv_sec)) {
// it has never been updated before
// set a fake last_updated, in the past using usec_since_last_update
- unsigned long long ut = st->last_collected_time.tv_sec * 1000000ULL + st->last_collected_time.tv_usec - st->usec_since_last_update;
- st->last_updated.tv_sec = (time_t) (ut / 1000000ULL);
- st->last_updated.tv_usec = (suseconds_t) (ut % 1000000ULL);
+ usec_t ut = st->last_collected_time.tv_sec * USEC_PER_SEC + st->last_collected_time.tv_usec - st->usec_since_last_update;
+ st->last_updated.tv_sec = (time_t) (ut / USEC_PER_SEC);
+ st->last_updated.tv_usec = (suseconds_t) (ut % USEC_PER_SEC);
// the first entry should not be stored
store_this_entry = 0;
}
// check if we will re-write the entire data set
- if(unlikely(usec_dt(&st->last_collected_time, &st->last_updated) > st->entries * update_every_ut)) {
- info("%s: too old data (last updated at %ld.%ld, last collected at %ld.%ld). Reseting it. Will not store the next entry.", st->name, st->last_updated.tv_sec, st->last_updated.tv_usec, st->last_collected_time.tv_sec, st->last_collected_time.tv_usec);
+ if(unlikely(dt_usec(&st->last_collected_time, &st->last_updated) > st->entries * update_every_ut)) {
+ info("%s: too old data (last updated at %ld.%ld, last collected at %ld.%ld). Resetting it. Will not store the next entry.", st->name, st->last_updated.tv_sec, st->last_updated.tv_usec, st->last_collected_time.tv_sec, st->last_collected_time.tv_usec);
rrdset_reset(st);
st->usec_since_last_update = update_every_ut;
- gettimeofday(&st->last_collected_time, NULL);
+ now_realtime_timeval(&st->last_collected_time);
+ timeval_align(&st->last_collected_time, st->update_every);
- unsigned long long ut = st->last_collected_time.tv_sec * 1000000ULL + st->last_collected_time.tv_usec - st->usec_since_last_update;
- st->last_updated.tv_sec = (time_t) (ut / 1000000ULL);
- st->last_updated.tv_usec = (suseconds_t) (ut % 1000000ULL);
+ usec_t ut = st->last_collected_time.tv_sec * USEC_PER_SEC + st->last_collected_time.tv_usec - st->usec_since_last_update;
+ st->last_updated.tv_sec = (time_t) (ut / USEC_PER_SEC);
+ st->last_updated.tv_usec = (suseconds_t) (ut % USEC_PER_SEC);
// the first entry should not be stored
store_this_entry = 0;
// last_stored_ut = the last time we added a value to the storage
// now_collect_ut = the time the current value has been collected
// next_store_ut = the time of the next interpolation point
- last_stored_ut = st->last_updated.tv_sec * 1000000ULL + st->last_updated.tv_usec;
- now_collect_ut = st->last_collected_time.tv_sec * 1000000ULL + st->last_collected_time.tv_usec;
- next_store_ut = (st->last_updated.tv_sec + st->update_every) * 1000000ULL;
+ last_stored_ut = st->last_updated.tv_sec * USEC_PER_SEC + st->last_updated.tv_usec;
+ now_collect_ut = st->last_collected_time.tv_sec * USEC_PER_SEC + st->last_collected_time.tv_usec;
+ next_store_ut = (st->last_updated.tv_sec + st->update_every) * USEC_PER_SEC;
if(unlikely(st->debug)) {
debug(D_RRD_STATS, "%s: last_collect_ut = %0.3Lf (last collection time)", st->name, (long double)last_collect_ut/1000000.0);
int dimensions;
st->collected_total = 0;
for( rd = st->dimensions, dimensions = 0 ; rd ; rd = rd->next, dimensions++ )
- if(likely(rd->updated)) st->collected_total += rd->collected_value;
+ if(likely(rrddim_flag_check(rd, RRDDIM_FLAG_UPDATED)))
+ st->collected_total += rd->collected_value;
uint32_t storage_flags = SN_EXISTS;
// at this stage we do not interpolate anything
for( rd = st->dimensions ; rd ; rd = rd->next ) {
- if(unlikely(!rd->updated)) {
+ if(unlikely(!rrddim_flag_check(rd, RRDDIM_FLAG_UPDATED))) {
rd->calculated_value = 0;
continue;
}
);
switch(rd->algorithm) {
- case RRDDIM_ABSOLUTE:
+ case RRDDIM_ALGORITHM_ABSOLUTE:
rd->calculated_value = (calculated_number)rd->collected_value
* (calculated_number)rd->multiplier
/ (calculated_number)rd->divisor;
);
break;
- case RRDDIM_PCENT_OVER_ROW_TOTAL:
+ case RRDDIM_ALGORITHM_PCENT_OVER_ROW_TOTAL:
if(unlikely(!st->collected_total))
rd->calculated_value = 0;
else
);
break;
- case RRDDIM_INCREMENTAL:
+ case RRDDIM_ALGORITHM_INCREMENTAL:
if(unlikely(rd->counter <= 1)) {
rd->calculated_value = 0;
continue;
, st->name, rd->name
, rd->last_collected_value
, rd->collected_value);
- if(!(rd->flags & RRDDIM_FLAG_DONT_DETECT_RESETS_OR_OVERFLOWS)) storage_flags = SN_EXISTS_RESET;
+
+ if(!(rrddim_flag_check(rd, RRDDIM_FLAG_DONT_DETECT_RESETS_OR_OVERFLOWS)))
+ storage_flags = SN_EXISTS_RESET;
+
rd->last_collected_value = rd->collected_value;
}
);
break;
- case RRDDIM_PCENT_OVER_DIFF_TOTAL:
+ case RRDDIM_ALGORITHM_PCENT_OVER_DIFF_TOTAL:
if(unlikely(rd->counter <= 1)) {
rd->calculated_value = 0;
continue;
, st->name, rd->name
, rd->last_collected_value
, rd->collected_value);
- if(!(rd->flags & RRDDIM_FLAG_DONT_DETECT_RESETS_OR_OVERFLOWS)) storage_flags = SN_EXISTS_RESET;
+
+ if(!(rrddim_flag_check(rd, RRDDIM_FLAG_DONT_DETECT_RESETS_OR_OVERFLOWS)))
+ storage_flags = SN_EXISTS_RESET;
+
rd->last_collected_value = rd->collected_value;
}
if(unlikely(now_collect_ut < next_store_ut)) {
// this is collected in the same interpolation point
if(unlikely(st->debug)) debug(D_RRD_STATS, "%s: THIS IS IN THE SAME INTERPOLATION POINT", st->name);
+#ifdef NETDATA_INTERNAL_CHECKS
+ info("%s is collected in the same interpolation point: short by %llu microseconds", st->name, next_store_ut - now_collect_ut);
+#endif
}
- unsigned long long first_ut = last_stored_ut;
+ usec_t first_ut = last_stored_ut;
long long iterations = (now_collect_ut - last_stored_ut) / (update_every_ut);
if((now_collect_ut % (update_every_ut)) == 0) iterations++;
debug(D_RRD_STATS, "%s: next_store_ut = %0.3Lf (next interpolation point)", st->name, (long double)next_store_ut/1000000.0);
}
- st->last_updated.tv_sec = (time_t) (next_store_ut / 1000000ULL);
+ st->last_updated.tv_sec = (time_t) (next_store_ut / USEC_PER_SEC);
st->last_updated.tv_usec = 0;
for( rd = st->dimensions ; likely(rd) ; rd = rd->next ) {
calculated_number new_value;
switch(rd->algorithm) {
- case RRDDIM_INCREMENTAL:
+ case RRDDIM_ALGORITHM_INCREMENTAL:
new_value = (calculated_number)
( rd->calculated_value
* (calculated_number)(next_store_ut - last_collect_ut)
}
break;
- case RRDDIM_ABSOLUTE:
- case RRDDIM_PCENT_OVER_ROW_TOTAL:
- case RRDDIM_PCENT_OVER_DIFF_TOTAL:
+ case RRDDIM_ALGORITHM_ABSOLUTE:
+ case RRDDIM_ALGORITHM_PCENT_OVER_ROW_TOTAL:
+ case RRDDIM_ALGORITHM_PCENT_OVER_DIFF_TOTAL:
default:
if(iterations == 1) {
// this is the last iteration
continue;
}
- if(likely(rd->updated && rd->counter > 1 && iterations < st->gap_when_lost_iterations_above)) {
+ if(likely(rrddim_flag_check(rd, RRDDIM_FLAG_UPDATED) && rd->counter > 1 && iterations < st->gap_when_lost_iterations_above)) {
rd->values[st->current_entry] = pack_storage_number(new_value, storage_flags );
rd->last_stored_value = new_value;
st->last_collected_total = st->collected_total;
for( rd = st->dimensions; rd ; rd = rd->next ) {
- if(unlikely(!rd->updated)) continue;
+ if(unlikely(!rrddim_flag_check(rd, RRDDIM_FLAG_UPDATED)))
+ continue;
if(unlikely(st->debug)) debug(D_RRD_STATS, "%s/%s: setting last_collected_value (old: " COLLECTED_NUMBER_FORMAT ") to last_collected_value (new: " COLLECTED_NUMBER_FORMAT ")", st->id, rd->name, rd->last_collected_value, rd->collected_value);
rd->last_collected_value = rd->collected_value;
switch(rd->algorithm) {
- case RRDDIM_INCREMENTAL:
+ case RRDDIM_ALGORITHM_INCREMENTAL:
if(unlikely(!first_entry)) {
if(unlikely(st->debug)) debug(D_RRD_STATS, "%s/%s: setting last_calculated_value (old: " CALCULATED_NUMBER_FORMAT ") to last_calculated_value (new: " CALCULATED_NUMBER_FORMAT ")", st->id, rd->name, rd->last_calculated_value + rd->calculated_value, rd->calculated_value);
rd->last_calculated_value += rd->calculated_value;
}
break;
- case RRDDIM_ABSOLUTE:
- case RRDDIM_PCENT_OVER_ROW_TOTAL:
- case RRDDIM_PCENT_OVER_DIFF_TOTAL:
+ case RRDDIM_ALGORITHM_ABSOLUTE:
+ case RRDDIM_ALGORITHM_PCENT_OVER_ROW_TOTAL:
+ case RRDDIM_ALGORITHM_PCENT_OVER_DIFF_TOTAL:
if(unlikely(st->debug)) debug(D_RRD_STATS, "%s/%s: setting last_calculated_value (old: " CALCULATED_NUMBER_FORMAT ") to last_calculated_value (new: " CALCULATED_NUMBER_FORMAT ")", st->id, rd->name, rd->last_calculated_value, rd->calculated_value);
rd->last_calculated_value = rd->calculated_value;
break;
rd->calculated_value = 0;
rd->collected_value = 0;
- rd->updated = 0;
+ rrddim_flag_clear(rd, RRDDIM_FLAG_UPDATED);
if(unlikely(st->debug)) debug(D_RRD_STATS, "%s/%s: END "
" last_collected_value = " COLLECTED_NUMBER_FORMAT