// SPDX-License-Identifier: GPL-3.0-or-later #include "daemon/common.h" #include "database/KolmogorovSmirnovDist.h" #define MAX_POINTS 10000 int enable_metric_correlations = CONFIG_BOOLEAN_YES; int metric_correlations_version = 1; WEIGHTS_METHOD default_metric_correlations_method = WEIGHTS_METHOD_MC_KS2; typedef struct weights_stats { NETDATA_DOUBLE max_base_high_ratio; size_t db_points; size_t result_points; size_t db_queries; size_t db_points_per_tier[RRD_STORAGE_TIERS]; size_t binary_searches; } WEIGHTS_STATS; // ---------------------------------------------------------------------------- // parse and render metric correlations methods static struct { const char *name; WEIGHTS_METHOD value; } weights_methods[] = { { "ks2" , WEIGHTS_METHOD_MC_KS2} , { "volume" , WEIGHTS_METHOD_MC_VOLUME} , { "anomaly-rate" , WEIGHTS_METHOD_ANOMALY_RATE} , { "value" , WEIGHTS_METHOD_VALUE} , { NULL , 0 } }; WEIGHTS_METHOD weights_string_to_method(const char *method) { for(int i = 0; weights_methods[i].name ;i++) if(strcmp(method, weights_methods[i].name) == 0) return weights_methods[i].value; return default_metric_correlations_method; } const char *weights_method_to_string(WEIGHTS_METHOD method) { for(int i = 0; weights_methods[i].name ;i++) if(weights_methods[i].value == method) return weights_methods[i].name; return "unknown"; } // ---------------------------------------------------------------------------- // The results per dimension are aggregated into a dictionary typedef enum { RESULT_IS_BASE_HIGH_RATIO = (1 << 0), RESULT_IS_PERCENTAGE_OF_TIME = (1 << 1), } RESULT_FLAGS; struct register_result { RESULT_FLAGS flags; RRDHOST *host; RRDCONTEXT_ACQUIRED *rca; RRDINSTANCE_ACQUIRED *ria; RRDMETRIC_ACQUIRED *rma; NETDATA_DOUBLE value; STORAGE_POINT highlighted; STORAGE_POINT baseline; usec_t duration_ut; }; static DICTIONARY *register_result_init() { DICTIONARY *results = dictionary_create_advanced(DICT_OPTION_SINGLE_THREADED | DICT_OPTION_FIXED_SIZE, NULL, sizeof(struct register_result)); return results; } static void register_result_destroy(DICTIONARY *results) { dictionary_destroy(results); } static void register_result(DICTIONARY *results, RRDHOST *host, RRDCONTEXT_ACQUIRED *rca, RRDINSTANCE_ACQUIRED *ria, RRDMETRIC_ACQUIRED *rma, NETDATA_DOUBLE value, RESULT_FLAGS flags, STORAGE_POINT *highlighted, STORAGE_POINT *baseline, WEIGHTS_STATS *stats, bool register_zero, usec_t duration_ut) { if(!netdata_double_isnumber(value)) return; // make it positive NETDATA_DOUBLE v = fabsndd(value); // no need to store zero scored values if(unlikely(fpclassify(v) == FP_ZERO && !register_zero)) return; // keep track of the max of the baseline / highlight ratio if((flags & RESULT_IS_BASE_HIGH_RATIO) && v > stats->max_base_high_ratio) stats->max_base_high_ratio = v; struct register_result t = { .flags = flags, .host = host, .rca = rca, .ria = ria, .rma = rma, .value = v, .duration_ut = duration_ut, }; if(highlighted) t.highlighted = *highlighted; if(baseline) t.baseline = *baseline; // we can use the pointer address or RMA as a unique key for each metric char buf[20 + 1]; ssize_t len = snprintfz(buf, sizeof(buf) - 1, "%p", rma); dictionary_set_advanced(results, buf, len, &t, sizeof(struct register_result), NULL); } // ---------------------------------------------------------------------------- // Generation of JSON output for the results static void results_header_to_json(DICTIONARY *results __maybe_unused, BUFFER *wb, time_t after, time_t before, time_t baseline_after, time_t baseline_before, size_t points, WEIGHTS_METHOD method, RRDR_TIME_GROUPING group, RRDR_OPTIONS options, uint32_t shifts, size_t examined_dimensions __maybe_unused, usec_t duration, WEIGHTS_STATS *stats) { buffer_json_member_add_time_t(wb, "after", after); buffer_json_member_add_time_t(wb, "before", before); buffer_json_member_add_time_t(wb, "duration", before - after); buffer_json_member_add_uint64(wb, "points", points); if(method == WEIGHTS_METHOD_MC_KS2 || method == WEIGHTS_METHOD_MC_VOLUME) { buffer_json_member_add_time_t(wb, "baseline_after", baseline_after); buffer_json_member_add_time_t(wb, "baseline_before", baseline_before); buffer_json_member_add_time_t(wb, "baseline_duration", baseline_before - baseline_after); buffer_json_member_add_uint64(wb, "baseline_points", points << shifts); } buffer_json_member_add_object(wb, "statistics"); { buffer_json_member_add_double(wb, "query_time_ms", (double) duration / (double) USEC_PER_MS); buffer_json_member_add_uint64(wb, "db_queries", stats->db_queries); buffer_json_member_add_uint64(wb, "query_result_points", stats->result_points); buffer_json_member_add_uint64(wb, "binary_searches", stats->binary_searches); buffer_json_member_add_uint64(wb, "db_points_read", stats->db_points); buffer_json_member_add_array(wb, "db_points_per_tier"); { for (size_t tier = 0; tier < storage_tiers; tier++) buffer_json_add_array_item_uint64(wb, stats->db_points_per_tier[tier]); } buffer_json_array_close(wb); } buffer_json_object_close(wb); buffer_json_member_add_string(wb, "group", time_grouping_tostring(group)); buffer_json_member_add_string(wb, "method", weights_method_to_string(method)); rrdr_options_to_buffer_json_array(wb, "options", options); } static size_t registered_results_to_json_charts(DICTIONARY *results, BUFFER *wb, time_t after, time_t before, time_t baseline_after, time_t baseline_before, size_t points, WEIGHTS_METHOD method, RRDR_TIME_GROUPING group, RRDR_OPTIONS options, uint32_t shifts, size_t examined_dimensions, usec_t duration, WEIGHTS_STATS *stats) { buffer_json_initialize(wb, "\"", "\"", 0, true, (options & RRDR_OPTION_MINIFY) ? BUFFER_JSON_OPTIONS_MINIFY : BUFFER_JSON_OPTIONS_DEFAULT); results_header_to_json(results, wb, after, before, baseline_after, baseline_before, points, method, group, options, shifts, examined_dimensions, duration, stats); buffer_json_member_add_object(wb, "correlated_charts"); size_t charts = 0, total_dimensions = 0; struct register_result *t; RRDINSTANCE_ACQUIRED *last_ria = NULL; // never access this - we use it only for comparison dfe_start_read(results, t) { if(t->ria != last_ria) { last_ria = t->ria; if(charts) { buffer_json_object_close(wb); // dimensions buffer_json_object_close(wb); // chart:id } buffer_json_member_add_object(wb, rrdinstance_acquired_id(t->ria)); buffer_json_member_add_string(wb, "context", rrdcontext_acquired_id(t->rca)); buffer_json_member_add_object(wb, "dimensions"); charts++; } buffer_json_member_add_double(wb, rrdmetric_acquired_name(t->rma), t->value); total_dimensions++; } dfe_done(t); // close dimensions and chart if (total_dimensions) { buffer_json_object_close(wb); // dimensions buffer_json_object_close(wb); // chart:id } buffer_json_object_close(wb); buffer_json_member_add_uint64(wb, "correlated_dimensions", total_dimensions); buffer_json_member_add_uint64(wb, "total_dimensions_count", examined_dimensions); buffer_json_finalize(wb); return total_dimensions; } static size_t registered_results_to_json_contexts(DICTIONARY *results, BUFFER *wb, time_t after, time_t before, time_t baseline_after, time_t baseline_before, size_t points, WEIGHTS_METHOD method, RRDR_TIME_GROUPING group, RRDR_OPTIONS options, uint32_t shifts, size_t examined_dimensions, usec_t duration, WEIGHTS_STATS *stats) { buffer_json_initialize(wb, "\"", "\"", 0, true, (options & RRDR_OPTION_MINIFY) ? BUFFER_JSON_OPTIONS_MINIFY : BUFFER_JSON_OPTIONS_DEFAULT); results_header_to_json(results, wb, after, before, baseline_after, baseline_before, points, method, group, options, shifts, examined_dimensions, duration, stats); buffer_json_member_add_object(wb, "contexts"); size_t contexts = 0, charts = 0, total_dimensions = 0, context_dims = 0, chart_dims = 0; NETDATA_DOUBLE contexts_total_weight = 0.0, charts_total_weight = 0.0; struct register_result *t; RRDCONTEXT_ACQUIRED *last_rca = NULL; RRDINSTANCE_ACQUIRED *last_ria = NULL; dfe_start_read(results, t) { if(t->rca != last_rca) { last_rca = t->rca; if(contexts) { buffer_json_object_close(wb); // dimensions buffer_json_member_add_double(wb, "weight", charts_total_weight / (double) chart_dims); buffer_json_object_close(wb); // chart:id buffer_json_object_close(wb); // charts buffer_json_member_add_double(wb, "weight", contexts_total_weight / (double) context_dims); buffer_json_object_close(wb); // context } buffer_json_member_add_object(wb, rrdcontext_acquired_id(t->rca)); buffer_json_member_add_object(wb, "charts"); contexts++; charts = 0; context_dims = 0; contexts_total_weight = 0.0; last_ria = NULL; } if(t->ria != last_ria) { last_ria = t->ria; if(charts) { buffer_json_object_close(wb); // dimensions buffer_json_member_add_double(wb, "weight", charts_total_weight / (double) chart_dims); buffer_json_object_close(wb); // chart:id } buffer_json_member_add_object(wb, rrdinstance_acquired_id(t->ria)); buffer_json_member_add_object(wb, "dimensions"); charts++; chart_dims = 0; charts_total_weight = 0.0; } buffer_json_member_add_double(wb, rrdmetric_acquired_name(t->rma), t->value); charts_total_weight += t->value; contexts_total_weight += t->value; chart_dims++; context_dims++; total_dimensions++; } dfe_done(t); // close dimensions and chart if (total_dimensions) { buffer_json_object_close(wb); // dimensions buffer_json_member_add_double(wb, "weight", charts_total_weight / (double) chart_dims); buffer_json_object_close(wb); // chart:id buffer_json_object_close(wb); // charts buffer_json_member_add_double(wb, "weight", contexts_total_weight / (double) context_dims); buffer_json_object_close(wb); // context } buffer_json_object_close(wb); buffer_json_member_add_uint64(wb, "correlated_dimensions", total_dimensions); buffer_json_member_add_uint64(wb, "total_dimensions_count", examined_dimensions); buffer_json_finalize(wb); return total_dimensions; } struct query_weights_data { QUERY_WEIGHTS_REQUEST *qwr; SIMPLE_PATTERN *scope_nodes_sp; SIMPLE_PATTERN *scope_contexts_sp; SIMPLE_PATTERN *nodes_sp; SIMPLE_PATTERN *contexts_sp; SIMPLE_PATTERN *instances_sp; SIMPLE_PATTERN *dimensions_sp; SIMPLE_PATTERN *labels_sp; SIMPLE_PATTERN *alerts_sp; usec_t timeout_us; bool timed_out; bool interrupted; struct query_timings timings; size_t examined_dimensions; bool register_zero; DICTIONARY *results; WEIGHTS_STATS stats; uint32_t shifts; struct query_versions versions; }; #define AGGREGATED_WEIGHT_EMPTY (struct aggregated_weight) { \ .min = NAN, \ .max = NAN, \ .sum = NAN, \ .count = 0, \ .hsp = STORAGE_POINT_UNSET, \ .bsp = STORAGE_POINT_UNSET, \ } #define merge_into_aw(aw, t) do { \ if(!(aw).count) { \ (aw).count = 1; \ (aw).min = (aw).max = (aw).sum = (t)->value; \ (aw).hsp = (t)->highlighted; \ if(baseline) \ (aw).bsp = (t)->baseline; \ } \ else { \ (aw).count++; \ (aw).sum += (t)->value; \ if((t)->value < (aw).min) \ (aw).min = (t)->value; \ if((t)->value > (aw).max) \ (aw).max = (t)->value; \ storage_point_merge_to((aw).hsp, (t)->highlighted); \ if(baseline) \ storage_point_merge_to((aw).bsp, (t)->baseline); \ } \ } while(0) static void results_header_to_json_v2(DICTIONARY *results __maybe_unused, BUFFER *wb, struct query_weights_data *qwd, time_t after, time_t before, time_t baseline_after, time_t baseline_before, size_t points, WEIGHTS_METHOD method, RRDR_TIME_GROUPING group, RRDR_OPTIONS options, uint32_t shifts, size_t examined_dimensions __maybe_unused, usec_t duration __maybe_unused, WEIGHTS_STATS *stats, bool group_by) { buffer_json_member_add_object(wb, "request"); buffer_json_member_add_string(wb, "method", weights_method_to_string(method)); rrdr_options_to_buffer_json_array(wb, "options", options); buffer_json_member_add_object(wb, "scope"); buffer_json_member_add_string(wb, "scope_nodes", qwd->qwr->scope_nodes ? qwd->qwr->scope_nodes : "*"); buffer_json_member_add_string(wb, "scope_contexts", qwd->qwr->scope_contexts ? qwd->qwr->scope_contexts : "*"); buffer_json_object_close(wb); buffer_json_member_add_object(wb, "selectors"); buffer_json_member_add_string(wb, "nodes", qwd->qwr->nodes ? qwd->qwr->nodes : "*"); buffer_json_member_add_string(wb, "contexts", qwd->qwr->contexts ? qwd->qwr->contexts : "*"); buffer_json_member_add_string(wb, "instances", qwd->qwr->instances ? qwd->qwr->instances : "*"); buffer_json_member_add_string(wb, "dimensions", qwd->qwr->dimensions ? qwd->qwr->dimensions : "*"); buffer_json_member_add_string(wb, "labels", qwd->qwr->labels ? qwd->qwr->labels : "*"); buffer_json_member_add_string(wb, "alerts", qwd->qwr->alerts ? qwd->qwr->alerts : "*"); buffer_json_object_close(wb); buffer_json_member_add_object(wb, "window"); buffer_json_member_add_time_t(wb, "after", qwd->qwr->after); buffer_json_member_add_time_t(wb, "before", qwd->qwr->before); buffer_json_member_add_uint64(wb, "points", qwd->qwr->points); if(qwd->qwr->options & RRDR_OPTION_SELECTED_TIER) buffer_json_member_add_uint64(wb, "tier", qwd->qwr->tier); else buffer_json_member_add_string(wb, "tier", NULL); buffer_json_object_close(wb); if(method == WEIGHTS_METHOD_MC_KS2 || method == WEIGHTS_METHOD_MC_VOLUME) { buffer_json_member_add_object(wb, "baseline"); buffer_json_member_add_time_t(wb, "baseline_after", qwd->qwr->baseline_after); buffer_json_member_add_time_t(wb, "baseline_before", qwd->qwr->baseline_before); buffer_json_object_close(wb); } buffer_json_member_add_object(wb, "aggregations"); buffer_json_member_add_object(wb, "time"); buffer_json_member_add_string(wb, "time_group", time_grouping_tostring(qwd->qwr->time_group_method)); buffer_json_member_add_string(wb, "time_group_options", qwd->qwr->time_group_options); buffer_json_object_close(wb); // time buffer_json_member_add_array(wb, "metrics"); buffer_json_add_array_item_object(wb); { buffer_json_member_add_array(wb, "group_by"); buffer_json_group_by_to_array(wb, qwd->qwr->group_by.group_by); buffer_json_array_close(wb); // buffer_json_member_add_array(wb, "group_by_label"); // buffer_json_array_close(wb); buffer_json_member_add_string(wb, "aggregation", group_by_aggregate_function_to_string(qwd->qwr->group_by.aggregation)); } buffer_json_object_close(wb); // 1st group by buffer_json_array_close(wb); // array buffer_json_object_close(wb); // aggregations buffer_json_member_add_uint64(wb, "timeout", qwd->qwr->timeout_ms); buffer_json_object_close(wb); // request buffer_json_member_add_object(wb, "view"); buffer_json_member_add_string(wb, "format", (group_by)?"grouped":"full"); buffer_json_member_add_string(wb, "time_group", time_grouping_tostring(group)); buffer_json_member_add_object(wb, "window"); buffer_json_member_add_time_t(wb, "after", after); buffer_json_member_add_time_t(wb, "before", before); buffer_json_member_add_time_t(wb, "duration", before - after); buffer_json_member_add_uint64(wb, "points", points); buffer_json_object_close(wb); if(method == WEIGHTS_METHOD_MC_KS2 || method == WEIGHTS_METHOD_MC_VOLUME) { buffer_json_member_add_object(wb, "baseline"); buffer_json_member_add_time_t(wb, "after", baseline_after); buffer_json_member_add_time_t(wb, "before", baseline_before); buffer_json_member_add_time_t(wb, "duration", baseline_before - baseline_after); buffer_json_member_add_uint64(wb, "points", points << shifts); buffer_json_object_close(wb); } buffer_json_object_close(wb); // view buffer_json_member_add_object(wb, "db"); { buffer_json_member_add_uint64(wb, "db_queries", stats->db_queries); buffer_json_member_add_uint64(wb, "query_result_points", stats->result_points); buffer_json_member_add_uint64(wb, "binary_searches", stats->binary_searches); buffer_json_member_add_uint64(wb, "db_points_read", stats->db_points); buffer_json_member_add_array(wb, "db_points_per_tier"); { for (size_t tier = 0; tier < storage_tiers; tier++) buffer_json_add_array_item_uint64(wb, stats->db_points_per_tier[tier]); } buffer_json_array_close(wb); } buffer_json_object_close(wb); // db } typedef enum { WPT_DIMENSION = 0, WPT_INSTANCE = 1, WPT_CONTEXT = 2, WPT_NODE = 3, WPT_GROUP = 4, } WEIGHTS_POINT_TYPE; struct aggregated_weight { const char *name; NETDATA_DOUBLE min; NETDATA_DOUBLE max; NETDATA_DOUBLE sum; size_t count; STORAGE_POINT hsp; STORAGE_POINT bsp; }; static inline void storage_point_to_json(BUFFER *wb, WEIGHTS_POINT_TYPE type, ssize_t di, ssize_t ii, ssize_t ci, ssize_t ni, struct aggregated_weight *aw, RRDR_OPTIONS options __maybe_unused, bool baseline) { if(type != WPT_GROUP) { buffer_json_add_array_item_array(wb); buffer_json_add_array_item_uint64(wb, type); // "type" buffer_json_add_array_item_int64(wb, ni); if (type != WPT_NODE) { buffer_json_add_array_item_int64(wb, ci); if (type != WPT_CONTEXT) { buffer_json_add_array_item_int64(wb, ii); if (type != WPT_INSTANCE) buffer_json_add_array_item_int64(wb, di); else buffer_json_add_array_item_string(wb, NULL); } else { buffer_json_add_array_item_string(wb, NULL); buffer_json_add_array_item_string(wb, NULL); } } else { buffer_json_add_array_item_string(wb, NULL); buffer_json_add_array_item_string(wb, NULL); buffer_json_add_array_item_string(wb, NULL); } buffer_json_add_array_item_double(wb, (aw->count) ? aw->sum / (NETDATA_DOUBLE)aw->count : 0.0); // "weight" } else { buffer_json_member_add_array(wb, "v"); buffer_json_add_array_item_array(wb); buffer_json_add_array_item_double(wb, aw->min); // "min" buffer_json_add_array_item_double(wb, (aw->count) ? aw->sum / (NETDATA_DOUBLE)aw->count : 0.0); // "avg" buffer_json_add_array_item_double(wb, aw->max); // "max" buffer_json_add_array_item_double(wb, aw->sum); // "sum" buffer_json_add_array_item_uint64(wb, aw->count); // "count" buffer_json_array_close(wb); } buffer_json_add_array_item_array(wb); buffer_json_add_array_item_double(wb, aw->hsp.min); // "min" buffer_json_add_array_item_double(wb, (aw->hsp.count) ? aw->hsp.sum / (NETDATA_DOUBLE) aw->hsp.count : 0.0); // "avg" buffer_json_add_array_item_double(wb, aw->hsp.max); // "max" buffer_json_add_array_item_double(wb, aw->hsp.sum); // "sum" buffer_json_add_array_item_uint64(wb, aw->hsp.count); // "count" buffer_json_add_array_item_uint64(wb, aw->hsp.anomaly_count); // "anomaly_count" buffer_json_array_close(wb); if(baseline) { buffer_json_add_array_item_array(wb); buffer_json_add_array_item_double(wb, aw->bsp.min); // "min" buffer_json_add_array_item_double(wb, (aw->bsp.count) ? aw->bsp.sum / (NETDATA_DOUBLE) aw->bsp.count : 0.0); // "avg" buffer_json_add_array_item_double(wb, aw->bsp.max); // "max" buffer_json_add_array_item_double(wb, aw->bsp.sum); // "sum" buffer_json_add_array_item_uint64(wb, aw->bsp.count); // "count" buffer_json_add_array_item_uint64(wb, aw->bsp.anomaly_count); // "anomaly_count" buffer_json_array_close(wb); } buffer_json_array_close(wb); } static void multinode_data_schema(BUFFER *wb, RRDR_OPTIONS options __maybe_unused, const char *key, bool baseline, bool group_by) { buffer_json_member_add_object(wb, key); // schema buffer_json_member_add_string(wb, "type", "array"); buffer_json_member_add_array(wb, "items"); if(group_by) { buffer_json_add_array_item_object(wb); { buffer_json_member_add_string(wb, "name", "weight"); buffer_json_member_add_string(wb, "type", "array"); buffer_json_member_add_array(wb, "labels"); { buffer_json_add_array_item_string(wb, "min"); buffer_json_add_array_item_string(wb, "avg"); buffer_json_add_array_item_string(wb, "max"); buffer_json_add_array_item_string(wb, "sum"); buffer_json_add_array_item_string(wb, "count"); } buffer_json_array_close(wb); } buffer_json_object_close(wb); } else { buffer_json_add_array_item_object(wb); buffer_json_member_add_string(wb, "name", "row_type"); buffer_json_member_add_string(wb, "type", "integer"); buffer_json_member_add_array(wb, "value"); buffer_json_add_array_item_string(wb, "dimension"); buffer_json_add_array_item_string(wb, "instance"); buffer_json_add_array_item_string(wb, "context"); buffer_json_add_array_item_string(wb, "node"); buffer_json_array_close(wb); buffer_json_object_close(wb); buffer_json_add_array_item_object(wb); { buffer_json_member_add_string(wb, "name", "ni"); buffer_json_member_add_string(wb, "type", "integer"); buffer_json_member_add_string(wb, "dictionary", "nodes"); } buffer_json_object_close(wb); buffer_json_add_array_item_object(wb); { buffer_json_member_add_string(wb, "name", "ci"); buffer_json_member_add_string(wb, "type", "integer"); buffer_json_member_add_string(wb, "dictionary", "contexts"); } buffer_json_object_close(wb); buffer_json_add_array_item_object(wb); { buffer_json_member_add_string(wb, "name", "ii"); buffer_json_member_add_string(wb, "type", "integer"); buffer_json_member_add_string(wb, "dictionary", "instances"); } buffer_json_object_close(wb); buffer_json_add_array_item_object(wb); { buffer_json_member_add_string(wb, "name", "di"); buffer_json_member_add_string(wb, "type", "integer"); buffer_json_member_add_string(wb, "dictionary", "dimensions"); } buffer_json_object_close(wb); buffer_json_add_array_item_object(wb); { buffer_json_member_add_string(wb, "name", "weight"); buffer_json_member_add_string(wb, "type", "number"); } buffer_json_object_close(wb); } buffer_json_add_array_item_object(wb); { buffer_json_member_add_string(wb, "name", "timeframe"); buffer_json_member_add_string(wb, "type", "array"); buffer_json_member_add_array(wb, "labels"); { buffer_json_add_array_item_string(wb, "min"); buffer_json_add_array_item_string(wb, "avg"); buffer_json_add_array_item_string(wb, "max"); buffer_json_add_array_item_string(wb, "sum"); buffer_json_add_array_item_string(wb, "count"); buffer_json_add_array_item_string(wb, "anomaly_count"); } buffer_json_array_close(wb); buffer_json_member_add_object(wb, "calculations"); buffer_json_member_add_string(wb, "anomaly rate", "anomaly_count * 100 / count"); buffer_json_object_close(wb); } buffer_json_object_close(wb); if(baseline) { buffer_json_add_array_item_object(wb); { buffer_json_member_add_string(wb, "name", "baseline timeframe"); buffer_json_member_add_string(wb, "type", "array"); buffer_json_member_add_array(wb, "labels"); { buffer_json_add_array_item_string(wb, "min"); buffer_json_add_array_item_string(wb, "avg"); buffer_json_add_array_item_string(wb, "max"); buffer_json_add_array_item_string(wb, "sum"); buffer_json_add_array_item_string(wb, "count"); buffer_json_add_array_item_string(wb, "anomaly_count"); } buffer_json_array_close(wb); buffer_json_member_add_object(wb, "calculations"); buffer_json_member_add_string(wb, "anomaly rate", "anomaly_count * 100 / count"); buffer_json_object_close(wb); } buffer_json_object_close(wb); } buffer_json_array_close(wb); // items buffer_json_object_close(wb); // schema } struct dict_unique_node { bool existing; bool exposed; uint32_t i; RRDHOST *host; usec_t duration_ut; }; struct dict_unique_name_units { bool existing; bool exposed; uint32_t i; const char *units; }; struct dict_unique_id_name { bool existing; bool exposed; uint32_t i; const char *id; const char *name; }; static inline struct dict_unique_node *dict_unique_node_add(DICTIONARY *dict, RRDHOST *host, ssize_t *max_id) { struct dict_unique_node *dun = dictionary_set(dict, host->machine_guid, NULL, sizeof(struct dict_unique_node)); if(!dun->existing) { dun->existing = true; dun->host = host; dun->i = *max_id; (*max_id)++; } return dun; } static inline struct dict_unique_name_units *dict_unique_name_units_add(DICTIONARY *dict, const char *name, const char *units, ssize_t *max_id) { struct dict_unique_name_units *dun = dictionary_set(dict, name, NULL, sizeof(struct dict_unique_name_units)); if(!dun->existing) { dun->units = units; dun->existing = true; dun->i = *max_id; (*max_id)++; } return dun; } static inline struct dict_unique_id_name *dict_unique_id_name_add(DICTIONARY *dict, const char *id, const char *name, ssize_t *max_id) { char key[1024 + 1]; snprintfz(key, sizeof(key) - 1, "%s:%s", id, name); struct dict_unique_id_name *dun = dictionary_set(dict, key, NULL, sizeof(struct dict_unique_id_name)); if(!dun->existing) { dun->existing = true; dun->i = *max_id; (*max_id)++; dun->id = id; dun->name = name; } return dun; } static size_t registered_results_to_json_multinode_no_group_by( DICTIONARY *results, BUFFER *wb, time_t after, time_t before, time_t baseline_after, time_t baseline_before, size_t points, WEIGHTS_METHOD method, RRDR_TIME_GROUPING group, RRDR_OPTIONS options, uint32_t shifts, size_t examined_dimensions, struct query_weights_data *qwd, WEIGHTS_STATS *stats, struct query_versions *versions) { buffer_json_initialize(wb, "\"", "\"", 0, true, (options & RRDR_OPTION_MINIFY) ? BUFFER_JSON_OPTIONS_MINIFY : BUFFER_JSON_OPTIONS_DEFAULT); buffer_json_member_add_uint64(wb, "api", 2); results_header_to_json_v2(results, wb, qwd, after, before, baseline_after, baseline_before, points, method, group, options, shifts, examined_dimensions, qwd->timings.executed_ut - qwd->timings.received_ut, stats, false); version_hashes_api_v2(wb, versions); bool baseline = method == WEIGHTS_METHOD_MC_KS2 || method == WEIGHTS_METHOD_MC_VOLUME; multinode_data_schema(wb, options, "schema", baseline, false); DICTIONARY *dict_nodes = dictionary_create_advanced(DICT_OPTION_SINGLE_THREADED | DICT_OPTION_DONT_OVERWRITE_VALUE | DICT_OPTION_FIXED_SIZE, NULL, sizeof(struct dict_unique_node)); DICTIONARY *dict_contexts = dictionary_create_advanced(DICT_OPTION_SINGLE_THREADED | DICT_OPTION_DONT_OVERWRITE_VALUE | DICT_OPTION_FIXED_SIZE, NULL, sizeof(struct dict_unique_name_units)); DICTIONARY *dict_instances = dictionary_create_advanced(DICT_OPTION_SINGLE_THREADED | DICT_OPTION_DONT_OVERWRITE_VALUE | DICT_OPTION_FIXED_SIZE, NULL, sizeof(struct dict_unique_id_name)); DICTIONARY *dict_dimensions = dictionary_create_advanced(DICT_OPTION_SINGLE_THREADED | DICT_OPTION_DONT_OVERWRITE_VALUE | DICT_OPTION_FIXED_SIZE, NULL, sizeof(struct dict_unique_id_name)); buffer_json_member_add_array(wb, "result"); struct aggregated_weight node_aw = AGGREGATED_WEIGHT_EMPTY, context_aw = AGGREGATED_WEIGHT_EMPTY, instance_aw = AGGREGATED_WEIGHT_EMPTY; struct register_result *t; RRDHOST *last_host = NULL; RRDCONTEXT_ACQUIRED *last_rca = NULL; RRDINSTANCE_ACQUIRED *last_ria = NULL; struct dict_unique_name_units *context_dun = NULL; struct dict_unique_node *node_dun = NULL; struct dict_unique_id_name *instance_dun = NULL; struct dict_unique_id_name *dimension_dun = NULL; ssize_t di = -1, ii = -1, ci = -1, ni = -1; ssize_t di_max = 0, ii_max = 0, ci_max = 0, ni_max = 0; size_t total_dimensions = 0; dfe_start_read(results, t) { // close instance if(t->ria != last_ria && last_ria) { storage_point_to_json(wb, WPT_INSTANCE, di, ii, ci, ni, &instance_aw, options, baseline); instance_dun->exposed = true; last_ria = NULL; instance_aw = AGGREGATED_WEIGHT_EMPTY; } // close context if(t->rca != last_rca && last_rca) { storage_point_to_json(wb, WPT_CONTEXT, di, ii, ci, ni, &context_aw, options, baseline); context_dun->exposed = true; last_rca = NULL; context_aw = AGGREGATED_WEIGHT_EMPTY; } // close node if(t->host != last_host && last_host) { storage_point_to_json(wb, WPT_NODE, di, ii, ci, ni, &node_aw, options, baseline); node_dun->exposed = true; last_host = NULL; node_aw = AGGREGATED_WEIGHT_EMPTY; } // open node if(t->host != last_host) { last_host = t->host; node_dun = dict_unique_node_add(dict_nodes, t->host, &ni_max); ni = node_dun->i; } // open context if(t->rca != last_rca) { last_rca = t->rca; context_dun = dict_unique_name_units_add(dict_contexts, rrdcontext_acquired_id(t->rca), rrdcontext_acquired_units(t->rca), &ci_max); ci = context_dun->i; } // open instance if(t->ria != last_ria) { last_ria = t->ria; instance_dun = dict_unique_id_name_add(dict_instances, rrdinstance_acquired_id(t->ria), rrdinstance_acquired_name(t->ria), &ii_max); ii = instance_dun->i; } dimension_dun = dict_unique_id_name_add(dict_dimensions, rrdmetric_acquired_id(t->rma), rrdmetric_acquired_name(t->rma), &di_max); di = dimension_dun->i; struct aggregated_weight aw = { .min = t->value, .max = t->value, .sum = t->value, .count = 1, .hsp = t->highlighted, .bsp = t->baseline, }; storage_point_to_json(wb, WPT_DIMENSION, di, ii, ci, ni, &aw, options, baseline); node_dun->exposed = true; context_dun->exposed = true; instance_dun->exposed = true; dimension_dun->exposed = true; merge_into_aw(instance_aw, t); merge_into_aw(context_aw, t); merge_into_aw(node_aw, t); node_dun->duration_ut += t->duration_ut; total_dimensions++; } dfe_done(t); // close instance if(last_ria) { storage_point_to_json(wb, WPT_INSTANCE, di, ii, ci, ni, &instance_aw, options, baseline); instance_dun->exposed = true; } // close context if(last_rca) { storage_point_to_json(wb, WPT_CONTEXT, di, ii, ci, ni, &context_aw, options, baseline); context_dun->exposed = true; } // close node if(last_host) { storage_point_to_json(wb, WPT_NODE, di, ii, ci, ni, &node_aw, options, baseline); node_dun->exposed = true; } buffer_json_array_close(wb); // points buffer_json_member_add_object(wb, "dictionaries"); buffer_json_member_add_array(wb, "nodes"); { struct dict_unique_node *dun; dfe_start_read(dict_nodes, dun) { if(!dun->exposed) continue; buffer_json_add_array_item_object(wb); buffer_json_node_add_v2(wb, dun->host, dun->i, dun->duration_ut, true); buffer_json_object_close(wb); } dfe_done(dun); } buffer_json_array_close(wb); buffer_json_member_add_array(wb, "contexts"); { struct dict_unique_name_units *dun; dfe_start_read(dict_contexts, dun) { if(!dun->exposed) continue; buffer_json_add_array_item_object(wb); buffer_json_member_add_string(wb, "id", dun_dfe.name); buffer_json_member_add_string(wb, "units", dun->units); buffer_json_member_add_int64(wb, "ci", dun->i); buffer_json_object_close(wb); } dfe_done(dun); } buffer_json_array_close(wb); buffer_json_member_add_array(wb, "instances"); { struct dict_unique_id_name *dun; dfe_start_read(dict_instances, dun) { if(!dun->exposed) continue; buffer_json_add_array_item_object(wb); buffer_json_member_add_string(wb, "id", dun->id); if(dun->id != dun->name) buffer_json_member_add_string(wb, "nm", dun->name); buffer_json_member_add_int64(wb, "ii", dun->i); buffer_json_object_close(wb); } dfe_done(dun); } buffer_json_array_close(wb); buffer_json_member_add_array(wb, "dimensions"); { struct dict_unique_id_name *dun; dfe_start_read(dict_dimensions, dun) { if(!dun->exposed) continue; buffer_json_add_array_item_object(wb); buffer_json_member_add_string(wb, "id", dun->id); if(dun->id != dun->name) buffer_json_member_add_string(wb, "nm", dun->name); buffer_json_member_add_int64(wb, "di", dun->i); buffer_json_object_close(wb); } dfe_done(dun); } buffer_json_array_close(wb); buffer_json_object_close(wb); //dictionaries buffer_json_agents_v2(wb, &qwd->timings, 0, false, true); buffer_json_member_add_uint64(wb, "correlated_dimensions", total_dimensions); buffer_json_member_add_uint64(wb, "total_dimensions_count", examined_dimensions); buffer_json_finalize(wb); dictionary_destroy(dict_nodes); dictionary_destroy(dict_contexts); dictionary_destroy(dict_instances); dictionary_destroy(dict_dimensions); return total_dimensions; } static size_t registered_results_to_json_multinode_group_by( DICTIONARY *results, BUFFER *wb, time_t after, time_t before, time_t baseline_after, time_t baseline_before, size_t points, WEIGHTS_METHOD method, RRDR_TIME_GROUPING group, RRDR_OPTIONS options, uint32_t shifts, size_t examined_dimensions, struct query_weights_data *qwd, WEIGHTS_STATS *stats, struct query_versions *versions) { buffer_json_initialize(wb, "\"", "\"", 0, true, (options & RRDR_OPTION_MINIFY) ? BUFFER_JSON_OPTIONS_MINIFY : BUFFER_JSON_OPTIONS_DEFAULT); buffer_json_member_add_uint64(wb, "api", 2); results_header_to_json_v2(results, wb, qwd, after, before, baseline_after, baseline_before, points, method, group, options, shifts, examined_dimensions, qwd->timings.executed_ut - qwd->timings.received_ut, stats, true); version_hashes_api_v2(wb, versions); bool baseline = method == WEIGHTS_METHOD_MC_KS2 || method == WEIGHTS_METHOD_MC_VOLUME; multinode_data_schema(wb, options, "v_schema", baseline, true); DICTIONARY *group_by = dictionary_create_advanced(DICT_OPTION_SINGLE_THREADED | DICT_OPTION_DONT_OVERWRITE_VALUE | DICT_OPTION_FIXED_SIZE, NULL, sizeof(struct aggregated_weight)); struct register_result *t; size_t total_dimensions = 0; BUFFER *key = buffer_create(0, NULL); BUFFER *name = buffer_create(0, NULL); dfe_start_read(results, t) { buffer_flush(key); buffer_flush(name); if(qwd->qwr->group_by.group_by & RRDR_GROUP_BY_DIMENSION) { buffer_strcat(key, rrdmetric_acquired_name(t->rma)); buffer_strcat(name, rrdmetric_acquired_name(t->rma)); } if(qwd->qwr->group_by.group_by & RRDR_GROUP_BY_INSTANCE) { if(buffer_strlen(key)) { buffer_fast_strcat(key, ",", 1); buffer_fast_strcat(name, ",", 1); } buffer_strcat(key, rrdinstance_acquired_id(t->ria)); buffer_strcat(name, rrdinstance_acquired_name(t->ria)); if(!(qwd->qwr->group_by.group_by & RRDR_GROUP_BY_NODE)) { buffer_fast_strcat(key, "@", 1); buffer_fast_strcat(name, "@", 1); buffer_strcat(key, t->host->machine_guid); buffer_strcat(name, rrdhost_hostname(t->host)); } } if(qwd->qwr->group_by.group_by & RRDR_GROUP_BY_NODE) { if(buffer_strlen(key)) { buffer_fast_strcat(key, ",", 1); buffer_fast_strcat(name, ",", 1); } buffer_strcat(key, t->host->machine_guid); buffer_strcat(name, rrdhost_hostname(t->host)); } if(qwd->qwr->group_by.group_by & RRDR_GROUP_BY_CONTEXT) { if(buffer_strlen(key)) { buffer_fast_strcat(key, ",", 1); buffer_fast_strcat(name, ",", 1); } buffer_strcat(key, rrdcontext_acquired_id(t->rca)); buffer_strcat(name, rrdcontext_acquired_id(t->rca)); } if(qwd->qwr->group_by.group_by & RRDR_GROUP_BY_UNITS) { if(buffer_strlen(key)) { buffer_fast_strcat(key, ",", 1); buffer_fast_strcat(name, ",", 1); } buffer_strcat(key, rrdcontext_acquired_units(t->rca)); buffer_strcat(name, rrdcontext_acquired_units(t->rca)); } struct aggregated_weight *aw = dictionary_set(group_by, buffer_tostring(key), NULL, sizeof(struct aggregated_weight)); if(!aw->name) { aw->name = strdupz(buffer_tostring(name)); aw->min = aw->max = aw->sum = t->value; aw->count = 1; aw->hsp = t->highlighted; aw->bsp = t->baseline; } else merge_into_aw(*aw, t); total_dimensions++; } dfe_done(t); buffer_free(key); key = NULL; buffer_free(name); name = NULL; struct aggregated_weight *aw; buffer_json_member_add_array(wb, "result"); dfe_start_read(group_by, aw) { const char *k = aw_dfe.name; const char *n = aw->name; buffer_json_add_array_item_object(wb); buffer_json_member_add_string(wb, "id", k); if(strcmp(k, n) != 0) buffer_json_member_add_string(wb, "nm", n); storage_point_to_json(wb, WPT_GROUP, 0, 0, 0, 0, aw, options, baseline); buffer_json_object_close(wb); freez((void *)aw->name); } dfe_done(aw); buffer_json_array_close(wb); // result buffer_json_agents_v2(wb, &qwd->timings, 0, false, true); buffer_json_member_add_uint64(wb, "correlated_dimensions", total_dimensions); buffer_json_member_add_uint64(wb, "total_dimensions_count", examined_dimensions); buffer_json_finalize(wb); dictionary_destroy(group_by); return total_dimensions; } // ---------------------------------------------------------------------------- // KS2 algorithm functions typedef long int DIFFS_NUMBERS; #define DOUBLE_TO_INT_MULTIPLIER 100000 static inline int binary_search_bigger_than(const DIFFS_NUMBERS arr[], int left, int size, DIFFS_NUMBERS K) { // binary search to find the index the smallest index // of the first value in the array that is greater than K int right = size; while(left < right) { int middle = (int)(((unsigned int)(left + right)) >> 1); if(arr[middle] > K) right = middle; else left = middle + 1; } return left; } int compare_diffs(const void *left, const void *right) { DIFFS_NUMBERS lt = *(DIFFS_NUMBERS *)left; DIFFS_NUMBERS rt = *(DIFFS_NUMBERS *)right; // https://stackoverflow.com/a/3886497/1114110 return (lt > rt) - (lt < rt); } static size_t calculate_pairs_diff(DIFFS_NUMBERS *diffs, NETDATA_DOUBLE *arr, size_t size) { NETDATA_DOUBLE *last = &arr[size - 1]; size_t added = 0; while(last > arr) { NETDATA_DOUBLE second = *last--; NETDATA_DOUBLE first = *last; *diffs++ = (DIFFS_NUMBERS)((first - second) * (NETDATA_DOUBLE)DOUBLE_TO_INT_MULTIPLIER); added++; } return added; } static double ks_2samp( DIFFS_NUMBERS baseline_diffs[], int base_size, DIFFS_NUMBERS highlight_diffs[], int high_size, uint32_t base_shifts) { qsort(baseline_diffs, base_size, sizeof(DIFFS_NUMBERS), compare_diffs); qsort(highlight_diffs, high_size, sizeof(DIFFS_NUMBERS), compare_diffs); // Now we should be calculating this: // // For each number in the diffs arrays, we should find the index of the // number bigger than them in both arrays and calculate the % of this index // vs the total array size. Once we have the 2 percentages, we should find // the min and max across the delta of all of them. // // It should look like this: // // base_pcent = binary_search_bigger_than(...) / base_size; // high_pcent = binary_search_bigger_than(...) / high_size; // delta = base_pcent - high_pcent; // if(delta < min) min = delta; // if(delta > max) max = delta; // // This would require a lot of multiplications and divisions. // // To speed it up, we do the binary search to find the index of each number // but, then we divide the base index by the power of two number (shifts) it // is bigger than high index. So the 2 indexes are now comparable. // We also keep track of the original indexes with min and max, to properly // calculate their percentages once the loops finish. // initialize min and max using the first number of baseline_diffs DIFFS_NUMBERS K = baseline_diffs[0]; int base_idx = binary_search_bigger_than(baseline_diffs, 1, base_size, K); int high_idx = binary_search_bigger_than(highlight_diffs, 0, high_size, K); int delta = base_idx - (high_idx << base_shifts); int min = delta, max = delta; int base_min_idx = base_idx; int base_max_idx = base_idx; int high_min_idx = high_idx; int high_max_idx = high_idx; // do the baseline_diffs starting from 1 (we did position 0 above) for(int i = 1; i < base_size; i++) { K = baseline_diffs[i]; base_idx = binary_search_bigger_than(baseline_diffs, i + 1, base_size, K); // starting from i, since data1 is sorted high_idx = binary_search_bigger_than(highlight_diffs, 0, high_size, K); delta = base_idx - (high_idx << base_shifts); if(delta < min) { min = delta; base_min_idx = base_idx; high_min_idx = high_idx; } else if(delta > max) { max = delta; base_max_idx = base_idx; high_max_idx = high_idx; } } // do the highlight_diffs starting from 0 for(int i = 0; i < high_size; i++) { K = highlight_diffs[i]; base_idx = binary_search_bigger_than(baseline_diffs, 0, base_size, K); high_idx = binary_search_bigger_than(highlight_diffs, i + 1, high_size, K); // starting from i, since data2 is sorted delta = base_idx - (high_idx << base_shifts); if(delta < min) { min = delta; base_min_idx = base_idx; high_min_idx = high_idx; } else if(delta > max) { max = delta; base_max_idx = base_idx; high_max_idx = high_idx; } } // now we have the min, max and their indexes // properly calculate min and max as dmin and dmax double dbase_size = (double)base_size; double dhigh_size = (double)high_size; double dmin = ((double)base_min_idx / dbase_size) - ((double)high_min_idx / dhigh_size); double dmax = ((double)base_max_idx / dbase_size) - ((double)high_max_idx / dhigh_size); dmin = -dmin; if(islessequal(dmin, 0.0)) dmin = 0.0; else if(isgreaterequal(dmin, 1.0)) dmin = 1.0; double d; if(isgreaterequal(dmin, dmax)) d = dmin; else d = dmax; double en = round(dbase_size * dhigh_size / (dbase_size + dhigh_size)); // under these conditions, KSfbar() crashes if(unlikely(isnan(en) || isinf(en) || en == 0.0 || isnan(d) || isinf(d))) return NAN; return KSfbar((int)en, d); } static double kstwo( NETDATA_DOUBLE baseline[], int baseline_points, NETDATA_DOUBLE highlight[], int highlight_points, uint32_t base_shifts) { // -1 in size, since the calculate_pairs_diffs() returns one less point DIFFS_NUMBERS baseline_diffs[baseline_points - 1]; DIFFS_NUMBERS highlight_diffs[highlight_points - 1]; int base_size = (int)calculate_pairs_diff(baseline_diffs, baseline, baseline_points); int high_size = (int)calculate_pairs_diff(highlight_diffs, highlight, highlight_points); if(unlikely(!base_size || !high_size)) return NAN; if(unlikely(base_size != baseline_points - 1 || high_size != highlight_points - 1)) { netdata_log_error("Metric correlations: internal error - calculate_pairs_diff() returns the wrong number of entries"); return NAN; } return ks_2samp(baseline_diffs, base_size, highlight_diffs, high_size, base_shifts); } NETDATA_DOUBLE *rrd2rrdr_ks2( ONEWAYALLOC *owa, RRDHOST *host, RRDCONTEXT_ACQUIRED *rca, RRDINSTANCE_ACQUIRED *ria, RRDMETRIC_ACQUIRED *rma, time_t after, time_t before, size_t points, RRDR_OPTIONS options, RRDR_TIME_GROUPING time_group_method, const char *time_group_options, size_t tier, WEIGHTS_STATS *stats, size_t *entries, STORAGE_POINT *sp ) { NETDATA_DOUBLE *ret = NULL; QUERY_TARGET_REQUEST qtr = { .version = 1, .host = host, .rca = rca, .ria = ria, .rma = rma, .after = after, .before = before, .points = points, .options = options, .time_group_method = time_group_method, .time_group_options = time_group_options, .tier = tier, .query_source = QUERY_SOURCE_API_WEIGHTS, .priority = STORAGE_PRIORITY_SYNCHRONOUS, }; QUERY_TARGET *qt = query_target_create(&qtr); RRDR *r = rrd2rrdr(owa, qt); if(!r) goto cleanup; stats->db_queries++; stats->result_points += r->stats.result_points_generated; stats->db_points += r->stats.db_points_read; for(size_t tr = 0; tr < storage_tiers ; tr++) stats->db_points_per_tier[tr] += r->internal.qt->db.tiers[tr].points; if(r->d != 1 || r->internal.qt->query.used != 1) { netdata_log_error("WEIGHTS: on query '%s' expected 1 dimension in RRDR but got %zu r->d and %zu qt->query.used", r->internal.qt->id, r->d, (size_t)r->internal.qt->query.used); goto cleanup; } if(unlikely(r->od[0] & RRDR_DIMENSION_HIDDEN)) goto cleanup; if(unlikely(!(r->od[0] & RRDR_DIMENSION_QUERIED))) goto cleanup; if(unlikely(!(r->od[0] & RRDR_DIMENSION_NONZERO))) goto cleanup; if(rrdr_rows(r) < 2) goto cleanup; *entries = rrdr_rows(r); ret = onewayalloc_mallocz(owa, sizeof(NETDATA_DOUBLE) * rrdr_rows(r)); if(sp) *sp = r->internal.qt->query.array[0].query_points; // copy the points of the dimension to a contiguous array // there is no need to check for empty values, since empty values are already zero // https://github.com/netdata/netdata/blob/6e3144683a73a2024d51425b20ecfd569034c858/web/api/queries/average/average.c#L41-L43 memcpy(ret, r->v, rrdr_rows(r) * sizeof(NETDATA_DOUBLE)); cleanup: rrdr_free(owa, r); query_target_release(qt); return ret; } static void rrdset_metric_correlations_ks2( RRDHOST *host, RRDCONTEXT_ACQUIRED *rca, RRDINSTANCE_ACQUIRED *ria, RRDMETRIC_ACQUIRED *rma, DICTIONARY *results, time_t baseline_after, time_t baseline_before, time_t after, time_t before, size_t points, RRDR_OPTIONS options, RRDR_TIME_GROUPING time_group_method, const char *time_group_options, size_t tier, uint32_t shifts, WEIGHTS_STATS *stats, bool register_zero ) { options |= RRDR_OPTION_NATURAL_POINTS; usec_t started_ut = now_monotonic_usec(); ONEWAYALLOC *owa = onewayalloc_create(16 * 1024); size_t high_points = 0; STORAGE_POINT highlighted_sp; NETDATA_DOUBLE *highlight = rrd2rrdr_ks2( owa, host, rca, ria, rma, after, before, points, options, time_group_method, time_group_options, tier, stats, &high_points, &highlighted_sp); if(!highlight) goto cleanup; size_t base_points = 0; STORAGE_POINT baseline_sp; NETDATA_DOUBLE *baseline = rrd2rrdr_ks2( owa, host, rca, ria, rma, baseline_after, baseline_before, high_points << shifts, options, time_group_method, time_group_options, tier, stats, &base_points, &baseline_sp); if(!baseline) goto cleanup; stats->binary_searches += 2 * (base_points - 1) + 2 * (high_points - 1); double prob = kstwo(baseline, (int)base_points, highlight, (int)high_points, shifts); if(!isnan(prob) && !isinf(prob)) { // these conditions should never happen, but still let's check if(unlikely(prob < 0.0)) { netdata_log_error("Metric correlations: kstwo() returned a negative number: %f", prob); prob = -prob; } if(unlikely(prob > 1.0)) { netdata_log_error("Metric correlations: kstwo() returned a number above 1.0: %f", prob); prob = 1.0; } usec_t ended_ut = now_monotonic_usec(); // to spread the results evenly, 0.0 needs to be the less correlated and 1.0 the most correlated // so, we flip the result of kstwo() register_result(results, host, rca, ria, rma, 1.0 - prob, RESULT_IS_BASE_HIGH_RATIO, &highlighted_sp, &baseline_sp, stats, register_zero, ended_ut - started_ut); } cleanup: onewayalloc_destroy(owa); } // ---------------------------------------------------------------------------- // VOLUME algorithm functions static void merge_query_value_to_stats(QUERY_VALUE *qv, WEIGHTS_STATS *stats, size_t queries) { stats->db_queries += queries; stats->result_points += qv->result_points; stats->db_points += qv->points_read; for(size_t tier = 0; tier < storage_tiers ; tier++) stats->db_points_per_tier[tier] += qv->storage_points_per_tier[tier]; } static void rrdset_metric_correlations_volume( RRDHOST *host, RRDCONTEXT_ACQUIRED *rca, RRDINSTANCE_ACQUIRED *ria, RRDMETRIC_ACQUIRED *rma, DICTIONARY *results, time_t baseline_after, time_t baseline_before, time_t after, time_t before, RRDR_OPTIONS options, RRDR_TIME_GROUPING time_group_method, const char *time_group_options, size_t tier, WEIGHTS_STATS *stats, bool register_zero) { options |= RRDR_OPTION_MATCH_IDS | RRDR_OPTION_ABSOLUTE | RRDR_OPTION_NATURAL_POINTS; QUERY_VALUE baseline_average = rrdmetric2value(host, rca, ria, rma, baseline_after, baseline_before, options, time_group_method, time_group_options, tier, 0, QUERY_SOURCE_API_WEIGHTS, STORAGE_PRIORITY_SYNCHRONOUS); merge_query_value_to_stats(&baseline_average, stats, 1); if(!netdata_double_isnumber(baseline_average.value)) { // this means no data for the baseline window, but we may have data for the highlighted one - assume zero baseline_average.value = 0.0; } QUERY_VALUE highlight_average = rrdmetric2value(host, rca, ria, rma, after, before, options, time_group_method, time_group_options, tier, 0, QUERY_SOURCE_API_WEIGHTS, STORAGE_PRIORITY_SYNCHRONOUS); merge_query_value_to_stats(&highlight_average, stats, 1); if(!netdata_double_isnumber(highlight_average.value)) return; if(baseline_average.value == highlight_average.value) { // they are the same - let's move on return; } if((options & RRDR_OPTION_ANOMALY_BIT) && highlight_average.value < baseline_average.value) { // when working on anomaly bits, we are looking for an increase in the anomaly rate return; } char highlight_countif_options[50 + 1]; snprintfz(highlight_countif_options, 50, "%s" NETDATA_DOUBLE_FORMAT, highlight_average.value < baseline_average.value ? "<" : ">", baseline_average.value); QUERY_VALUE highlight_countif = rrdmetric2value(host, rca, ria, rma, after, before, options, RRDR_GROUPING_COUNTIF, highlight_countif_options, tier, 0, QUERY_SOURCE_API_WEIGHTS, STORAGE_PRIORITY_SYNCHRONOUS); merge_query_value_to_stats(&highlight_countif, stats, 1); if(!netdata_double_isnumber(highlight_countif.value)) { netdata_log_info("WEIGHTS: highlighted countif query failed, but highlighted average worked - strange..."); return; } // this represents the percentage of time // the highlighted window was above/below the baseline window // (above or below depending on their averages) highlight_countif.value = highlight_countif.value / 100.0; // countif returns 0 - 100.0 RESULT_FLAGS flags; NETDATA_DOUBLE pcent = NAN; if(isgreater(baseline_average.value, 0.0) || isless(baseline_average.value, 0.0)) { flags = RESULT_IS_BASE_HIGH_RATIO; pcent = (highlight_average.value - baseline_average.value) / baseline_average.value * highlight_countif.value; } else { flags = RESULT_IS_PERCENTAGE_OF_TIME; pcent = highlight_countif.value; } register_result(results, host, rca, ria, rma, pcent, flags, &highlight_average.sp, &baseline_average.sp, stats, register_zero, baseline_average.duration_ut + highlight_average.duration_ut + highlight_countif.duration_ut); } // ---------------------------------------------------------------------------- // VALUE / ANOMALY RATE algorithm functions static void rrdset_weights_value( RRDHOST *host, RRDCONTEXT_ACQUIRED *rca, RRDINSTANCE_ACQUIRED *ria, RRDMETRIC_ACQUIRED *rma, DICTIONARY *results, time_t after, time_t before, RRDR_OPTIONS options, RRDR_TIME_GROUPING time_group_method, const char *time_group_options, size_t tier, WEIGHTS_STATS *stats, bool register_zero) { options |= RRDR_OPTION_MATCH_IDS | RRDR_OPTION_NATURAL_POINTS; QUERY_VALUE qv = rrdmetric2value(host, rca, ria, rma, after, before, options, time_group_method, time_group_options, tier, 0, QUERY_SOURCE_API_WEIGHTS, STORAGE_PRIORITY_SYNCHRONOUS); merge_query_value_to_stats(&qv, stats, 1); if(netdata_double_isnumber(qv.value)) register_result(results, host, rca, ria, rma, qv.value, 0, &qv.sp, NULL, stats, register_zero, qv.duration_ut); } static void rrdset_weights_multi_dimensional_value(struct query_weights_data *qwd) { QUERY_TARGET_REQUEST qtr = { .version = 1, .scope_nodes = qwd->qwr->scope_nodes, .scope_contexts = qwd->qwr->scope_contexts, .nodes = qwd->qwr->nodes, .contexts = qwd->qwr->contexts, .instances = qwd->qwr->instances, .dimensions = qwd->qwr->dimensions, .labels = qwd->qwr->labels, .alerts = qwd->qwr->alerts, .after = qwd->qwr->after, .before = qwd->qwr->before, .points = 1, .options = qwd->qwr->options | RRDR_OPTION_NATURAL_POINTS, .time_group_method = qwd->qwr->time_group_method, .time_group_options = qwd->qwr->time_group_options, .tier = qwd->qwr->tier, .timeout_ms = qwd->qwr->timeout_ms, .query_source = QUERY_SOURCE_API_WEIGHTS, .priority = STORAGE_PRIORITY_NORMAL, }; ONEWAYALLOC *owa = onewayalloc_create(16 * 1024); QUERY_TARGET *qt = query_target_create(&qtr); RRDR *r = rrd2rrdr(owa, qt); if(!r || rrdr_rows(r) != 1 || !r->d || r->d != r->internal.qt->query.used) goto cleanup; QUERY_VALUE qv = { .after = r->view.after, .before = r->view.before, .points_read = r->stats.db_points_read, .result_points = r->stats.result_points_generated, }; size_t queries = 0; for(size_t d = 0; d < r->d ;d++) { if(!rrdr_dimension_should_be_exposed(r->od[d], qwd->qwr->options)) continue; long i = 0; // only one row NETDATA_DOUBLE *cn = &r->v[ i * r->d ]; NETDATA_DOUBLE *ar = &r->ar[ i * r->d ]; qv.value = cn[d]; qv.anomaly_rate = ar[d]; storage_point_merge_to(qv.sp, r->internal.qt->query.array[d].query_points); if(netdata_double_isnumber(qv.value)) { QUERY_METRIC *qm = query_metric(r->internal.qt, d); QUERY_DIMENSION *qd = query_dimension(r->internal.qt, qm->link.query_dimension_id); QUERY_INSTANCE *qi = query_instance(r->internal.qt, qm->link.query_instance_id); QUERY_CONTEXT *qc = query_context(r->internal.qt, qm->link.query_context_id); QUERY_NODE *qn = query_node(r->internal.qt, qm->link.query_node_id); register_result(qwd->results, qn->rrdhost, qc->rca, qi->ria, qd->rma, qv.value, 0, &qv.sp, NULL, &qwd->stats, qwd->register_zero, qm->duration_ut); } queries++; } merge_query_value_to_stats(&qv, &qwd->stats, queries); cleanup: rrdr_free(owa, r); query_target_release(qt); onewayalloc_destroy(owa); } // ---------------------------------------------------------------------------- int compare_netdata_doubles(const void *left, const void *right) { NETDATA_DOUBLE lt = *(NETDATA_DOUBLE *)left; NETDATA_DOUBLE rt = *(NETDATA_DOUBLE *)right; // https://stackoverflow.com/a/3886497/1114110 return (lt > rt) - (lt < rt); } static inline int binary_search_bigger_than_netdata_double(const NETDATA_DOUBLE arr[], int left, int size, NETDATA_DOUBLE K) { // binary search to find the index the smallest index // of the first value in the array that is greater than K int right = size; while(left < right) { int middle = (int)(((unsigned int)(left + right)) >> 1); if(arr[middle] > K) right = middle; else left = middle + 1; } return left; } // ---------------------------------------------------------------------------- // spread the results evenly according to their value static size_t spread_results_evenly(DICTIONARY *results, WEIGHTS_STATS *stats) { struct register_result *t; // count the dimensions size_t dimensions = dictionary_entries(results); if(!dimensions) return 0; if(stats->max_base_high_ratio == 0.0) stats->max_base_high_ratio = 1.0; // create an array of the right size and copy all the values in it NETDATA_DOUBLE slots[dimensions]; dimensions = 0; dfe_start_read(results, t) { if(t->flags & RESULT_IS_PERCENTAGE_OF_TIME) t->value = t->value * stats->max_base_high_ratio; slots[dimensions++] = t->value; } dfe_done(t); if(!dimensions) return 0; // Coverity fix // sort the array with the values of all dimensions qsort(slots, dimensions, sizeof(NETDATA_DOUBLE), compare_netdata_doubles); // skip the duplicates in the sorted array NETDATA_DOUBLE last_value = NAN; size_t unique_values = 0; for(size_t i = 0; i < dimensions ;i++) { if(likely(slots[i] != last_value)) slots[unique_values++] = last_value = slots[i]; } // this cannot happen, but coverity thinks otherwise... if(!unique_values) unique_values = dimensions; // calculate the weight of each slot, using the number of unique values NETDATA_DOUBLE slot_weight = 1.0 / (NETDATA_DOUBLE)unique_values; dfe_start_read(results, t) { int slot = binary_search_bigger_than_netdata_double(slots, 0, (int)unique_values, t->value); NETDATA_DOUBLE v = slot * slot_weight; if(unlikely(v > 1.0)) v = 1.0; v = 1.0 - v; t->value = v; } dfe_done(t); return dimensions; } // ---------------------------------------------------------------------------- // The main function static ssize_t weights_for_rrdmetric(void *data, RRDHOST *host, RRDCONTEXT_ACQUIRED *rca, RRDINSTANCE_ACQUIRED *ria, RRDMETRIC_ACQUIRED *rma) { struct query_weights_data *qwd = data; QUERY_WEIGHTS_REQUEST *qwr = qwd->qwr; if(qwd->qwr->interrupt_callback && qwd->qwr->interrupt_callback(qwd->qwr->interrupt_callback_data)) { qwd->interrupted = true; return -1; } qwd->examined_dimensions++; switch(qwr->method) { case WEIGHTS_METHOD_VALUE: rrdset_weights_value( host, rca, ria, rma, qwd->results, qwr->after, qwr->before, qwr->options, qwr->time_group_method, qwr->time_group_options, qwr->tier, &qwd->stats, qwd->register_zero ); break; case WEIGHTS_METHOD_ANOMALY_RATE: qwr->options |= RRDR_OPTION_ANOMALY_BIT; rrdset_weights_value( host, rca, ria, rma, qwd->results, qwr->after, qwr->before, qwr->options, qwr->time_group_method, qwr->time_group_options, qwr->tier, &qwd->stats, qwd->register_zero ); break; case WEIGHTS_METHOD_MC_VOLUME: rrdset_metric_correlations_volume( host, rca, ria, rma, qwd->results, qwr->baseline_after, qwr->baseline_before, qwr->after, qwr->before, qwr->options, qwr->time_group_method, qwr->time_group_options, qwr->tier, &qwd->stats, qwd->register_zero ); break; default: case WEIGHTS_METHOD_MC_KS2: rrdset_metric_correlations_ks2( host, rca, ria, rma, qwd->results, qwr->baseline_after, qwr->baseline_before, qwr->after, qwr->before, qwr->points, qwr->options, qwr->time_group_method, qwr->time_group_options, qwr->tier, qwd->shifts, &qwd->stats, qwd->register_zero ); break; } qwd->timings.executed_ut = now_monotonic_usec(); if(qwd->timings.executed_ut - qwd->timings.received_ut > qwd->timeout_us) { qwd->timed_out = true; return -1; } query_progress_done_step(qwr->transaction, 1); return 1; } static ssize_t weights_do_context_callback(void *data, RRDCONTEXT_ACQUIRED *rca, bool queryable_context) { if(!queryable_context) return false; struct query_weights_data *qwd = data; bool has_retention = false; switch(qwd->qwr->method) { case WEIGHTS_METHOD_VALUE: case WEIGHTS_METHOD_ANOMALY_RATE: has_retention = rrdcontext_retention_match(rca, qwd->qwr->after, qwd->qwr->before); break; case WEIGHTS_METHOD_MC_KS2: case WEIGHTS_METHOD_MC_VOLUME: has_retention = rrdcontext_retention_match(rca, qwd->qwr->after, qwd->qwr->before); if(has_retention) has_retention = rrdcontext_retention_match(rca, qwd->qwr->baseline_after, qwd->qwr->baseline_before); break; } if(!has_retention) return 0; ssize_t ret = weights_foreach_rrdmetric_in_context(rca, qwd->instances_sp, NULL, qwd->labels_sp, qwd->alerts_sp, qwd->dimensions_sp, true, true, qwd->qwr->version, weights_for_rrdmetric, qwd); return ret; } ssize_t weights_do_node_callback(void *data, RRDHOST *host, bool queryable) { if(!queryable) return 0; struct query_weights_data *qwd = data; ssize_t ret = query_scope_foreach_context(host, qwd->qwr->scope_contexts, qwd->scope_contexts_sp, qwd->contexts_sp, weights_do_context_callback, queryable, qwd); return ret; } int web_api_v12_weights(BUFFER *wb, QUERY_WEIGHTS_REQUEST *qwr) { char *error = NULL; int resp = HTTP_RESP_OK; // if the user didn't give a timeout // assume 60 seconds if(!qwr->timeout_ms) qwr->timeout_ms = 5 * 60 * MSEC_PER_SEC; // if the timeout is less than 1 second // make it at least 1 second if(qwr->timeout_ms < (long)(1 * MSEC_PER_SEC)) qwr->timeout_ms = 1 * MSEC_PER_SEC; struct query_weights_data qwd = { .qwr = qwr, .scope_nodes_sp = string_to_simple_pattern(qwr->scope_nodes), .scope_contexts_sp = string_to_simple_pattern(qwr->scope_contexts), .nodes_sp = string_to_simple_pattern(qwr->nodes), .contexts_sp = string_to_simple_pattern(qwr->contexts), .instances_sp = string_to_simple_pattern(qwr->instances), .dimensions_sp = string_to_simple_pattern(qwr->dimensions), .labels_sp = string_to_simple_pattern(qwr->labels), .alerts_sp = string_to_simple_pattern(qwr->alerts), .timeout_us = qwr->timeout_ms * USEC_PER_MS, .timed_out = false, .examined_dimensions = 0, .register_zero = true, .results = register_result_init(), .stats = {}, .shifts = 0, .timings = { .received_ut = now_monotonic_usec(), } }; if(!rrdr_relative_window_to_absolute_query(&qwr->after, &qwr->before, NULL, false)) buffer_no_cacheable(wb); else buffer_cacheable(wb); if (qwr->before <= qwr->after) { resp = HTTP_RESP_BAD_REQUEST; error = "Invalid selected time-range."; goto cleanup; } if(qwr->method == WEIGHTS_METHOD_MC_KS2 || qwr->method == WEIGHTS_METHOD_MC_VOLUME) { if(!qwr->points) qwr->points = 500; if(qwr->baseline_before <= API_RELATIVE_TIME_MAX) qwr->baseline_before += qwr->after; rrdr_relative_window_to_absolute_query(&qwr->baseline_after, &qwr->baseline_before, NULL, false); if (qwr->baseline_before <= qwr->baseline_after) { resp = HTTP_RESP_BAD_REQUEST; error = "Invalid baseline time-range."; goto cleanup; } // baseline should be a power of two multiple of highlight long long base_delta = qwr->baseline_before - qwr->baseline_after; long long high_delta = qwr->before - qwr->after; uint32_t multiplier = (uint32_t)round((double)base_delta / (double)high_delta); // check if the multiplier is a power of two // https://stackoverflow.com/a/600306/1114110 if((multiplier & (multiplier - 1)) != 0) { // it is not power of two // let's find the closest power of two // https://stackoverflow.com/a/466242/1114110 multiplier--; multiplier |= multiplier >> 1; multiplier |= multiplier >> 2; multiplier |= multiplier >> 4; multiplier |= multiplier >> 8; multiplier |= multiplier >> 16; multiplier++; } // convert the multiplier to the number of shifts // we need to do, to divide baseline numbers to match // the highlight ones while(multiplier > 1) { qwd.shifts++; multiplier = multiplier >> 1; } // if the baseline size will not comply to MAX_POINTS // lower the window of the baseline while(qwd.shifts && (qwr->points << qwd.shifts) > MAX_POINTS) qwd.shifts--; // if the baseline size still does not comply to MAX_POINTS // lower the resolution of the highlight and the baseline while((qwr->points << qwd.shifts) > MAX_POINTS) qwr->points = qwr->points >> 1; if(qwr->points < 15) { resp = HTTP_RESP_BAD_REQUEST; error = "Too few points available, at least 15 are needed."; goto cleanup; } // adjust the baseline to be multiplier times bigger than the highlight qwr->baseline_after = qwr->baseline_before - (high_delta << qwd.shifts); } if(qwr->options & RRDR_OPTION_NONZERO) { qwd.register_zero = false; // remove it to run the queries without it qwr->options &= ~RRDR_OPTION_NONZERO; } if(qwr->host && qwr->version == 1) weights_do_node_callback(&qwd, qwr->host, true); else { if((qwd.qwr->method == WEIGHTS_METHOD_VALUE || qwd.qwr->method == WEIGHTS_METHOD_ANOMALY_RATE) && (qwd.contexts_sp || qwd.scope_contexts_sp)) { rrdset_weights_multi_dimensional_value(&qwd); } else { query_scope_foreach_host(qwd.scope_nodes_sp, qwd.nodes_sp, weights_do_node_callback, &qwd, &qwd.versions, NULL); } } if(!qwd.register_zero) { // put it back, to show it in the response qwr->options |= RRDR_OPTION_NONZERO; } if(qwd.timed_out) { error = "timed out"; resp = HTTP_RESP_GATEWAY_TIMEOUT; goto cleanup; } if(qwd.interrupted) { error = "interrupted"; resp = HTTP_RESP_CLIENT_CLOSED_REQUEST; goto cleanup; } if(!qwd.register_zero) qwr->options |= RRDR_OPTION_NONZERO; if(!(qwr->options & RRDR_OPTION_RETURN_RAW) && qwr->method != WEIGHTS_METHOD_VALUE) spread_results_evenly(qwd.results, &qwd.stats); usec_t ended_usec = qwd.timings.executed_ut = now_monotonic_usec(); // generate the json output we need buffer_flush(wb); size_t added_dimensions = 0; switch(qwr->format) { case WEIGHTS_FORMAT_CHARTS: added_dimensions = registered_results_to_json_charts( qwd.results, wb, qwr->after, qwr->before, qwr->baseline_after, qwr->baseline_before, qwr->points, qwr->method, qwr->time_group_method, qwr->options, qwd.shifts, qwd.examined_dimensions, ended_usec - qwd.timings.received_ut, &qwd.stats); break; case WEIGHTS_FORMAT_CONTEXTS: added_dimensions = registered_results_to_json_contexts( qwd.results, wb, qwr->after, qwr->before, qwr->baseline_after, qwr->baseline_before, qwr->points, qwr->method, qwr->time_group_method, qwr->options, qwd.shifts, qwd.examined_dimensions, ended_usec - qwd.timings.received_ut, &qwd.stats); break; default: case WEIGHTS_FORMAT_MULTINODE: // we don't support these groupings in weights qwr->group_by.group_by &= ~(RRDR_GROUP_BY_LABEL|RRDR_GROUP_BY_SELECTED|RRDR_GROUP_BY_PERCENTAGE_OF_INSTANCE); if(qwr->group_by.group_by == RRDR_GROUP_BY_NONE) { added_dimensions = registered_results_to_json_multinode_no_group_by( qwd.results, wb, qwr->after, qwr->before, qwr->baseline_after, qwr->baseline_before, qwr->points, qwr->method, qwr->time_group_method, qwr->options, qwd.shifts, qwd.examined_dimensions, &qwd, &qwd.stats, &qwd.versions); } else { added_dimensions = registered_results_to_json_multinode_group_by( qwd.results, wb, qwr->after, qwr->before, qwr->baseline_after, qwr->baseline_before, qwr->points, qwr->method, qwr->time_group_method, qwr->options, qwd.shifts, qwd.examined_dimensions, &qwd, &qwd.stats, &qwd.versions); } break; } if(!added_dimensions && qwr->version < 2) { error = "no results produced."; resp = HTTP_RESP_NOT_FOUND; } cleanup: simple_pattern_free(qwd.scope_nodes_sp); simple_pattern_free(qwd.scope_contexts_sp); simple_pattern_free(qwd.nodes_sp); simple_pattern_free(qwd.contexts_sp); simple_pattern_free(qwd.instances_sp); simple_pattern_free(qwd.dimensions_sp); simple_pattern_free(qwd.labels_sp); simple_pattern_free(qwd.alerts_sp); register_result_destroy(qwd.results); if(error) { buffer_flush(wb); buffer_sprintf(wb, "{\"error\": \"%s\" }", error); } return resp; } // ---------------------------------------------------------------------------- // unittest /* Unit tests against the output of this: https://github.com/scipy/scipy/blob/4cf21e753cf937d1c6c2d2a0e372fbc1dbbeea81/scipy/stats/_stats_py.py#L7275-L7449 import matplotlib.pyplot as plt import pandas as pd import numpy as np import scipy as sp from scipy import stats data1 = np.array([ 1111, -2222, 33, 100, 100, 15555, -1, 19999, 888, 755, -1, -730 ]) data2 = np.array([365, -123, 0]) data1 = np.sort(data1) data2 = np.sort(data2) n1 = data1.shape[0] n2 = data2.shape[0] data_all = np.concatenate([data1, data2]) cdf1 = np.searchsorted(data1, data_all, side='right') / n1 cdf2 = np.searchsorted(data2, data_all, side='right') / n2 print(data_all) print("\ndata1", data1, cdf1) print("\ndata2", data2, cdf2) cddiffs = cdf1 - cdf2 print("\ncddiffs", cddiffs) minS = np.clip(-np.min(cddiffs), 0, 1) maxS = np.max(cddiffs) print("\nmin", minS) print("max", maxS) m, n = sorted([float(n1), float(n2)], reverse=True) en = m * n / (m + n) d = max(minS, maxS) prob = stats.distributions.kstwo.sf(d, np.round(en)) print("\nprob", prob) */ static int double_expect(double v, const char *str, const char *descr) { char buf[100 + 1]; snprintfz(buf, sizeof(buf) - 1, "%0.6f", v); int ret = strcmp(buf, str) ? 1 : 0; fprintf(stderr, "%s %s, expected %s, got %s\n", ret?"FAILED":"OK", descr, str, buf); return ret; } static int mc_unittest1(void) { int bs = 3, hs = 3; DIFFS_NUMBERS base[3] = { 1, 2, 3 }; DIFFS_NUMBERS high[3] = { 3, 4, 6 }; double prob = ks_2samp(base, bs, high, hs, 0); return double_expect(prob, "0.222222", "3x3"); } static int mc_unittest2(void) { int bs = 6, hs = 3; DIFFS_NUMBERS base[6] = { 1, 2, 3, 10, 10, 15 }; DIFFS_NUMBERS high[3] = { 3, 4, 6 }; double prob = ks_2samp(base, bs, high, hs, 1); return double_expect(prob, "0.500000", "6x3"); } static int mc_unittest3(void) { int bs = 12, hs = 3; DIFFS_NUMBERS base[12] = { 1, 2, 3, 10, 10, 15, 111, 19999, 8, 55, -1, -73 }; DIFFS_NUMBERS high[3] = { 3, 4, 6 }; double prob = ks_2samp(base, bs, high, hs, 2); return double_expect(prob, "0.347222", "12x3"); } static int mc_unittest4(void) { int bs = 12, hs = 3; DIFFS_NUMBERS base[12] = { 1111, -2222, 33, 100, 100, 15555, -1, 19999, 888, 755, -1, -730 }; DIFFS_NUMBERS high[3] = { 365, -123, 0 }; double prob = ks_2samp(base, bs, high, hs, 2); return double_expect(prob, "0.777778", "12x3"); } int mc_unittest(void) { int errors = 0; errors += mc_unittest1(); errors += mc_unittest2(); errors += mc_unittest3(); errors += mc_unittest4(); return errors; }