X-Git-Url: https://gerrit.o-ran-sc.org/r/gitweb?a=blobdiff_plain;f=cfg%2Fexternal_fcns.def;h=9a97a5c22d5dec1692913c9f2a18baa9675242bd;hb=HEAD;hp=0043b84b1b722c63dfa8382f150ac31aa9ff51a7;hpb=eb761d89890df8d74532dd4faad118db18fd3b7d;p=com%2Fgs-lite.git diff --git a/cfg/external_fcns.def b/cfg/external_fcns.def index 0043b84..9a97a5c 100644 --- a/cfg/external_fcns.def +++ b/cfg/external_fcns.def @@ -1,4 +1,4 @@ - /////////////////////////////////////////////////////////// +/////////////////////////////////////////////////////////// // Matching predicates /////////////////////////////////////////////////////////// PRED [LFTA_LEGAL, COST HIGH]str_exists_substr[string, string]; @@ -454,10 +454,16 @@ uint FUN [LFTA_LEGAL, COST EXPENSIVE] /////////////////////////////////////////////////////////// -// Truncating strings +// Truncating strings and substrings /////////////////////////////////////////////////////////// +// str_truncate(str, n) : return the 1st n chars of str, or as much as possible string FUN [LFTA_LEGAL,PARTIAL,COST FREE] str_truncate (string, uint); +// str_suffix(str, n) : return the last n chars of str, or as much as possible + string FUN [LFTA_LEGAL,PARTIAL,COST FREE] str_suffix (string, uint); +// get_list_entry(list_str, sep_str, i) : split the list by sep, +// return the i-th value, if it exists. + string FUN [LFTA_LEGAL,PARTIAL,COST FREE] get_list_entry (string, string, uint CONST); /////////////////////////////////////////////////////////// @@ -508,6 +514,8 @@ uint FUN [LFTA_LEGAL, COST EXPENSIVE] llong FUN [LFTA_LEGAL,COST FREE]LLONG(llong); llong FUN [LFTA_LEGAL,COST FREE]LLONG(float); + llong FUN [LFTA_LEGAL,COST LOW] to_llong(string); + /////////////////////////////////////////////////////////// // Numeric functions /////////////////////////////////////////////////////////// @@ -543,6 +551,13 @@ uint FUN [LFTA_LEGAL, COST EXPENSIVE] IP FUN [LFTA_LEGAL,COST LOW] strtoip_c(string HANDLE); +///////////////////////////////////////////////////////////// +// Add up uints in a delimited ascii list. +// return 135 on '34|45|56' and sep '|' + + llong FUN [LFTA_LEGAL,COST LOW] sum_uint_in_list(string, string CONST); + + /////////////////////////////////////////////////////////// // Compute running sum /////////////////////////////////////////////////////////// @@ -604,15 +619,51 @@ uint FUN [LFTA_LEGAL, COST EXPENSIVE] // Flips approximate quantile /////////////////////////////////////////////////////////// - uint EXTR quantile_of quant_udaf_hfta0 extr_quant_hfta0_fcn (uint, float); - uint FUN [COST LOW] extr_quant_hfta0_fcn(string, float); - uint EXTR median_of quant_udaf_hfta0 extr_med_hfta0_fcn (uint); - uint FUN [COST LOW] extr_med_hfta0_fcn(string); - uint EXTR qspace_of quant_udaf_hfta0 extr_quant_hfta0_space (uint); - uint FUN [COST LOW] extr_quant_hfta0_space(string); - string UDAF [SUBAGGR quant_udaf_lfta3, SUPERAGGR quant_udaf_hfta3] quant_udaf_hfta0 fstring16 (uint); - string UDAF quant_udaf_hfta3 fstring16 (string); - string UDAF quant_udaf_lfta3 fstring6600 (uint); +// uint + uint EXTR quantile_of quant_ui_udaf_hftaZ extr_quant_ui_hftaZ_fcn (uint, float); + uint FUN [COST LOW] extr_quant_ui_hftaZ_fcn(string, float); + uint EXTR median_of quant_ui_udaf_hftaZ extr_med_ui_hftaZ_fcn (uint); + uint FUN [COST LOW] extr_med_ui_hftaZ_fcn(string); + + string UDAF [SUBAGGR quant_ui_udaf_lfta3, SUPERAGGR quant_ui_udaf_hfta3] quant_ui_udaf_hftaZ fstring32 (uint); + string UDAF quant_ui_udaf_hfta3 fstring32 (string); + string UDAF quant_ui_udaf_lfta3 fstring2088 (uint); +// int + int EXTR quantile_of quant_i_udaf_hftaZ extr_quant_i_hftaZ_fcn (int, float); + int FUN [COST LOW] extr_quant_i_hftaZ_fcn(string, float); + int EXTR median_of quant_i_udaf_hftaZ extr_med_i_hftaZ_fcn (int); + int FUN [COST LOW] extr_med_i_hftaZ_fcn(string); + + string UDAF [SUBAGGR quant_i_udaf_lfta3, SUPERAGGR quant_i_udaf_hfta3] quant_i_udaf_hftaZ fstring32 (int); + string UDAF quant_i_udaf_hfta3 fstring32 (string); + string UDAF quant_i_udaf_lfta3 fstring2088 (int); +// ullong + ullong EXTR quantile_of quant_ul_udaf_hftaZ extr_quant_ul_hftaZ_fcn (ullong, float); + ullong FUN [COST LOW] extr_quant_ul_hftaZ_fcn(string, float); + ullong EXTR median_of quant_ul_udaf_hftaZ extr_med_ul_hftaZ_fcn (ullong); + ullong FUN [COST LOW] extr_med_ul_hftaZ_fcn(string); + + string UDAF [SUBAGGR quant_ul_udaf_lfta3, SUPERAGGR quant_ul_udaf_hfta3] quant_ul_udaf_hftaZ fstring32 (ullong); + string UDAF quant_ul_udaf_hfta3 fstring32 (string); + string UDAF quant_ul_udaf_lfta3 fstring2904 (ullong); +// llong + llong EXTR quantile_of quant_l_udaf_hftaZ extr_quant_l_hftaZ_fcn (llong, float); + llong FUN [COST LOW] extr_quant_l_hftaZ_fcn(string, float); + llong EXTR median_of quant_l_udaf_hftaZ extr_med_l_hftaZ_fcn (llong); + llong FUN [COST LOW] extr_med_l_hftaZ_fcn(string); + + string UDAF [SUBAGGR quant_l_udaf_lfta3, SUPERAGGR quant_l_udaf_hfta3] quant_l_udaf_hftaZ fstring32 (llong); + string UDAF quant_l_udaf_hfta3 fstring32 (string); + string UDAF quant_l_udaf_lfta3 fstring2904 (llong); +// float + float EXTR quantile_of quant_f_udaf_hftaZ extr_quant_f_hftaZ_fcn (float, float); + float FUN [COST LOW] extr_quant_f_hftaZ_fcn(string, float); + float EXTR median_of quant_f_udaf_hftaZ extr_med_f_hftaZ_fcn (float); + float FUN [COST LOW] extr_med_f_hftaZ_fcn(string); + + string UDAF [SUBAGGR quant_f_udaf_lfta3, SUPERAGGR quant_f_udaf_hfta3] quant_f_udaf_hftaZ fstring32 (float); + string UDAF quant_f_udaf_hfta3 fstring32 (string); + string UDAF quant_f_udaf_lfta3 fstring2904 (float); /////////////////////////////////////////////////////////// // FIRST and LAST aggregation funciton @@ -676,31 +727,101 @@ uint FUN [LFTA_LEGAL, COST EXPENSIVE] // count the # times the payload is different from the previous value ///////////////////////////////////////////////////////////// - uint UDAF [SUBAGGR count_diff_lfta_ui, SUPERAGGR count_diff_hfta] count_diff fstring12 (uint); - uint UDAF count_diff_hfta fstring12 (string); + uint UDAF [SUBAGGR count_diff_lfta_ui, SUPERAGGR count_diff_hfta] count_diff fstring16 (uint); + uint UDAF count_diff_hfta fstring16 (string); string UDAF count_diff_lfta_ui fstring20 (uint); - uint UDAF [SUBAGGR count_diff_lfta_i, SUPERAGGR count_diff_hfta] count_diff fstring12 (int); + uint UDAF [SUBAGGR count_diff_lfta_i, SUPERAGGR count_diff_hfta] count_diff fstring16 (int); string UDAF count_diff_lfta_i fstring20 (int); - uint UDAF [SUBAGGR count_diff_lfta_ul, SUPERAGGR count_diff_hfta] count_diff fstring12 (ullong); + uint UDAF [SUBAGGR count_diff_lfta_ul, SUPERAGGR count_diff_hfta] count_diff fstring16 (ullong); string UDAF count_diff_lfta_ul fstring20 (ullong); - uint UDAF [SUBAGGR count_diff_lfta_l, SUPERAGGR count_diff_hfta] count_diff fstring12 (llong); + uint UDAF [SUBAGGR count_diff_lfta_l, SUPERAGGR count_diff_hfta] count_diff fstring16 (llong); string UDAF count_diff_lfta_l fstring20 (llong); - uint UDAF [SUBAGGR count_diff_lfta_s, SUPERAGGR count_diff_hfta] count_diff fstring12 (string); + uint UDAF [SUBAGGR count_diff_lfta_s, SUPERAGGR count_diff_hfta] count_diff fstring16 (string); string UDAF count_diff_lfta_s fstring20 (string); +//////////////////////////////////////////////////////////////// +// string aggregation via catenation +////////////////////////////////////////////////////// + + string UDAF [HFTA_ONLY] CAT_aggr fstring8 (string, string); + +//////////////////////////////////////////////////////////////// +// string aggregation via catenation, only collect strings different than the previous +////////////////////////////////////////////////////// + + string UDAF [HFTA_ONLY,RUNNING] CAT_aggr_diff fstring8 (string); + /////////////////////////////////////////////////////////// -// integer array aggregation funciton +// integer array aggregation function // We are going to store 4 values in LFTA in fixed size buffer -// plus one byte for array length (17 bytes total) -// HFTA will combine partial aggregates +// plus one byte for array length (17 bytes total) +// HFTA will combine partial aggregates +// This seems to create a string with a comma-separated list of the uints /////////////////////////////////////////////////////////// string UDAF [RUNNING, SUBAGGR running_array_aggr_lfta, SUPERAGGR running_array_aggr_hfta] running_array_aggr string (uint); string UDAF [RUNNING] running_array_aggr_hfta string (string); string UDAF [RUNNING] running_array_aggr_lfta fstring17 (uint); +////////////////////////////////////////////////////////// +// Mapping functions +// Should eventually be replaced by watchlist join ? +////////////////////////////////// + string FUN [HFTA_ONLY, COST EXPENSIVE] int_to_string_map(llong, string HANDLE); + string FUN [HFTA_ONLY, COST EXPENSIVE] int_to_string_map(ullong, string HANDLE); + string FUN [HFTA_ONLY, COST EXPENSIVE] int_to_string_map(int, string HANDLE); + string FUN [HFTA_ONLY, COST EXPENSIVE] int_to_string_map(uint, string HANDLE); + +////////////////////////////////////////////////////////// +// time-averaged aggregate. +// time_avg(sample, ts, window_size) + float UDAF [HFTA_ONLY, RUNNING] time_avg fstring44 (uint, llong, llong) ; + float UDAF [HFTA_ONLY, RUNNING] time_avg fstring44 (int, llong, llong) ; + float UDAF [HFTA_ONLY, RUNNING] time_avg fstring44 (ullong, llong, llong) ; + float UDAF [HFTA_ONLY, RUNNING] time_avg fstring44 (llong, llong, llong) ; + float UDAF [HFTA_ONLY, RUNNING] time_avg fstring44 (float, llong, llong) ; + +// ------------------------------------------------------------ +// running_sum_max : get the running sum of an int, +// be able to report this sum and also its max value +// during the time window + + llong EXTR running_sum run_sum_max extr_running_sum (uint); + llong EXTR running_sum run_sum_max extr_running_sum (int); + llong EXTR running_sum run_sum_max extr_running_sum (llong); + llong EXTR running_sum run_sum_max extr_running_sum (ullong); + llong FUN [COST LOW] extr_running_sum(string); + llong EXTR running_sum_max run_sum_max extr_running_sum_max (uint); + llong EXTR running_sum_max run_sum_max extr_running_sum_max (int); + llong EXTR running_sum_max run_sum_max extr_running_sum_max (llong); + llong EXTR running_sum_max run_sum_max extr_running_sum_max (ullong); + llong FUN [COST LOW] extr_running_sum_max(string); + string UDAF [HFTA_ONLY, RUNNING] run_sum_max fstring16 (uint); + string UDAF [HFTA_ONLY, RUNNING] run_sum_max fstring16 (int); + string UDAF [HFTA_ONLY, RUNNING] run_sum_max fstring16 (ullong); + string UDAF [HFTA_ONLY, RUNNING] run_sum_max fstring16 (llong); + +// ------------------------------------------------------------ +// to_hex_string : allow printing of binary strings + + string FUN [HFTA_ONLY, COST EXPENSIVE] to_hex_string(string); + +// ------------------------------------------------------------------- +// approx_count_distinct : approximate the count distinct by +// taking minhashes. accurate to 7%, tested up to 100M distinct +// items. +// +// TODO : allow running aggregates to be used in regular aggregation? + + float EXTR approx_count_distinct approx_count_distinct_udaf extr_approx_count_distinct(string); + string UDAF approx_count_distinct_udaf fstring1000 (string); + float FUN extr_approx_count_distinct(string); + + float EXTR running_approx_count_distinct running_approx_count_distinct_udaf extr_approx_count_distinct(string); + string UDAF [RUNNING] running_approx_count_distinct_udaf fstring1000 (string); + float FUN extr_approx_count_distinct(string);