From 52d0f111dab17350f6a5d25906f1326568429f11 Mon Sep 17 00:00:00 2001 From: zz_y Date: Tue, 29 Sep 2026 18:21:01 +0000 Subject: [PATCH 1/8] feat(asap-tools): add trace label and value skew analysis Add asap-tools/dataset-analysis: query sets over Google 2011, Alibaba v2022 and BOOM traces, a fetch script, and fit_skew.py, which fits a discrete Zipf theta per key query and a power-law alpha per value query, with lower/upper bounds from per-window fits. Add a CI job running its lint, type check and unit tests. Co-Authored-By: Claude Opus 5.5 --- .github/workflows/python.yml | 34 + asap-tools/dataset-analysis/.gitignore | 1 + asap-tools/dataset-analysis/.isort.cfg | 2 + asap-tools/dataset-analysis/.mypy.ini | 4 + asap-tools/dataset-analysis/README.md | 145 ++++ asap-tools/dataset-analysis/fetch_data.sh | 66 ++ asap-tools/dataset-analysis/fit_skew.py | 798 ++++++++++++++++++ .../queries/alibaba_v2022.yaml | 145 ++++ asap-tools/dataset-analysis/queries/boom.yaml | 38 + .../dataset-analysis/queries/google_2011.yaml | 85 ++ asap-tools/dataset-analysis/requirements.txt | 8 + .../dataset-analysis/tests/test_fit_skew.py | 235 ++++++ 12 files changed, 1561 insertions(+) create mode 100644 asap-tools/dataset-analysis/.gitignore create mode 100644 asap-tools/dataset-analysis/.isort.cfg create mode 100644 asap-tools/dataset-analysis/.mypy.ini create mode 100644 asap-tools/dataset-analysis/README.md create mode 100755 asap-tools/dataset-analysis/fetch_data.sh create mode 100644 asap-tools/dataset-analysis/fit_skew.py create mode 100644 asap-tools/dataset-analysis/queries/alibaba_v2022.yaml create mode 100644 asap-tools/dataset-analysis/queries/boom.yaml create mode 100644 asap-tools/dataset-analysis/queries/google_2011.yaml create mode 100644 asap-tools/dataset-analysis/requirements.txt create mode 100644 asap-tools/dataset-analysis/tests/test_fit_skew.py diff --git a/.github/workflows/python.yml b/.github/workflows/python.yml index d185ecf3..4a00b872 100644 --- a/.github/workflows/python.yml +++ b/.github/workflows/python.yml @@ -39,6 +39,7 @@ jobs: utilities: ${{ steps.filter.outputs.utilities }} prometheus_exporters: ${{ steps.filter.outputs.prometheus_exporters }} execution_utilities: ${{ steps.filter.outputs.execution_utilities }} + dataset_analysis: ${{ steps.filter.outputs.dataset_analysis }} steps: - uses: actions/checkout@v4 - uses: dorny/paths-filter@v2 @@ -57,6 +58,8 @@ jobs: execution_utilities: - 'asap-tools/execution-utilities/**' - 'asap-common/dependencies/py/**' + dataset_analysis: + - 'asap-tools/dataset-analysis/**' test-prometheus-client: needs: detect-changes @@ -137,6 +140,37 @@ jobs: working-directory: asap-tools/experiments run: python -m unittest discover -s tests -p 'test_*.py' -v + test-dataset-analysis: + needs: detect-changes + if: needs.detect-changes.outputs.dataset_analysis == 'true' + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v4 + - name: Set up Python + uses: actions/setup-python@v4 + with: + python-version: '3.11' + - name: Install dependencies + run: | + python -m pip install --upgrade pip + pip install black==24.8.0 flake8==6.1.0 isort==5.13.2 mypy==1.14.1 types-PyYAML + pip install -r asap-tools/dataset-analysis/requirements.txt + - name: Check formatting with Black + working-directory: asap-tools/dataset-analysis + run: black --check --diff . + - name: Check import sorting with isort + working-directory: asap-tools/dataset-analysis + run: isort --check-only --diff --settings-file .isort.cfg . + - name: Lint with flake8 + working-directory: asap-tools/dataset-analysis + run: flake8 . --config=../../.flake8 --count --show-source --statistics + - name: Type check with mypy + working-directory: asap-tools/dataset-analysis + run: mypy . --config-file=.mypy.ini + - name: Run tests + working-directory: asap-tools/dataset-analysis + run: python -m unittest discover -s tests -p 'test_*.py' -v + test-prometheus-exporters: needs: detect-changes if: needs.detect-changes.outputs.prometheus_exporters == 'true' diff --git a/asap-tools/dataset-analysis/.gitignore b/asap-tools/dataset-analysis/.gitignore new file mode 100644 index 00000000..89f9ac04 --- /dev/null +++ b/asap-tools/dataset-analysis/.gitignore @@ -0,0 +1 @@ +out/ diff --git a/asap-tools/dataset-analysis/.isort.cfg b/asap-tools/dataset-analysis/.isort.cfg new file mode 100644 index 00000000..b9fb3f3e --- /dev/null +++ b/asap-tools/dataset-analysis/.isort.cfg @@ -0,0 +1,2 @@ +[settings] +profile=black diff --git a/asap-tools/dataset-analysis/.mypy.ini b/asap-tools/dataset-analysis/.mypy.ini new file mode 100644 index 00000000..8cb50b6d --- /dev/null +++ b/asap-tools/dataset-analysis/.mypy.ini @@ -0,0 +1,4 @@ +[mypy] +files = "**/*.py" +ignore_missing_imports = True +disable_error_code = import-untyped diff --git a/asap-tools/dataset-analysis/README.md b/asap-tools/dataset-analysis/README.md new file mode 100644 index 00000000..73b91de5 --- /dev/null +++ b/asap-tools/dataset-analysis/README.md @@ -0,0 +1,145 @@ +# Dataset skew analysis + +Measures how skewed real observability traces are, so sketch benchmarks can +be run over a realistic range of skew rather than a single guessed value. + +Two tasks: + +1. **Label query sets per dataset.** `queries/*.yaml` lists PromQL-style + queries over each trace (`sum by (user) (cpu_rate)`, + `count by (um, dm) (rt)`, `quantile(0.99, cpu_rate)`, ...), each with + the table, group-by labels and value column it reads. +2. **Lower / MLE / upper skew per distribution.** `fit_skew.py` fits + - a discrete Zipf exponent θ to the rank-frequency of every key query's + group-by key (weighted by row count and by value sum), and + - a continuous power-law tail exponent α to every value query's column, + + once on all data and once per time window. + +## Running + +```bash +pip install -r requirements.txt +./fetch_data.sh /path/to/trace-data # ~5 GB; re-run to resume +python fit_skew.py --data-root /path/to/trace-data +``` + +This writes `results/skew_summary.csv` (committed) and plots to `out/` +(gitignored). Useful flags: + +- `--queries queries/google_2011.yaml`: run a subset of datasets. +- `--max-rows 300000`: rows read per file (BOOM: time steps per series) + for a quick smoke run. +- `--no-plots`, `--out DIR`, `--summary PATH`. +- `--min-window-rows` (default 200) and `--min-window-keys` (default 2): + windows below either threshold are skipped when computing the bounds. +- `--workers N`: process pool size (default: all cores). Files and fits run + in parallel. + +A full run over the fetched data takes about 5 minutes with 48 workers on a +56-core machine (peak RSS of the main process about 3.6 GB). Alibaba archives are streamed with `tarfile`, not extracted. + +Tests: `python -m unittest discover -s tests -p 'test_*.py'`. + +## Datasets + +| Dataset | Files | Tables | Window | +|---|---|---|---| +| Google ClusterData 2011-2 | `task_usage` and `task_events` part 0 of 500, all 500 `job_events` parts, `schema.csv` | `task_usage` joined with task and job attributes | 5 min | +| Alibaba microservices v2022 | `NodeMetricsUpdate_0`, `MSMetricsUpdate_0`, `CallGraph_0..9`, `MCRRTUpdate_0..9` (first 30 minutes) | `MSRTMCR`, `CallGraph`, `MSMetrics`, `NodeMetrics` | 1 min | +| Datadog BOOM | `dataset_taxonomy.json` and 20 multivariate series | per-series `target` | 20 equal chunks per series | + +Citations: + +```bibtex +@online{google-traces-2011, + title={{Google ClusterData 2011 traces}}, + url={{https://github.com/google/cluster-data/blob/master/ClusterData2011_2.md}}, + year={2025} +} + +@inproceedings{luo2022Prediction, + title={The Power of Prediction: Microservice Auto Scaling via Workload Learning}, + author={Luo, Shutian and Xu, Huanle and Ye, Kejiang and Xu, Guoyao and Zhang, Liping and Yang, Guodong and Xu, Chengzhong}, + booktitle={Proceedings of the ACM Symposium on Cloud Computing}, + year={2022} +} + +@misc{cohen2025timedifferentobservabilityperspective, + title={This Time is Different: An Observability Perspective on Time Series Foundation Models}, + author={Ben Cohen and Emaad Khwaja and Youssef Doubli and Salahidine Lemaachi and Chris Lettieri and Charles Masson and Hugo Miccinilli and Elise Ramé and Qiqi Ren and Afshin Rostamizadeh and Jean Ogier du Terrail and Anna-Monica Toon and Kan Wang and Stephan Xie and Zongzhe Xu and Viktoriya Zhukova and David Asker and Ameet Talwalkar and Othmane Abou-Amal}, + year={2025}, + eprint={2505.14766}, + archivePrefix={arXiv}, + primaryClass={cs.LG}, + url={https://arxiv.org/abs/2505.14766} +} +``` + +## Definitions + +- **Key θ**: sort the per-key weights descending and fit the exponent `s` of + a discrete Zipf over ranks `1..K` by maximum likelihood + (`scipy.optimize.minimize_scalar`, bounded to [0, 5]). The weight is + either the row count per key (`weight=count`) or the sum of the value per + key with negatives clipped to 0 (`weight=value`). +- **Value α**: `powerlaw.Fit` (continuous, `xmin` chosen by minimizing the + KS distance), with α the exponent of the pdf `p(x) ∝ x^-α` for + `x ≥ xmin`. Non-positive values are dropped first. Each fit uses a uniform + subsample of at most 5000 values because the `xmin` search is quadratic, + and `xmin` is only searched where at least 100 values remain in the tail, + so α describes roughly the top 2% or more of the distribution. +- **lower / upper**: min / max of the estimate over the windows that pass the + thresholds. **mle**: the estimate on all data pooled. mle is not a bound + and can sit outside [lower, upper]: pooling many windows adds rare keys to + the tail and accumulates mass on persistent heavy keys, which steepens the + pooled rank-frequency (seen in most CallGraph queries). +- **power_law_ok**: the power law is not significantly worse than both a + lognormal and an exponential (`distribution_compare`; worse means `R < 0` + with `p < 0.1`). + +## Output: `results/skew_summary.csv` + +One row per (query, kind, weight). The sketch-bench saturation study reads +`dataset, query_id, kind, weight, lower, mle, upper` to pick the θ and α +range it sweeps. + +| Column | Meaning | +|---|---| +| `dataset`, `query_id`, `promql` | query identity (a query with both kinds gets a `keys` and a `values` row) | +| `kind` | `keys` (θ) or `values` (α) | +| `weight` | `count` or `value` for key rows, empty for value rows | +| `K` | distinct keys with positive weight (BOOM: variates) | +| `rows` | rows with non-null keys (values: finite values) | +| `n_windows` | windows used for the bounds (BOOM: variate-chunk fits) | +| `lower`, `mle`, `upper` | θ or α as defined above | +| `top1_share`, `theta_ls` | key rows: share of the largest key, negated log-log least-squares slope | +| `dropped_frac` | value rows: fraction of finite values that were ≤ 0 | +| `xmin`, `ks_d`, `tail_frac` | value rows: fitted `xmin`, KS distance of the tail, and fraction of the fitted sample at or above `xmin` | +| `R_lognormal`, `p_lognormal`, `R_exponential`, `p_exponential` | log-likelihood ratio (power law vs alternative) and its p-value | +| `power_law_ok` | see Definitions | + +Plots in `out/`: `____rank_.png` (log-log +rank-frequency with the lower/mle/upper θ lines) and +`____ccdf.png` (empirical CCDF with the fitted α). + +## Caveats + +- **BOOM** strips tags and z-scores each variate, so there is no key θ and + the raw value scale is lost. α is fitted per variate on `x - min(x)` + (zeros dropped); the series row reports the median over variates of each + variate's lower, mle and upper, and `power_law_ok` is true when at least + half of the variates pass. +- **Google join rule**: `task_usage` rows get `user`, `priority` and + `scheduling_class` from the last non-null `task_events` value for the same + `(job_id, task_index)`, and `logical_job_name` from the last non-null + `job_events` value for the same `job_id` (both ordered by event time). +- **Small counts bias θ upward**: θ is fitted to the *sorted observed* + counts, so the long tail of keys seen once or twice is flatter than the + true law and the order statistics exaggerate the head. Windows with few + rows per key (short windows, high-cardinality keys) are most affected, which + widens `upper`. +- Alibaba tables are clipped to the first 30 minutes (`max_time_secs`), the + span of the 10 CallGraph / MCRRTUpdate shards. CallGraph has malformed rows + (extra fields), which are skipped and counted in the log, and `rt` values + of `None`, which are read as missing. diff --git a/asap-tools/dataset-analysis/fetch_data.sh b/asap-tools/dataset-analysis/fetch_data.sh new file mode 100755 index 00000000..244dae36 --- /dev/null +++ b/asap-tools/dataset-analysis/fetch_data.sh @@ -0,0 +1,66 @@ +#!/usr/bin/env bash +# Download the trace subsets analyzed by fit_skew.py into DATA_ROOT. +# Files that already exist are skipped, so the script can be re-run to resume. +set -euo pipefail + +if [ "$#" -ne 1 ]; then + echo "usage: $0 DATA_ROOT" >&2 + exit 1 +fi +DATA_ROOT=$1 + +GOOGLE_URL=https://storage.googleapis.com/clusterdata-2011-2 +ALIBABA_URL=https://aliopentrace.oss-cn-beijing.aliyuncs.com/v2022MicroservicesTraces +BOOM_URL=https://huggingface.co/datasets/Datadog/BOOM/resolve/main + +GOOGLE_JOB_EVENT_PARTS=500 +# CallGraph and MCRRTUpdate shards each cover 3 minutes; 10 shards = 30 minutes. +ALIBABA_RPC_SHARDS=10 + +BOOM_SERIES=( + ds-2187-H ds-2394-D ds-1135-5T ds-1833-D ds-2806-D + ds-2573-D ds-2222-30T ds-1914-30T ds-2577-H ds-2212-D + ds-2782-H ds-1400-10S ds-2650-D ds-1316-10S ds-1558-5T + ds-1972-D ds-1840-D ds-671-10S ds-1524-5T ds-899-T +) +BOOM_SERIES_FILES=(data-00000-of-00001.arrow dataset_info.json state.json) + +# fetch URL DEST: download to a temp file, then rename so partial files never look complete. +fetch() { + local url=$1 dest=$2 + if [ -s "$dest" ]; then + return + fi + mkdir -p "$(dirname "$dest")" + echo "fetch $url" + curl -fL --retry 5 --retry-delay 5 -C - -o "$dest.part" "$url" + mv "$dest.part" "$dest" +} + +google_part() { + printf 'part-%05d-of-00500.csv.gz' "$1" +} + +G=$DATA_ROOT/google-2011 +fetch "$GOOGLE_URL/schema.csv" "$G/schema.csv" +fetch "$GOOGLE_URL/task_usage/$(google_part 0)" "$G/task_usage/$(google_part 0)" +fetch "$GOOGLE_URL/task_events/$(google_part 0)" "$G/task_events/$(google_part 0)" +for ((i = 0; i < GOOGLE_JOB_EVENT_PARTS; i++)); do + fetch "$GOOGLE_URL/job_events/$(google_part "$i")" "$G/job_events/$(google_part "$i")" +done + +A=$DATA_ROOT/alibaba-v2022 +fetch "$ALIBABA_URL/NodeMetricsUpdate/NodeMetricsUpdate_0.tar.gz" "$A/NodeMetricsUpdate_0.tar.gz" +fetch "$ALIBABA_URL/MSMetricsUpdate/MSMetricsUpdate_0.tar.gz" "$A/MSMetricsUpdate_0.tar.gz" +for ((i = 0; i < ALIBABA_RPC_SHARDS; i++)); do + fetch "$ALIBABA_URL/CallGraph/CallGraph_$i.tar.gz" "$A/CallGraph_$i.tar.gz" + fetch "$ALIBABA_URL/MCRRTUpdate/MCRRTUpdate_$i.tar.gz" "$A/MCRRTUpdate_$i.tar.gz" +done + +B=$DATA_ROOT/boom +fetch "$BOOM_URL/dataset_taxonomy.json" "$B/dataset_taxonomy.json" +for series in "${BOOM_SERIES[@]}"; do + for f in "${BOOM_SERIES_FILES[@]}"; do + fetch "$BOOM_URL/$series/$f" "$B/$series/$f" + done +done diff --git a/asap-tools/dataset-analysis/fit_skew.py b/asap-tools/dataset-analysis/fit_skew.py new file mode 100644 index 00000000..ae81a97c --- /dev/null +++ b/asap-tools/dataset-analysis/fit_skew.py @@ -0,0 +1,798 @@ +#!/usr/bin/env python3 +"""Fit label skew (Zipf theta) and value skew (power-law alpha) for trace query sets. + +Key queries fit a discrete Zipf exponent to the rank-frequency of the group-by +key; value queries fit a continuous power law to the queried column. Every fit +is repeated per window: lower/upper are the min/max over windows and mle is the +fit on all data. +""" + +import argparse +import glob +import io +import logging +import os +import tarfile +import time +import warnings +from contextlib import redirect_stdout +from multiprocessing import Pool +from pathlib import Path +from typing import Any, Dict, Iterator, List, Optional, Sequence, Set, Tuple + +import numpy as np +import pandas as pd +import powerlaw +import pyarrow as pa +import pyarrow.csv as pacsv +import yaml +from matplotlib.figure import Figure +from scipy.optimize import minimize_scalar + +SCRIPT_DIR = Path(__file__).resolve().parent +DEFAULT_QUERIES = sorted(str(p) for p in (SCRIPT_DIR / "queries").glob("*.yaml")) +DEFAULT_SUMMARY = SCRIPT_DIR / "results" / "skew_summary.csv" +DEFAULT_OUT = SCRIPT_DIR / "out" + +ZIPF_THETA_BOUNDS = (0.0, 5.0) +# powerlaw's xmin search is quadratic in sample size, so fits use a uniform subsample. +MAX_FIT_SAMPLES = 5000 +# xmin is searched only where at least this many values remain in the tail; +# tinier tails give meaningless alphas. +MIN_TAIL_SAMPLES = 100 +SAMPLE_SEED = 0 +DEFAULT_MIN_WINDOW_ROWS = 200 +DEFAULT_MIN_WINDOW_KEYS = 2 +# R < 0 with p below this means the power law fits significantly worse. +COMPARE_P_THRESHOLD = 0.1 +POWER_LAW_ALTERNATIVES = ("lognormal", "exponential") + +CSV_BLOCK_BYTES = 64 << 20 +CSV_NULL_VALUES = ["", "None", "NULL", "NaN", "nan"] +LABEL_TYPE = pa.dictionary(pa.int32(), pa.string()) + +WINDOW_COL = "_window" +COUNT_COL = "count" +VALUE_SUM_COL = "value_sum" +KEY_WEIGHTS = {"count", "value"} +QUERY_KINDS = {"keys", "values"} + +SUMMARY_COLUMNS = [ + "dataset", + "query_id", + "promql", + "kind", + "weight", + "K", + "rows", + "n_windows", + "lower", + "mle", + "upper", + "top1_share", + "theta_ls", + "dropped_frac", + "xmin", + "ks_d", + "tail_frac", + "R_lognormal", + "p_lognormal", + "R_exponential", + "p_exponential", + "power_law_ok", +] + +# Plot colors: observed data in neutral ink, the three estimates as one blue ramp. +OBSERVED_COLOR = "#8a8984" +BOUND_COLORS = {"lower": "#86b6ef", "mle": "#2a78d6", "upper": "#104281"} + +log = logging.getLogger("fit_skew") + + +# ---------------------------------------------------------------- config + + +def load_config(path: str) -> Dict[str, Any]: + with open(path) as f: + cfg = yaml.safe_load(f) + validate_config(cfg) + return cfg + + +def validate_query(q: Dict[str, Any], table: Dict[str, Any], where: str) -> None: + if q["kind"] not in QUERY_KINDS: + raise ValueError(f"{where}: kind must be one of {sorted(QUERY_KINDS)}") + for col in q["group_by"]: + if col not in table["label_columns"]: + raise ValueError(f"{where}: {col!r} is not a label column") + value = q.get("value") + if value is not None and value not in table["value_columns"]: + raise ValueError(f"{where}: {value!r} is not a value column") + if q["kind"] == "values": + if value is None: + raise ValueError(f"{where}: value queries need a value column") + return + if not q["group_by"]: + raise ValueError(f"{where}: key queries need group_by") + weights = set(q["weights"]) + if not weights or not weights <= KEY_WEIGHTS: + raise ValueError(f"{where}: weights must be a subset of {KEY_WEIGHTS}") + if "value" in weights and value is None: + raise ValueError(f"{where}: weight 'value' needs a value column") + + +def validate_config(cfg: Dict[str, Any]) -> None: + for q in cfg["queries"]: + where = f"{cfg['dataset']}/{q['id']}" + table = cfg["tables"].get(q["table"]) + if table is None: + raise ValueError(f"{where}: unknown table {q['table']!r}") + validate_query(q, table, where) + + +def expand_files(data_root: str, patterns: Sequence[str]) -> List[str]: + paths = [] + for pattern in patterns: + matches = sorted(glob.glob(os.path.join(data_root, pattern))) + if not matches: + raise FileNotFoundError(f"no files match {pattern} under {data_root}") + paths.extend(matches) + return paths + + +# ---------------------------------------------------------------- reading + + +def google_column_names(schema_path: str, table: str) -> List[str]: + """Column names for a headerless Google table, e.g. 'CPU rate' -> 'cpu_rate'.""" + schema = pd.read_csv(schema_path) + rows = schema[schema["file pattern"].str.startswith(table + "/")] + if rows.empty: + raise ValueError(f"table {table!r} not found in {schema_path}") + contents = rows.sort_values("field number")["content"] + return [c.strip().lower().replace(" ", "_") for c in contents] + + +def csv_batches( + source: Any, + columns: Sequence[str], + float_columns: Set[str], + column_names: Optional[List[str]], + bad_rows: List[str], +) -> Iterator[pd.DataFrame]: + """Stream a CSV as DataFrames. Float columns are float64, the rest categorical.""" + + def skip_row(row: Any) -> str: + bad_rows.append(row.text) + return "skip" + + types = {c: pa.float64() if c in float_columns else LABEL_TYPE for c in columns} + reader = pacsv.open_csv( + source, + read_options=pacsv.ReadOptions( + column_names=column_names, block_size=CSV_BLOCK_BYTES + ), + parse_options=pacsv.ParseOptions(invalid_row_handler=skip_row), + convert_options=pacsv.ConvertOptions( + include_columns=list(columns), + column_types=types, + null_values=CSV_NULL_VALUES, + strings_can_be_null=True, + ), + ) + for batch in reader: + yield batch.to_pandas() + + +def table_frames( + data_root: str, + table: Dict[str, Any], + path: str, + columns: Sequence[str], + float_columns: Set[str], + bad_rows: List[str], +) -> Iterator[pd.DataFrame]: + fmt = table["format"] + if fmt == "google_csv": + # The table name is the directory name, as in the schema's file patterns. + schema = os.path.join(data_root, table["schema"]) + names = google_column_names(schema, Path(path).parent.name) + yield from csv_batches(path, columns, float_columns, names, bad_rows) + elif fmt == "alibaba_tar": + # Stream members straight out of the archive instead of extracting. + with tarfile.open(path, mode="r|gz") as archive: + for member in archive: + f = archive.extractfile(member) + if f is not None: + yield from csv_batches(f, columns, float_columns, None, bad_rows) + else: + raise ValueError(f"unsupported table format {fmt!r}") + + +def load_join( + data_root: str, table: Dict[str, Any], join: Dict[str, Any] +) -> pd.DataFrame: + """Last non-null value of each join column per key, ordered by sort_by.""" + columns = join["keys"] + [join["sort_by"]] + join["columns"] + bad_rows: List[str] = [] + frames = [ + frame + for path in expand_files(data_root, join["files"]) + for frame in table_frames( + data_root, table, path, columns, {join["sort_by"]}, bad_rows + ) + ] + df = pd.concat(frames, ignore_index=True) + df = df.astype({c: object for c in join["keys"] + join["columns"]}) + df = df.sort_values(join["sort_by"], kind="stable") + return df.groupby(join["keys"])[join["columns"]].last() + + +def read_boom_series(path: str) -> np.ndarray: + """Target of a BOOM series as a (variates, time) array.""" + with pa.memory_map(path) as src: + table = pa.ipc.open_stream(src).read_all() + if table.num_rows != 1: + raise ValueError(f"{path}: expected one row, found {table.num_rows}") + return np.atleast_2d(np.array(table.column("target")[0].as_py(), dtype=float)) + + +# ---------------------------------------------------------------- aggregation + + +def query_key(q: Dict[str, Any]) -> Tuple[str, str]: + return q["id"], q["kind"] + + +def merge_key_parts(parts: List[pd.DataFrame], group_by: List[str]) -> pd.DataFrame: + """Sum per-(window, key) counts and value sums; indexed by window and keys.""" + return pd.concat(parts, ignore_index=True).groupby([WINDOW_COL] + group_by).sum() + + +def key_part(frame: pd.DataFrame, q: Dict[str, Any]) -> pd.DataFrame: + keys = [WINDOW_COL] + q["group_by"] + if "value" in q["weights"]: + clipped = frame.assign(**{VALUE_SUM_COL: frame[q["value"]].clip(lower=0)}) + part = clipped.groupby(keys, observed=True, sort=False).agg( + **{ + COUNT_COL: (VALUE_SUM_COL, "size"), + VALUE_SUM_COL: (VALUE_SUM_COL, "sum"), + } + ) + else: + part = frame.groupby(keys, observed=True, sort=False).size().to_frame(COUNT_COL) + # Categories differ between batches, so merge on plain values. + return part.reset_index().astype({c: object for c in q["group_by"]}) + + +def add_values(acc: Dict[str, Any], windows: np.ndarray, values: np.ndarray) -> None: + finite = np.isfinite(values) + positive = values > 0 + acc["n_finite"] += int(finite.sum()) + for w in np.unique(windows[positive]): + acc["windows"].setdefault(int(w), []).append(values[positive & (windows == w)]) + + +def aggregate_file(task: Tuple[Any, ...]) -> Dict[str, Any]: + """Per-window key aggregates and positive values for one file.""" + data_root, table, path, queries, window_secs, max_time_secs, max_rows = task + time_col = table["time_column"] + value_cols = {q["value"] for q in queries if q.get("value")} + join_cols = [c for j in table.get("joins", []) for c in j["columns"]] + needed = {time_col} | value_cols + needed |= {c for q in queries for c in q["group_by"] if c not in join_cols} + needed |= {c for j in table.get("joins", []) for c in j["keys"]} + joins = [(j, load_join(data_root, table, j)) for j in table.get("joins", [])] + + key_parts: Dict[Tuple[str, str], List[pd.DataFrame]] = {} + values: Dict[Tuple[str, str], Dict[str, Any]] = {} + for q in queries: + if q["kind"] == "keys": + key_parts[query_key(q)] = [] + else: + values[query_key(q)] = {"n_finite": 0, "windows": {}} + rows_read = 0 + bad_rows: List[str] = [] + frames = table_frames( + data_root, table, path, sorted(needed), value_cols | {time_col}, bad_rows + ) + for frame in frames: + if max_rows is not None: + frame = frame.iloc[: max_rows - rows_read] + rows_read += len(frame) + secs = frame[time_col] * table["time_unit_secs"] + keep = secs.notna() + if max_time_secs is not None: + keep &= secs < max_time_secs + frame = frame[keep].copy() + frame[WINDOW_COL] = np.floor(secs[keep] / window_secs).astype(np.int64) + for join, lookup in joins: + frame = frame.astype({c: object for c in join["keys"]}) + frame = frame.join(lookup, on=join["keys"]) + for q in queries: + if q["kind"] == "keys": + key_parts[query_key(q)].append(key_part(frame, q)) + else: + add_values( + values[query_key(q)], + frame[WINDOW_COL].to_numpy(), + frame[q["value"]].to_numpy(dtype=float), + ) + if max_rows is not None and rows_read >= max_rows: + break + keys = { + query_key(q): merge_key_parts(key_parts[query_key(q)], q["group_by"]) + for q in queries + if q["kind"] == "keys" + } + return { + "keys": keys, + "values": values, + "rows_read": rows_read, + "bad_rows": len(bad_rows), + } + + +# ---------------------------------------------------------------- fitting + + +def zipf_mle(weights: Sequence[float]) -> float: + """Discrete Zipf exponent over ranks 1..K maximizing the likelihood of the + sorted weights (counts, or value sums used as fractional counts).""" + w = np.sort(np.asarray(weights, dtype=float))[::-1] + w = w[w > 0] + if len(w) < 2: + return float("nan") + log_rank = np.log(np.arange(1, len(w) + 1)) + total, weighted_log_rank = w.sum(), (w * log_rank).sum() + + def neg_log_likelihood(s: float) -> float: + return s * weighted_log_rank + total * np.log(np.exp(-s * log_rank).sum()) + + res = minimize_scalar( + neg_log_likelihood, bounds=ZIPF_THETA_BOUNDS, method="bounded" + ) + return float(res.x) + + +def loglog_slope(weights: Sequence[float]) -> float: + """Negated least-squares slope of log(weight) vs log(rank).""" + w = np.sort(np.asarray(weights, dtype=float))[::-1] + w = w[w > 0] + if len(w) < 2: + return float("nan") + return float(-np.polyfit(np.log(np.arange(1, len(w) + 1)), np.log(w), 1)[0]) + + +def window_bounds(estimates: Sequence[float]) -> Tuple[float, float, int]: + """(min, max, count) over the finite per-window estimates.""" + finite = [e for e in estimates if np.isfinite(e)] + if not finite: + return float("nan"), float("nan"), 0 + return min(finite), max(finite), len(finite) + + +def subsample(x: np.ndarray) -> np.ndarray: + if len(x) <= MAX_FIT_SAMPLES: + return x + rng = np.random.default_rng(SAMPLE_SEED) + return x[rng.choice(len(x), MAX_FIT_SAMPLES, replace=False)] + + +def power_law_ok(comparisons: Sequence[Tuple[float, float]]) -> bool: + """False if any (R, p) comparison says the power law is significantly worse.""" + return not any(r < 0 and p < COMPARE_P_THRESHOLD for r, p in comparisons) + + +def fit_power_law(x: np.ndarray, compare: bool) -> Dict[str, Any]: + """Continuous power-law fit (xmin by KS) of positive values; with compare, + also the likelihood ratio against each alternative distribution.""" + result: Dict[str, Any] = {"alpha": np.nan, "xmin": np.nan, "ks_d": np.nan} + if len(x) < MIN_TAIL_SAMPLES: + return result + xmin_range = (float(np.min(x)), float(np.sort(x)[-MIN_TAIL_SAMPLES])) + # powerlaw prints xmin search progress unconditionally. + with warnings.catch_warnings(), np.errstate(all="ignore"), redirect_stdout( + io.StringIO() + ): + warnings.simplefilter("ignore") + fit = powerlaw.Fit(x, xmin=xmin_range, verbose=False) + result.update( + alpha=fit.power_law.alpha, + xmin=fit.xmin, + ks_d=fit.power_law.D, + tail_frac=np.mean(x >= fit.xmin), + ) + if not compare or not np.isfinite(result["alpha"]): + return result + comparisons = [] + for alt in POWER_LAW_ALTERNATIVES: + ratio, p = fit.distribution_compare("power_law", alt) + result[f"R_{alt}"], result[f"p_{alt}"] = ratio, p + comparisons.append((ratio, p)) + result["power_law_ok"] = power_law_ok(comparisons) + return result + + +def median_or_nan(values: Sequence[float]) -> float: + finite = [v for v in values if v is not None and np.isfinite(v)] + return float(np.median(finite)) if finite else float("nan") + + +# ---------------------------------------------------------------- plots + + +def plot_rank_frequency( + weights_desc: np.ndarray, thetas: Dict[str, float], title: str, path: Path +) -> None: + ranks = np.arange(1, len(weights_desc) + 1) + fig = Figure(figsize=(6, 4)) + ax = fig.subplots() + ax.loglog(ranks, weights_desc, ".", ms=3, color=OBSERVED_COLOR, label="observed") + for name, theta in thetas.items(): + if np.isfinite(theta): + ref = weights_desc.sum() * ranks**-theta / np.sum(ranks**-theta) + style = "-" if name == "mle" else "--" + ax.loglog( + ranks, + ref, + style, + lw=2, + color=BOUND_COLORS[name], + label=f"{name} θ={theta:.2f}", + ) + ax.set(xlabel="rank", ylabel="weight", title=title) + ax.legend() + fig.savefig(path, dpi=120, bbox_inches="tight") + + +def plot_ccdf(x: np.ndarray, fit: Dict[str, Any], title: str, path: Path) -> None: + xs = np.sort(x) + ccdf = 1.0 - np.arange(len(xs)) / len(xs) + fig = Figure(figsize=(6, 4)) + ax = fig.subplots() + ax.loglog(xs, ccdf, ".", ms=3, color=OBSERVED_COLOR, label="observed") + alpha, xmin = fit["alpha"], fit["xmin"] + if np.isfinite(alpha): + tail = xs[xs >= xmin] + ref = np.mean(xs >= xmin) * (tail / xmin) ** (1.0 - alpha) + label = f"power law α={alpha:.2f}, xmin={xmin:.3g}" + ax.loglog(tail, ref, "-", lw=2, color=BOUND_COLORS["mle"], label=label) + ax.set(xlabel="value", ylabel="P(X ≥ x)", title=title) + ax.legend() + fig.savefig(path, dpi=120, bbox_inches="tight") + + +def plot_path(plot_dir: Path, dataset: str, name: str) -> Path: + return plot_dir / f"{dataset}__{name}.png" + + +# ---------------------------------------------------------------- summaries + + +def summarize_keys( + dataset: str, + q: Dict[str, Any], + agg: pd.DataFrame, + min_rows: int, + min_keys: int, + plot_dir: Optional[Path], +) -> List[Dict[str, Any]]: + rows = int(agg[COUNT_COL].sum()) + if rows == 0: + raise ValueError(f"{dataset}/{q['id']}: no rows with non-null group keys") + out = [] + for weight in q["weights"]: + col = COUNT_COL if weight == "count" else VALUE_SUM_COL + per_key = agg.groupby(level=q["group_by"])[col].sum().to_numpy() + per_key = np.sort(per_key[per_key > 0])[::-1] + estimates = [] + for _, window in agg.groupby(level=WINDOW_COL): + w = window[col].to_numpy() + if window[COUNT_COL].sum() >= min_rows and np.sum(w > 0) >= min_keys: + estimates.append(zipf_mle(w)) + lower, upper, n_windows = window_bounds(estimates) + mle = zipf_mle(per_key) + out.append( + { + "dataset": dataset, + "query_id": q["id"], + "promql": q["promql"], + "kind": "keys", + "weight": weight, + "K": len(per_key), + "rows": rows, + "n_windows": n_windows, + "lower": lower, + "mle": mle, + "upper": upper, + "top1_share": per_key[0] / per_key.sum() if len(per_key) else np.nan, + "theta_ls": loglog_slope(per_key), + } + ) + if plot_dir is not None and len(per_key): + plot_rank_frequency( + per_key, + {"lower": lower, "mle": mle, "upper": upper}, + f"{dataset}: {q['promql']} [{weight}]", + plot_path(plot_dir, dataset, f"{q['id']}__rank_{weight}"), + ) + return out + + +def summarize_values( + dataset: str, + q: Dict[str, Any], + acc: Dict[str, Any], + pool: Any, + min_rows: int, + plot_dir: Optional[Path], +) -> Dict[str, Any]: + windows = {w: np.concatenate(parts) for w, parts in acc["windows"].items()} + if not windows: + raise ValueError(f"{dataset}/{q['id']}: no positive values") + all_values = np.concatenate(list(windows.values())) + mle_sample = subsample(all_values) + jobs = [(mle_sample, True)] + [ + (subsample(x), False) for x in windows.values() if len(x) >= min_rows + ] + fits = pool.starmap(fit_power_law, jobs) + lower, upper, n_windows = window_bounds([f["alpha"] for f in fits[1:]]) + mle_fit = fits[0] + if plot_dir is not None: + plot_ccdf( + mle_sample, + mle_fit, + f"{dataset}: {q['value']} ({q['id']})", + plot_path(plot_dir, dataset, f"{q['id']}__ccdf"), + ) + return { + "dataset": dataset, + "query_id": q["id"], + "promql": q["promql"], + "kind": "values", + "weight": "", + "rows": acc["n_finite"], + "n_windows": n_windows, + "lower": lower, + "mle": mle_fit["alpha"], + "upper": upper, + "dropped_frac": 1.0 - len(all_values) / acc["n_finite"], + **{k: v for k, v in mle_fit.items() if k != "alpha"}, + } + + +def analyze_table( + cfg: Dict[str, Any], + table: Dict[str, Any], + queries: List[Dict[str, Any]], + data_root: str, + pool: Any, + args: argparse.Namespace, + plot_dir: Optional[Path], +) -> List[Dict[str, Any]]: + tasks = [ + ( + data_root, + table, + path, + queries, + cfg["window_secs"], + cfg.get("max_time_secs"), + args.max_rows, + ) + for path in expand_files(data_root, table["files"]) + ] + partials = pool.map(aggregate_file, tasks) + log.info( + "read %d rows (%d malformed rows skipped) from %d files", + sum(p["rows_read"] for p in partials), + sum(p["bad_rows"] for p in partials), + len(partials), + ) + out: List[Dict[str, Any]] = [] + for q in queries: + key = query_key(q) + if q["kind"] == "keys": + agg = merge_key_parts( + [p["keys"][key].reset_index() for p in partials], q["group_by"] + ) + out.extend( + summarize_keys( + cfg["dataset"], + q, + agg, + args.min_window_rows, + args.min_window_keys, + plot_dir, + ) + ) + else: + acc: Dict[str, Any] = {"n_finite": 0, "windows": {}} + for p in partials: + acc["n_finite"] += p["values"][key]["n_finite"] + for w, parts in p["values"][key]["windows"].items(): + acc["windows"].setdefault(w, []).extend(parts) + out.append( + summarize_values( + cfg["dataset"], q, acc, pool, args.min_window_rows, plot_dir + ) + ) + log.info("%s %s %s done", cfg["dataset"], q["id"], q["kind"]) + return out + + +def boom_fit_jobs( + shifted: np.ndarray, n_chunks: int, min_rows: int +) -> Tuple[List[Tuple[np.ndarray, bool]], List[int]]: + """Fit jobs for each variate (full series with comparisons, then each + chunk) and the variate each job belongs to.""" + jobs: List[Tuple[np.ndarray, bool]] = [] + owners: List[int] = [] + for v, y in enumerate(shifted): + jobs.append((subsample(y[y > 0]), True)) + owners.append(v) + for chunk in np.array_split(y, n_chunks): + chunk = chunk[chunk > 0] + if len(chunk) >= min_rows: + jobs.append((subsample(chunk), False)) + owners.append(v) + return jobs, owners + + +def summarize_boom_series( + dataset: str, + q: Dict[str, Any], + series: str, + shifted: np.ndarray, + jobs: List[Tuple[np.ndarray, bool]], + owners: List[int], + fits: List[Dict[str, Any]], + plot_dir: Optional[Path], +) -> Dict[str, Any]: + """Median over variates of each variate's lower/mle/upper and diagnostics.""" + full: Dict[int, Dict[str, Any]] = {} + samples: Dict[int, np.ndarray] = {} + chunk_alphas: Dict[int, List[float]] = {v: [] for v in range(len(shifted))} + for (x, is_full), v, fit in zip(jobs, owners, fits): + if is_full: + full[v], samples[v] = fit, x + else: + chunk_alphas[v].append(fit["alpha"]) + bounds = [window_bounds(alphas) for alphas in chunk_alphas.values()] + oks = [f["power_law_ok"] for f in full.values() if "power_law_ok" in f] + finite = int(np.isfinite(shifted).sum()) + row = { + "dataset": dataset, + "query_id": f"{q['id']}[{series}]", + "promql": q["promql"], + "kind": "values", + "weight": "", + "K": len(shifted), + "rows": finite, + "n_windows": sum(b[2] for b in bounds), + "lower": median_or_nan([b[0] for b in bounds]), + "mle": median_or_nan([f["alpha"] for f in full.values()]), + "upper": median_or_nan([b[1] for b in bounds]), + "dropped_frac": 1.0 - np.sum(shifted > 0) / finite, + "power_law_ok": np.mean(oks) >= 0.5 if oks else np.nan, + } + for col in ("xmin", "ks_d", "tail_frac") + tuple( + f"{k}_{alt}" for alt in POWER_LAW_ALTERNATIVES for k in ("R", "p") + ): + row[col] = median_or_nan([f.get(col, np.nan) for f in full.values()]) + fitted = [v for v in full if np.isfinite(full[v]["alpha"])] + if plot_dir is not None and fitted: + # Show the variate whose alpha is closest to the series median. + v = min(fitted, key=lambda v: abs(full[v]["alpha"] - row["mle"])) + plot_ccdf( + samples[v], + full[v], + f"boom {series}: variate {v} of {len(shifted)}", + plot_path(plot_dir, dataset, f"{series}__ccdf"), + ) + return row + + +def analyze_boom( + cfg: Dict[str, Any], + table: Dict[str, Any], + q: Dict[str, Any], + data_root: str, + pool: Any, + args: argparse.Namespace, + plot_dir: Optional[Path], +) -> List[Dict[str, Any]]: + """Per-variate tail fits on x - min(x), summarized per series.""" + out = [] + for path in expand_files(data_root, table["files"]): + variates = read_boom_series(path) + if args.max_rows is not None: + variates = variates[:, : args.max_rows] + shifted = variates - np.nanmin(variates, axis=1, keepdims=True) + jobs, owners = boom_fit_jobs(shifted, cfg["n_chunks"], args.min_window_rows) + fits = pool.starmap(fit_power_law, jobs) + series = Path(path).parent.name + out.append( + summarize_boom_series( + cfg["dataset"], q, series, shifted, jobs, owners, fits, plot_dir + ) + ) + log.info("boom %s done", series) + return out + + +def analyze_dataset( + cfg: Dict[str, Any], + data_root: str, + pool: Any, + args: argparse.Namespace, + plot_dir: Optional[Path], +) -> List[Dict[str, Any]]: + out: List[Dict[str, Any]] = [] + for name, table in cfg["tables"].items(): + queries = [q for q in cfg["queries"] if q["table"] == name] + if not queries: + continue + log.info("%s: table %s, %d queries", cfg["dataset"], name, len(queries)) + if table["format"] == "boom_arrow": + for q in queries: + out.extend(analyze_boom(cfg, table, q, data_root, pool, args, plot_dir)) + else: + out.extend( + analyze_table(cfg, table, queries, data_root, pool, args, plot_dir) + ) + return out + + +def parse_args(argv: Optional[Sequence[str]] = None) -> argparse.Namespace: + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--data-root", required=True, help="fetch_data.sh DATA_ROOT") + parser.add_argument("--queries", nargs="+", default=DEFAULT_QUERIES) + parser.add_argument("--out", type=Path, default=DEFAULT_OUT, help="plot dir") + parser.add_argument("--summary", type=Path, default=DEFAULT_SUMMARY) + parser.add_argument("--no-plots", action="store_true") + parser.add_argument( + "--max-rows", + type=int, + default=None, + help="rows read per file (BOOM: time steps per series), for smoke runs", + ) + parser.add_argument( + "--min-window-rows", + type=int, + default=DEFAULT_MIN_WINDOW_ROWS, + help="skip windows with fewer rows (values: fewer positive values)", + ) + parser.add_argument( + "--min-window-keys", + type=int, + default=DEFAULT_MIN_WINDOW_KEYS, + help="skip key-query windows with fewer distinct keys", + ) + parser.add_argument("--workers", type=int, default=os.cpu_count()) + return parser.parse_args(argv) + + +def main() -> None: + logging.basicConfig(level=logging.INFO, format="%(asctime)s %(message)s") + args = parse_args() + configs = [load_config(path) for path in args.queries] + plot_dir = None if args.no_plots else args.out + if plot_dir is not None: + plot_dir.mkdir(parents=True, exist_ok=True) + start = time.time() + rows: List[Dict[str, Any]] = [] + with Pool(args.workers) as pool: + for cfg in configs: + rows.extend(analyze_dataset(cfg, args.data_root, pool, args, plot_dir)) + args.summary.parent.mkdir(parents=True, exist_ok=True) + summary = pd.DataFrame(rows).reindex(columns=SUMMARY_COLUMNS) + summary.to_csv(args.summary, index=False, float_format="%.6g") + log.info( + "wrote %s (%d rows) in %.0fs", args.summary, len(rows), time.time() - start + ) + + +if __name__ == "__main__": + main() diff --git a/asap-tools/dataset-analysis/queries/alibaba_v2022.yaml b/asap-tools/dataset-analysis/queries/alibaba_v2022.yaml new file mode 100644 index 00000000..b416459c --- /dev/null +++ b/asap-tools/dataset-analysis/queries/alibaba_v2022.yaml @@ -0,0 +1,145 @@ +# Alibaba cluster-trace-microservices-v2022, first 30 minutes. +dataset: alibaba_v2022 +window_secs: 60 +# NodeMetricsUpdate_0 covers 12 hours; clip every table to the 30 minutes +# covered by the CallGraph and MCRRTUpdate shards. +max_time_secs: 1800 +tables: + MSRTMCR: + format: alibaba_tar + files: ["alibaba-v2022/MCRRTUpdate_[0-9].tar.gz"] + time_column: timestamp + time_unit_secs: 1.0e-3 + label_columns: [msname, msinstanceid, nodeid] + value_columns: [providerrpc_rt, providerrpc_mcr] + CallGraph: + format: alibaba_tar + files: ["alibaba-v2022/CallGraph_[0-9].tar.gz"] + time_column: timestamp + time_unit_secs: 1.0e-3 + label_columns: [traceid, service, rpc_id, rpctype, um, uminstanceid, interface, dm, dminstanceid] + value_columns: [rt] + MSMetrics: + format: alibaba_tar + files: [alibaba-v2022/MSMetricsUpdate_0.tar.gz] + time_column: timestamp + time_unit_secs: 1.0e-3 + label_columns: [msname, msinstanceid, nodeid] + value_columns: [cpu_utilization, memory_utilization] + NodeMetrics: + format: alibaba_tar + files: [alibaba-v2022/NodeMetricsUpdate_0.tar.gz] + time_column: timestamp + time_unit_secs: 1.0e-3 + label_columns: [nodeid] + value_columns: [cpu_utilization, memory_utilization] +queries: + - id: mcr_by_msname + promql: sum by (msname) (providerrpc_mcr) + table: MSRTMCR + kind: keys + group_by: [msname] + value: providerrpc_mcr + weights: [count, value] + - id: mcr_by_nodeid + promql: sum by (nodeid) (providerrpc_mcr) + table: MSRTMCR + kind: keys + group_by: [nodeid] + value: providerrpc_mcr + weights: [count, value] + - id: rt_p99_by_msname + promql: quantile by (msname) (0.99, providerrpc_rt) + table: MSRTMCR + kind: keys + group_by: [msname] + value: providerrpc_rt + weights: [count, value] + - id: rt_p99_by_msname + promql: quantile by (msname) (0.99, providerrpc_rt) + table: MSRTMCR + kind: values + group_by: [] + value: providerrpc_rt + - id: calls_by_rpctype + promql: count by (rpctype) (rt) + table: CallGraph + kind: keys + group_by: [rpctype] + weights: [count] + - id: calls_by_service + promql: count by (service) (rt) + table: CallGraph + kind: keys + group_by: [service] + weights: [count] + - id: calls_by_um + promql: count by (um) (rt) + table: CallGraph + kind: keys + group_by: [um] + weights: [count] + - id: calls_by_dm + promql: count by (dm) (rt) + table: CallGraph + kind: keys + group_by: [dm] + weights: [count] + - id: calls_by_interface + promql: count by (interface) (rt) + table: CallGraph + kind: keys + group_by: [interface] + weights: [count] + - id: calls_by_um_dm + promql: count by (um, dm) (rt) + table: CallGraph + kind: keys + group_by: [um, dm] + weights: [count] + - id: calls_by_service_um_dm + promql: count by (service, um, dm) (rt) + table: CallGraph + kind: keys + group_by: [service, um, dm] + weights: [count] + - id: rt_p99_by_service + promql: quantile by (service) (0.99, rt) + table: CallGraph + kind: keys + group_by: [service] + value: rt + weights: [count, value] + - id: rt_p99_by_service + promql: quantile by (service) (0.99, rt) + table: CallGraph + kind: values + group_by: [] + value: rt + - id: ms_cpu_by_msname + promql: sum by (msname) (cpu_utilization) + table: MSMetrics + kind: keys + group_by: [msname] + value: cpu_utilization + weights: [count, value] + # Baseline: one key per node, expected to be close to uniform. + - id: node_cpu_by_nodeid + promql: sum by (nodeid) (cpu_utilization) + table: NodeMetrics + kind: keys + group_by: [nodeid] + value: cpu_utilization + weights: [count, value] + - id: ms_cpu_p99 + promql: quantile(0.99, cpu_utilization) + table: MSMetrics + kind: values + group_by: [] + value: cpu_utilization + - id: node_cpu_p99 + promql: quantile(0.99, cpu_utilization) + table: NodeMetrics + kind: values + group_by: [] + value: cpu_utilization diff --git a/asap-tools/dataset-analysis/queries/boom.yaml b/asap-tools/dataset-analysis/queries/boom.yaml new file mode 100644 index 00000000..3797194d --- /dev/null +++ b/asap-tools/dataset-analysis/queries/boom.yaml @@ -0,0 +1,38 @@ +# Datadog BOOM: 20 multivariate series. Tags are stripped and each variate is +# z-scored, so only the value tail is fitted, per variate on x - min(x). +dataset: boom +# Each series is split into this many equal-length chunks for the bounds. +n_chunks: 20 +tables: + series: + format: boom_arrow + files: + - boom/ds-2187-H/data-00000-of-00001.arrow + - boom/ds-2394-D/data-00000-of-00001.arrow + - boom/ds-1135-5T/data-00000-of-00001.arrow + - boom/ds-1833-D/data-00000-of-00001.arrow + - boom/ds-2806-D/data-00000-of-00001.arrow + - boom/ds-2573-D/data-00000-of-00001.arrow + - boom/ds-2222-30T/data-00000-of-00001.arrow + - boom/ds-1914-30T/data-00000-of-00001.arrow + - boom/ds-2577-H/data-00000-of-00001.arrow + - boom/ds-2212-D/data-00000-of-00001.arrow + - boom/ds-2782-H/data-00000-of-00001.arrow + - boom/ds-1400-10S/data-00000-of-00001.arrow + - boom/ds-2650-D/data-00000-of-00001.arrow + - boom/ds-1316-10S/data-00000-of-00001.arrow + - boom/ds-1558-5T/data-00000-of-00001.arrow + - boom/ds-1972-D/data-00000-of-00001.arrow + - boom/ds-1840-D/data-00000-of-00001.arrow + - boom/ds-671-10S/data-00000-of-00001.arrow + - boom/ds-1524-5T/data-00000-of-00001.arrow + - boom/ds-899-T/data-00000-of-00001.arrow + label_columns: [] + value_columns: [target] +queries: + - id: target_tail + promql: quantile(0.99, target) + table: series + kind: values + group_by: [] + value: target diff --git a/asap-tools/dataset-analysis/queries/google_2011.yaml b/asap-tools/dataset-analysis/queries/google_2011.yaml new file mode 100644 index 00000000..7bee91a4 --- /dev/null +++ b/asap-tools/dataset-analysis/queries/google_2011.yaml @@ -0,0 +1,85 @@ +# Google ClusterData 2011-2, shard 0 of task_usage joined with task attributes. +dataset: google_2011 +window_secs: 300 +tables: + task_usage: + format: google_csv + schema: google-2011/schema.csv + files: [google-2011/task_usage/part-00000-of-00500.csv.gz] + time_column: start_time + time_unit_secs: 1.0e-6 + # Each join keeps the last event per key (sorted by sort_by) and left-joins it. + joins: + - files: [google-2011/task_events/part-00000-of-00500.csv.gz] + keys: [job_id, task_index] + sort_by: time + columns: [user, priority, scheduling_class] + - files: [google-2011/job_events/part-*-of-00500.csv.gz] + keys: [job_id] + sort_by: time + columns: [logical_job_name] + label_columns: [job_id, machine_id, user, priority, scheduling_class, logical_job_name] + value_columns: [cpu_rate, canonical_memory_usage] +queries: + - id: cpu_by_user + promql: sum by (user) (cpu_rate) + table: task_usage + kind: keys + group_by: [user] + value: cpu_rate + weights: [count, value] + - id: cpu_by_user_priority + promql: sum by (user, priority) (cpu_rate) + table: task_usage + kind: keys + group_by: [user, priority] + value: cpu_rate + weights: [count, value] + - id: cpu_by_priority + promql: sum by (priority) (cpu_rate) + table: task_usage + kind: keys + group_by: [priority] + value: cpu_rate + weights: [count, value] + - id: cpu_by_job_id + promql: sum by (job_id) (cpu_rate) + table: task_usage + kind: keys + group_by: [job_id] + value: cpu_rate + weights: [count, value] + - id: cpu_by_logical_job_name + promql: sum by (logical_job_name) (cpu_rate) + table: task_usage + kind: keys + group_by: [logical_job_name] + value: cpu_rate + weights: [count, value] + - id: cpu_by_scheduling_class + promql: sum by (scheduling_class) (cpu_rate) + table: task_usage + kind: keys + group_by: [scheduling_class] + value: cpu_rate + weights: [count, value] + # Baseline: one key per machine, expected to be close to uniform. + - id: cpu_by_machine_id + promql: sum by (machine_id) (cpu_rate) + table: task_usage + kind: keys + group_by: [machine_id] + value: cpu_rate + weights: [count, value] + - id: cpu_p99 + promql: quantile(0.99, cpu_rate) + table: task_usage + kind: values + group_by: [] + value: cpu_rate + - id: memory_p99 + promql: quantile(0.99, canonical_memory_usage) + table: task_usage + kind: values + group_by: [] + value: canonical_memory_usage diff --git a/asap-tools/dataset-analysis/requirements.txt b/asap-tools/dataset-analysis/requirements.txt new file mode 100644 index 00000000..2faa653d --- /dev/null +++ b/asap-tools/dataset-analysis/requirements.txt @@ -0,0 +1,8 @@ +matplotlib==3.10.9 +numpy==2.2.6 +pandas==2.3.3 +# 2.x caps alpha at 3 by default and falls back to slow numerical fits. +powerlaw==1.5 +pyarrow==25.0.1 +PyYAML==6.0.3 +scipy==1.15.3 diff --git a/asap-tools/dataset-analysis/tests/test_fit_skew.py b/asap-tools/dataset-analysis/tests/test_fit_skew.py new file mode 100644 index 00000000..67704da9 --- /dev/null +++ b/asap-tools/dataset-analysis/tests/test_fit_skew.py @@ -0,0 +1,235 @@ +"""Tests for the skew fits, window bounds, config validation and readers.""" + +import copy +import io +import tarfile +import tempfile +import unittest +from pathlib import Path + +import numpy as np +import pandas as pd + +import fit_skew + +ZIPF_K = 1000 +ZIPF_SAMPLES = 2_000_000 +ZIPF_TOLERANCE = 0.05 +PARETO_SAMPLES = fit_skew.MAX_FIT_SAMPLES +PARETO_REL_TOLERANCE = 0.05 + + +def zipf_counts(theta: float, rng: np.random.Generator) -> np.ndarray: + ranks = np.arange(1, ZIPF_K + 1) + probs = ranks**-theta / np.sum(ranks**-theta) + return rng.multinomial(ZIPF_SAMPLES, probs) + + +class ZipfFitTest(unittest.TestCase): + def test_recovers_theta(self): + rng = np.random.default_rng(1) + for theta in (0.8, 1.2): + with self.subTest(theta=theta): + counts = zipf_counts(theta, rng) + # Rank order is recovered by sorting; key order must not matter. + rng.shuffle(counts) + self.assertAlmostEqual( + fit_skew.zipf_mle(counts), theta, delta=ZIPF_TOLERANCE + ) + + def test_uniform_is_zero(self): + self.assertAlmostEqual(fit_skew.zipf_mle(np.full(100, 50.0)), 0.0, places=3) + + def test_zero_weights_ignored(self): + counts = zipf_counts(1.0, np.random.default_rng(2)).astype(float) + padded = np.concatenate([counts, np.zeros(500)]) + self.assertAlmostEqual( + fit_skew.zipf_mle(padded), fit_skew.zipf_mle(counts), places=6 + ) + + def test_fewer_than_two_keys_is_nan(self): + self.assertTrue(np.isnan(fit_skew.zipf_mle([10.0]))) + self.assertTrue(np.isnan(fit_skew.zipf_mle([10.0, 0.0]))) + self.assertTrue(np.isnan(fit_skew.loglog_slope([]))) + + +class PowerLawFitTest(unittest.TestCase): + def test_recovers_pareto_alpha(self): + rng = np.random.default_rng(3) + for shape in (1.0, 2.0, 4.0): + alpha = shape + 1.0 # pdf exponent of a Pareto with this shape + with self.subTest(alpha=alpha): + x = rng.pareto(shape, PARETO_SAMPLES) + 1.0 + fit = fit_skew.fit_power_law(x, compare=True) + self.assertAlmostEqual( + fit["alpha"], alpha, delta=PARETO_REL_TOLERANCE * alpha + ) + self.assertTrue(fit["power_law_ok"]) + tail = np.sum(x >= fit["xmin"]) + self.assertGreaterEqual(tail, fit_skew.MIN_TAIL_SAMPLES) + + def test_power_law_ok_rule(self): + self.assertTrue(fit_skew.power_law_ok([(1.0, 0.01), (-1.0, 0.5)])) + self.assertFalse(fit_skew.power_law_ok([(1.0, 0.01), (-1.0, 0.05)])) + self.assertTrue(fit_skew.power_law_ok([])) + + def test_too_few_samples_is_nan(self): + fit = fit_skew.fit_power_law( + np.arange(1.0, fit_skew.MIN_TAIL_SAMPLES), compare=True + ) + self.assertTrue(np.isnan(fit["alpha"])) + self.assertNotIn("power_law_ok", fit) + + +class WindowBoundsTest(unittest.TestCase): + def test_min_max_count(self): + self.assertEqual(fit_skew.window_bounds([1.1, 0.7, 1.4]), (0.7, 1.4, 3)) + + def test_nan_windows_skipped(self): + self.assertEqual( + fit_skew.window_bounds([np.nan, 0.9, np.nan, 1.2]), (0.9, 1.2, 2) + ) + + def test_no_windows(self): + for estimates in ([], [np.nan]): + lower, upper, n = fit_skew.window_bounds(estimates) + self.assertTrue(np.isnan(lower) and np.isnan(upper)) + self.assertEqual(n, 0) + + def test_summarize_keys_skips_small_windows(self): + rng = np.random.default_rng(5) + frames = [] + for window, theta in ((0, 0.8), (1, 1.2)): + counts = zipf_counts(theta, rng) + frames.append( + pd.DataFrame( + { + fit_skew.WINDOW_COL: window, + "k": np.arange(ZIPF_K).astype(str).astype(object), + fit_skew.COUNT_COL: counts, + } + ) + ) + # Window 2 has too few keys to be fitted. + frames.append( + pd.DataFrame( + {fit_skew.WINDOW_COL: 2, "k": ["0", "1"], fit_skew.COUNT_COL: [1e6, 1]} + ) + ) + agg = fit_skew.merge_key_parts(frames, ["k"]) + q = {"id": "q", "promql": "count by (k) (x)", "group_by": ["k"]} + q["weights"] = ["count"] + (row,) = fit_skew.summarize_keys("test", q, agg, 1, 10, None) + self.assertEqual(row["n_windows"], 2) + self.assertAlmostEqual(row["lower"], 0.8, delta=ZIPF_TOLERANCE) + self.assertAlmostEqual(row["upper"], 1.2, delta=ZIPF_TOLERANCE) + self.assertTrue(row["lower"] <= row["mle"] <= row["upper"]) + self.assertEqual(row["K"], ZIPF_K) + + +VALID_CONFIG = { + "dataset": "d", + "tables": { + "t": {"label_columns": ["a", "b"], "value_columns": ["v"]}, + }, + "queries": [ + { + "id": "keys", + "table": "t", + "kind": "keys", + "group_by": ["a"], + "value": "v", + "weights": ["count", "value"], + }, + {"id": "vals", "table": "t", "kind": "values", "group_by": [], "value": "v"}, + ], +} + + +class ValidateConfigTest(unittest.TestCase): + def test_valid(self): + fit_skew.validate_config(VALID_CONFIG) + + def test_invalid(self): + cases = { + "unknown table": ("table", "missing"), + "unknown label": ("group_by", ["c"]), + "unknown value": ("value", "w"), + "bad kind": ("kind", "other"), + "bad weight": ("weights", ["sum"]), + "no weights": ("weights", []), + "no group_by": ("group_by", []), + } + for name, (field, value) in cases.items(): + with self.subTest(name): + cfg = copy.deepcopy(VALID_CONFIG) + cfg["queries"][0][field] = value + with self.assertRaises(ValueError): + fit_skew.validate_config(cfg) + + def test_value_weight_needs_value(self): + cfg = copy.deepcopy(VALID_CONFIG) + del cfg["queries"][0]["value"] + with self.assertRaises(ValueError): + fit_skew.validate_config(cfg) + + def test_values_query_needs_value(self): + cfg = copy.deepcopy(VALID_CONFIG) + del cfg["queries"][1]["value"] + with self.assertRaises(ValueError): + fit_skew.validate_config(cfg) + + def test_missing_files_fail(self): + with tempfile.TemporaryDirectory() as root: + with self.assertRaises(FileNotFoundError): + fit_skew.expand_files(root, ["nothing-*.csv"]) + + +class ReaderTest(unittest.TestCase): + def test_alibaba_tar_streaming(self): + # CallGraph shards contain rows with extra fields and rt == "None". + csv = ( + "timestamp,um,dm,rt\n" + "1000,MS_1,MS_2,3.0\n" + "2000,MS_1,MS_3,None\n" + "3000,MS_1,MS_2,4.0,extra\n" + "61000,MS_2,MS_3,5.0\n" + ).encode() + with tempfile.TemporaryDirectory() as root: + path = Path(root) / "t.tar.gz" + with tarfile.open(path, "w:gz") as archive: + info = tarfile.TarInfo("t.csv") + info.size = len(csv) + archive.addfile(info, io.BytesIO(csv)) + table = {"format": "alibaba_tar"} + bad: list = [] + frames = list( + fit_skew.table_frames( + root, table, str(path), ["timestamp", "um", "rt"], {"rt"}, bad + ) + ) + df = frames[0] + self.assertEqual(len(bad), 1) + self.assertEqual(list(df["um"].astype(str)), ["MS_1", "MS_1", "MS_2"]) + self.assertTrue(np.isnan(df["rt"][1])) + + def test_google_column_names(self): + schema = ( + "file pattern,field number,content,format,mandatory\n" + "task_usage/part-?????-of-?????.csv.gz,2,CPU rate,FLOAT,NO\n" + "task_usage/part-?????-of-?????.csv.gz,1,start time,INTEGER,YES\n" + "job_events/part-?????-of-?????.csv.gz,1,time,INTEGER,YES\n" + ) + with tempfile.TemporaryDirectory() as root: + path = Path(root) / "schema.csv" + path.write_text(schema) + self.assertEqual( + fit_skew.google_column_names(str(path), "task_usage"), + ["start_time", "cpu_rate"], + ) + with self.assertRaises(ValueError): + fit_skew.google_column_names(str(path), "machine_events") + + +if __name__ == "__main__": + unittest.main() From 1eb27415804b95db30d24c6b55c989e722472fc2 Mon Sep 17 00:00:00 2001 From: zz_y Date: Tue, 29 Sep 2026 18:21:01 +0000 Subject: [PATCH 2/8] feat(asap-tools): add skew summary for the fetched traces Output of fit_skew.py over the data fetched by fetch_data.sh. Co-Authored-By: Claude Opus 5.5 --- .../dataset-analysis/results/skew_summary.csv | 60 +++++++++++++++++++ 1 file changed, 60 insertions(+) create mode 100644 asap-tools/dataset-analysis/results/skew_summary.csv diff --git a/asap-tools/dataset-analysis/results/skew_summary.csv b/asap-tools/dataset-analysis/results/skew_summary.csv new file mode 100644 index 00000000..0d5cb985 --- /dev/null +++ b/asap-tools/dataset-analysis/results/skew_summary.csv @@ -0,0 +1,60 @@ +dataset,query_id,promql,kind,weight,K,rows,n_windows,lower,mle,upper,top1_share,theta_ls,dropped_frac,xmin,ks_d,tail_frac,R_lognormal,p_lognormal,R_exponential,p_exponential,power_law_ok +alibaba_v2022,mcr_by_msname,sum by (msname) (providerrpc_mcr),keys,count,26077,90315535,30,1.34145,1.53568,1.90045,0.551844,1.35882,,,,,,,,, +alibaba_v2022,mcr_by_msname,sum by (msname) (providerrpc_mcr),keys,value,17911,90315535,30,1.02886,1.11054,1.30697,0.18365,3.6235,,,,,,,,, +alibaba_v2022,mcr_by_nodeid,sum by (nodeid) (providerrpc_mcr),keys,count,30776,90315535,30,1.06962,1.1256,1.22637,0.0299395,0.671771,,,,,,,,, +alibaba_v2022,mcr_by_nodeid,sum by (nodeid) (providerrpc_mcr),keys,value,28319,90315535,30,0.629764,0.760365,0.985563,0.0103042,0.905303,,,,,,,,, +alibaba_v2022,rt_p99_by_msname,"quantile by (msname) (0.99, providerrpc_rt)",keys,count,26077,90315535,30,1.34145,1.53568,1.90045,0.551844,1.35882,,,,,,,,, +alibaba_v2022,rt_p99_by_msname,"quantile by (msname) (0.99, providerrpc_rt)",keys,value,17879,90315535,30,1.55788,2.06565,2.86274,0.883125,2.23262,,,,,,,,, +alibaba_v2022,rt_p99_by_msname,"quantile by (msname) (0.99, providerrpc_rt)",values,,,90315535,30,4.99239,8.88803,25.2897,,,0.0733479,102.743,0.0829702,0.3652,0.0583085,0.915929,336.406,0.00272157,True +alibaba_v2022,calls_by_rpctype,count by (rpctype) (rt),keys,count,6,127635817,30,1.25893,1.3204,1.38466,0.426987,2.23811,,,,,,,,, +alibaba_v2022,calls_by_service,count by (service) (rt),keys,count,399933,127635817,30,0.999766,1.0731,1.02082,0.0388438,1.59871,,,,,,,,, +alibaba_v2022,calls_by_um,count by (um) (rt),keys,count,15063,127635817,30,1.11269,1.14611,1.13341,0.128004,2.68552,,,,,,,,, +alibaba_v2022,calls_by_dm,count by (dm) (rt),keys,count,25155,127635817,30,1.09664,1.12579,1.11105,0.0709133,2.60259,,,,,,,,, +alibaba_v2022,calls_by_interface,count by (interface) (rt),keys,count,1.19888e+06,127635817,30,0.989149,1.06008,1.00892,0.0259165,1.28963,,,,,,,,, +alibaba_v2022,calls_by_um_dm,"count by (um, dm) (rt)",keys,count,99257,127635817,30,0.976609,1.02162,1.00079,0.0262826,2.34181,,,,,,,,, +alibaba_v2022,calls_by_service_um_dm,"count by (service, um, dm) (rt)",keys,count,1.27135e+06,127635817,30,0.91038,0.981876,0.929804,0.010094,1.68258,,,,,,,,, +alibaba_v2022,rt_p99_by_service,"quantile by (service) (0.99, rt)",keys,count,399933,127635817,30,0.999766,1.0731,1.02082,0.0388438,1.59871,,,,,,,,, +alibaba_v2022,rt_p99_by_service,"quantile by (service) (0.99, rt)",keys,value,313796,127635817,30,1.12843,1.17197,1.18869,0.241919,2.3833,,,,,,,,, +alibaba_v2022,rt_p99_by_service,"quantile by (service) (0.99, rt)",values,,,125647293,30,1.90633,2.4739,2.78544,,,0.386496,71,0.0377468,0.0356,-0.305327,0.153917,92.7487,0.00348067,True +alibaba_v2022,ms_cpu_by_msname,sum by (msname) (cpu_utilization),keys,count,28159,13987704,30,0.826067,0.826138,0.82617,0.0164781,1.26917,,,,,,,,, +alibaba_v2022,ms_cpu_by_msname,sum by (msname) (cpu_utilization),keys,value,28158,13987704,30,0.891051,0.893458,0.897012,0.0092067,1.6656,,,,,,,,, +alibaba_v2022,ms_cpu_p99,"quantile(0.99, cpu_utilization)",values,,,13987704,30,3.02388,4.46166,6.93479,,,2.97404e-05,0.32589,0.0603559,0.0854,-13.7365,0.000639644,-14.3703,9.63628e-06,False +alibaba_v2022,node_cpu_by_nodeid,sum by (nodeid) (cpu_utilization),keys,count,42554,1228782,29,3.68585e-06,0.00427455,3.69803e-06,2.36006e-05,0.00882373,,,,,,,,, +alibaba_v2022,node_cpu_by_nodeid,sum by (nodeid) (cpu_utilization),keys,value,42552,1228782,29,0.316475,0.302619,0.32804,0.000107701,0.374094,,,,,,,,, +alibaba_v2022,node_cpu_p99,"quantile(0.99, cpu_utilization)",values,,,1228782,29,4.69344,5.19128,6.59384,,,4.72012e-05,0.257581,0.0283684,0.2176,-3.97421,0.128424,7.36288,0.350139,True +boom,target_tail[ds-2187-H],"quantile(0.99, target)",values,,100,523100,2000,1.72632,3.21772,5.37616,,,0.000191168,1.85333,0.0647201,0.0728,-2.07292,0.132572,8.52511,0.0461671,True +boom,target_tail[ds-2394-D],"quantile(0.99, target)",values,,73,10001,0,,2.05901,,,,0.185881,0.4824,0.18029,0.779412,-14.299,0.000918518,-13.9953,0.000104956,False +boom,target_tail[ds-1135-5T],"quantile(0.99, target)",values,,26,425984,243,2.12844,4.04798,6.31335,,,0.549368,3.02737,0.0743629,0.0542,-1.83713,0.128304,1.6523,0.0594927,True +boom,target_tail[ds-1833-D],"quantile(0.99, target)",values,,17,3689,0,,1.72967,,,,0.239631,0.665448,0.594321,1,-283.626,8.1371e-12,-98.1767,0,False +boom,target_tail[ds-2806-D],"quantile(0.99, target)",values,,100,13700,0,,1.85064,,,,0.700365,0.177947,0.18851,0.88806,-18.3939,0.000684349,-14.5781,0.0146828,False +boom,target_tail[ds-2573-D],"quantile(0.99, target)",values,,45,9765,0,,4.28086,,,,0.00798771,1.94081,0.153677,0.625,-2.42592,0.133614,-1.4821,0.0125487,True +boom,target_tail[ds-2222-30T],"quantile(0.99, target)",values,,100,1045600,678,1.47344,5.49131,19.7826,,,0.570518,1.16523,0.227535,0.74046,-4.35745,6.92289e-12,11.5169,1.24782e-14,False +boom,target_tail[ds-1914-30T],"quantile(0.99, target)",values,,64,669504,0,,,,,,0.999177,,,,,,,, +boom,target_tail[ds-2577-H],"quantile(0.99, target)",values,,11,57541,220,2.21739,4.0196,6.90404,,,0.000191168,2.73386,0.0396294,0.1084,-1.70375,0.197066,6.70502,0.0128851,True +boom,target_tail[ds-2212-D],"quantile(0.99, target)",values,,42,9114,0,,1.13374,,,,0.205508,2.69982e-06,0.230087,1,-10.4749,0.0179962,366.112,1.47908e-08,False +boom,target_tail[ds-2782-H],"quantile(0.99, target)",values,,20,16500,0,,,,,,0.992364,,,,,,,, +boom,target_tail[ds-1400-10S],"quantile(0.99, target)",values,,75,1228800,1500,4.036,7.0724,9.03294,,,0.000139974,3.82339,0.039047,0.129,-1.27558,0.263896,2.47535,0.102376,True +boom,target_tail[ds-2650-D],"quantile(0.99, target)",values,,56,12152,0,,2.64825,,,,0.00477288,0.723296,0.124754,0.490741,-5.05782,0.124238,-2.87425,0.0484973,True +boom,target_tail[ds-1316-10S],"quantile(0.99, target)",values,,40,655360,800,1.34693,1.98494,3.77865,,,0.122093,0.10877,0.0391658,0.5031,-2.97671,0.0570022,1181.72,2.81468e-45,False +boom,target_tail[ds-1558-5T],"quantile(0.99, target)",values,,97,1589248,1764,2.06103,3.87851,12.9998,,,0.197184,1.6553,0.124462,0.2916,-0.702945,0.150216,41.5952,3.53002e-05,True +boom,target_tail[ds-1972-D],"quantile(0.99, target)",values,,39,5343,0,,2.28479,,,,0.0557739,0.376831,0.276055,0.806086,-36.3262,0.000493092,-4.89259,4.82754e-23,False +boom,target_tail[ds-1840-D],"quantile(0.99, target)",values,,100,21700,0,,348.72,,,,0.00465438,8.33471,0.273522,0.689815,-34.8883,1.74754e-05,-1.04022,1.66232e-22,True +boom,target_tail[ds-671-10S],"quantile(0.99, target)",values,,100,1638400,2000,79.9422,11259.5,12666.3,,,6.10352e-05,10.9861,0.144019,0.0386,-43.3943,1.49559e-10,-5.50753,1.98273e-38,True +boom,target_tail[ds-1524-5T],"quantile(0.99, target)",values,,93,1267683,122,1.61633,3.93845,4.90315,,,0.944851,7.32407,0.294664,0.963303,-23.7515,0.000142278,-10.6513,6.75745e-26,False +boom,target_tail[ds-899-T],"quantile(0.99, target)",values,,12,196608,144,2.35649,2.71558,3.5848,,,0.420344,0.373495,0.068062,0.6426,-0.547811,0.146172,1391.71,6.17661e-104,True +google_2011,cpu_by_user,sum by (user) (cpu_rate),keys,count,518,2520773,17,1.22012,1.23997,1.27526,0.157436,2.33409,,,,,,,,, +google_2011,cpu_by_user,sum by (user) (cpu_rate),keys,value,495,2520773,17,1.24604,1.30345,1.42414,0.1682,3.7868,,,,,,,,, +google_2011,cpu_by_user_priority,"sum by (user, priority) (cpu_rate)",keys,count,869,2520773,17,1.22497,1.24584,1.27931,0.151999,2.11869,,,,,,,,, +google_2011,cpu_by_user_priority,"sum by (user, priority) (cpu_rate)",keys,value,840,2520773,17,1.26988,1.32416,1.43661,0.168118,3.41093,,,,,,,,, +google_2011,cpu_by_priority,sum by (priority) (cpu_rate),keys,count,7,2520773,17,1.0334,1.10046,1.17431,0.32255,1.89497,,,,,,,,, +google_2011,cpu_by_priority,sum by (priority) (cpu_rate),keys,value,7,2520773,17,1.43865,1.60501,1.75174,0.536005,2.03241,,,,,,,,, +google_2011,cpu_by_job_id,sum by (job_id) (cpu_rate),keys,count,4852,2520773,17,1.11406,1.1028,1.1396,0.138099,1.68596,,,,,,,,, +google_2011,cpu_by_job_id,sum by (job_id) (cpu_rate),keys,value,4741,2520773,17,1.14258,1.14339,1.22505,0.0488375,2.91631,,,,,,,,, +google_2011,cpu_by_logical_job_name,sum by (logical_job_name) (cpu_rate),keys,count,4076,2520773,17,1.11531,1.10016,1.13977,0.138099,1.67481,,,,,,,,, +google_2011,cpu_by_logical_job_name,sum by (logical_job_name) (cpu_rate),keys,value,3994,2520773,17,1.13852,1.13736,1.22246,0.0488375,2.95553,,,,,,,,, +google_2011,cpu_by_scheduling_class,sum by (scheduling_class) (cpu_rate),keys,count,4,2520773,17,0.409689,0.582621,0.758605,0.381155,0.574297,,,,,,,,, +google_2011,cpu_by_scheduling_class,sum by (scheduling_class) (cpu_rate),keys,value,4,2520773,17,0.373199,0.429641,0.984739,0.306212,0.565076,,,,,,,,, +google_2011,cpu_by_machine_id,sum by (machine_id) (cpu_rate),keys,count,12478,2520773,17,0.22599,0.207643,0.246048,0.000191211,0.252654,,,,,,,,, +google_2011,cpu_by_machine_id,sum by (machine_id) (cpu_rate),keys,value,12477,2520773,17,0.310753,0.286387,0.354508,0.000345691,0.399985,,,,,,,,, +google_2011,cpu_p99,"quantile(0.99, cpu_rate)",values,,,2520773,17,2.51611,2.78462,6.0283,,,0.095295,0.04016,0.0415811,0.1648,-3.3012,0.0492978,58.9964,1.35817e-07,False +google_2011,memory_p99,"quantile(0.99, canonical_memory_usage)",values,,,2520773,17,1.83045,3.24354,4.59216,,,0.113868,0.04865,0.128324,0.1642,-4.71955,0.0171806,30.6367,0.00238745,False From 8b74ec36297dd8d2b8c27523450c49b9f571a8aa Mon Sep 17 00:00:00 2001 From: zz_y Date: Tue, 29 Sep 2026 18:46:38 +0000 Subject: [PATCH 3/8] feat(asap-tools): sweep skew window lengths and refine value-alpha fits - lower/upper now span the per-window fits and the pooled fit, so lower <= mle <= upper. - Bounds are computed at several window lengths (window_lengths_s per dataset) by merging finest-window aggregates; results gain window_len_s. - Value fits use up to 100k samples and pick xmin over a 50-quantile grid (p50..p99.9, at least 100 tail values); losing fits report best_alt. - BOOM series report ok_frac and alpha over passing variates only. Co-Authored-By: Claude Opus 5.5 --- asap-tools/dataset-analysis/README.md | 76 +++-- asap-tools/dataset-analysis/fit_skew.py | 302 ++++++++++++------ .../queries/alibaba_v2022.yaml | 3 +- .../dataset-analysis/queries/google_2011.yaml | 3 +- .../dataset-analysis/results/skew_summary.csv | 198 ++++++++---- .../dataset-analysis/tests/test_fit_skew.py | 214 +++++++++++-- 6 files changed, 585 insertions(+), 211 deletions(-) diff --git a/asap-tools/dataset-analysis/README.md b/asap-tools/dataset-analysis/README.md index 73b91de5..8526c593 100644 --- a/asap-tools/dataset-analysis/README.md +++ b/asap-tools/dataset-analysis/README.md @@ -14,7 +14,7 @@ Two tasks: group-by key (weighted by row count and by value sum), and - a continuous power-law tail exponent α to every value query's column, - once on all data and once per time window. + once on all data and once per time window, at several window lengths. ## Running @@ -43,10 +43,10 @@ Tests: `python -m unittest discover -s tests -p 'test_*.py'`. ## Datasets -| Dataset | Files | Tables | Window | +| Dataset | Files | Tables | Window lengths | |---|---|---|---| -| Google ClusterData 2011-2 | `task_usage` and `task_events` part 0 of 500, all 500 `job_events` parts, `schema.csv` | `task_usage` joined with task and job attributes | 5 min | -| Alibaba microservices v2022 | `NodeMetricsUpdate_0`, `MSMetricsUpdate_0`, `CallGraph_0..9`, `MCRRTUpdate_0..9` (first 30 minutes) | `MSRTMCR`, `CallGraph`, `MSMetrics`, `NodeMetrics` | 1 min | +| Google ClusterData 2011-2 | `task_usage` and `task_events` part 0 of 500, all 500 `job_events` parts, `schema.csv` | `task_usage` joined with task and job attributes | 5, 15, 60 min | +| Alibaba microservices v2022 | `NodeMetricsUpdate_0`, `MSMetricsUpdate_0`, `CallGraph_0..9`, `MCRRTUpdate_0..9` (first 30 minutes) | `MSRTMCR`, `CallGraph`, `MSMetrics`, `NodeMetrics` | 1, 5, 30 min | | Datadog BOOM | `dataset_taxonomy.json` and 20 multivariate series | per-series `target` | 20 equal chunks per series | Citations: @@ -83,25 +83,37 @@ Citations: (`scipy.optimize.minimize_scalar`, bounded to [0, 5]). The weight is either the row count per key (`weight=count`) or the sum of the value per key with negatives clipped to 0 (`weight=value`). -- **Value α**: `powerlaw.Fit` (continuous, `xmin` chosen by minimizing the - KS distance), with α the exponent of the pdf `p(x) ∝ x^-α` for - `x ≥ xmin`. Non-positive values are dropped first. Each fit uses a uniform - subsample of at most 5000 values because the `xmin` search is quadratic, - and `xmin` is only searched where at least 100 values remain in the tail, - so α describes roughly the top 2% or more of the distribution. -- **lower / upper**: min / max of the estimate over the windows that pass the - thresholds. **mle**: the estimate on all data pooled. mle is not a bound - and can sit outside [lower, upper]: pooling many windows adds rare keys to - the tail and accumulates mass on persistent heavy keys, which steepens the - pooled rank-frequency (seen in most CallGraph queries). -- **power_law_ok**: the power law is not significantly worse than both a - lognormal and an exponential (`distribution_compare`; worse means `R < 0` - with `p < 0.1`). +- **Value α**: continuous power law fitted with `powerlaw.Fit` (pinned to + 1.5), with α the exponent of the pdf `p(x) ∝ x^-α` for `x ≥ xmin`. + Non-positive values are dropped first, and each fit uses a uniform + subsample of at most 100,000 values. `xmin` minimizes the KS distance over + a grid of 50 quantiles from p50 to p99.9, restricted to candidates that + keep at least 100 values in the tail. α therefore describes a tail between + the top half and roughly the top 0.1% of the values; `tail_frac` says + which. A window needs at least 200 positive values to be fittable. +- **mle**: the estimate on all data pooled. +- **lower / upper**: min / max over the set {every per-window estimate that + passes the thresholds, mle}, so `lower <= mle <= upper` always. The pooled + and per-window fits have no fixed order: pooling adds rare keys to the tail + and accumulates mass on persistent heavy keys, which usually steepens the + pooled rank-frequency (most CallGraph queries), but it can also flatten it. +- **Window lengths**: each dataset YAML lists `window_lengths_s`, finest + first; every length must be a multiple of the finest. Data are read once + and aggregated per finest window; coarser windows sum the finest per-key + aggregates (key queries) or concatenate the finest windows' values before + subsampling (value queries). mle does not depend on the window length. + BOOM has no timestamps in this analysis and keeps its 20 equal chunks per + series (`window_len_s` is empty). +- **power_law_ok / best_alt**: the power law is compared with a lognormal + and an exponential (`distribution_compare`); it is significantly worse + when `R < 0` with `p < 0.1`. If it is worse than either, `power_law_ok` is + false and `best_alt` names the alternative with the most negative `R`; + α is still reported. `best_alt` is empty when `power_law_ok` is true. ## Output: `results/skew_summary.csv` -One row per (query, kind, weight). The sketch-bench saturation study reads -`dataset, query_id, kind, weight, lower, mle, upper` to pick the θ and α +One row per (query, kind, weight, window length). The sketch-bench saturation study reads +`dataset, query_id, kind, weight, window_len_s, lower, mle, upper` to pick the θ and α range it sweeps. | Column | Meaning | @@ -109,6 +121,7 @@ range it sweeps. | `dataset`, `query_id`, `promql` | query identity (a query with both kinds gets a `keys` and a `values` row) | | `kind` | `keys` (θ) or `values` (α) | | `weight` | `count` or `value` for key rows, empty for value rows | +| `window_len_s` | window length the bounds were computed at (empty for BOOM) | | `K` | distinct keys with positive weight (BOOM: variates) | | `rows` | rows with non-null keys (values: finite values) | | `n_windows` | windows used for the bounds (BOOM: variate-chunk fits) | @@ -117,19 +130,30 @@ range it sweeps. | `dropped_frac` | value rows: fraction of finite values that were ≤ 0 | | `xmin`, `ks_d`, `tail_frac` | value rows: fitted `xmin`, KS distance of the tail, and fraction of the fitted sample at or above `xmin` | | `R_lognormal`, `p_lognormal`, `R_exponential`, `p_exponential` | log-likelihood ratio (power law vs alternative) and its p-value | -| `power_law_ok` | see Definitions | +| `power_law_ok`, `best_alt` | see Definitions | +| `ok_frac` | BOOM rows: share of variates with `power_law_ok` | -Plots in `out/`: `____rank_.png` (log-log -rank-frequency with the lower/mle/upper θ lines) and +Plots in `out/`: `____rank___s.png` (log-log +rank-frequency with the lower/mle/upper θ lines, one per window length) and `____ccdf.png` (empirical CCDF with the fitted α). ## Caveats +- **θ depends on time scale.** A sketch sees the keys of one window of + length x, while a query aggregates over its lookback S (often many + windows). Short windows see fewer keys with noisier counts; long ones pool + more keys. Pick the row whose `window_len_s` matches the sketch window, and + compare it with mle (all data) for long lookbacks. + - **BOOM** strips tags and z-scores each variate, so there is no key θ and the raw value scale is lost. α is fitted per variate on `x - min(x)` - (zeros dropped); the series row reports the median over variates of each - variate's lower, mle and upper, and `power_law_ok` is true when at least - half of the variates pass. + (zeros dropped). `ok_frac` is the share of compared variates with + `power_law_ok`. If `ok_frac >= 0.5`, the series row reports the medians + over the passing variates of each variate's lower, mle and upper, and the + diagnostics (`xmin`, `R`, `p`, ...) are medians over the same variates. If + `ok_frac < 0.5`, lower/mle/upper are empty, `power_law_ok` is false, + `best_alt` is the alternative most failing variates lose to, and the + diagnostics are medians over the failing variates. - **Google join rule**: `task_usage` rows get `user`, `priority` and `scheduling_class` from the last non-null `task_events` value for the same `(job_id, task_index)`, and `logical_job_name` from the last non-null diff --git a/asap-tools/dataset-analysis/fit_skew.py b/asap-tools/dataset-analysis/fit_skew.py index ae81a97c..47b3767a 100644 --- a/asap-tools/dataset-analysis/fit_skew.py +++ b/asap-tools/dataset-analysis/fit_skew.py @@ -27,6 +27,7 @@ import pyarrow.csv as pacsv import yaml from matplotlib.figure import Figure +from numpy.typing import ArrayLike from scipy.optimize import minimize_scalar SCRIPT_DIR = Path(__file__).resolve().parent @@ -35,11 +36,15 @@ DEFAULT_OUT = SCRIPT_DIR / "out" ZIPF_THETA_BOUNDS = (0.0, 5.0) -# powerlaw's xmin search is quadratic in sample size, so fits use a uniform subsample. -MAX_FIT_SAMPLES = 5000 -# xmin is searched only where at least this many values remain in the tail; -# tinier tails give meaningless alphas. +# Each power-law fit uses a uniform subsample of at most this many values. +MAX_FIT_SAMPLES = 100_000 +# xmin is chosen by KS distance over this many quantiles of the sample, and only +# where at least MIN_TAIL_SAMPLES values remain in the tail. +XMIN_GRID_SIZE = 50 +XMIN_GRID_QUANTILES = (0.5, 0.999) MIN_TAIL_SAMPLES = 100 +# BOOM series report alpha only if at least this share of variates pass. +BOOM_MIN_OK_FRAC = 0.5 SAMPLE_SEED = 0 DEFAULT_MIN_WINDOW_ROWS = 200 DEFAULT_MIN_WINDOW_KEYS = 2 @@ -63,6 +68,7 @@ "promql", "kind", "weight", + "window_len_s", "K", "rows", "n_windows", @@ -80,6 +86,8 @@ "R_exponential", "p_exponential", "power_law_ok", + "best_alt", + "ok_frac", ] # Plot colors: observed data in neutral ink, the three estimates as one blue ramp. @@ -121,7 +129,18 @@ def validate_query(q: Dict[str, Any], table: Dict[str, Any], where: str) -> None raise ValueError(f"{where}: weight 'value' needs a value column") +def validate_window_lengths(lengths: Sequence[int], where: str) -> None: + """Coarser windows are built by merging finest windows, so every length + must be a multiple of the first (finest) one.""" + if not lengths or list(lengths) != sorted(set(lengths)): + raise ValueError(f"{where}: window_lengths_s must be ascending and unique") + if any(length % lengths[0] for length in lengths): + raise ValueError(f"{where}: window_lengths_s must be multiples of the first") + + def validate_config(cfg: Dict[str, Any]) -> None: + if "window_lengths_s" in cfg: + validate_window_lengths(cfg["window_lengths_s"], cfg["dataset"]) for q in cfg["queries"]: where = f"{cfg['dataset']}/{q['id']}" table = cfg["tables"].get(q["table"]) @@ -275,7 +294,7 @@ def add_values(acc: Dict[str, Any], windows: np.ndarray, values: np.ndarray) -> def aggregate_file(task: Tuple[Any, ...]) -> Dict[str, Any]: """Per-window key aggregates and positive values for one file.""" - data_root, table, path, queries, window_secs, max_time_secs, max_rows = task + data_root, table, path, queries, window_len_s, max_time_secs, max_rows = task time_col = table["time_column"] value_cols = {q["value"] for q in queries if q.get("value")} join_cols = [c for j in table.get("joins", []) for c in j["columns"]] @@ -305,7 +324,7 @@ def aggregate_file(task: Tuple[Any, ...]) -> Dict[str, Any]: if max_time_secs is not None: keep &= secs < max_time_secs frame = frame[keep].copy() - frame[WINDOW_COL] = np.floor(secs[keep] / window_secs).astype(np.int64) + frame[WINDOW_COL] = np.floor(secs[keep] / window_len_s).astype(np.int64) for join, lookup in joins: frame = frame.astype({c: object for c in join["keys"]}) frame = frame.join(lookup, on=join["keys"]) @@ -336,7 +355,7 @@ def aggregate_file(task: Tuple[Any, ...]) -> Dict[str, Any]: # ---------------------------------------------------------------- fitting -def zipf_mle(weights: Sequence[float]) -> float: +def zipf_mle(weights: ArrayLike) -> float: """Discrete Zipf exponent over ranks 1..K maximizing the likelihood of the sorted weights (counts, or value sums used as fractional counts).""" w = np.sort(np.asarray(weights, dtype=float))[::-1] @@ -355,7 +374,7 @@ def neg_log_likelihood(s: float) -> float: return float(res.x) -def loglog_slope(weights: Sequence[float]) -> float: +def loglog_slope(weights: ArrayLike) -> float: """Negated least-squares slope of log(weight) vs log(rank).""" w = np.sort(np.asarray(weights, dtype=float))[::-1] w = w[w > 0] @@ -364,12 +383,33 @@ def loglog_slope(weights: Sequence[float]) -> float: return float(-np.polyfit(np.log(np.arange(1, len(w) + 1)), np.log(w), 1)[0]) -def window_bounds(estimates: Sequence[float]) -> Tuple[float, float, int]: - """(min, max, count) over the finite per-window estimates.""" - finite = [e for e in estimates if np.isfinite(e)] - if not finite: +def window_bounds( + window_estimates: Sequence[float], pooled: float +) -> Tuple[float, float, int]: + """(lower, upper, n_windows): min and max over the finite per-window + estimates together with the pooled estimate, so lower <= pooled <= upper.""" + windows = [e for e in window_estimates if np.isfinite(e)] + candidates = windows + ([pooled] if np.isfinite(pooled) else []) + if not candidates: return float("nan"), float("nan"), 0 - return min(finite), max(finite), len(finite) + return min(candidates), max(candidates), len(windows) + + +def coarsen_keys(agg: pd.DataFrame, factor: int, group_by: List[str]) -> pd.DataFrame: + """Merge every `factor` consecutive finest windows of a key aggregate.""" + frame = agg.reset_index() + frame[WINDOW_COL] //= factor + return merge_key_parts([frame], group_by) + + +def coarsen_values( + windows: Dict[int, np.ndarray], factor: int +) -> Dict[int, np.ndarray]: + """Concatenate the values of every `factor` consecutive finest windows.""" + parts: Dict[int, List[np.ndarray]] = {} + for w, x in windows.items(): + parts.setdefault(w // factor, []).append(x) + return {w: np.concatenate(xs) for w, xs in parts.items()} def subsample(x: np.ndarray) -> np.ndarray: @@ -379,24 +419,45 @@ def subsample(x: np.ndarray) -> np.ndarray: return x[rng.choice(len(x), MAX_FIT_SAMPLES, replace=False)] -def power_law_ok(comparisons: Sequence[Tuple[float, float]]) -> bool: - """False if any (R, p) comparison says the power law is significantly worse.""" - return not any(r < 0 and p < COMPARE_P_THRESHOLD for r, p in comparisons) +def best_alternative(comparisons: Dict[str, Tuple[float, float]]) -> str: + """The alternative that fits significantly better than the power law + (R < 0 with small p), preferring the most negative R; '' if none.""" + losing = { + alt: r + for alt, (r, p) in comparisons.items() + if r < 0 and p < COMPARE_P_THRESHOLD + } + return min(losing, key=lambda alt: losing[alt]) if losing else "" + + +def xmin_candidates(x_sorted: np.ndarray) -> np.ndarray: + """Quantile grid of xmin values that leave at least MIN_TAIL_SAMPLES in the tail.""" + levels = np.linspace(*XMIN_GRID_QUANTILES, XMIN_GRID_SIZE) + grid = np.unique(np.quantile(x_sorted, levels)) + return grid[grid <= x_sorted[-MIN_TAIL_SAMPLES]] def fit_power_law(x: np.ndarray, compare: bool) -> Dict[str, Any]: - """Continuous power-law fit (xmin by KS) of positive values; with compare, - also the likelihood ratio against each alternative distribution.""" + """Continuous power-law fit of positive values with xmin minimizing the KS + distance over a quantile grid; with compare, also the likelihood ratio + against each alternative distribution.""" result: Dict[str, Any] = {"alpha": np.nan, "xmin": np.nan, "ks_d": np.nan} if len(x) < MIN_TAIL_SAMPLES: return result - xmin_range = (float(np.min(x)), float(np.sort(x)[-MIN_TAIL_SAMPLES])) + x = np.sort(x) + candidates = xmin_candidates(x) + if not len(candidates): + return result # powerlaw prints xmin search progress unconditionally. with warnings.catch_warnings(), np.errstate(all="ignore"), redirect_stdout( io.StringIO() ): warnings.simplefilter("ignore") - fit = powerlaw.Fit(x, xmin=xmin_range, verbose=False) + fits = [powerlaw.Fit(x, xmin=xmin, verbose=False) for xmin in candidates] + distances = np.array([f.power_law.D for f in fits], dtype=float) + if np.all(np.isnan(distances)): + return result + fit = fits[int(np.nanargmin(distances))] result.update( alpha=fit.power_law.alpha, xmin=fit.xmin, @@ -405,12 +466,13 @@ def fit_power_law(x: np.ndarray, compare: bool) -> Dict[str, Any]: ) if not compare or not np.isfinite(result["alpha"]): return result - comparisons = [] + comparisons = {} for alt in POWER_LAW_ALTERNATIVES: ratio, p = fit.distribution_compare("power_law", alt) result[f"R_{alt}"], result[f"p_{alt}"] = ratio, p - comparisons.append((ratio, p)) - result["power_law_ok"] = power_law_ok(comparisons) + comparisons[alt] = (ratio, p) + result["best_alt"] = best_alternative(comparisons) + result["power_law_ok"] = not result["best_alt"] return result @@ -474,49 +536,59 @@ def summarize_keys( dataset: str, q: Dict[str, Any], agg: pd.DataFrame, + window_lengths: Sequence[int], min_rows: int, min_keys: int, plot_dir: Optional[Path], ) -> List[Dict[str, Any]]: + """One row per weight and window length; agg holds finest-window counts.""" rows = int(agg[COUNT_COL].sum()) if rows == 0: raise ValueError(f"{dataset}/{q['id']}: no rows with non-null group keys") + columns = {w: COUNT_COL if w == "count" else VALUE_SUM_COL for w in q["weights"]} + per_key = {} + for weight, col in columns.items(): + totals = agg.groupby(level=q["group_by"])[col].sum().to_numpy() + per_key[weight] = np.sort(totals[totals > 0])[::-1] + pooled = {weight: zipf_mle(w) for weight, w in per_key.items()} out = [] - for weight in q["weights"]: - col = COUNT_COL if weight == "count" else VALUE_SUM_COL - per_key = agg.groupby(level=q["group_by"])[col].sum().to_numpy() - per_key = np.sort(per_key[per_key > 0])[::-1] - estimates = [] - for _, window in agg.groupby(level=WINDOW_COL): - w = window[col].to_numpy() - if window[COUNT_COL].sum() >= min_rows and np.sum(w > 0) >= min_keys: - estimates.append(zipf_mle(w)) - lower, upper, n_windows = window_bounds(estimates) - mle = zipf_mle(per_key) - out.append( - { - "dataset": dataset, - "query_id": q["id"], - "promql": q["promql"], - "kind": "keys", - "weight": weight, - "K": len(per_key), - "rows": rows, - "n_windows": n_windows, - "lower": lower, - "mle": mle, - "upper": upper, - "top1_share": per_key[0] / per_key.sum() if len(per_key) else np.nan, - "theta_ls": loglog_slope(per_key), - } - ) - if plot_dir is not None and len(per_key): - plot_rank_frequency( - per_key, - {"lower": lower, "mle": mle, "upper": upper}, - f"{dataset}: {q['promql']} [{weight}]", - plot_path(plot_dir, dataset, f"{q['id']}__rank_{weight}"), + for window_len in window_lengths: + coarse = coarsen_keys(agg, window_len // window_lengths[0], q["group_by"]) + for weight, col in columns.items(): + estimates = [] + for _, window in coarse.groupby(level=WINDOW_COL): + w = window[col].to_numpy() + if window[COUNT_COL].sum() >= min_rows and np.sum(w > 0) >= min_keys: + estimates.append(zipf_mle(w)) + lower, upper, n_windows = window_bounds(estimates, pooled[weight]) + keys = per_key[weight] + out.append( + { + "dataset": dataset, + "query_id": q["id"], + "promql": q["promql"], + "kind": "keys", + "weight": weight, + "window_len_s": window_len, + "K": len(keys), + "rows": rows, + "n_windows": n_windows, + "lower": lower, + "mle": pooled[weight], + "upper": upper, + "top1_share": keys[0] / keys.sum() if len(keys) else np.nan, + "theta_ls": loglog_slope(keys), + } ) + if plot_dir is not None and len(keys): + plot_rank_frequency( + keys, + {"lower": lower, "mle": pooled[weight], "upper": upper}, + f"{dataset}: {q['promql']} [{weight}, {window_len}s windows]", + plot_path( + plot_dir, dataset, f"{q['id']}__rank_{weight}__{window_len}s" + ), + ) return out @@ -524,20 +596,27 @@ def summarize_values( dataset: str, q: Dict[str, Any], acc: Dict[str, Any], + window_lengths: Sequence[int], pool: Any, min_rows: int, plot_dir: Optional[Path], -) -> Dict[str, Any]: - windows = {w: np.concatenate(parts) for w, parts in acc["windows"].items()} - if not windows: +) -> List[Dict[str, Any]]: + """One row per window length; acc holds positive values per finest window. + Coarser windows concatenate the full finest-window values, then subsample.""" + finest = {w: np.concatenate(parts) for w, parts in acc["windows"].items()} + if not finest: raise ValueError(f"{dataset}/{q['id']}: no positive values") - all_values = np.concatenate(list(windows.values())) + all_values = np.concatenate(list(finest.values())) mle_sample = subsample(all_values) - jobs = [(mle_sample, True)] + [ - (subsample(x), False) for x in windows.values() if len(x) >= min_rows - ] + jobs = [(mle_sample, True)] + job_window_lens = [0] + for window_len in window_lengths: + coarse = coarsen_values(finest, window_len // window_lengths[0]) + for x in coarse.values(): + if len(x) >= min_rows: + jobs.append((subsample(x), False)) + job_window_lens.append(window_len) fits = pool.starmap(fit_power_law, jobs) - lower, upper, n_windows = window_bounds([f["alpha"] for f in fits[1:]]) mle_fit = fits[0] if plot_dir is not None: plot_ccdf( @@ -546,20 +625,30 @@ def summarize_values( f"{dataset}: {q['value']} ({q['id']})", plot_path(plot_dir, dataset, f"{q['id']}__ccdf"), ) - return { - "dataset": dataset, - "query_id": q["id"], - "promql": q["promql"], - "kind": "values", - "weight": "", - "rows": acc["n_finite"], - "n_windows": n_windows, - "lower": lower, - "mle": mle_fit["alpha"], - "upper": upper, - "dropped_frac": 1.0 - len(all_values) / acc["n_finite"], - **{k: v for k, v in mle_fit.items() if k != "alpha"}, - } + out = [] + for window_len in window_lengths: + alphas = [ + f["alpha"] for f, wl in zip(fits, job_window_lens) if wl == window_len + ] + lower, upper, n_windows = window_bounds(alphas, mle_fit["alpha"]) + out.append( + { + "dataset": dataset, + "query_id": q["id"], + "promql": q["promql"], + "kind": "values", + "weight": "", + "window_len_s": window_len, + "rows": acc["n_finite"], + "n_windows": n_windows, + "lower": lower, + "mle": mle_fit["alpha"], + "upper": upper, + "dropped_frac": 1.0 - len(all_values) / acc["n_finite"], + **{k: v for k, v in mle_fit.items() if k != "alpha"}, + } + ) + return out def analyze_table( @@ -577,7 +666,7 @@ def analyze_table( table, path, queries, - cfg["window_secs"], + cfg["window_lengths_s"][0], cfg.get("max_time_secs"), args.max_rows, ) @@ -602,6 +691,7 @@ def analyze_table( cfg["dataset"], q, agg, + cfg["window_lengths_s"], args.min_window_rows, args.min_window_keys, plot_dir, @@ -613,9 +703,15 @@ def analyze_table( acc["n_finite"] += p["values"][key]["n_finite"] for w, parts in p["values"][key]["windows"].items(): acc["windows"].setdefault(w, []).extend(parts) - out.append( + out.extend( summarize_values( - cfg["dataset"], q, acc, pool, args.min_window_rows, plot_dir + cfg["dataset"], + q, + acc, + cfg["window_lengths_s"], + pool, + args.min_window_rows, + plot_dir, ) ) log.info("%s %s %s done", cfg["dataset"], q["id"], q["kind"]) @@ -650,7 +746,8 @@ def summarize_boom_series( fits: List[Dict[str, Any]], plot_dir: Optional[Path], ) -> Dict[str, Any]: - """Median over variates of each variate's lower/mle/upper and diagnostics.""" + """Medians over the passing variates if at least BOOM_MIN_OK_FRAC of the + compared variates pass; otherwise no alpha and medians over the failing ones.""" full: Dict[int, Dict[str, Any]] = {} samples: Dict[int, np.ndarray] = {} chunk_alphas: Dict[int, List[float]] = {v: [] for v in range(len(shifted))} @@ -659,10 +756,13 @@ def summarize_boom_series( full[v], samples[v] = fit, x else: chunk_alphas[v].append(fit["alpha"]) - bounds = [window_bounds(alphas) for alphas in chunk_alphas.values()] - oks = [f["power_law_ok"] for f in full.values() if "power_law_ok" in f] + compared = [v for v, f in full.items() if "power_law_ok" in f] + passing = [v for v in compared if full[v]["power_law_ok"]] + ok_frac = len(passing) / len(compared) if compared else np.nan + ok = bool(compared) and ok_frac >= BOOM_MIN_OK_FRAC + chosen = passing if ok else [v for v in compared if v not in passing] finite = int(np.isfinite(shifted).sum()) - row = { + row: Dict[str, Any] = { "dataset": dataset, "query_id": f"{q['id']}[{series}]", "promql": q["promql"], @@ -670,21 +770,31 @@ def summarize_boom_series( "weight": "", "K": len(shifted), "rows": finite, - "n_windows": sum(b[2] for b in bounds), - "lower": median_or_nan([b[0] for b in bounds]), - "mle": median_or_nan([f["alpha"] for f in full.values()]), - "upper": median_or_nan([b[1] for b in bounds]), "dropped_frac": 1.0 - np.sum(shifted > 0) / finite, - "power_law_ok": np.mean(oks) >= 0.5 if oks else np.nan, + "power_law_ok": ok, + "ok_frac": ok_frac, + "n_windows": 0, } + if ok: + bounds = [window_bounds(chunk_alphas[v], full[v]["alpha"]) for v in chosen] + row.update( + n_windows=sum(b[2] for b in bounds), + lower=median_or_nan([b[0] for b in bounds]), + mle=median_or_nan([full[v]["alpha"] for v in chosen]), + upper=median_or_nan([b[1] for b in bounds]), + best_alt="", + ) + elif chosen: + alts = [full[v]["best_alt"] for v in chosen] + row["best_alt"] = max(POWER_LAW_ALTERNATIVES, key=alts.count) for col in ("xmin", "ks_d", "tail_frac") + tuple( f"{k}_{alt}" for alt in POWER_LAW_ALTERNATIVES for k in ("R", "p") ): - row[col] = median_or_nan([f.get(col, np.nan) for f in full.values()]) - fitted = [v for v in full if np.isfinite(full[v]["alpha"])] - if plot_dir is not None and fitted: - # Show the variate whose alpha is closest to the series median. - v = min(fitted, key=lambda v: abs(full[v]["alpha"] - row["mle"])) + row[col] = median_or_nan([full[v].get(col, np.nan) for v in chosen]) + if plot_dir is not None and chosen: + # Show the chosen variate whose alpha is closest to their median. + median_alpha = median_or_nan([full[v]["alpha"] for v in chosen]) + v = min(chosen, key=lambda v: abs(full[v]["alpha"] - median_alpha)) plot_ccdf( samples[v], full[v], diff --git a/asap-tools/dataset-analysis/queries/alibaba_v2022.yaml b/asap-tools/dataset-analysis/queries/alibaba_v2022.yaml index b416459c..fb992253 100644 --- a/asap-tools/dataset-analysis/queries/alibaba_v2022.yaml +++ b/asap-tools/dataset-analysis/queries/alibaba_v2022.yaml @@ -1,6 +1,7 @@ # Alibaba cluster-trace-microservices-v2022, first 30 minutes. dataset: alibaba_v2022 -window_secs: 60 +# Bounds are computed at each window length; the first is the finest. +window_lengths_s: [60, 300, 1800] # NodeMetricsUpdate_0 covers 12 hours; clip every table to the 30 minutes # covered by the CallGraph and MCRRTUpdate shards. max_time_secs: 1800 diff --git a/asap-tools/dataset-analysis/queries/google_2011.yaml b/asap-tools/dataset-analysis/queries/google_2011.yaml index 7bee91a4..bc50c8ed 100644 --- a/asap-tools/dataset-analysis/queries/google_2011.yaml +++ b/asap-tools/dataset-analysis/queries/google_2011.yaml @@ -1,6 +1,7 @@ # Google ClusterData 2011-2, shard 0 of task_usage joined with task attributes. dataset: google_2011 -window_secs: 300 +# Bounds are computed at each window length; the first is the finest. +window_lengths_s: [300, 900, 3600] tables: task_usage: format: google_csv diff --git a/asap-tools/dataset-analysis/results/skew_summary.csv b/asap-tools/dataset-analysis/results/skew_summary.csv index 0d5cb985..f15c6d06 100644 --- a/asap-tools/dataset-analysis/results/skew_summary.csv +++ b/asap-tools/dataset-analysis/results/skew_summary.csv @@ -1,60 +1,138 @@ -dataset,query_id,promql,kind,weight,K,rows,n_windows,lower,mle,upper,top1_share,theta_ls,dropped_frac,xmin,ks_d,tail_frac,R_lognormal,p_lognormal,R_exponential,p_exponential,power_law_ok -alibaba_v2022,mcr_by_msname,sum by (msname) (providerrpc_mcr),keys,count,26077,90315535,30,1.34145,1.53568,1.90045,0.551844,1.35882,,,,,,,,, -alibaba_v2022,mcr_by_msname,sum by (msname) (providerrpc_mcr),keys,value,17911,90315535,30,1.02886,1.11054,1.30697,0.18365,3.6235,,,,,,,,, -alibaba_v2022,mcr_by_nodeid,sum by (nodeid) (providerrpc_mcr),keys,count,30776,90315535,30,1.06962,1.1256,1.22637,0.0299395,0.671771,,,,,,,,, -alibaba_v2022,mcr_by_nodeid,sum by (nodeid) (providerrpc_mcr),keys,value,28319,90315535,30,0.629764,0.760365,0.985563,0.0103042,0.905303,,,,,,,,, -alibaba_v2022,rt_p99_by_msname,"quantile by (msname) (0.99, providerrpc_rt)",keys,count,26077,90315535,30,1.34145,1.53568,1.90045,0.551844,1.35882,,,,,,,,, -alibaba_v2022,rt_p99_by_msname,"quantile by (msname) (0.99, providerrpc_rt)",keys,value,17879,90315535,30,1.55788,2.06565,2.86274,0.883125,2.23262,,,,,,,,, -alibaba_v2022,rt_p99_by_msname,"quantile by (msname) (0.99, providerrpc_rt)",values,,,90315535,30,4.99239,8.88803,25.2897,,,0.0733479,102.743,0.0829702,0.3652,0.0583085,0.915929,336.406,0.00272157,True -alibaba_v2022,calls_by_rpctype,count by (rpctype) (rt),keys,count,6,127635817,30,1.25893,1.3204,1.38466,0.426987,2.23811,,,,,,,,, -alibaba_v2022,calls_by_service,count by (service) (rt),keys,count,399933,127635817,30,0.999766,1.0731,1.02082,0.0388438,1.59871,,,,,,,,, -alibaba_v2022,calls_by_um,count by (um) (rt),keys,count,15063,127635817,30,1.11269,1.14611,1.13341,0.128004,2.68552,,,,,,,,, -alibaba_v2022,calls_by_dm,count by (dm) (rt),keys,count,25155,127635817,30,1.09664,1.12579,1.11105,0.0709133,2.60259,,,,,,,,, -alibaba_v2022,calls_by_interface,count by (interface) (rt),keys,count,1.19888e+06,127635817,30,0.989149,1.06008,1.00892,0.0259165,1.28963,,,,,,,,, -alibaba_v2022,calls_by_um_dm,"count by (um, dm) (rt)",keys,count,99257,127635817,30,0.976609,1.02162,1.00079,0.0262826,2.34181,,,,,,,,, -alibaba_v2022,calls_by_service_um_dm,"count by (service, um, dm) (rt)",keys,count,1.27135e+06,127635817,30,0.91038,0.981876,0.929804,0.010094,1.68258,,,,,,,,, -alibaba_v2022,rt_p99_by_service,"quantile by (service) (0.99, rt)",keys,count,399933,127635817,30,0.999766,1.0731,1.02082,0.0388438,1.59871,,,,,,,,, -alibaba_v2022,rt_p99_by_service,"quantile by (service) (0.99, rt)",keys,value,313796,127635817,30,1.12843,1.17197,1.18869,0.241919,2.3833,,,,,,,,, -alibaba_v2022,rt_p99_by_service,"quantile by (service) (0.99, rt)",values,,,125647293,30,1.90633,2.4739,2.78544,,,0.386496,71,0.0377468,0.0356,-0.305327,0.153917,92.7487,0.00348067,True -alibaba_v2022,ms_cpu_by_msname,sum by (msname) (cpu_utilization),keys,count,28159,13987704,30,0.826067,0.826138,0.82617,0.0164781,1.26917,,,,,,,,, -alibaba_v2022,ms_cpu_by_msname,sum by (msname) (cpu_utilization),keys,value,28158,13987704,30,0.891051,0.893458,0.897012,0.0092067,1.6656,,,,,,,,, -alibaba_v2022,ms_cpu_p99,"quantile(0.99, cpu_utilization)",values,,,13987704,30,3.02388,4.46166,6.93479,,,2.97404e-05,0.32589,0.0603559,0.0854,-13.7365,0.000639644,-14.3703,9.63628e-06,False -alibaba_v2022,node_cpu_by_nodeid,sum by (nodeid) (cpu_utilization),keys,count,42554,1228782,29,3.68585e-06,0.00427455,3.69803e-06,2.36006e-05,0.00882373,,,,,,,,, -alibaba_v2022,node_cpu_by_nodeid,sum by (nodeid) (cpu_utilization),keys,value,42552,1228782,29,0.316475,0.302619,0.32804,0.000107701,0.374094,,,,,,,,, -alibaba_v2022,node_cpu_p99,"quantile(0.99, cpu_utilization)",values,,,1228782,29,4.69344,5.19128,6.59384,,,4.72012e-05,0.257581,0.0283684,0.2176,-3.97421,0.128424,7.36288,0.350139,True -boom,target_tail[ds-2187-H],"quantile(0.99, target)",values,,100,523100,2000,1.72632,3.21772,5.37616,,,0.000191168,1.85333,0.0647201,0.0728,-2.07292,0.132572,8.52511,0.0461671,True -boom,target_tail[ds-2394-D],"quantile(0.99, target)",values,,73,10001,0,,2.05901,,,,0.185881,0.4824,0.18029,0.779412,-14.299,0.000918518,-13.9953,0.000104956,False -boom,target_tail[ds-1135-5T],"quantile(0.99, target)",values,,26,425984,243,2.12844,4.04798,6.31335,,,0.549368,3.02737,0.0743629,0.0542,-1.83713,0.128304,1.6523,0.0594927,True -boom,target_tail[ds-1833-D],"quantile(0.99, target)",values,,17,3689,0,,1.72967,,,,0.239631,0.665448,0.594321,1,-283.626,8.1371e-12,-98.1767,0,False -boom,target_tail[ds-2806-D],"quantile(0.99, target)",values,,100,13700,0,,1.85064,,,,0.700365,0.177947,0.18851,0.88806,-18.3939,0.000684349,-14.5781,0.0146828,False -boom,target_tail[ds-2573-D],"quantile(0.99, target)",values,,45,9765,0,,4.28086,,,,0.00798771,1.94081,0.153677,0.625,-2.42592,0.133614,-1.4821,0.0125487,True -boom,target_tail[ds-2222-30T],"quantile(0.99, target)",values,,100,1045600,678,1.47344,5.49131,19.7826,,,0.570518,1.16523,0.227535,0.74046,-4.35745,6.92289e-12,11.5169,1.24782e-14,False -boom,target_tail[ds-1914-30T],"quantile(0.99, target)",values,,64,669504,0,,,,,,0.999177,,,,,,,, -boom,target_tail[ds-2577-H],"quantile(0.99, target)",values,,11,57541,220,2.21739,4.0196,6.90404,,,0.000191168,2.73386,0.0396294,0.1084,-1.70375,0.197066,6.70502,0.0128851,True -boom,target_tail[ds-2212-D],"quantile(0.99, target)",values,,42,9114,0,,1.13374,,,,0.205508,2.69982e-06,0.230087,1,-10.4749,0.0179962,366.112,1.47908e-08,False -boom,target_tail[ds-2782-H],"quantile(0.99, target)",values,,20,16500,0,,,,,,0.992364,,,,,,,, -boom,target_tail[ds-1400-10S],"quantile(0.99, target)",values,,75,1228800,1500,4.036,7.0724,9.03294,,,0.000139974,3.82339,0.039047,0.129,-1.27558,0.263896,2.47535,0.102376,True -boom,target_tail[ds-2650-D],"quantile(0.99, target)",values,,56,12152,0,,2.64825,,,,0.00477288,0.723296,0.124754,0.490741,-5.05782,0.124238,-2.87425,0.0484973,True -boom,target_tail[ds-1316-10S],"quantile(0.99, target)",values,,40,655360,800,1.34693,1.98494,3.77865,,,0.122093,0.10877,0.0391658,0.5031,-2.97671,0.0570022,1181.72,2.81468e-45,False -boom,target_tail[ds-1558-5T],"quantile(0.99, target)",values,,97,1589248,1764,2.06103,3.87851,12.9998,,,0.197184,1.6553,0.124462,0.2916,-0.702945,0.150216,41.5952,3.53002e-05,True -boom,target_tail[ds-1972-D],"quantile(0.99, target)",values,,39,5343,0,,2.28479,,,,0.0557739,0.376831,0.276055,0.806086,-36.3262,0.000493092,-4.89259,4.82754e-23,False -boom,target_tail[ds-1840-D],"quantile(0.99, target)",values,,100,21700,0,,348.72,,,,0.00465438,8.33471,0.273522,0.689815,-34.8883,1.74754e-05,-1.04022,1.66232e-22,True -boom,target_tail[ds-671-10S],"quantile(0.99, target)",values,,100,1638400,2000,79.9422,11259.5,12666.3,,,6.10352e-05,10.9861,0.144019,0.0386,-43.3943,1.49559e-10,-5.50753,1.98273e-38,True -boom,target_tail[ds-1524-5T],"quantile(0.99, target)",values,,93,1267683,122,1.61633,3.93845,4.90315,,,0.944851,7.32407,0.294664,0.963303,-23.7515,0.000142278,-10.6513,6.75745e-26,False -boom,target_tail[ds-899-T],"quantile(0.99, target)",values,,12,196608,144,2.35649,2.71558,3.5848,,,0.420344,0.373495,0.068062,0.6426,-0.547811,0.146172,1391.71,6.17661e-104,True -google_2011,cpu_by_user,sum by (user) (cpu_rate),keys,count,518,2520773,17,1.22012,1.23997,1.27526,0.157436,2.33409,,,,,,,,, -google_2011,cpu_by_user,sum by (user) (cpu_rate),keys,value,495,2520773,17,1.24604,1.30345,1.42414,0.1682,3.7868,,,,,,,,, -google_2011,cpu_by_user_priority,"sum by (user, priority) (cpu_rate)",keys,count,869,2520773,17,1.22497,1.24584,1.27931,0.151999,2.11869,,,,,,,,, -google_2011,cpu_by_user_priority,"sum by (user, priority) (cpu_rate)",keys,value,840,2520773,17,1.26988,1.32416,1.43661,0.168118,3.41093,,,,,,,,, -google_2011,cpu_by_priority,sum by (priority) (cpu_rate),keys,count,7,2520773,17,1.0334,1.10046,1.17431,0.32255,1.89497,,,,,,,,, -google_2011,cpu_by_priority,sum by (priority) (cpu_rate),keys,value,7,2520773,17,1.43865,1.60501,1.75174,0.536005,2.03241,,,,,,,,, -google_2011,cpu_by_job_id,sum by (job_id) (cpu_rate),keys,count,4852,2520773,17,1.11406,1.1028,1.1396,0.138099,1.68596,,,,,,,,, -google_2011,cpu_by_job_id,sum by (job_id) (cpu_rate),keys,value,4741,2520773,17,1.14258,1.14339,1.22505,0.0488375,2.91631,,,,,,,,, -google_2011,cpu_by_logical_job_name,sum by (logical_job_name) (cpu_rate),keys,count,4076,2520773,17,1.11531,1.10016,1.13977,0.138099,1.67481,,,,,,,,, -google_2011,cpu_by_logical_job_name,sum by (logical_job_name) (cpu_rate),keys,value,3994,2520773,17,1.13852,1.13736,1.22246,0.0488375,2.95553,,,,,,,,, -google_2011,cpu_by_scheduling_class,sum by (scheduling_class) (cpu_rate),keys,count,4,2520773,17,0.409689,0.582621,0.758605,0.381155,0.574297,,,,,,,,, -google_2011,cpu_by_scheduling_class,sum by (scheduling_class) (cpu_rate),keys,value,4,2520773,17,0.373199,0.429641,0.984739,0.306212,0.565076,,,,,,,,, -google_2011,cpu_by_machine_id,sum by (machine_id) (cpu_rate),keys,count,12478,2520773,17,0.22599,0.207643,0.246048,0.000191211,0.252654,,,,,,,,, -google_2011,cpu_by_machine_id,sum by (machine_id) (cpu_rate),keys,value,12477,2520773,17,0.310753,0.286387,0.354508,0.000345691,0.399985,,,,,,,,, -google_2011,cpu_p99,"quantile(0.99, cpu_rate)",values,,,2520773,17,2.51611,2.78462,6.0283,,,0.095295,0.04016,0.0415811,0.1648,-3.3012,0.0492978,58.9964,1.35817e-07,False -google_2011,memory_p99,"quantile(0.99, canonical_memory_usage)",values,,,2520773,17,1.83045,3.24354,4.59216,,,0.113868,0.04865,0.128324,0.1642,-4.71955,0.0171806,30.6367,0.00238745,False +dataset,query_id,promql,kind,weight,window_len_s,K,rows,n_windows,lower,mle,upper,top1_share,theta_ls,dropped_frac,xmin,ks_d,tail_frac,R_lognormal,p_lognormal,R_exponential,p_exponential,power_law_ok,best_alt,ok_frac +alibaba_v2022,mcr_by_msname,sum by (msname) (providerrpc_mcr),keys,count,60,26077,90315535,30,1.34145,1.53568,1.90045,0.551844,1.35882,,,,,,,,,,, +alibaba_v2022,mcr_by_msname,sum by (msname) (providerrpc_mcr),keys,value,60,17911,90315535,30,1.02886,1.11054,1.30697,0.18365,3.6235,,,,,,,,,,, +alibaba_v2022,mcr_by_msname,sum by (msname) (providerrpc_mcr),keys,count,300,26077,90315535,6,1.45905,1.53568,1.66474,0.551844,1.35882,,,,,,,,,,, +alibaba_v2022,mcr_by_msname,sum by (msname) (providerrpc_mcr),keys,value,300,17911,90315535,6,1.07345,1.11054,1.18124,0.18365,3.6235,,,,,,,,,,, +alibaba_v2022,mcr_by_msname,sum by (msname) (providerrpc_mcr),keys,count,1800,26077,90315535,1,1.53568,1.53568,1.53568,0.551844,1.35882,,,,,,,,,,, +alibaba_v2022,mcr_by_msname,sum by (msname) (providerrpc_mcr),keys,value,1800,17911,90315535,1,1.11054,1.11054,1.11054,0.18365,3.6235,,,,,,,,,,, +alibaba_v2022,mcr_by_nodeid,sum by (nodeid) (providerrpc_mcr),keys,count,60,30776,90315535,30,1.06962,1.1256,1.22637,0.0299395,0.671771,,,,,,,,,,, +alibaba_v2022,mcr_by_nodeid,sum by (nodeid) (providerrpc_mcr),keys,value,60,28319,90315535,30,0.629764,0.760365,0.985563,0.0103042,0.905303,,,,,,,,,,, +alibaba_v2022,mcr_by_nodeid,sum by (nodeid) (providerrpc_mcr),keys,count,300,30776,90315535,6,1.11474,1.1256,1.17579,0.0299395,0.671771,,,,,,,,,,, +alibaba_v2022,mcr_by_nodeid,sum by (nodeid) (providerrpc_mcr),keys,value,300,28319,90315535,6,0.711785,0.760365,0.858603,0.0103042,0.905303,,,,,,,,,,, +alibaba_v2022,mcr_by_nodeid,sum by (nodeid) (providerrpc_mcr),keys,count,1800,30776,90315535,1,1.1256,1.1256,1.1256,0.0299395,0.671771,,,,,,,,,,, +alibaba_v2022,mcr_by_nodeid,sum by (nodeid) (providerrpc_mcr),keys,value,1800,28319,90315535,1,0.760365,0.760365,0.760365,0.0103042,0.905303,,,,,,,,,,, +alibaba_v2022,rt_p99_by_msname,"quantile by (msname) (0.99, providerrpc_rt)",keys,count,60,26077,90315535,30,1.34145,1.53568,1.90045,0.551844,1.35882,,,,,,,,,,, +alibaba_v2022,rt_p99_by_msname,"quantile by (msname) (0.99, providerrpc_rt)",keys,value,60,17879,90315535,30,1.55788,2.06565,2.86274,0.883125,2.23262,,,,,,,,,,, +alibaba_v2022,rt_p99_by_msname,"quantile by (msname) (0.99, providerrpc_rt)",keys,count,300,26077,90315535,6,1.45905,1.53568,1.66474,0.551844,1.35882,,,,,,,,,,, +alibaba_v2022,rt_p99_by_msname,"quantile by (msname) (0.99, providerrpc_rt)",keys,value,300,17879,90315535,6,1.91457,2.06565,2.26485,0.883125,2.23262,,,,,,,,,,, +alibaba_v2022,rt_p99_by_msname,"quantile by (msname) (0.99, providerrpc_rt)",keys,count,1800,26077,90315535,1,1.53568,1.53568,1.53568,0.551844,1.35882,,,,,,,,,,, +alibaba_v2022,rt_p99_by_msname,"quantile by (msname) (0.99, providerrpc_rt)",keys,value,1800,17879,90315535,1,2.06565,2.06565,2.06565,0.883125,2.23262,,,,,,,,,,, +alibaba_v2022,rt_p99_by_msname,"quantile by (msname) (0.99, providerrpc_rt)",values,,60,,90315535,30,2.26083,9.48921,19.3664,,,0.0733479,104.752,0.0722386,0.33763,20.9205,1.58403e-24,33305.7,0.0400746,True,, +alibaba_v2022,rt_p99_by_msname,"quantile by (msname) (0.99, providerrpc_rt)",values,,300,,90315535,6,2.69795,9.48921,9.48921,,,0.0733479,104.752,0.0722386,0.33763,20.9205,1.58403e-24,33305.7,0.0400746,True,, +alibaba_v2022,rt_p99_by_msname,"quantile by (msname) (0.99, providerrpc_rt)",values,,1800,,90315535,1,9.48921,9.48921,9.48921,,,0.0733479,104.752,0.0722386,0.33763,20.9205,1.58403e-24,33305.7,0.0400746,True,, +alibaba_v2022,calls_by_rpctype,count by (rpctype) (rt),keys,count,60,6,127635817,30,1.25893,1.3204,1.38466,0.426987,2.23811,,,,,,,,,,, +alibaba_v2022,calls_by_rpctype,count by (rpctype) (rt),keys,count,300,6,127635817,6,1.29467,1.3204,1.33952,0.426987,2.23811,,,,,,,,,,, +alibaba_v2022,calls_by_rpctype,count by (rpctype) (rt),keys,count,1800,6,127635817,1,1.3204,1.3204,1.3204,0.426987,2.23811,,,,,,,,,,, +alibaba_v2022,calls_by_service,count by (service) (rt),keys,count,60,399933,127635817,30,0.999766,1.0731,1.0731,0.0388438,1.59871,,,,,,,,,,, +alibaba_v2022,calls_by_service,count by (service) (rt),keys,count,300,399933,127635817,6,1.03815,1.0731,1.0731,0.0388438,1.59871,,,,,,,,,,, +alibaba_v2022,calls_by_service,count by (service) (rt),keys,count,1800,399933,127635817,1,1.0731,1.0731,1.0731,0.0388438,1.59871,,,,,,,,,,, +alibaba_v2022,calls_by_um,count by (um) (rt),keys,count,60,15063,127635817,30,1.11269,1.14611,1.14611,0.128004,2.68552,,,,,,,,,,, +alibaba_v2022,calls_by_um,count by (um) (rt),keys,count,300,15063,127635817,6,1.13005,1.14611,1.14611,0.128004,2.68552,,,,,,,,,,, +alibaba_v2022,calls_by_um,count by (um) (rt),keys,count,1800,15063,127635817,1,1.14611,1.14611,1.14611,0.128004,2.68552,,,,,,,,,,, +alibaba_v2022,calls_by_dm,count by (dm) (rt),keys,count,60,25155,127635817,30,1.09664,1.12579,1.12579,0.0709133,2.60259,,,,,,,,,,, +alibaba_v2022,calls_by_dm,count by (dm) (rt),keys,count,300,25155,127635817,6,1.11312,1.12579,1.12579,0.0709133,2.60259,,,,,,,,,,, +alibaba_v2022,calls_by_dm,count by (dm) (rt),keys,count,1800,25155,127635817,1,1.12579,1.12579,1.12579,0.0709133,2.60259,,,,,,,,,,, +alibaba_v2022,calls_by_interface,count by (interface) (rt),keys,count,60,1.19888e+06,127635817,30,0.989149,1.06008,1.06008,0.0259165,1.28963,,,,,,,,,,, +alibaba_v2022,calls_by_interface,count by (interface) (rt),keys,count,300,1.19888e+06,127635817,6,1.02446,1.06008,1.06008,0.0259165,1.28963,,,,,,,,,,, +alibaba_v2022,calls_by_interface,count by (interface) (rt),keys,count,1800,1.19888e+06,127635817,1,1.06008,1.06008,1.06008,0.0259165,1.28963,,,,,,,,,,, +alibaba_v2022,calls_by_um_dm,"count by (um, dm) (rt)",keys,count,60,99257,127635817,30,0.976609,1.02162,1.02162,0.0262826,2.34181,,,,,,,,,,, +alibaba_v2022,calls_by_um_dm,"count by (um, dm) (rt)",keys,count,300,99257,127635817,6,0.998943,1.02162,1.02162,0.0262826,2.34181,,,,,,,,,,, +alibaba_v2022,calls_by_um_dm,"count by (um, dm) (rt)",keys,count,1800,99257,127635817,1,1.02162,1.02162,1.02162,0.0262826,2.34181,,,,,,,,,,, +alibaba_v2022,calls_by_service_um_dm,"count by (service, um, dm) (rt)",keys,count,60,1.27135e+06,127635817,30,0.91038,0.981876,0.981876,0.010094,1.68258,,,,,,,,,,, +alibaba_v2022,calls_by_service_um_dm,"count by (service, um, dm) (rt)",keys,count,300,1.27135e+06,127635817,6,0.945969,0.981876,0.981876,0.010094,1.68258,,,,,,,,,,, +alibaba_v2022,calls_by_service_um_dm,"count by (service, um, dm) (rt)",keys,count,1800,1.27135e+06,127635817,1,0.981876,0.981876,0.981876,0.010094,1.68258,,,,,,,,,,, +alibaba_v2022,rt_p99_by_service,"quantile by (service) (0.99, rt)",keys,count,60,399933,127635817,30,0.999766,1.0731,1.0731,0.0388438,1.59871,,,,,,,,,,, +alibaba_v2022,rt_p99_by_service,"quantile by (service) (0.99, rt)",keys,value,60,313796,127635817,30,1.12843,1.17197,1.18869,0.241919,2.3833,,,,,,,,,,, +alibaba_v2022,rt_p99_by_service,"quantile by (service) (0.99, rt)",keys,count,300,399933,127635817,6,1.03815,1.0731,1.0731,0.0388438,1.59871,,,,,,,,,,, +alibaba_v2022,rt_p99_by_service,"quantile by (service) (0.99, rt)",keys,value,300,313796,127635817,6,1.149,1.17197,1.17378,0.241919,2.3833,,,,,,,,,,, +alibaba_v2022,rt_p99_by_service,"quantile by (service) (0.99, rt)",keys,count,1800,399933,127635817,1,1.0731,1.0731,1.0731,0.0388438,1.59871,,,,,,,,,,, +alibaba_v2022,rt_p99_by_service,"quantile by (service) (0.99, rt)",keys,value,1800,313796,127635817,1,1.17197,1.17197,1.17197,0.241919,2.3833,,,,,,,,,,, +alibaba_v2022,rt_p99_by_service,"quantile by (service) (0.99, rt)",values,,60,,125647293,30,2.10507,2.22496,2.39368,,,0.386496,54,0.0305356,0.04198,0.058631,0.574121,4657.66,1.18251e-37,True,, +alibaba_v2022,rt_p99_by_service,"quantile by (service) (0.99, rt)",values,,300,,125647293,6,2.22251,2.22496,2.37091,,,0.386496,54,0.0305356,0.04198,0.058631,0.574121,4657.66,1.18251e-37,True,, +alibaba_v2022,rt_p99_by_service,"quantile by (service) (0.99, rt)",values,,1800,,125647293,1,2.22496,2.22496,2.22496,,,0.386496,54,0.0305356,0.04198,0.058631,0.574121,4657.66,1.18251e-37,True,, +alibaba_v2022,ms_cpu_by_msname,sum by (msname) (cpu_utilization),keys,count,60,28159,13987704,30,0.826067,0.826138,0.82617,0.0164781,1.26917,,,,,,,,,,, +alibaba_v2022,ms_cpu_by_msname,sum by (msname) (cpu_utilization),keys,value,60,28158,13987704,30,0.891051,0.893458,0.897012,0.0092067,1.6656,,,,,,,,,,, +alibaba_v2022,ms_cpu_by_msname,sum by (msname) (cpu_utilization),keys,count,300,28159,13987704,6,0.8261,0.826138,0.826145,0.0164781,1.26917,,,,,,,,,,, +alibaba_v2022,ms_cpu_by_msname,sum by (msname) (cpu_utilization),keys,value,300,28158,13987704,6,0.891446,0.893458,0.895369,0.0092067,1.6656,,,,,,,,,,, +alibaba_v2022,ms_cpu_by_msname,sum by (msname) (cpu_utilization),keys,count,1800,28159,13987704,1,0.826138,0.826138,0.826138,0.0164781,1.26917,,,,,,,,,,, +alibaba_v2022,ms_cpu_by_msname,sum by (msname) (cpu_utilization),keys,value,1800,28158,13987704,1,0.893458,0.893458,0.893458,0.0092067,1.6656,,,,,,,,,,, +alibaba_v2022,ms_cpu_p99,"quantile(0.99, cpu_utilization)",values,,60,,13987704,30,3.12623,5.54219,7.13806,,,2.97404e-05,0.462804,0.0489465,0.03156,-76.2721,2.03777e-16,-76.0488,9.72424e-30,False,lognormal, +alibaba_v2022,ms_cpu_p99,"quantile(0.99, cpu_utilization)",values,,300,,13987704,6,5.24142,5.54219,6.13548,,,2.97404e-05,0.462804,0.0489465,0.03156,-76.2721,2.03777e-16,-76.0488,9.72424e-30,False,lognormal, +alibaba_v2022,ms_cpu_p99,"quantile(0.99, cpu_utilization)",values,,1800,,13987704,1,5.54219,5.54219,5.54219,,,2.97404e-05,0.462804,0.0489465,0.03156,-76.2721,2.03777e-16,-76.0488,9.72424e-30,False,lognormal, +alibaba_v2022,node_cpu_by_nodeid,sum by (nodeid) (cpu_utilization),keys,count,60,42554,1228782,29,3.68585e-06,0.00427455,0.00427455,2.36006e-05,0.00882373,,,,,,,,,,, +alibaba_v2022,node_cpu_by_nodeid,sum by (nodeid) (cpu_utilization),keys,value,60,42552,1228782,29,0.302619,0.302619,0.32804,0.000107701,0.374094,,,,,,,,,,, +alibaba_v2022,node_cpu_by_nodeid,sum by (nodeid) (cpu_utilization),keys,count,300,42554,1228782,6,0.00173761,0.00427455,0.00427455,2.36006e-05,0.00882373,,,,,,,,,,, +alibaba_v2022,node_cpu_by_nodeid,sum by (nodeid) (cpu_utilization),keys,value,300,42552,1228782,6,0.302619,0.302619,0.311077,0.000107701,0.374094,,,,,,,,,,, +alibaba_v2022,node_cpu_by_nodeid,sum by (nodeid) (cpu_utilization),keys,count,1800,42554,1228782,1,0.00427455,0.00427455,0.00427455,2.36006e-05,0.00882373,,,,,,,,,,, +alibaba_v2022,node_cpu_by_nodeid,sum by (nodeid) (cpu_utilization),keys,value,1800,42552,1228782,1,0.302619,0.302619,0.302619,0.000107701,0.374094,,,,,,,,,,, +alibaba_v2022,node_cpu_p99,"quantile(0.99, cpu_utilization)",values,,60,,1228782,29,5.55533,5.88868,6.15762,,,4.72012e-05,0.355012,0.0153465,0.06211,-3.90752,0.0576593,71.8823,3.08632e-08,False,lognormal, +alibaba_v2022,node_cpu_p99,"quantile(0.99, cpu_utilization)",values,,300,,1228782,6,5.69748,5.88868,5.99247,,,4.72012e-05,0.355012,0.0153465,0.06211,-3.90752,0.0576593,71.8823,3.08632e-08,False,lognormal, +alibaba_v2022,node_cpu_p99,"quantile(0.99, cpu_utilization)",values,,1800,,1228782,1,5.88868,5.88868,5.88868,,,4.72012e-05,0.355012,0.0153465,0.06211,-3.90752,0.0576593,71.8823,3.08632e-08,False,lognormal, +boom,target_tail[ds-2187-H],"quantile(0.99, target)",values,,,100,523100,1000,1.83826,4.25548,6.2417,,,0.000191168,2.55269,0.0564534,0.0722753,-0.511853,0.405175,13.901,0.0635678,True,,0.5 +boom,target_tail[ds-2394-D],"quantile(0.99, target)",values,,,73,10001,0,,,,,,0.185881,,,,,,,,False,, +boom,target_tail[ds-1135-5T],"quantile(0.99, target)",values,,,26,425984,0,,,,,,0.549368,3.26443,0.106705,0.0519633,-34.771,0.00522338,-6.81313,0.0425655,False,lognormal,0.428571 +boom,target_tail[ds-1833-D],"quantile(0.99, target)",values,,,17,3689,0,,,,,,0.239631,,,,,,,,False,, +boom,target_tail[ds-2806-D],"quantile(0.99, target)",values,,,100,13700,0,,,,,,0.700365,,,,,,,,False,, +boom,target_tail[ds-2573-D],"quantile(0.99, target)",values,,,45,9765,0,4.39465,4.39465,4.39465,,,0.00798771,1.87847,0.169387,0.481481,-0.555623,0.314343,2.08433,0.234396,True,,0.6 +boom,target_tail[ds-2222-30T],"quantile(0.99, target)",values,,,100,1045600,692,5.12284,27.8931,45.4353,,,0.570518,3.90947,0.136929,0.0349965,-0.172378,0.350612,16.7272,1.14374e-14,True,,0.81 +boom,target_tail[ds-1914-30T],"quantile(0.99, target)",values,,,64,669504,0,,,,,,0.999177,,,,,,,,False,, +boom,target_tail[ds-2577-H],"quantile(0.99, target)",values,,,11,57541,0,,,,,,0.000191168,2.49525,0.0506031,0.270937,-8.53816,0.00348972,3.98324,0.365683,False,lognormal,0.454545 +boom,target_tail[ds-2212-D],"quantile(0.99, target)",values,,,42,9114,0,,,,,,0.205508,0.0171532,0.268598,0.5,-21.0003,0.000620382,-13.2558,0.000145154,False,lognormal,0.363636 +boom,target_tail[ds-2782-H],"quantile(0.99, target)",values,,,20,16500,0,,,,,,0.992364,,,,,,,,False,, +boom,target_tail[ds-1400-10S],"quantile(0.99, target)",values,,,75,1228800,0,,,,,,0.000139974,3.58167,0.0401948,0.113044,-11.3256,0.00374703,-3.37719,7.22762e-05,False,lognormal,0.4 +boom,target_tail[ds-2650-D],"quantile(0.99, target)",values,,,56,12152,0,2.52362,2.52362,2.52362,,,0.00477288,0.4255,0.0813898,0.481481,-1.1773,0.365167,11.8682,0.103707,True,,0.5 +boom,target_tail[ds-1316-10S],"quantile(0.99, target)",values,,,40,655360,420,1.34981,2.94518,2.9669,,,0.122093,2.43799,0.0396472,0.021441,-0.127417,0.605348,39.883,0.000108837,True,,0.525 +boom,target_tail[ds-1558-5T],"quantile(0.99, target)",values,,,97,1589248,1185,2.98708,5.76602,24.7461,,,0.197184,2.2767,0.0870426,0.220245,0.0176096,0.27179,130.926,3.24486e-07,True,,0.659794 +boom,target_tail[ds-1972-D],"quantile(0.99, target)",values,,,39,5343,0,,,,,,0.0557739,,,,,,,,False,, +boom,target_tail[ds-1840-D],"quantile(0.99, target)",values,,,100,21700,0,779.957,779.957,779.957,,,0.00465438,8.61433,0.355908,0.587963,-0.435604,0.505999,4.25879,0.00299889,True,,0.71 +boom,target_tail[ds-671-10S],"quantile(0.99, target)",values,,,100,1638400,1900,127.269,10151.9,28143.7,,,6.10352e-05,11.085,0.160838,0.0315571,,,,,True,,1 +boom,target_tail[ds-1524-5T],"quantile(0.99, target)",values,,,93,1267683,0,,,,,,0.944851,2.77447,0.137907,0.0781713,-10.2982,0.00465206,-8.15093,7.45138e-08,False,lognormal,0.470588 +boom,target_tail[ds-899-T],"quantile(0.99, target)",values,,,12,196608,96,2.36862,4.77602,4.77602,,,0.420344,3.31643,0.0820839,0.0530058,-0.412674,0.218355,64.5435,4.61242e-07,True,,0.666667 +google_2011,cpu_by_user,sum by (user) (cpu_rate),keys,count,300,518,2520773,17,1.22012,1.23997,1.27526,0.157436,2.33409,,,,,,,,,,, +google_2011,cpu_by_user,sum by (user) (cpu_rate),keys,value,300,495,2520773,17,1.24604,1.30345,1.42414,0.1682,3.7868,,,,,,,,,,, +google_2011,cpu_by_user,sum by (user) (cpu_rate),keys,count,900,518,2520773,7,1.22012,1.23997,1.25824,0.157436,2.33409,,,,,,,,,,, +google_2011,cpu_by_user,sum by (user) (cpu_rate),keys,value,900,495,2520773,7,1.24604,1.30345,1.36946,0.1682,3.7868,,,,,,,,,,, +google_2011,cpu_by_user,sum by (user) (cpu_rate),keys,count,3600,518,2520773,2,1.2314,1.23997,1.24591,0.157436,2.33409,,,,,,,,,,, +google_2011,cpu_by_user,sum by (user) (cpu_rate),keys,value,3600,495,2520773,2,1.299,1.30345,1.30858,0.1682,3.7868,,,,,,,,,,, +google_2011,cpu_by_user_priority,"sum by (user, priority) (cpu_rate)",keys,count,300,869,2520773,17,1.22497,1.24584,1.27931,0.151999,2.11869,,,,,,,,,,, +google_2011,cpu_by_user_priority,"sum by (user, priority) (cpu_rate)",keys,value,300,840,2520773,17,1.26988,1.32416,1.43661,0.168118,3.41093,,,,,,,,,,, +google_2011,cpu_by_user_priority,"sum by (user, priority) (cpu_rate)",keys,count,900,869,2520773,7,1.22497,1.24584,1.26245,0.151999,2.11869,,,,,,,,,,, +google_2011,cpu_by_user_priority,"sum by (user, priority) (cpu_rate)",keys,value,900,840,2520773,7,1.26988,1.32416,1.38497,0.168118,3.41093,,,,,,,,,,, +google_2011,cpu_by_user_priority,"sum by (user, priority) (cpu_rate)",keys,count,3600,869,2520773,2,1.23706,1.24584,1.25092,0.151999,2.11869,,,,,,,,,,, +google_2011,cpu_by_user_priority,"sum by (user, priority) (cpu_rate)",keys,value,3600,840,2520773,2,1.31927,1.32416,1.32812,0.168118,3.41093,,,,,,,,,,, +google_2011,cpu_by_priority,sum by (priority) (cpu_rate),keys,count,300,7,2520773,17,1.0334,1.10046,1.17431,0.32255,1.89497,,,,,,,,,,, +google_2011,cpu_by_priority,sum by (priority) (cpu_rate),keys,value,300,7,2520773,17,1.43865,1.60501,1.75174,0.536005,2.03241,,,,,,,,,,, +google_2011,cpu_by_priority,sum by (priority) (cpu_rate),keys,count,900,7,2520773,7,1.06809,1.10046,1.17431,0.32255,1.89497,,,,,,,,,,, +google_2011,cpu_by_priority,sum by (priority) (cpu_rate),keys,value,900,7,2520773,7,1.49898,1.60501,1.7108,0.536005,2.03241,,,,,,,,,,, +google_2011,cpu_by_priority,sum by (priority) (cpu_rate),keys,count,3600,7,2520773,2,1.08297,1.10046,1.1272,0.32255,1.89497,,,,,,,,,,, +google_2011,cpu_by_priority,sum by (priority) (cpu_rate),keys,value,3600,7,2520773,2,1.59355,1.60501,1.64514,0.536005,2.03241,,,,,,,,,,, +google_2011,cpu_by_job_id,sum by (job_id) (cpu_rate),keys,count,300,4852,2520773,17,1.1028,1.1028,1.1396,0.138099,1.68596,,,,,,,,,,, +google_2011,cpu_by_job_id,sum by (job_id) (cpu_rate),keys,value,300,4741,2520773,17,1.14258,1.14339,1.22505,0.0488375,2.91631,,,,,,,,,,, +google_2011,cpu_by_job_id,sum by (job_id) (cpu_rate),keys,count,900,4852,2520773,7,1.1028,1.1028,1.11909,0.138099,1.68596,,,,,,,,,,, +google_2011,cpu_by_job_id,sum by (job_id) (cpu_rate),keys,value,900,4741,2520773,7,1.14339,1.14339,1.2012,0.0488375,2.91631,,,,,,,,,,, +google_2011,cpu_by_job_id,sum by (job_id) (cpu_rate),keys,count,3600,4852,2520773,2,1.1028,1.1028,1.11042,0.138099,1.68596,,,,,,,,,,, +google_2011,cpu_by_job_id,sum by (job_id) (cpu_rate),keys,value,3600,4741,2520773,2,1.14299,1.14339,1.17023,0.0488375,2.91631,,,,,,,,,,, +google_2011,cpu_by_logical_job_name,sum by (logical_job_name) (cpu_rate),keys,count,300,4076,2520773,17,1.10016,1.10016,1.13977,0.138099,1.67481,,,,,,,,,,, +google_2011,cpu_by_logical_job_name,sum by (logical_job_name) (cpu_rate),keys,value,300,3994,2520773,17,1.13736,1.13736,1.22246,0.0488375,2.95553,,,,,,,,,,, +google_2011,cpu_by_logical_job_name,sum by (logical_job_name) (cpu_rate),keys,count,900,4076,2520773,7,1.10016,1.10016,1.11896,0.138099,1.67481,,,,,,,,,,, +google_2011,cpu_by_logical_job_name,sum by (logical_job_name) (cpu_rate),keys,value,900,3994,2520773,7,1.13736,1.13736,1.19819,0.0488375,2.95553,,,,,,,,,,, +google_2011,cpu_by_logical_job_name,sum by (logical_job_name) (cpu_rate),keys,count,3600,4076,2520773,2,1.10016,1.10016,1.11033,0.138099,1.67481,,,,,,,,,,, +google_2011,cpu_by_logical_job_name,sum by (logical_job_name) (cpu_rate),keys,value,3600,3994,2520773,2,1.13736,1.13736,1.16633,0.0488375,2.95553,,,,,,,,,,, +google_2011,cpu_by_scheduling_class,sum by (scheduling_class) (cpu_rate),keys,count,300,4,2520773,17,0.409689,0.582621,0.758605,0.381155,0.574297,,,,,,,,,,, +google_2011,cpu_by_scheduling_class,sum by (scheduling_class) (cpu_rate),keys,value,300,4,2520773,17,0.373199,0.429641,0.984739,0.306212,0.565076,,,,,,,,,,, +google_2011,cpu_by_scheduling_class,sum by (scheduling_class) (cpu_rate),keys,count,900,4,2520773,7,0.409689,0.582621,0.688766,0.381155,0.574297,,,,,,,,,,, +google_2011,cpu_by_scheduling_class,sum by (scheduling_class) (cpu_rate),keys,value,900,4,2520773,7,0.385382,0.429641,0.750656,0.306212,0.565076,,,,,,,,,,, +google_2011,cpu_by_scheduling_class,sum by (scheduling_class) (cpu_rate),keys,count,3600,4,2520773,2,0.509008,0.582621,0.632622,0.381155,0.574297,,,,,,,,,,, +google_2011,cpu_by_scheduling_class,sum by (scheduling_class) (cpu_rate),keys,value,3600,4,2520773,2,0.429641,0.429641,0.515166,0.306212,0.565076,,,,,,,,,,, +google_2011,cpu_by_machine_id,sum by (machine_id) (cpu_rate),keys,count,300,12478,2520773,17,0.207643,0.207643,0.246048,0.000191211,0.252654,,,,,,,,,,, +google_2011,cpu_by_machine_id,sum by (machine_id) (cpu_rate),keys,value,300,12477,2520773,17,0.286387,0.286387,0.354508,0.000345691,0.399985,,,,,,,,,,, +google_2011,cpu_by_machine_id,sum by (machine_id) (cpu_rate),keys,count,900,12478,2520773,7,0.207643,0.207643,0.238947,0.000191211,0.252654,,,,,,,,,,, +google_2011,cpu_by_machine_id,sum by (machine_id) (cpu_rate),keys,value,900,12477,2520773,7,0.286387,0.286387,0.352387,0.000345691,0.399985,,,,,,,,,,, +google_2011,cpu_by_machine_id,sum by (machine_id) (cpu_rate),keys,count,3600,12478,2520773,2,0.207112,0.207643,0.215858,0.000191211,0.252654,,,,,,,,,,, +google_2011,cpu_by_machine_id,sum by (machine_id) (cpu_rate),keys,value,3600,12477,2520773,2,0.284414,0.286387,0.31254,0.000345691,0.399985,,,,,,,,,,, +google_2011,cpu_p99,"quantile(0.99, cpu_rate)",values,,300,,2520773,17,2.60391,2.9174,14.4531,,,0.095295,0.04578,0.0423316,0.14383,-46.9071,3.19362e-13,851.96,6.06387e-88,False,lognormal, +google_2011,cpu_p99,"quantile(0.99, cpu_rate)",values,,900,,2520773,7,2.67306,2.9174,3.34021,,,0.095295,0.04578,0.0423316,0.14383,-46.9071,3.19362e-13,851.96,6.06387e-88,False,lognormal, +google_2011,cpu_p99,"quantile(0.99, cpu_rate)",values,,3600,,2520773,2,2.84976,2.9174,2.9174,,,0.095295,0.04578,0.0423316,0.14383,-46.9071,3.19362e-13,851.96,6.06387e-88,False,lognormal, +google_2011,memory_p99,"quantile(0.99, canonical_memory_usage)",values,,300,,2520773,17,1.77476,3.29427,4.33728,,,0.113868,0.05066,0.14122,0.15382,-34.9439,7.23912e-13,747.907,2.31647e-98,False,lognormal, +google_2011,memory_p99,"quantile(0.99, canonical_memory_usage)",values,,900,,2520773,7,1.80739,3.29427,3.29427,,,0.113868,0.05066,0.14122,0.15382,-34.9439,7.23912e-13,747.907,2.31647e-98,False,lognormal, +google_2011,memory_p99,"quantile(0.99, canonical_memory_usage)",values,,3600,,2520773,2,1.79867,3.29427,3.29427,,,0.113868,0.05066,0.14122,0.15382,-34.9439,7.23912e-13,747.907,2.31647e-98,False,lognormal, diff --git a/asap-tools/dataset-analysis/tests/test_fit_skew.py b/asap-tools/dataset-analysis/tests/test_fit_skew.py index 67704da9..e4daad13 100644 --- a/asap-tools/dataset-analysis/tests/test_fit_skew.py +++ b/asap-tools/dataset-analysis/tests/test_fit_skew.py @@ -5,6 +5,7 @@ import tarfile import tempfile import unittest +from multiprocessing.pool import ThreadPool from pathlib import Path import numpy as np @@ -15,7 +16,7 @@ ZIPF_K = 1000 ZIPF_SAMPLES = 2_000_000 ZIPF_TOLERANCE = 0.05 -PARETO_SAMPLES = fit_skew.MAX_FIT_SAMPLES +PARETO_SAMPLES = 20_000 PARETO_REL_TOLERANCE = 0.05 @@ -65,13 +66,52 @@ def test_recovers_pareto_alpha(self): fit["alpha"], alpha, delta=PARETO_REL_TOLERANCE * alpha ) self.assertTrue(fit["power_law_ok"]) + self.assertEqual(fit["best_alt"], "") tail = np.sum(x >= fit["xmin"]) self.assertGreaterEqual(tail, fit_skew.MIN_TAIL_SAMPLES) - def test_power_law_ok_rule(self): - self.assertTrue(fit_skew.power_law_ok([(1.0, 0.01), (-1.0, 0.5)])) - self.assertFalse(fit_skew.power_law_ok([(1.0, 0.01), (-1.0, 0.05)])) - self.assertTrue(fit_skew.power_law_ok([])) + def test_best_alternative(self): + best = fit_skew.best_alternative + # Not significant, or the power law wins: no better alternative. + self.assertEqual( + best({"lognormal": (-1.0, 0.5), "exponential": (3.0, 0.01)}), "" + ) + self.assertEqual(best({}), "") + self.assertEqual( + best({"lognormal": (-1.0, 0.05), "exponential": (3.0, 0.01)}), "lognormal" + ) + # Both significantly better: the most negative R wins. + self.assertEqual( + best({"lognormal": (-1.0, 0.01), "exponential": (-5.0, 0.01)}), + "exponential", + ) + + def test_losing_fit_still_reports_alpha(self): + # A pure lognormal loses to the lognormal alternative over the body. + x = np.random.default_rng(8).lognormal(0.0, 0.5, PARETO_SAMPLES) + fit = fit_skew.fit_power_law(x, compare=True) + self.assertTrue(np.isfinite(fit["alpha"])) + self.assertEqual(fit["power_law_ok"], fit["best_alt"] == "") + + def test_xmin_grid(self): + x = np.sort(np.random.default_rng(9).pareto(1.5, PARETO_SAMPLES) + 1.0) + grid = fit_skew.xmin_candidates(x) + self.assertLessEqual(len(grid), fit_skew.XMIN_GRID_SIZE) + self.assertGreaterEqual(grid[0], np.quantile(x, 0.5)) + self.assertGreaterEqual(np.sum(x >= grid[-1]), fit_skew.MIN_TAIL_SAMPLES) + fit = fit_skew.fit_power_law(x, compare=False) + self.assertIn(fit["xmin"], grid) + + def test_xmin_grid_small_sample(self): + rng = np.random.default_rng(10) + # 300 values: p99.9 leaves one value, so the grid stops at 100 tail values. + x = np.sort(rng.pareto(1.5, 300) + 1.0) + grid = fit_skew.xmin_candidates(x) + self.assertGreaterEqual(np.sum(x >= grid[-1]), fit_skew.MIN_TAIL_SAMPLES) + # 150 values: 100 tail values would reach below the median, so no fit. + x = np.sort(rng.pareto(1.5, 150) + 1.0) + self.assertEqual(len(fit_skew.xmin_candidates(x)), 0) + self.assertTrue(np.isnan(fit_skew.fit_power_law(x, compare=True)["alpha"])) def test_too_few_samples_is_nan(self): fit = fit_skew.fit_power_law( @@ -81,35 +121,54 @@ def test_too_few_samples_is_nan(self): self.assertNotIn("power_law_ok", fit) +def key_window_frames(thetas, rng): + """Finest-window key count frames, one Zipf window per theta.""" + frames = [ + pd.DataFrame( + { + fit_skew.WINDOW_COL: window, + "k": np.arange(ZIPF_K).astype(str).astype(object), + fit_skew.COUNT_COL: zipf_counts(theta, rng), + } + ) + for window, theta in enumerate(thetas) + ] + return frames + + +COUNT_QUERY = { + "id": "q", + "promql": "count by (k) (x)", + "group_by": ["k"], + "weights": ["count"], +} + + class WindowBoundsTest(unittest.TestCase): def test_min_max_count(self): - self.assertEqual(fit_skew.window_bounds([1.1, 0.7, 1.4]), (0.7, 1.4, 3)) + self.assertEqual(fit_skew.window_bounds([1.1, 0.7, 1.4], 1.0), (0.7, 1.4, 3)) + + def test_pooled_extends_bounds(self): + # The pooled fit need not lie between the window fits; it widens them. + self.assertEqual(fit_skew.window_bounds([1.1, 1.2], 1.5), (1.1, 1.5, 2)) + self.assertEqual(fit_skew.window_bounds([1.1, 1.2], 0.9), (0.9, 1.2, 2)) def test_nan_windows_skipped(self): self.assertEqual( - fit_skew.window_bounds([np.nan, 0.9, np.nan, 1.2]), (0.9, 1.2, 2) + fit_skew.window_bounds([np.nan, 0.9, np.nan, 1.2], 1.0), (0.9, 1.2, 2) ) - def test_no_windows(self): + def test_no_windows_uses_pooled(self): for estimates in ([], [np.nan]): - lower, upper, n = fit_skew.window_bounds(estimates) - self.assertTrue(np.isnan(lower) and np.isnan(upper)) - self.assertEqual(n, 0) + self.assertEqual(fit_skew.window_bounds(estimates, 1.3), (1.3, 1.3, 0)) + + def test_nothing_finite(self): + lower, upper, n = fit_skew.window_bounds([np.nan], np.nan) + self.assertTrue(np.isnan(lower) and np.isnan(upper)) + self.assertEqual(n, 0) def test_summarize_keys_skips_small_windows(self): - rng = np.random.default_rng(5) - frames = [] - for window, theta in ((0, 0.8), (1, 1.2)): - counts = zipf_counts(theta, rng) - frames.append( - pd.DataFrame( - { - fit_skew.WINDOW_COL: window, - "k": np.arange(ZIPF_K).astype(str).astype(object), - fit_skew.COUNT_COL: counts, - } - ) - ) + frames = key_window_frames((0.8, 1.2), np.random.default_rng(5)) # Window 2 has too few keys to be fitted. frames.append( pd.DataFrame( @@ -117,14 +176,108 @@ def test_summarize_keys_skips_small_windows(self): ) ) agg = fit_skew.merge_key_parts(frames, ["k"]) - q = {"id": "q", "promql": "count by (k) (x)", "group_by": ["k"]} - q["weights"] = ["count"] - (row,) = fit_skew.summarize_keys("test", q, agg, 1, 10, None) + (row,) = fit_skew.summarize_keys("test", COUNT_QUERY, agg, [60], 1, 10, None) self.assertEqual(row["n_windows"], 2) self.assertAlmostEqual(row["lower"], 0.8, delta=ZIPF_TOLERANCE) self.assertAlmostEqual(row["upper"], 1.2, delta=ZIPF_TOLERANCE) self.assertTrue(row["lower"] <= row["mle"] <= row["upper"]) self.assertEqual(row["K"], ZIPF_K) + self.assertEqual(row["window_len_s"], 60) + + def test_summarize_keys_window_lengths(self): + frames = key_window_frames((0.8, 1.2, 0.8, 1.2), np.random.default_rng(6)) + agg = fit_skew.merge_key_parts(frames, ["k"]) + fine, coarse = fit_skew.summarize_keys( + "test", COUNT_QUERY, agg, [60, 120], 1, 2, None + ) + self.assertEqual((fine["window_len_s"], coarse["window_len_s"]), (60, 120)) + self.assertEqual((fine["n_windows"], coarse["n_windows"]), (4, 2)) + self.assertEqual(fine["mle"], coarse["mle"]) + # Merging a 0.8 and a 1.2 window gives something in between. + self.assertGreater(coarse["lower"], fine["lower"]) + self.assertLess(coarse["upper"], fine["upper"]) + for row in (fine, coarse): + self.assertTrue(row["lower"] <= row["mle"] <= row["upper"]) + + def test_coarsen_values(self): + windows = {0: np.array([1.0]), 1: np.array([2.0]), 2: np.array([3.0])} + coarse = fit_skew.coarsen_values(windows, 2) + self.assertEqual(sorted(coarse), [0, 1]) + np.testing.assert_array_equal(coarse[0], [1.0, 2.0]) + np.testing.assert_array_equal(coarse[1], [3.0]) + + def test_summarize_values_window_lengths(self): + rng = np.random.default_rng(7) + acc = { + "n_finite": 4000, + "windows": {w: [rng.pareto(1.5, 1000) + 1.0] for w in range(4)}, + } + q = {"id": "v", "promql": "quantile(0.99, x)", "value": "x"} + # One thread: redirect_stdout in fit_power_law is process-wide. + with ThreadPool(1) as pool: + rows = fit_skew.summarize_values("test", q, acc, [60, 240], pool, 1, None) + self.assertEqual([r["window_len_s"] for r in rows], [60, 240]) + self.assertEqual([r["n_windows"] for r in rows], [4, 1]) + for row in rows: + self.assertTrue(row["lower"] <= row["mle"] <= row["upper"]) + + +def boom_inputs(oks): + """Fake per-variate full fits (alpha = index + 2) with the given flags.""" + shifted = np.ones((len(oks), 10)) + jobs = [(np.ones(10), True) for _ in oks] + fits = [ + { + "alpha": v + 2.0, + "xmin": 1.0, + "ks_d": 0.01, + "tail_frac": 0.1, + "R_lognormal": 1.0 if ok else -3.0, + "p_lognormal": 0.5 if ok else 0.01, + "R_exponential": 2.0, + "p_exponential": 0.01, + "best_alt": "" if ok else "lognormal", + "power_law_ok": ok, + } + for v, ok in enumerate(oks) + ] + return shifted, jobs, list(range(len(oks))), fits + + +class BoomSummaryTest(unittest.TestCase): + def summarize(self, oks): + q = {"id": "t", "promql": "quantile(0.99, target)"} + return fit_skew.summarize_boom_series("boom", q, "s", *boom_inputs(oks), None) + + def test_alpha_over_passing_variates(self): + row = self.summarize([True, False, True, True]) + self.assertEqual(row["ok_frac"], 0.75) + self.assertTrue(row["power_law_ok"]) + self.assertEqual(row["best_alt"], "") + # Passing variates 0, 2, 3 have alpha 2, 4, 5. + self.assertEqual(row["mle"], 4.0) + self.assertTrue(row["lower"] <= row["mle"] <= row["upper"]) + self.assertEqual(row["R_lognormal"], 1.0) + + def test_mostly_failing_series_has_no_alpha(self): + row = self.summarize([True, False, False, False]) + self.assertEqual(row["ok_frac"], 0.25) + self.assertFalse(row["power_law_ok"]) + self.assertEqual(row["best_alt"], "lognormal") + self.assertNotIn("mle", row) + self.assertNotIn("lower", row) + # Diagnostics come from the failing variates, consistent with the flag. + self.assertEqual(row["R_lognormal"], -3.0) + + def test_no_compared_variates(self): + q = {"id": "t", "promql": "quantile(0.99, target)"} + shifted, jobs, owners, _ = boom_inputs([True]) + fits = [{"alpha": np.nan, "xmin": np.nan, "ks_d": np.nan}] + row = fit_skew.summarize_boom_series( + "boom", q, "s", shifted, jobs, owners, fits, None + ) + self.assertFalse(row["power_law_ok"]) + self.assertTrue(np.isnan(row["ok_frac"])) VALID_CONFIG = { @@ -167,6 +320,13 @@ def test_invalid(self): with self.assertRaises(ValueError): fit_skew.validate_config(cfg) + def test_window_lengths(self): + fit_skew.validate_window_lengths([60, 300, 1800], "d") + for lengths in ([], [300, 60], [60, 60], [60, 90]): + with self.subTest(lengths=lengths): + with self.assertRaises(ValueError): + fit_skew.validate_window_lengths(lengths, "d") + def test_value_weight_needs_value(self): cfg = copy.deepcopy(VALID_CONFIG) del cfg["queries"][0]["value"] From 0710da14d9665eb33f2f4c40aeae2f09c7140553 Mon Sep 17 00:00:00 2001 From: zz_y Date: Tue, 29 Sep 2026 18:59:20 +0000 Subject: [PATCH 4/8] feat(asap-tools): require power law to beat both alternatives power_law_ok now needs the power law to significantly beat both the lognormal and the exponential. Otherwise best_alt names the significantly better alternative or "inconclusive". BOOM ok_frac uses the same rule. Co-Authored-By: Claude Opus 5.5 --- asap-tools/dataset-analysis/README.md | 14 +++--- asap-tools/dataset-analysis/fit_skew.py | 18 +++++--- .../dataset-analysis/results/skew_summary.csv | 34 +++++++------- .../dataset-analysis/tests/test_fit_skew.py | 45 +++++++++++++------ 4 files changed, 70 insertions(+), 41 deletions(-) diff --git a/asap-tools/dataset-analysis/README.md b/asap-tools/dataset-analysis/README.md index 8526c593..d61da245 100644 --- a/asap-tools/dataset-analysis/README.md +++ b/asap-tools/dataset-analysis/README.md @@ -105,10 +105,14 @@ Citations: BOOM has no timestamps in this analysis and keeps its 20 equal chunks per series (`window_len_s` is empty). - **power_law_ok / best_alt**: the power law is compared with a lognormal - and an exponential (`distribution_compare`); it is significantly worse - when `R < 0` with `p < 0.1`. If it is worse than either, `power_law_ok` is - false and `best_alt` names the alternative with the most negative `R`; - α is still reported. `best_alt` is empty when `power_law_ok` is true. + and an exponential (`distribution_compare`, likelihood ratio `R` and + p-value `p`). `power_law_ok` is true only if the power law significantly + beats both (`R > 0` and `p < 0.1` for each). Otherwise `best_alt` names the + alternative that is significantly better with the most negative `R`, or + `inconclusive` if neither is; α is still reported. `best_alt` is empty + when `power_law_ok` is true. A lognormal with large σ mimics a power-law + tail, so this rule rarely passes: even an exact Pareto(α=2) sample comes out + `inconclusive` (see the tests). ## Output: `results/skew_summary.csv` @@ -152,7 +156,7 @@ rank-frequency with the lower/mle/upper θ lines, one per window length) and over the passing variates of each variate's lower, mle and upper, and the diagnostics (`xmin`, `R`, `p`, ...) are medians over the same variates. If `ok_frac < 0.5`, lower/mle/upper are empty, `power_law_ok` is false, - `best_alt` is the alternative most failing variates lose to, and the + `best_alt` is the most common `best_alt` among the failing variates, and the diagnostics are medians over the failing variates. - **Google join rule**: `task_usage` rows get `user`, `priority` and `scheduling_class` from the last non-null `task_events` value for the same diff --git a/asap-tools/dataset-analysis/fit_skew.py b/asap-tools/dataset-analysis/fit_skew.py index 47b3767a..d86a447d 100644 --- a/asap-tools/dataset-analysis/fit_skew.py +++ b/asap-tools/dataset-analysis/fit_skew.py @@ -48,8 +48,9 @@ SAMPLE_SEED = 0 DEFAULT_MIN_WINDOW_ROWS = 200 DEFAULT_MIN_WINDOW_KEYS = 2 -# R < 0 with p below this means the power law fits significantly worse. +# A likelihood-ratio comparison is significant when its p is below this. COMPARE_P_THRESHOLD = 0.1 +INCONCLUSIVE = "inconclusive" POWER_LAW_ALTERNATIVES = ("lognormal", "exponential") CSV_BLOCK_BYTES = 64 << 20 @@ -420,14 +421,19 @@ def subsample(x: np.ndarray) -> np.ndarray: def best_alternative(comparisons: Dict[str, Tuple[float, float]]) -> str: - """The alternative that fits significantly better than the power law - (R < 0 with small p), preferring the most negative R; '' if none.""" - losing = { + """'' if the power law significantly beats every alternative (R > 0 with + small p); otherwise the alternative significantly better than it with the + most negative R, or 'inconclusive' if none is significantly better.""" + if comparisons and all( + r > 0 and p < COMPARE_P_THRESHOLD for r, p in comparisons.values() + ): + return "" + better = { alt: r for alt, (r, p) in comparisons.items() if r < 0 and p < COMPARE_P_THRESHOLD } - return min(losing, key=lambda alt: losing[alt]) if losing else "" + return min(better, key=lambda alt: better[alt]) if better else INCONCLUSIVE def xmin_candidates(x_sorted: np.ndarray) -> np.ndarray: @@ -786,7 +792,7 @@ def summarize_boom_series( ) elif chosen: alts = [full[v]["best_alt"] for v in chosen] - row["best_alt"] = max(POWER_LAW_ALTERNATIVES, key=alts.count) + row["best_alt"] = max(sorted(set(alts)), key=alts.count) for col in ("xmin", "ks_d", "tail_frac") + tuple( f"{k}_{alt}" for alt in POWER_LAW_ALTERNATIVES for k in ("R", "p") ): diff --git a/asap-tools/dataset-analysis/results/skew_summary.csv b/asap-tools/dataset-analysis/results/skew_summary.csv index f15c6d06..7d3f10d5 100644 --- a/asap-tools/dataset-analysis/results/skew_summary.csv +++ b/asap-tools/dataset-analysis/results/skew_summary.csv @@ -47,9 +47,9 @@ alibaba_v2022,rt_p99_by_service,"quantile by (service) (0.99, rt)",keys,count,30 alibaba_v2022,rt_p99_by_service,"quantile by (service) (0.99, rt)",keys,value,300,313796,127635817,6,1.149,1.17197,1.17378,0.241919,2.3833,,,,,,,,,,, alibaba_v2022,rt_p99_by_service,"quantile by (service) (0.99, rt)",keys,count,1800,399933,127635817,1,1.0731,1.0731,1.0731,0.0388438,1.59871,,,,,,,,,,, alibaba_v2022,rt_p99_by_service,"quantile by (service) (0.99, rt)",keys,value,1800,313796,127635817,1,1.17197,1.17197,1.17197,0.241919,2.3833,,,,,,,,,,, -alibaba_v2022,rt_p99_by_service,"quantile by (service) (0.99, rt)",values,,60,,125647293,30,2.10507,2.22496,2.39368,,,0.386496,54,0.0305356,0.04198,0.058631,0.574121,4657.66,1.18251e-37,True,, -alibaba_v2022,rt_p99_by_service,"quantile by (service) (0.99, rt)",values,,300,,125647293,6,2.22251,2.22496,2.37091,,,0.386496,54,0.0305356,0.04198,0.058631,0.574121,4657.66,1.18251e-37,True,, -alibaba_v2022,rt_p99_by_service,"quantile by (service) (0.99, rt)",values,,1800,,125647293,1,2.22496,2.22496,2.22496,,,0.386496,54,0.0305356,0.04198,0.058631,0.574121,4657.66,1.18251e-37,True,, +alibaba_v2022,rt_p99_by_service,"quantile by (service) (0.99, rt)",values,,60,,125647293,30,2.10507,2.22496,2.39368,,,0.386496,54,0.0305356,0.04198,0.058631,0.574121,4657.66,1.18251e-37,False,inconclusive, +alibaba_v2022,rt_p99_by_service,"quantile by (service) (0.99, rt)",values,,300,,125647293,6,2.22251,2.22496,2.37091,,,0.386496,54,0.0305356,0.04198,0.058631,0.574121,4657.66,1.18251e-37,False,inconclusive, +alibaba_v2022,rt_p99_by_service,"quantile by (service) (0.99, rt)",values,,1800,,125647293,1,2.22496,2.22496,2.22496,,,0.386496,54,0.0305356,0.04198,0.058631,0.574121,4657.66,1.18251e-37,False,inconclusive, alibaba_v2022,ms_cpu_by_msname,sum by (msname) (cpu_utilization),keys,count,60,28159,13987704,30,0.826067,0.826138,0.82617,0.0164781,1.26917,,,,,,,,,,, alibaba_v2022,ms_cpu_by_msname,sum by (msname) (cpu_utilization),keys,value,60,28158,13987704,30,0.891051,0.893458,0.897012,0.0092067,1.6656,,,,,,,,,,, alibaba_v2022,ms_cpu_by_msname,sum by (msname) (cpu_utilization),keys,count,300,28159,13987704,6,0.8261,0.826138,0.826145,0.0164781,1.26917,,,,,,,,,,, @@ -68,26 +68,26 @@ alibaba_v2022,node_cpu_by_nodeid,sum by (nodeid) (cpu_utilization),keys,value,18 alibaba_v2022,node_cpu_p99,"quantile(0.99, cpu_utilization)",values,,60,,1228782,29,5.55533,5.88868,6.15762,,,4.72012e-05,0.355012,0.0153465,0.06211,-3.90752,0.0576593,71.8823,3.08632e-08,False,lognormal, alibaba_v2022,node_cpu_p99,"quantile(0.99, cpu_utilization)",values,,300,,1228782,6,5.69748,5.88868,5.99247,,,4.72012e-05,0.355012,0.0153465,0.06211,-3.90752,0.0576593,71.8823,3.08632e-08,False,lognormal, alibaba_v2022,node_cpu_p99,"quantile(0.99, cpu_utilization)",values,,1800,,1228782,1,5.88868,5.88868,5.88868,,,4.72012e-05,0.355012,0.0153465,0.06211,-3.90752,0.0576593,71.8823,3.08632e-08,False,lognormal, -boom,target_tail[ds-2187-H],"quantile(0.99, target)",values,,,100,523100,1000,1.83826,4.25548,6.2417,,,0.000191168,2.55269,0.0564534,0.0722753,-0.511853,0.405175,13.901,0.0635678,True,,0.5 +boom,target_tail[ds-2187-H],"quantile(0.99, target)",values,,,100,523100,0,,,,,,0.000191168,1.86372,0.0678309,0.0621415,-2.66997,0.0957456,7.26352,0.0103471,False,inconclusive,0.02 boom,target_tail[ds-2394-D],"quantile(0.99, target)",values,,,73,10001,0,,,,,,0.185881,,,,,,,,False,, -boom,target_tail[ds-1135-5T],"quantile(0.99, target)",values,,,26,425984,0,,,,,,0.549368,3.26443,0.106705,0.0519633,-34.771,0.00522338,-6.81313,0.0425655,False,lognormal,0.428571 +boom,target_tail[ds-1135-5T],"quantile(0.99, target)",values,,,26,425984,0,,,,,,0.549368,3.04047,0.0770813,0.0723464,-4.64396,0.0889076,2.50936,0.0851311,False,lognormal,0.0714286 boom,target_tail[ds-1833-D],"quantile(0.99, target)",values,,,17,3689,0,,,,,,0.239631,,,,,,,,False,, boom,target_tail[ds-2806-D],"quantile(0.99, target)",values,,,100,13700,0,,,,,,0.700365,,,,,,,,False,, -boom,target_tail[ds-2573-D],"quantile(0.99, target)",values,,,45,9765,0,4.39465,4.39465,4.39465,,,0.00798771,1.87847,0.169387,0.481481,-0.555623,0.314343,2.08433,0.234396,True,,0.6 -boom,target_tail[ds-2222-30T],"quantile(0.99, target)",values,,,100,1045600,692,5.12284,27.8931,45.4353,,,0.570518,3.90947,0.136929,0.0349965,-0.172378,0.350612,16.7272,1.14374e-14,True,,0.81 +boom,target_tail[ds-2573-D],"quantile(0.99, target)",values,,,45,9765,0,,,,,,0.00798771,2,0.196448,0.490608,-2.20309,0.169861,-1.48001,0.00529496,False,inconclusive,0.0222222 +boom,target_tail[ds-2222-30T],"quantile(0.99, target)",values,,,100,1045600,0,,,,,,0.570518,3.90768,0.142619,0.036589,-0.636215,0.359395,16.5504,3.04357e-15,False,inconclusive,0.23 boom,target_tail[ds-1914-30T],"quantile(0.99, target)",values,,,64,669504,0,,,,,,0.999177,,,,,,,,False,, -boom,target_tail[ds-2577-H],"quantile(0.99, target)",values,,,11,57541,0,,,,,,0.000191168,2.49525,0.0506031,0.270937,-8.53816,0.00348972,3.98324,0.365683,False,lognormal,0.454545 -boom,target_tail[ds-2212-D],"quantile(0.99, target)",values,,,42,9114,0,,,,,,0.205508,0.0171532,0.268598,0.5,-21.0003,0.000620382,-13.2558,0.000145154,False,lognormal,0.363636 +boom,target_tail[ds-2577-H],"quantile(0.99, target)",values,,,11,57541,0,,,,,,0.000191168,2.86054,0.0485189,0.123327,-3.68521,0.108043,5.58335,0.252722,False,inconclusive,0 +boom,target_tail[ds-2212-D],"quantile(0.99, target)",values,,,42,9114,0,,,,,,0.205508,0.108561,0.160336,0.481481,-13.3573,0.00217957,11.7339,0.00479764,False,lognormal,0 boom,target_tail[ds-2782-H],"quantile(0.99, target)",values,,,20,16500,0,,,,,,0.992364,,,,,,,,False,, -boom,target_tail[ds-1400-10S],"quantile(0.99, target)",values,,,75,1228800,0,,,,,,0.000139974,3.58167,0.0401948,0.113044,-11.3256,0.00374703,-3.37719,7.22762e-05,False,lognormal,0.4 -boom,target_tail[ds-2650-D],"quantile(0.99, target)",values,,,56,12152,0,2.52362,2.52362,2.52362,,,0.00477288,0.4255,0.0813898,0.481481,-1.1773,0.365167,11.8682,0.103707,True,,0.5 -boom,target_tail[ds-1316-10S],"quantile(0.99, target)",values,,,40,655360,420,1.34981,2.94518,2.9669,,,0.122093,2.43799,0.0396472,0.021441,-0.127417,0.605348,39.883,0.000108837,True,,0.525 -boom,target_tail[ds-1558-5T],"quantile(0.99, target)",values,,,97,1589248,1185,2.98708,5.76602,24.7461,,,0.197184,2.2767,0.0870426,0.220245,0.0176096,0.27179,130.926,3.24486e-07,True,,0.659794 +boom,target_tail[ds-1400-10S],"quantile(0.99, target)",values,,,75,1228800,0,,,,,,0.000139974,3.87737,0.0363198,0.092657,-3.81591,0.0601745,3.24,0.000648227,False,lognormal,0.0266667 +boom,target_tail[ds-2650-D],"quantile(0.99, target)",values,,,56,12152,0,,,,,,0.00477288,0.742612,0.131788,0.481481,-5.62187,0.100787,-3.08806,0.0629494,False,inconclusive,0 +boom,target_tail[ds-1316-10S],"quantile(0.99, target)",values,,,40,655360,0,,,,,,0.122093,2.27323,0.0380431,0.0316185,-1.52691,0.162568,48.8426,4.79386e-08,False,inconclusive,0 +boom,target_tail[ds-1558-5T],"quantile(0.99, target)",values,,,97,1589248,0,,,,,,0.197184,2.2767,0.124378,0.174525,-0.874186,0.159869,19.4441,2.12478e-06,False,inconclusive,0.195876 boom,target_tail[ds-1972-D],"quantile(0.99, target)",values,,,39,5343,0,,,,,,0.0557739,,,,,,,,False,, -boom,target_tail[ds-1840-D],"quantile(0.99, target)",values,,,100,21700,0,779.957,779.957,779.957,,,0.00465438,8.61433,0.355908,0.587963,-0.435604,0.505999,4.25879,0.00299889,True,,0.71 -boom,target_tail[ds-671-10S],"quantile(0.99, target)",values,,,100,1638400,1900,127.269,10151.9,28143.7,,,6.10352e-05,11.085,0.160838,0.0315571,,,,,True,,1 -boom,target_tail[ds-1524-5T],"quantile(0.99, target)",values,,,93,1267683,0,,,,,,0.944851,2.77447,0.137907,0.0781713,-10.2982,0.00465206,-8.15093,7.45138e-08,False,lognormal,0.470588 -boom,target_tail[ds-899-T],"quantile(0.99, target)",values,,,12,196608,96,2.36862,4.77602,4.77602,,,0.420344,3.31643,0.0820839,0.0530058,-0.412674,0.218355,64.5435,4.61242e-07,True,,0.666667 +boom,target_tail[ds-1840-D],"quantile(0.99, target)",values,,,100,21700,0,,,,,,0.00465438,8.38342,0.357878,0.587963,-15.6984,0.0157093,-0.485135,3.22441e-08,False,inconclusive,0 +boom,target_tail[ds-671-10S],"quantile(0.99, target)",values,,,100,1638400,0,,,,,,6.10352e-05,11.085,0.160838,0.0315571,,,,,False,inconclusive,0 +boom,target_tail[ds-1524-5T],"quantile(0.99, target)",values,,,93,1267683,0,,,,,,0.944851,2.87022,0.171058,0.154978,-2.0138,0.0819491,30.5114,2.10736e-05,False,inconclusive,0.0588235 +boom,target_tail[ds-899-T],"quantile(0.99, target)",values,,,12,196608,0,,,,,,0.420344,3.35591,0.0826745,0.0524982,-0.699821,0.165161,63.6559,3.49682e-07,False,inconclusive,0.0833333 google_2011,cpu_by_user,sum by (user) (cpu_rate),keys,count,300,518,2520773,17,1.22012,1.23997,1.27526,0.157436,2.33409,,,,,,,,,,, google_2011,cpu_by_user,sum by (user) (cpu_rate),keys,value,300,495,2520773,17,1.24604,1.30345,1.42414,0.1682,3.7868,,,,,,,,,,, google_2011,cpu_by_user,sum by (user) (cpu_rate),keys,count,900,518,2520773,7,1.22012,1.23997,1.25824,0.157436,2.33409,,,,,,,,,,, diff --git a/asap-tools/dataset-analysis/tests/test_fit_skew.py b/asap-tools/dataset-analysis/tests/test_fit_skew.py index e4daad13..2c9f1ec7 100644 --- a/asap-tools/dataset-analysis/tests/test_fit_skew.py +++ b/asap-tools/dataset-analysis/tests/test_fit_skew.py @@ -61,22 +61,48 @@ def test_recovers_pareto_alpha(self): alpha = shape + 1.0 # pdf exponent of a Pareto with this shape with self.subTest(alpha=alpha): x = rng.pareto(shape, PARETO_SAMPLES) + 1.0 - fit = fit_skew.fit_power_law(x, compare=True) + fit = fit_skew.fit_power_law(x, compare=False) self.assertAlmostEqual( fit["alpha"], alpha, delta=PARETO_REL_TOLERANCE * alpha ) - self.assertTrue(fit["power_law_ok"]) - self.assertEqual(fit["best_alt"], "") tail = np.sum(x >= fit["xmin"]) self.assertGreaterEqual(tail, fit_skew.MIN_TAIL_SAMPLES) + def test_exponential_and_lognormal_rejected(self): + samples = { + "exponential": np.random.default_rng(11).exponential(1.0, 20_000), + "lognormal": np.random.default_rng(12).lognormal(0.0, 1.0, 20_000), + } + for name, x in samples.items(): + with self.subTest(name): + fit = fit_skew.fit_power_law(x, compare=True) + self.assertFalse(fit["power_law_ok"]) + self.assertEqual(fit["best_alt"], name) + self.assertTrue(np.isfinite(fit["alpha"])) + + def test_pareto_beats_exponential_but_not_lognormal(self): + # A lognormal with large sigma mimics a power-law tail, so even an exact + # Pareto(alpha=2) cannot significantly beat it: the result is + # inconclusive rather than a pass. + x = np.random.default_rng(13).pareto(1.0, 20_000) + 1.0 + fit = fit_skew.fit_power_law(x, compare=True) + self.assertGreater(fit["R_exponential"], 0) + self.assertLess(fit["p_exponential"], fit_skew.COMPARE_P_THRESHOLD) + self.assertFalse(fit["power_law_ok"]) + self.assertEqual(fit["best_alt"], fit_skew.INCONCLUSIVE) + def test_best_alternative(self): best = fit_skew.best_alternative - # Not significant, or the power law wins: no better alternative. + # The power law significantly beats both alternatives. + self.assertEqual( + best({"lognormal": (2.0, 0.05), "exponential": (3.0, 0.01)}), "" + ) + # Winning one comparison without significance is not enough. self.assertEqual( - best({"lognormal": (-1.0, 0.5), "exponential": (3.0, 0.01)}), "" + best({"lognormal": (2.0, 0.5), "exponential": (3.0, 0.01)}), + fit_skew.INCONCLUSIVE, ) - self.assertEqual(best({}), "") + self.assertEqual(best({}), fit_skew.INCONCLUSIVE) self.assertEqual( best({"lognormal": (-1.0, 0.05), "exponential": (3.0, 0.01)}), "lognormal" ) @@ -86,13 +112,6 @@ def test_best_alternative(self): "exponential", ) - def test_losing_fit_still_reports_alpha(self): - # A pure lognormal loses to the lognormal alternative over the body. - x = np.random.default_rng(8).lognormal(0.0, 0.5, PARETO_SAMPLES) - fit = fit_skew.fit_power_law(x, compare=True) - self.assertTrue(np.isfinite(fit["alpha"])) - self.assertEqual(fit["power_law_ok"], fit["best_alt"] == "") - def test_xmin_grid(self): x = np.sort(np.random.default_rng(9).pareto(1.5, PARETO_SAMPLES) + 1.0) grid = fit_skew.xmin_candidates(x) From 0a3ca7975e2524f433e702c284fbce0ec39ed358 Mon Sep 17 00:00:00 2001 From: zz_y Date: Tue, 29 Sep 2026 19:23:30 +0000 Subject: [PATCH 5/8] feat(asap-tools): classify value tails instead of a pass/fail flag Replace power_law_ok and best_alt with tail_class (light, power_law, lognormal, heavy_inconclusive). BOOM series report the majority class, ok_frac as the share of non-light variates, and alpha and R/p medians over the non-light variates. Co-Authored-By: Claude Opus 5.5 --- asap-tools/dataset-analysis/README.md | 43 +-- asap-tools/dataset-analysis/fit_skew.py | 66 ++--- .../dataset-analysis/results/skew_summary.csv | 276 +++++++++--------- .../dataset-analysis/tests/test_fit_skew.py | 136 ++++----- 4 files changed, 264 insertions(+), 257 deletions(-) diff --git a/asap-tools/dataset-analysis/README.md b/asap-tools/dataset-analysis/README.md index d61da245..a2b5763b 100644 --- a/asap-tools/dataset-analysis/README.md +++ b/asap-tools/dataset-analysis/README.md @@ -104,21 +104,27 @@ Citations: subsampling (value queries). mle does not depend on the window length. BOOM has no timestamps in this analysis and keeps its 20 equal chunks per series (`window_len_s` is empty). -- **power_law_ok / best_alt**: the power law is compared with a lognormal - and an exponential (`distribution_compare`, likelihood ratio `R` and - p-value `p`). `power_law_ok` is true only if the power law significantly - beats both (`R > 0` and `p < 0.1` for each). Otherwise `best_alt` names the - alternative that is significantly better with the most negative `R`, or - `inconclusive` if neither is; α is still reported. `best_alt` is empty - when `power_law_ok` is true. A lognormal with large σ mimics a power-law - tail, so this rule rarely passes: even an exact Pareto(α=2) sample comes out - `inconclusive` (see the tests). +- **tail_class**: the power law is compared with an exponential and a + lognormal (`distribution_compare`, likelihood ratio `R` and p-value `p`; + significant means `p < 0.1`). `light` if the power law does not + significantly beat the exponential (`R > 0`); otherwise `power_law` if it + also significantly beats the lognormal, `lognormal` if it is significantly + worse than the lognormal (`R < 0`), else `heavy_inconclusive`. α is always + reported. Power law and lognormal are often indistinguishable: a lognormal + with large σ is nearly straight on a log-log plot over several decades, so + the likelihood-ratio test usually cannot separate them without far more + tail data than a trace provides (Clauset, Shalizi and Newman, "Power-law + distributions in empirical data", SIAM Review 2009). Even an exact + Pareto(α=2) sample of 20,000 values comes out `heavy_inconclusive` here. ## Output: `results/skew_summary.csv` One row per (query, kind, weight, window length). The sketch-bench saturation study reads `dataset, query_id, kind, weight, window_len_s, lower, mle, upper` to pick the θ and α -range it sweeps. +range it sweeps. For value rows it should use only rows whose `tail_class` is +not `light`: a light tail decays at least exponentially, so its α is just the +slope of whatever sliver of the tail the fit picked and does not describe a +power-law regime. | Column | Meaning | |---|---| @@ -134,8 +140,8 @@ range it sweeps. | `dropped_frac` | value rows: fraction of finite values that were ≤ 0 | | `xmin`, `ks_d`, `tail_frac` | value rows: fitted `xmin`, KS distance of the tail, and fraction of the fitted sample at or above `xmin` | | `R_lognormal`, `p_lognormal`, `R_exponential`, `p_exponential` | log-likelihood ratio (power law vs alternative) and its p-value | -| `power_law_ok`, `best_alt` | see Definitions | -| `ok_frac` | BOOM rows: share of variates with `power_law_ok` | +| `tail_class` | see Definitions (BOOM: majority class over variates) | +| `ok_frac` | BOOM rows: share of variates whose `tail_class` is not `light` | Plots in `out/`: `____rank___s.png` (log-log rank-frequency with the lower/mle/upper θ lines, one per window length) and @@ -151,13 +157,12 @@ rank-frequency with the lower/mle/upper θ lines, one per window length) and - **BOOM** strips tags and z-scores each variate, so there is no key θ and the raw value scale is lost. α is fitted per variate on `x - min(x)` - (zeros dropped). `ok_frac` is the share of compared variates with - `power_law_ok`. If `ok_frac >= 0.5`, the series row reports the medians - over the passing variates of each variate's lower, mle and upper, and the - diagnostics (`xmin`, `R`, `p`, ...) are medians over the same variates. If - `ok_frac < 0.5`, lower/mle/upper are empty, `power_law_ok` is false, - `best_alt` is the most common `best_alt` among the failing variates, and the - diagnostics are medians over the failing variates. + (zeros dropped), and each variate gets its own `tail_class`. The series + row reports the majority class and `ok_frac`, the share of variates that + are not `light`. lower/mle/upper are medians over the non-light variates of + each variate's lower, mle and upper, and the diagnostics (`xmin`, `R`, + `p`, ...) are medians over the same variates; all are empty if every + variate is light. - **Google join rule**: `task_usage` rows get `user`, `priority` and `scheduling_class` from the last non-null `task_events` value for the same `(job_id, task_index)`, and `logical_job_name` from the last non-null diff --git a/asap-tools/dataset-analysis/fit_skew.py b/asap-tools/dataset-analysis/fit_skew.py index d86a447d..d0f6aa8e 100644 --- a/asap-tools/dataset-analysis/fit_skew.py +++ b/asap-tools/dataset-analysis/fit_skew.py @@ -43,14 +43,15 @@ XMIN_GRID_SIZE = 50 XMIN_GRID_QUANTILES = (0.5, 0.999) MIN_TAIL_SAMPLES = 100 -# BOOM series report alpha only if at least this share of variates pass. -BOOM_MIN_OK_FRAC = 0.5 SAMPLE_SEED = 0 DEFAULT_MIN_WINDOW_ROWS = 200 DEFAULT_MIN_WINDOW_KEYS = 2 # A likelihood-ratio comparison is significant when its p is below this. COMPARE_P_THRESHOLD = 0.1 -INCONCLUSIVE = "inconclusive" +TAIL_LIGHT = "light" +TAIL_POWER_LAW = "power_law" +TAIL_LOGNORMAL = "lognormal" +TAIL_HEAVY_INCONCLUSIVE = "heavy_inconclusive" POWER_LAW_ALTERNATIVES = ("lognormal", "exponential") CSV_BLOCK_BYTES = 64 << 20 @@ -86,8 +87,7 @@ "p_lognormal", "R_exponential", "p_exponential", - "power_law_ok", - "best_alt", + "tail_class", "ok_frac", ] @@ -420,20 +420,22 @@ def subsample(x: np.ndarray) -> np.ndarray: return x[rng.choice(len(x), MAX_FIT_SAMPLES, replace=False)] -def best_alternative(comparisons: Dict[str, Tuple[float, float]]) -> str: - """'' if the power law significantly beats every alternative (R > 0 with - small p); otherwise the alternative significantly better than it with the - most negative R, or 'inconclusive' if none is significantly better.""" - if comparisons and all( - r > 0 and p < COMPARE_P_THRESHOLD for r, p in comparisons.values() - ): - return "" - better = { - alt: r - for alt, (r, p) in comparisons.items() - if r < 0 and p < COMPARE_P_THRESHOLD - } - return min(better, key=lambda alt: better[alt]) if better else INCONCLUSIVE +def significant(comparison: Tuple[float, float], sign: int) -> bool: + """Whether (R, p) favors the power law (sign=1) or the alternative (sign=-1).""" + ratio, p = comparison + return ratio * sign > 0 and p < COMPARE_P_THRESHOLD + + +def tail_class(comparisons: Dict[str, Tuple[float, float]]) -> str: + """light unless the power law significantly beats the exponential; then + power_law or lognormal by whichever significantly wins, else inconclusive.""" + if not significant(comparisons["exponential"], 1): + return TAIL_LIGHT + if significant(comparisons["lognormal"], 1): + return TAIL_POWER_LAW + if significant(comparisons["lognormal"], -1): + return TAIL_LOGNORMAL + return TAIL_HEAVY_INCONCLUSIVE def xmin_candidates(x_sorted: np.ndarray) -> np.ndarray: @@ -477,8 +479,7 @@ def fit_power_law(x: np.ndarray, compare: bool) -> Dict[str, Any]: ratio, p = fit.distribution_compare("power_law", alt) result[f"R_{alt}"], result[f"p_{alt}"] = ratio, p comparisons[alt] = (ratio, p) - result["best_alt"] = best_alternative(comparisons) - result["power_law_ok"] = not result["best_alt"] + result["tail_class"] = tail_class(comparisons) return result @@ -752,8 +753,8 @@ def summarize_boom_series( fits: List[Dict[str, Any]], plot_dir: Optional[Path], ) -> Dict[str, Any]: - """Medians over the passing variates if at least BOOM_MIN_OK_FRAC of the - compared variates pass; otherwise no alpha and medians over the failing ones.""" + """Majority tail class over the variates; alpha and diagnostics are medians + over the non-light variates, empty if every variate is light.""" full: Dict[int, Dict[str, Any]] = {} samples: Dict[int, np.ndarray] = {} chunk_alphas: Dict[int, List[float]] = {v: [] for v in range(len(shifted))} @@ -762,11 +763,10 @@ def summarize_boom_series( full[v], samples[v] = fit, x else: chunk_alphas[v].append(fit["alpha"]) - compared = [v for v, f in full.items() if "power_law_ok" in f] - passing = [v for v in compared if full[v]["power_law_ok"]] - ok_frac = len(passing) / len(compared) if compared else np.nan - ok = bool(compared) and ok_frac >= BOOM_MIN_OK_FRAC - chosen = passing if ok else [v for v in compared if v not in passing] + classes = [f["tail_class"] for f in full.values() if "tail_class" in f] + chosen = [ + v for v, f in full.items() if f.get("tail_class", TAIL_LIGHT) != TAIL_LIGHT + ] finite = int(np.isfinite(shifted).sum()) row: Dict[str, Any] = { "dataset": dataset, @@ -777,22 +777,18 @@ def summarize_boom_series( "K": len(shifted), "rows": finite, "dropped_frac": 1.0 - np.sum(shifted > 0) / finite, - "power_law_ok": ok, - "ok_frac": ok_frac, + "tail_class": max(sorted(set(classes)), key=classes.count) if classes else "", + "ok_frac": len(chosen) / len(classes) if classes else np.nan, "n_windows": 0, } - if ok: + if chosen: bounds = [window_bounds(chunk_alphas[v], full[v]["alpha"]) for v in chosen] row.update( n_windows=sum(b[2] for b in bounds), lower=median_or_nan([b[0] for b in bounds]), mle=median_or_nan([full[v]["alpha"] for v in chosen]), upper=median_or_nan([b[1] for b in bounds]), - best_alt="", ) - elif chosen: - alts = [full[v]["best_alt"] for v in chosen] - row["best_alt"] = max(sorted(set(alts)), key=alts.count) for col in ("xmin", "ks_d", "tail_frac") + tuple( f"{k}_{alt}" for alt in POWER_LAW_ALTERNATIVES for k in ("R", "p") ): diff --git a/asap-tools/dataset-analysis/results/skew_summary.csv b/asap-tools/dataset-analysis/results/skew_summary.csv index 7d3f10d5..8422d58c 100644 --- a/asap-tools/dataset-analysis/results/skew_summary.csv +++ b/asap-tools/dataset-analysis/results/skew_summary.csv @@ -1,138 +1,138 @@ -dataset,query_id,promql,kind,weight,window_len_s,K,rows,n_windows,lower,mle,upper,top1_share,theta_ls,dropped_frac,xmin,ks_d,tail_frac,R_lognormal,p_lognormal,R_exponential,p_exponential,power_law_ok,best_alt,ok_frac -alibaba_v2022,mcr_by_msname,sum by (msname) (providerrpc_mcr),keys,count,60,26077,90315535,30,1.34145,1.53568,1.90045,0.551844,1.35882,,,,,,,,,,, -alibaba_v2022,mcr_by_msname,sum by (msname) (providerrpc_mcr),keys,value,60,17911,90315535,30,1.02886,1.11054,1.30697,0.18365,3.6235,,,,,,,,,,, -alibaba_v2022,mcr_by_msname,sum by (msname) (providerrpc_mcr),keys,count,300,26077,90315535,6,1.45905,1.53568,1.66474,0.551844,1.35882,,,,,,,,,,, -alibaba_v2022,mcr_by_msname,sum by (msname) (providerrpc_mcr),keys,value,300,17911,90315535,6,1.07345,1.11054,1.18124,0.18365,3.6235,,,,,,,,,,, -alibaba_v2022,mcr_by_msname,sum by (msname) (providerrpc_mcr),keys,count,1800,26077,90315535,1,1.53568,1.53568,1.53568,0.551844,1.35882,,,,,,,,,,, -alibaba_v2022,mcr_by_msname,sum by (msname) (providerrpc_mcr),keys,value,1800,17911,90315535,1,1.11054,1.11054,1.11054,0.18365,3.6235,,,,,,,,,,, -alibaba_v2022,mcr_by_nodeid,sum by (nodeid) (providerrpc_mcr),keys,count,60,30776,90315535,30,1.06962,1.1256,1.22637,0.0299395,0.671771,,,,,,,,,,, -alibaba_v2022,mcr_by_nodeid,sum by (nodeid) (providerrpc_mcr),keys,value,60,28319,90315535,30,0.629764,0.760365,0.985563,0.0103042,0.905303,,,,,,,,,,, -alibaba_v2022,mcr_by_nodeid,sum by (nodeid) (providerrpc_mcr),keys,count,300,30776,90315535,6,1.11474,1.1256,1.17579,0.0299395,0.671771,,,,,,,,,,, -alibaba_v2022,mcr_by_nodeid,sum by (nodeid) (providerrpc_mcr),keys,value,300,28319,90315535,6,0.711785,0.760365,0.858603,0.0103042,0.905303,,,,,,,,,,, -alibaba_v2022,mcr_by_nodeid,sum by (nodeid) (providerrpc_mcr),keys,count,1800,30776,90315535,1,1.1256,1.1256,1.1256,0.0299395,0.671771,,,,,,,,,,, -alibaba_v2022,mcr_by_nodeid,sum by (nodeid) (providerrpc_mcr),keys,value,1800,28319,90315535,1,0.760365,0.760365,0.760365,0.0103042,0.905303,,,,,,,,,,, -alibaba_v2022,rt_p99_by_msname,"quantile by (msname) (0.99, providerrpc_rt)",keys,count,60,26077,90315535,30,1.34145,1.53568,1.90045,0.551844,1.35882,,,,,,,,,,, -alibaba_v2022,rt_p99_by_msname,"quantile by (msname) (0.99, providerrpc_rt)",keys,value,60,17879,90315535,30,1.55788,2.06565,2.86274,0.883125,2.23262,,,,,,,,,,, -alibaba_v2022,rt_p99_by_msname,"quantile by (msname) (0.99, providerrpc_rt)",keys,count,300,26077,90315535,6,1.45905,1.53568,1.66474,0.551844,1.35882,,,,,,,,,,, -alibaba_v2022,rt_p99_by_msname,"quantile by (msname) (0.99, providerrpc_rt)",keys,value,300,17879,90315535,6,1.91457,2.06565,2.26485,0.883125,2.23262,,,,,,,,,,, -alibaba_v2022,rt_p99_by_msname,"quantile by (msname) (0.99, providerrpc_rt)",keys,count,1800,26077,90315535,1,1.53568,1.53568,1.53568,0.551844,1.35882,,,,,,,,,,, -alibaba_v2022,rt_p99_by_msname,"quantile by (msname) (0.99, providerrpc_rt)",keys,value,1800,17879,90315535,1,2.06565,2.06565,2.06565,0.883125,2.23262,,,,,,,,,,, -alibaba_v2022,rt_p99_by_msname,"quantile by (msname) (0.99, providerrpc_rt)",values,,60,,90315535,30,2.26083,9.48921,19.3664,,,0.0733479,104.752,0.0722386,0.33763,20.9205,1.58403e-24,33305.7,0.0400746,True,, -alibaba_v2022,rt_p99_by_msname,"quantile by (msname) (0.99, providerrpc_rt)",values,,300,,90315535,6,2.69795,9.48921,9.48921,,,0.0733479,104.752,0.0722386,0.33763,20.9205,1.58403e-24,33305.7,0.0400746,True,, -alibaba_v2022,rt_p99_by_msname,"quantile by (msname) (0.99, providerrpc_rt)",values,,1800,,90315535,1,9.48921,9.48921,9.48921,,,0.0733479,104.752,0.0722386,0.33763,20.9205,1.58403e-24,33305.7,0.0400746,True,, -alibaba_v2022,calls_by_rpctype,count by (rpctype) (rt),keys,count,60,6,127635817,30,1.25893,1.3204,1.38466,0.426987,2.23811,,,,,,,,,,, -alibaba_v2022,calls_by_rpctype,count by (rpctype) (rt),keys,count,300,6,127635817,6,1.29467,1.3204,1.33952,0.426987,2.23811,,,,,,,,,,, -alibaba_v2022,calls_by_rpctype,count by (rpctype) (rt),keys,count,1800,6,127635817,1,1.3204,1.3204,1.3204,0.426987,2.23811,,,,,,,,,,, -alibaba_v2022,calls_by_service,count by (service) (rt),keys,count,60,399933,127635817,30,0.999766,1.0731,1.0731,0.0388438,1.59871,,,,,,,,,,, -alibaba_v2022,calls_by_service,count by (service) (rt),keys,count,300,399933,127635817,6,1.03815,1.0731,1.0731,0.0388438,1.59871,,,,,,,,,,, -alibaba_v2022,calls_by_service,count by (service) (rt),keys,count,1800,399933,127635817,1,1.0731,1.0731,1.0731,0.0388438,1.59871,,,,,,,,,,, -alibaba_v2022,calls_by_um,count by (um) (rt),keys,count,60,15063,127635817,30,1.11269,1.14611,1.14611,0.128004,2.68552,,,,,,,,,,, -alibaba_v2022,calls_by_um,count by (um) (rt),keys,count,300,15063,127635817,6,1.13005,1.14611,1.14611,0.128004,2.68552,,,,,,,,,,, -alibaba_v2022,calls_by_um,count by (um) (rt),keys,count,1800,15063,127635817,1,1.14611,1.14611,1.14611,0.128004,2.68552,,,,,,,,,,, -alibaba_v2022,calls_by_dm,count by (dm) (rt),keys,count,60,25155,127635817,30,1.09664,1.12579,1.12579,0.0709133,2.60259,,,,,,,,,,, -alibaba_v2022,calls_by_dm,count by (dm) (rt),keys,count,300,25155,127635817,6,1.11312,1.12579,1.12579,0.0709133,2.60259,,,,,,,,,,, -alibaba_v2022,calls_by_dm,count by (dm) (rt),keys,count,1800,25155,127635817,1,1.12579,1.12579,1.12579,0.0709133,2.60259,,,,,,,,,,, -alibaba_v2022,calls_by_interface,count by (interface) (rt),keys,count,60,1.19888e+06,127635817,30,0.989149,1.06008,1.06008,0.0259165,1.28963,,,,,,,,,,, -alibaba_v2022,calls_by_interface,count by (interface) (rt),keys,count,300,1.19888e+06,127635817,6,1.02446,1.06008,1.06008,0.0259165,1.28963,,,,,,,,,,, -alibaba_v2022,calls_by_interface,count by (interface) (rt),keys,count,1800,1.19888e+06,127635817,1,1.06008,1.06008,1.06008,0.0259165,1.28963,,,,,,,,,,, -alibaba_v2022,calls_by_um_dm,"count by (um, dm) (rt)",keys,count,60,99257,127635817,30,0.976609,1.02162,1.02162,0.0262826,2.34181,,,,,,,,,,, -alibaba_v2022,calls_by_um_dm,"count by (um, dm) (rt)",keys,count,300,99257,127635817,6,0.998943,1.02162,1.02162,0.0262826,2.34181,,,,,,,,,,, -alibaba_v2022,calls_by_um_dm,"count by (um, dm) (rt)",keys,count,1800,99257,127635817,1,1.02162,1.02162,1.02162,0.0262826,2.34181,,,,,,,,,,, -alibaba_v2022,calls_by_service_um_dm,"count by (service, um, dm) (rt)",keys,count,60,1.27135e+06,127635817,30,0.91038,0.981876,0.981876,0.010094,1.68258,,,,,,,,,,, -alibaba_v2022,calls_by_service_um_dm,"count by (service, um, dm) (rt)",keys,count,300,1.27135e+06,127635817,6,0.945969,0.981876,0.981876,0.010094,1.68258,,,,,,,,,,, -alibaba_v2022,calls_by_service_um_dm,"count by (service, um, dm) (rt)",keys,count,1800,1.27135e+06,127635817,1,0.981876,0.981876,0.981876,0.010094,1.68258,,,,,,,,,,, -alibaba_v2022,rt_p99_by_service,"quantile by (service) (0.99, rt)",keys,count,60,399933,127635817,30,0.999766,1.0731,1.0731,0.0388438,1.59871,,,,,,,,,,, -alibaba_v2022,rt_p99_by_service,"quantile by (service) (0.99, rt)",keys,value,60,313796,127635817,30,1.12843,1.17197,1.18869,0.241919,2.3833,,,,,,,,,,, -alibaba_v2022,rt_p99_by_service,"quantile by (service) (0.99, rt)",keys,count,300,399933,127635817,6,1.03815,1.0731,1.0731,0.0388438,1.59871,,,,,,,,,,, -alibaba_v2022,rt_p99_by_service,"quantile by (service) (0.99, rt)",keys,value,300,313796,127635817,6,1.149,1.17197,1.17378,0.241919,2.3833,,,,,,,,,,, -alibaba_v2022,rt_p99_by_service,"quantile by (service) (0.99, rt)",keys,count,1800,399933,127635817,1,1.0731,1.0731,1.0731,0.0388438,1.59871,,,,,,,,,,, -alibaba_v2022,rt_p99_by_service,"quantile by (service) (0.99, rt)",keys,value,1800,313796,127635817,1,1.17197,1.17197,1.17197,0.241919,2.3833,,,,,,,,,,, -alibaba_v2022,rt_p99_by_service,"quantile by (service) (0.99, rt)",values,,60,,125647293,30,2.10507,2.22496,2.39368,,,0.386496,54,0.0305356,0.04198,0.058631,0.574121,4657.66,1.18251e-37,False,inconclusive, -alibaba_v2022,rt_p99_by_service,"quantile by (service) (0.99, rt)",values,,300,,125647293,6,2.22251,2.22496,2.37091,,,0.386496,54,0.0305356,0.04198,0.058631,0.574121,4657.66,1.18251e-37,False,inconclusive, -alibaba_v2022,rt_p99_by_service,"quantile by (service) (0.99, rt)",values,,1800,,125647293,1,2.22496,2.22496,2.22496,,,0.386496,54,0.0305356,0.04198,0.058631,0.574121,4657.66,1.18251e-37,False,inconclusive, -alibaba_v2022,ms_cpu_by_msname,sum by (msname) (cpu_utilization),keys,count,60,28159,13987704,30,0.826067,0.826138,0.82617,0.0164781,1.26917,,,,,,,,,,, -alibaba_v2022,ms_cpu_by_msname,sum by (msname) (cpu_utilization),keys,value,60,28158,13987704,30,0.891051,0.893458,0.897012,0.0092067,1.6656,,,,,,,,,,, -alibaba_v2022,ms_cpu_by_msname,sum by (msname) (cpu_utilization),keys,count,300,28159,13987704,6,0.8261,0.826138,0.826145,0.0164781,1.26917,,,,,,,,,,, -alibaba_v2022,ms_cpu_by_msname,sum by (msname) (cpu_utilization),keys,value,300,28158,13987704,6,0.891446,0.893458,0.895369,0.0092067,1.6656,,,,,,,,,,, -alibaba_v2022,ms_cpu_by_msname,sum by (msname) (cpu_utilization),keys,count,1800,28159,13987704,1,0.826138,0.826138,0.826138,0.0164781,1.26917,,,,,,,,,,, -alibaba_v2022,ms_cpu_by_msname,sum by (msname) (cpu_utilization),keys,value,1800,28158,13987704,1,0.893458,0.893458,0.893458,0.0092067,1.6656,,,,,,,,,,, -alibaba_v2022,ms_cpu_p99,"quantile(0.99, cpu_utilization)",values,,60,,13987704,30,3.12623,5.54219,7.13806,,,2.97404e-05,0.462804,0.0489465,0.03156,-76.2721,2.03777e-16,-76.0488,9.72424e-30,False,lognormal, -alibaba_v2022,ms_cpu_p99,"quantile(0.99, cpu_utilization)",values,,300,,13987704,6,5.24142,5.54219,6.13548,,,2.97404e-05,0.462804,0.0489465,0.03156,-76.2721,2.03777e-16,-76.0488,9.72424e-30,False,lognormal, -alibaba_v2022,ms_cpu_p99,"quantile(0.99, cpu_utilization)",values,,1800,,13987704,1,5.54219,5.54219,5.54219,,,2.97404e-05,0.462804,0.0489465,0.03156,-76.2721,2.03777e-16,-76.0488,9.72424e-30,False,lognormal, -alibaba_v2022,node_cpu_by_nodeid,sum by (nodeid) (cpu_utilization),keys,count,60,42554,1228782,29,3.68585e-06,0.00427455,0.00427455,2.36006e-05,0.00882373,,,,,,,,,,, -alibaba_v2022,node_cpu_by_nodeid,sum by (nodeid) (cpu_utilization),keys,value,60,42552,1228782,29,0.302619,0.302619,0.32804,0.000107701,0.374094,,,,,,,,,,, -alibaba_v2022,node_cpu_by_nodeid,sum by (nodeid) (cpu_utilization),keys,count,300,42554,1228782,6,0.00173761,0.00427455,0.00427455,2.36006e-05,0.00882373,,,,,,,,,,, -alibaba_v2022,node_cpu_by_nodeid,sum by (nodeid) (cpu_utilization),keys,value,300,42552,1228782,6,0.302619,0.302619,0.311077,0.000107701,0.374094,,,,,,,,,,, -alibaba_v2022,node_cpu_by_nodeid,sum by (nodeid) (cpu_utilization),keys,count,1800,42554,1228782,1,0.00427455,0.00427455,0.00427455,2.36006e-05,0.00882373,,,,,,,,,,, -alibaba_v2022,node_cpu_by_nodeid,sum by (nodeid) (cpu_utilization),keys,value,1800,42552,1228782,1,0.302619,0.302619,0.302619,0.000107701,0.374094,,,,,,,,,,, -alibaba_v2022,node_cpu_p99,"quantile(0.99, cpu_utilization)",values,,60,,1228782,29,5.55533,5.88868,6.15762,,,4.72012e-05,0.355012,0.0153465,0.06211,-3.90752,0.0576593,71.8823,3.08632e-08,False,lognormal, -alibaba_v2022,node_cpu_p99,"quantile(0.99, cpu_utilization)",values,,300,,1228782,6,5.69748,5.88868,5.99247,,,4.72012e-05,0.355012,0.0153465,0.06211,-3.90752,0.0576593,71.8823,3.08632e-08,False,lognormal, -alibaba_v2022,node_cpu_p99,"quantile(0.99, cpu_utilization)",values,,1800,,1228782,1,5.88868,5.88868,5.88868,,,4.72012e-05,0.355012,0.0153465,0.06211,-3.90752,0.0576593,71.8823,3.08632e-08,False,lognormal, -boom,target_tail[ds-2187-H],"quantile(0.99, target)",values,,,100,523100,0,,,,,,0.000191168,1.86372,0.0678309,0.0621415,-2.66997,0.0957456,7.26352,0.0103471,False,inconclusive,0.02 -boom,target_tail[ds-2394-D],"quantile(0.99, target)",values,,,73,10001,0,,,,,,0.185881,,,,,,,,False,, -boom,target_tail[ds-1135-5T],"quantile(0.99, target)",values,,,26,425984,0,,,,,,0.549368,3.04047,0.0770813,0.0723464,-4.64396,0.0889076,2.50936,0.0851311,False,lognormal,0.0714286 -boom,target_tail[ds-1833-D],"quantile(0.99, target)",values,,,17,3689,0,,,,,,0.239631,,,,,,,,False,, -boom,target_tail[ds-2806-D],"quantile(0.99, target)",values,,,100,13700,0,,,,,,0.700365,,,,,,,,False,, -boom,target_tail[ds-2573-D],"quantile(0.99, target)",values,,,45,9765,0,,,,,,0.00798771,2,0.196448,0.490608,-2.20309,0.169861,-1.48001,0.00529496,False,inconclusive,0.0222222 -boom,target_tail[ds-2222-30T],"quantile(0.99, target)",values,,,100,1045600,0,,,,,,0.570518,3.90768,0.142619,0.036589,-0.636215,0.359395,16.5504,3.04357e-15,False,inconclusive,0.23 -boom,target_tail[ds-1914-30T],"quantile(0.99, target)",values,,,64,669504,0,,,,,,0.999177,,,,,,,,False,, -boom,target_tail[ds-2577-H],"quantile(0.99, target)",values,,,11,57541,0,,,,,,0.000191168,2.86054,0.0485189,0.123327,-3.68521,0.108043,5.58335,0.252722,False,inconclusive,0 -boom,target_tail[ds-2212-D],"quantile(0.99, target)",values,,,42,9114,0,,,,,,0.205508,0.108561,0.160336,0.481481,-13.3573,0.00217957,11.7339,0.00479764,False,lognormal,0 -boom,target_tail[ds-2782-H],"quantile(0.99, target)",values,,,20,16500,0,,,,,,0.992364,,,,,,,,False,, -boom,target_tail[ds-1400-10S],"quantile(0.99, target)",values,,,75,1228800,0,,,,,,0.000139974,3.87737,0.0363198,0.092657,-3.81591,0.0601745,3.24,0.000648227,False,lognormal,0.0266667 -boom,target_tail[ds-2650-D],"quantile(0.99, target)",values,,,56,12152,0,,,,,,0.00477288,0.742612,0.131788,0.481481,-5.62187,0.100787,-3.08806,0.0629494,False,inconclusive,0 -boom,target_tail[ds-1316-10S],"quantile(0.99, target)",values,,,40,655360,0,,,,,,0.122093,2.27323,0.0380431,0.0316185,-1.52691,0.162568,48.8426,4.79386e-08,False,inconclusive,0 -boom,target_tail[ds-1558-5T],"quantile(0.99, target)",values,,,97,1589248,0,,,,,,0.197184,2.2767,0.124378,0.174525,-0.874186,0.159869,19.4441,2.12478e-06,False,inconclusive,0.195876 -boom,target_tail[ds-1972-D],"quantile(0.99, target)",values,,,39,5343,0,,,,,,0.0557739,,,,,,,,False,, -boom,target_tail[ds-1840-D],"quantile(0.99, target)",values,,,100,21700,0,,,,,,0.00465438,8.38342,0.357878,0.587963,-15.6984,0.0157093,-0.485135,3.22441e-08,False,inconclusive,0 -boom,target_tail[ds-671-10S],"quantile(0.99, target)",values,,,100,1638400,0,,,,,,6.10352e-05,11.085,0.160838,0.0315571,,,,,False,inconclusive,0 -boom,target_tail[ds-1524-5T],"quantile(0.99, target)",values,,,93,1267683,0,,,,,,0.944851,2.87022,0.171058,0.154978,-2.0138,0.0819491,30.5114,2.10736e-05,False,inconclusive,0.0588235 -boom,target_tail[ds-899-T],"quantile(0.99, target)",values,,,12,196608,0,,,,,,0.420344,3.35591,0.0826745,0.0524982,-0.699821,0.165161,63.6559,3.49682e-07,False,inconclusive,0.0833333 -google_2011,cpu_by_user,sum by (user) (cpu_rate),keys,count,300,518,2520773,17,1.22012,1.23997,1.27526,0.157436,2.33409,,,,,,,,,,, -google_2011,cpu_by_user,sum by (user) (cpu_rate),keys,value,300,495,2520773,17,1.24604,1.30345,1.42414,0.1682,3.7868,,,,,,,,,,, -google_2011,cpu_by_user,sum by (user) (cpu_rate),keys,count,900,518,2520773,7,1.22012,1.23997,1.25824,0.157436,2.33409,,,,,,,,,,, -google_2011,cpu_by_user,sum by (user) (cpu_rate),keys,value,900,495,2520773,7,1.24604,1.30345,1.36946,0.1682,3.7868,,,,,,,,,,, -google_2011,cpu_by_user,sum by (user) (cpu_rate),keys,count,3600,518,2520773,2,1.2314,1.23997,1.24591,0.157436,2.33409,,,,,,,,,,, -google_2011,cpu_by_user,sum by (user) (cpu_rate),keys,value,3600,495,2520773,2,1.299,1.30345,1.30858,0.1682,3.7868,,,,,,,,,,, -google_2011,cpu_by_user_priority,"sum by (user, priority) (cpu_rate)",keys,count,300,869,2520773,17,1.22497,1.24584,1.27931,0.151999,2.11869,,,,,,,,,,, -google_2011,cpu_by_user_priority,"sum by (user, priority) (cpu_rate)",keys,value,300,840,2520773,17,1.26988,1.32416,1.43661,0.168118,3.41093,,,,,,,,,,, -google_2011,cpu_by_user_priority,"sum by (user, priority) (cpu_rate)",keys,count,900,869,2520773,7,1.22497,1.24584,1.26245,0.151999,2.11869,,,,,,,,,,, -google_2011,cpu_by_user_priority,"sum by (user, priority) (cpu_rate)",keys,value,900,840,2520773,7,1.26988,1.32416,1.38497,0.168118,3.41093,,,,,,,,,,, -google_2011,cpu_by_user_priority,"sum by (user, priority) (cpu_rate)",keys,count,3600,869,2520773,2,1.23706,1.24584,1.25092,0.151999,2.11869,,,,,,,,,,, -google_2011,cpu_by_user_priority,"sum by (user, priority) (cpu_rate)",keys,value,3600,840,2520773,2,1.31927,1.32416,1.32812,0.168118,3.41093,,,,,,,,,,, -google_2011,cpu_by_priority,sum by (priority) (cpu_rate),keys,count,300,7,2520773,17,1.0334,1.10046,1.17431,0.32255,1.89497,,,,,,,,,,, -google_2011,cpu_by_priority,sum by (priority) (cpu_rate),keys,value,300,7,2520773,17,1.43865,1.60501,1.75174,0.536005,2.03241,,,,,,,,,,, -google_2011,cpu_by_priority,sum by (priority) (cpu_rate),keys,count,900,7,2520773,7,1.06809,1.10046,1.17431,0.32255,1.89497,,,,,,,,,,, -google_2011,cpu_by_priority,sum by (priority) (cpu_rate),keys,value,900,7,2520773,7,1.49898,1.60501,1.7108,0.536005,2.03241,,,,,,,,,,, -google_2011,cpu_by_priority,sum by (priority) (cpu_rate),keys,count,3600,7,2520773,2,1.08297,1.10046,1.1272,0.32255,1.89497,,,,,,,,,,, -google_2011,cpu_by_priority,sum by (priority) (cpu_rate),keys,value,3600,7,2520773,2,1.59355,1.60501,1.64514,0.536005,2.03241,,,,,,,,,,, -google_2011,cpu_by_job_id,sum by (job_id) (cpu_rate),keys,count,300,4852,2520773,17,1.1028,1.1028,1.1396,0.138099,1.68596,,,,,,,,,,, -google_2011,cpu_by_job_id,sum by (job_id) (cpu_rate),keys,value,300,4741,2520773,17,1.14258,1.14339,1.22505,0.0488375,2.91631,,,,,,,,,,, -google_2011,cpu_by_job_id,sum by (job_id) (cpu_rate),keys,count,900,4852,2520773,7,1.1028,1.1028,1.11909,0.138099,1.68596,,,,,,,,,,, -google_2011,cpu_by_job_id,sum by (job_id) (cpu_rate),keys,value,900,4741,2520773,7,1.14339,1.14339,1.2012,0.0488375,2.91631,,,,,,,,,,, -google_2011,cpu_by_job_id,sum by (job_id) (cpu_rate),keys,count,3600,4852,2520773,2,1.1028,1.1028,1.11042,0.138099,1.68596,,,,,,,,,,, -google_2011,cpu_by_job_id,sum by (job_id) (cpu_rate),keys,value,3600,4741,2520773,2,1.14299,1.14339,1.17023,0.0488375,2.91631,,,,,,,,,,, -google_2011,cpu_by_logical_job_name,sum by (logical_job_name) (cpu_rate),keys,count,300,4076,2520773,17,1.10016,1.10016,1.13977,0.138099,1.67481,,,,,,,,,,, -google_2011,cpu_by_logical_job_name,sum by (logical_job_name) (cpu_rate),keys,value,300,3994,2520773,17,1.13736,1.13736,1.22246,0.0488375,2.95553,,,,,,,,,,, -google_2011,cpu_by_logical_job_name,sum by (logical_job_name) (cpu_rate),keys,count,900,4076,2520773,7,1.10016,1.10016,1.11896,0.138099,1.67481,,,,,,,,,,, -google_2011,cpu_by_logical_job_name,sum by (logical_job_name) (cpu_rate),keys,value,900,3994,2520773,7,1.13736,1.13736,1.19819,0.0488375,2.95553,,,,,,,,,,, -google_2011,cpu_by_logical_job_name,sum by (logical_job_name) (cpu_rate),keys,count,3600,4076,2520773,2,1.10016,1.10016,1.11033,0.138099,1.67481,,,,,,,,,,, -google_2011,cpu_by_logical_job_name,sum by (logical_job_name) (cpu_rate),keys,value,3600,3994,2520773,2,1.13736,1.13736,1.16633,0.0488375,2.95553,,,,,,,,,,, -google_2011,cpu_by_scheduling_class,sum by (scheduling_class) (cpu_rate),keys,count,300,4,2520773,17,0.409689,0.582621,0.758605,0.381155,0.574297,,,,,,,,,,, -google_2011,cpu_by_scheduling_class,sum by (scheduling_class) (cpu_rate),keys,value,300,4,2520773,17,0.373199,0.429641,0.984739,0.306212,0.565076,,,,,,,,,,, -google_2011,cpu_by_scheduling_class,sum by (scheduling_class) (cpu_rate),keys,count,900,4,2520773,7,0.409689,0.582621,0.688766,0.381155,0.574297,,,,,,,,,,, -google_2011,cpu_by_scheduling_class,sum by (scheduling_class) (cpu_rate),keys,value,900,4,2520773,7,0.385382,0.429641,0.750656,0.306212,0.565076,,,,,,,,,,, -google_2011,cpu_by_scheduling_class,sum by (scheduling_class) (cpu_rate),keys,count,3600,4,2520773,2,0.509008,0.582621,0.632622,0.381155,0.574297,,,,,,,,,,, -google_2011,cpu_by_scheduling_class,sum by (scheduling_class) (cpu_rate),keys,value,3600,4,2520773,2,0.429641,0.429641,0.515166,0.306212,0.565076,,,,,,,,,,, -google_2011,cpu_by_machine_id,sum by (machine_id) (cpu_rate),keys,count,300,12478,2520773,17,0.207643,0.207643,0.246048,0.000191211,0.252654,,,,,,,,,,, -google_2011,cpu_by_machine_id,sum by (machine_id) (cpu_rate),keys,value,300,12477,2520773,17,0.286387,0.286387,0.354508,0.000345691,0.399985,,,,,,,,,,, -google_2011,cpu_by_machine_id,sum by (machine_id) (cpu_rate),keys,count,900,12478,2520773,7,0.207643,0.207643,0.238947,0.000191211,0.252654,,,,,,,,,,, -google_2011,cpu_by_machine_id,sum by (machine_id) (cpu_rate),keys,value,900,12477,2520773,7,0.286387,0.286387,0.352387,0.000345691,0.399985,,,,,,,,,,, -google_2011,cpu_by_machine_id,sum by (machine_id) (cpu_rate),keys,count,3600,12478,2520773,2,0.207112,0.207643,0.215858,0.000191211,0.252654,,,,,,,,,,, -google_2011,cpu_by_machine_id,sum by (machine_id) (cpu_rate),keys,value,3600,12477,2520773,2,0.284414,0.286387,0.31254,0.000345691,0.399985,,,,,,,,,,, -google_2011,cpu_p99,"quantile(0.99, cpu_rate)",values,,300,,2520773,17,2.60391,2.9174,14.4531,,,0.095295,0.04578,0.0423316,0.14383,-46.9071,3.19362e-13,851.96,6.06387e-88,False,lognormal, -google_2011,cpu_p99,"quantile(0.99, cpu_rate)",values,,900,,2520773,7,2.67306,2.9174,3.34021,,,0.095295,0.04578,0.0423316,0.14383,-46.9071,3.19362e-13,851.96,6.06387e-88,False,lognormal, -google_2011,cpu_p99,"quantile(0.99, cpu_rate)",values,,3600,,2520773,2,2.84976,2.9174,2.9174,,,0.095295,0.04578,0.0423316,0.14383,-46.9071,3.19362e-13,851.96,6.06387e-88,False,lognormal, -google_2011,memory_p99,"quantile(0.99, canonical_memory_usage)",values,,300,,2520773,17,1.77476,3.29427,4.33728,,,0.113868,0.05066,0.14122,0.15382,-34.9439,7.23912e-13,747.907,2.31647e-98,False,lognormal, -google_2011,memory_p99,"quantile(0.99, canonical_memory_usage)",values,,900,,2520773,7,1.80739,3.29427,3.29427,,,0.113868,0.05066,0.14122,0.15382,-34.9439,7.23912e-13,747.907,2.31647e-98,False,lognormal, -google_2011,memory_p99,"quantile(0.99, canonical_memory_usage)",values,,3600,,2520773,2,1.79867,3.29427,3.29427,,,0.113868,0.05066,0.14122,0.15382,-34.9439,7.23912e-13,747.907,2.31647e-98,False,lognormal, +dataset,query_id,promql,kind,weight,window_len_s,K,rows,n_windows,lower,mle,upper,top1_share,theta_ls,dropped_frac,xmin,ks_d,tail_frac,R_lognormal,p_lognormal,R_exponential,p_exponential,tail_class,ok_frac +alibaba_v2022,mcr_by_msname,sum by (msname) (providerrpc_mcr),keys,count,60,26077,90315535,30,1.34145,1.53568,1.90045,0.551844,1.35882,,,,,,,,,, +alibaba_v2022,mcr_by_msname,sum by (msname) (providerrpc_mcr),keys,value,60,17911,90315535,30,1.02886,1.11054,1.30697,0.18365,3.6235,,,,,,,,,, +alibaba_v2022,mcr_by_msname,sum by (msname) (providerrpc_mcr),keys,count,300,26077,90315535,6,1.45905,1.53568,1.66474,0.551844,1.35882,,,,,,,,,, +alibaba_v2022,mcr_by_msname,sum by (msname) (providerrpc_mcr),keys,value,300,17911,90315535,6,1.07345,1.11054,1.18124,0.18365,3.6235,,,,,,,,,, +alibaba_v2022,mcr_by_msname,sum by (msname) (providerrpc_mcr),keys,count,1800,26077,90315535,1,1.53568,1.53568,1.53568,0.551844,1.35882,,,,,,,,,, +alibaba_v2022,mcr_by_msname,sum by (msname) (providerrpc_mcr),keys,value,1800,17911,90315535,1,1.11054,1.11054,1.11054,0.18365,3.6235,,,,,,,,,, +alibaba_v2022,mcr_by_nodeid,sum by (nodeid) (providerrpc_mcr),keys,count,60,30776,90315535,30,1.06962,1.1256,1.22637,0.0299395,0.671771,,,,,,,,,, +alibaba_v2022,mcr_by_nodeid,sum by (nodeid) (providerrpc_mcr),keys,value,60,28319,90315535,30,0.629764,0.760365,0.985563,0.0103042,0.905303,,,,,,,,,, +alibaba_v2022,mcr_by_nodeid,sum by (nodeid) (providerrpc_mcr),keys,count,300,30776,90315535,6,1.11474,1.1256,1.17579,0.0299395,0.671771,,,,,,,,,, +alibaba_v2022,mcr_by_nodeid,sum by (nodeid) (providerrpc_mcr),keys,value,300,28319,90315535,6,0.711785,0.760365,0.858603,0.0103042,0.905303,,,,,,,,,, +alibaba_v2022,mcr_by_nodeid,sum by (nodeid) (providerrpc_mcr),keys,count,1800,30776,90315535,1,1.1256,1.1256,1.1256,0.0299395,0.671771,,,,,,,,,, +alibaba_v2022,mcr_by_nodeid,sum by (nodeid) (providerrpc_mcr),keys,value,1800,28319,90315535,1,0.760365,0.760365,0.760365,0.0103042,0.905303,,,,,,,,,, +alibaba_v2022,rt_p99_by_msname,"quantile by (msname) (0.99, providerrpc_rt)",keys,count,60,26077,90315535,30,1.34145,1.53568,1.90045,0.551844,1.35882,,,,,,,,,, +alibaba_v2022,rt_p99_by_msname,"quantile by (msname) (0.99, providerrpc_rt)",keys,value,60,17879,90315535,30,1.55788,2.06565,2.86274,0.883125,2.23262,,,,,,,,,, +alibaba_v2022,rt_p99_by_msname,"quantile by (msname) (0.99, providerrpc_rt)",keys,count,300,26077,90315535,6,1.45905,1.53568,1.66474,0.551844,1.35882,,,,,,,,,, +alibaba_v2022,rt_p99_by_msname,"quantile by (msname) (0.99, providerrpc_rt)",keys,value,300,17879,90315535,6,1.91457,2.06565,2.26485,0.883125,2.23262,,,,,,,,,, +alibaba_v2022,rt_p99_by_msname,"quantile by (msname) (0.99, providerrpc_rt)",keys,count,1800,26077,90315535,1,1.53568,1.53568,1.53568,0.551844,1.35882,,,,,,,,,, +alibaba_v2022,rt_p99_by_msname,"quantile by (msname) (0.99, providerrpc_rt)",keys,value,1800,17879,90315535,1,2.06565,2.06565,2.06565,0.883125,2.23262,,,,,,,,,, +alibaba_v2022,rt_p99_by_msname,"quantile by (msname) (0.99, providerrpc_rt)",values,,60,,90315535,30,2.26083,9.48921,19.3664,,,0.0733479,104.752,0.0722386,0.33763,20.9205,1.58403e-24,33305.7,0.0400746,power_law, +alibaba_v2022,rt_p99_by_msname,"quantile by (msname) (0.99, providerrpc_rt)",values,,300,,90315535,6,2.69795,9.48921,9.48921,,,0.0733479,104.752,0.0722386,0.33763,20.9205,1.58403e-24,33305.7,0.0400746,power_law, +alibaba_v2022,rt_p99_by_msname,"quantile by (msname) (0.99, providerrpc_rt)",values,,1800,,90315535,1,9.48921,9.48921,9.48921,,,0.0733479,104.752,0.0722386,0.33763,20.9205,1.58403e-24,33305.7,0.0400746,power_law, +alibaba_v2022,calls_by_rpctype,count by (rpctype) (rt),keys,count,60,6,127635817,30,1.25893,1.3204,1.38466,0.426987,2.23811,,,,,,,,,, +alibaba_v2022,calls_by_rpctype,count by (rpctype) (rt),keys,count,300,6,127635817,6,1.29467,1.3204,1.33952,0.426987,2.23811,,,,,,,,,, +alibaba_v2022,calls_by_rpctype,count by (rpctype) (rt),keys,count,1800,6,127635817,1,1.3204,1.3204,1.3204,0.426987,2.23811,,,,,,,,,, +alibaba_v2022,calls_by_service,count by (service) (rt),keys,count,60,399933,127635817,30,0.999766,1.0731,1.0731,0.0388438,1.59871,,,,,,,,,, +alibaba_v2022,calls_by_service,count by (service) (rt),keys,count,300,399933,127635817,6,1.03815,1.0731,1.0731,0.0388438,1.59871,,,,,,,,,, +alibaba_v2022,calls_by_service,count by (service) (rt),keys,count,1800,399933,127635817,1,1.0731,1.0731,1.0731,0.0388438,1.59871,,,,,,,,,, +alibaba_v2022,calls_by_um,count by (um) (rt),keys,count,60,15063,127635817,30,1.11269,1.14611,1.14611,0.128004,2.68552,,,,,,,,,, +alibaba_v2022,calls_by_um,count by (um) (rt),keys,count,300,15063,127635817,6,1.13005,1.14611,1.14611,0.128004,2.68552,,,,,,,,,, +alibaba_v2022,calls_by_um,count by (um) (rt),keys,count,1800,15063,127635817,1,1.14611,1.14611,1.14611,0.128004,2.68552,,,,,,,,,, +alibaba_v2022,calls_by_dm,count by (dm) (rt),keys,count,60,25155,127635817,30,1.09664,1.12579,1.12579,0.0709133,2.60259,,,,,,,,,, +alibaba_v2022,calls_by_dm,count by (dm) (rt),keys,count,300,25155,127635817,6,1.11312,1.12579,1.12579,0.0709133,2.60259,,,,,,,,,, +alibaba_v2022,calls_by_dm,count by (dm) (rt),keys,count,1800,25155,127635817,1,1.12579,1.12579,1.12579,0.0709133,2.60259,,,,,,,,,, +alibaba_v2022,calls_by_interface,count by (interface) (rt),keys,count,60,1.19888e+06,127635817,30,0.989149,1.06008,1.06008,0.0259165,1.28963,,,,,,,,,, +alibaba_v2022,calls_by_interface,count by (interface) (rt),keys,count,300,1.19888e+06,127635817,6,1.02446,1.06008,1.06008,0.0259165,1.28963,,,,,,,,,, +alibaba_v2022,calls_by_interface,count by (interface) (rt),keys,count,1800,1.19888e+06,127635817,1,1.06008,1.06008,1.06008,0.0259165,1.28963,,,,,,,,,, +alibaba_v2022,calls_by_um_dm,"count by (um, dm) (rt)",keys,count,60,99257,127635817,30,0.976609,1.02162,1.02162,0.0262826,2.34181,,,,,,,,,, +alibaba_v2022,calls_by_um_dm,"count by (um, dm) (rt)",keys,count,300,99257,127635817,6,0.998943,1.02162,1.02162,0.0262826,2.34181,,,,,,,,,, +alibaba_v2022,calls_by_um_dm,"count by (um, dm) (rt)",keys,count,1800,99257,127635817,1,1.02162,1.02162,1.02162,0.0262826,2.34181,,,,,,,,,, +alibaba_v2022,calls_by_service_um_dm,"count by (service, um, dm) (rt)",keys,count,60,1.27135e+06,127635817,30,0.91038,0.981876,0.981876,0.010094,1.68258,,,,,,,,,, +alibaba_v2022,calls_by_service_um_dm,"count by (service, um, dm) (rt)",keys,count,300,1.27135e+06,127635817,6,0.945969,0.981876,0.981876,0.010094,1.68258,,,,,,,,,, +alibaba_v2022,calls_by_service_um_dm,"count by (service, um, dm) (rt)",keys,count,1800,1.27135e+06,127635817,1,0.981876,0.981876,0.981876,0.010094,1.68258,,,,,,,,,, +alibaba_v2022,rt_p99_by_service,"quantile by (service) (0.99, rt)",keys,count,60,399933,127635817,30,0.999766,1.0731,1.0731,0.0388438,1.59871,,,,,,,,,, +alibaba_v2022,rt_p99_by_service,"quantile by (service) (0.99, rt)",keys,value,60,313796,127635817,30,1.12843,1.17197,1.18869,0.241919,2.3833,,,,,,,,,, +alibaba_v2022,rt_p99_by_service,"quantile by (service) (0.99, rt)",keys,count,300,399933,127635817,6,1.03815,1.0731,1.0731,0.0388438,1.59871,,,,,,,,,, +alibaba_v2022,rt_p99_by_service,"quantile by (service) (0.99, rt)",keys,value,300,313796,127635817,6,1.149,1.17197,1.17378,0.241919,2.3833,,,,,,,,,, +alibaba_v2022,rt_p99_by_service,"quantile by (service) (0.99, rt)",keys,count,1800,399933,127635817,1,1.0731,1.0731,1.0731,0.0388438,1.59871,,,,,,,,,, +alibaba_v2022,rt_p99_by_service,"quantile by (service) (0.99, rt)",keys,value,1800,313796,127635817,1,1.17197,1.17197,1.17197,0.241919,2.3833,,,,,,,,,, +alibaba_v2022,rt_p99_by_service,"quantile by (service) (0.99, rt)",values,,60,,125647293,30,2.10507,2.22496,2.39368,,,0.386496,54,0.0305356,0.04198,0.058631,0.574121,4657.66,1.18251e-37,heavy_inconclusive, +alibaba_v2022,rt_p99_by_service,"quantile by (service) (0.99, rt)",values,,300,,125647293,6,2.22251,2.22496,2.37091,,,0.386496,54,0.0305356,0.04198,0.058631,0.574121,4657.66,1.18251e-37,heavy_inconclusive, +alibaba_v2022,rt_p99_by_service,"quantile by (service) (0.99, rt)",values,,1800,,125647293,1,2.22496,2.22496,2.22496,,,0.386496,54,0.0305356,0.04198,0.058631,0.574121,4657.66,1.18251e-37,heavy_inconclusive, +alibaba_v2022,ms_cpu_by_msname,sum by (msname) (cpu_utilization),keys,count,60,28159,13987704,30,0.826067,0.826138,0.82617,0.0164781,1.26917,,,,,,,,,, +alibaba_v2022,ms_cpu_by_msname,sum by (msname) (cpu_utilization),keys,value,60,28158,13987704,30,0.891051,0.893458,0.897012,0.0092067,1.6656,,,,,,,,,, +alibaba_v2022,ms_cpu_by_msname,sum by (msname) (cpu_utilization),keys,count,300,28159,13987704,6,0.8261,0.826138,0.826145,0.0164781,1.26917,,,,,,,,,, +alibaba_v2022,ms_cpu_by_msname,sum by (msname) (cpu_utilization),keys,value,300,28158,13987704,6,0.891446,0.893458,0.895369,0.0092067,1.6656,,,,,,,,,, +alibaba_v2022,ms_cpu_by_msname,sum by (msname) (cpu_utilization),keys,count,1800,28159,13987704,1,0.826138,0.826138,0.826138,0.0164781,1.26917,,,,,,,,,, +alibaba_v2022,ms_cpu_by_msname,sum by (msname) (cpu_utilization),keys,value,1800,28158,13987704,1,0.893458,0.893458,0.893458,0.0092067,1.6656,,,,,,,,,, +alibaba_v2022,ms_cpu_p99,"quantile(0.99, cpu_utilization)",values,,60,,13987704,30,3.12623,5.54219,7.13806,,,2.97404e-05,0.462804,0.0489465,0.03156,-76.2721,2.03777e-16,-76.0488,9.72424e-30,light, +alibaba_v2022,ms_cpu_p99,"quantile(0.99, cpu_utilization)",values,,300,,13987704,6,5.24142,5.54219,6.13548,,,2.97404e-05,0.462804,0.0489465,0.03156,-76.2721,2.03777e-16,-76.0488,9.72424e-30,light, +alibaba_v2022,ms_cpu_p99,"quantile(0.99, cpu_utilization)",values,,1800,,13987704,1,5.54219,5.54219,5.54219,,,2.97404e-05,0.462804,0.0489465,0.03156,-76.2721,2.03777e-16,-76.0488,9.72424e-30,light, +alibaba_v2022,node_cpu_by_nodeid,sum by (nodeid) (cpu_utilization),keys,count,60,42554,1228782,29,3.68585e-06,0.00427455,0.00427455,2.36006e-05,0.00882373,,,,,,,,,, +alibaba_v2022,node_cpu_by_nodeid,sum by (nodeid) (cpu_utilization),keys,value,60,42552,1228782,29,0.302619,0.302619,0.32804,0.000107701,0.374094,,,,,,,,,, +alibaba_v2022,node_cpu_by_nodeid,sum by (nodeid) (cpu_utilization),keys,count,300,42554,1228782,6,0.00173761,0.00427455,0.00427455,2.36006e-05,0.00882373,,,,,,,,,, +alibaba_v2022,node_cpu_by_nodeid,sum by (nodeid) (cpu_utilization),keys,value,300,42552,1228782,6,0.302619,0.302619,0.311077,0.000107701,0.374094,,,,,,,,,, +alibaba_v2022,node_cpu_by_nodeid,sum by (nodeid) (cpu_utilization),keys,count,1800,42554,1228782,1,0.00427455,0.00427455,0.00427455,2.36006e-05,0.00882373,,,,,,,,,, +alibaba_v2022,node_cpu_by_nodeid,sum by (nodeid) (cpu_utilization),keys,value,1800,42552,1228782,1,0.302619,0.302619,0.302619,0.000107701,0.374094,,,,,,,,,, +alibaba_v2022,node_cpu_p99,"quantile(0.99, cpu_utilization)",values,,60,,1228782,29,5.55533,5.88868,6.15762,,,4.72012e-05,0.355012,0.0153465,0.06211,-3.90752,0.0576593,71.8823,3.08632e-08,lognormal, +alibaba_v2022,node_cpu_p99,"quantile(0.99, cpu_utilization)",values,,300,,1228782,6,5.69748,5.88868,5.99247,,,4.72012e-05,0.355012,0.0153465,0.06211,-3.90752,0.0576593,71.8823,3.08632e-08,lognormal, +alibaba_v2022,node_cpu_p99,"quantile(0.99, cpu_utilization)",values,,1800,,1228782,1,5.88868,5.88868,5.88868,,,4.72012e-05,0.355012,0.0153465,0.06211,-3.90752,0.0576593,71.8823,3.08632e-08,lognormal, +boom,target_tail[ds-2187-H],"quantile(0.99, target)",values,,,100,523100,900,1.67386,2.87982,5.44934,,,0.000191168,1.1365,0.0571967,0.133461,-0.751854,0.198545,81.9579,4.29716e-06,light,0.45 +boom,target_tail[ds-2394-D],"quantile(0.99, target)",values,,,73,10001,0,,,,,,0.185881,,,,,,,,, +boom,target_tail[ds-1135-5T],"quantile(0.99, target)",values,,,26,425984,63,2.07242,2.55527,4.46447,,,0.549368,1.30922,0.0957155,0.378019,-3.20217,0.0889076,233.826,9.588e-10,light,0.357143 +boom,target_tail[ds-1833-D],"quantile(0.99, target)",values,,,17,3689,0,,,,,,0.239631,,,,,,,,, +boom,target_tail[ds-2806-D],"quantile(0.99, target)",values,,,100,13700,0,,,,,,0.700365,,,,,,,,, +boom,target_tail[ds-2573-D],"quantile(0.99, target)",values,,,45,9765,0,7.82481,7.82481,7.82481,,,0.00798771,2.83257,0.223752,0.481481,-0.154993,0.181168,8.45051,8.1377e-05,light,0.244444 +boom,target_tail[ds-2222-30T],"quantile(0.99, target)",values,,,100,1045600,800,5.12108,27.1595,45.4353,,,0.570518,3.90768,0.138595,0.0361021,-0.364346,0.235456,16.7272,3.11047e-15,heavy_inconclusive,0.97 +boom,target_tail[ds-1914-30T],"quantile(0.99, target)",values,,,64,669504,0,,,,,,0.999177,,,,,,,,, +boom,target_tail[ds-2577-H],"quantile(0.99, target)",values,,,11,57541,40,2.35732,3.31861,7.11469,,,0.000191168,1.45191,0.045834,0.433748,-3.61922,0.287892,168.563,1.88161e-20,light,0.181818 +boom,target_tail[ds-2212-D],"quantile(0.99, target)",values,,,42,9114,0,2.09751,2.09751,2.09751,,,0.205508,0.172825,0.0786156,0.474181,-0.610425,0.380201,57.445,0.00363611,light,0.363636 +boom,target_tail[ds-2782-H],"quantile(0.99, target)",values,,,20,16500,0,,,,,,0.992364,,,,,,,,, +boom,target_tail[ds-1400-10S],"quantile(0.99, target)",values,,,75,1228800,680,3.66581,5.9273,8.60804,,,0.000139974,3.22594,0.0346188,0.1945,-0.502049,0.105243,67.4898,1.41433e-05,light,0.453333 +boom,target_tail[ds-2650-D],"quantile(0.99, target)",values,,,56,12152,0,2.37226,2.37226,2.37226,,,0.00477288,0.306035,0.0702522,0.481481,-0.434555,0.553246,23.5437,0.0370767,light,0.25 +boom,target_tail[ds-1316-10S],"quantile(0.99, target)",values,,,40,655360,800,1.39445,2.84118,3.78275,,,0.122093,2.27323,0.0380431,0.0316185,-1.52691,0.162568,48.8426,4.79386e-08,heavy_inconclusive,1 +boom,target_tail[ds-1558-5T],"quantile(0.99, target)",values,,,97,1589248,1195,2.85901,4.96551,14.9347,,,0.197184,2.03041,0.0845437,0.235309,0.0144614,0.147769,143.827,7.49471e-08,heavy_inconclusive,0.670103 +boom,target_tail[ds-1972-D],"quantile(0.99, target)",values,,,39,5343,0,,,,,,0.0557739,,,,,,,,, +boom,target_tail[ds-1840-D],"quantile(0.99, target)",values,,,100,21700,0,48.7089,48.7089,48.7089,,,0.00465438,5.80894,0.17295,0.50463,-0.155849,0.691138,15.2522,2.85103e-05,light,0.11 +boom,target_tail[ds-671-10S],"quantile(0.99, target)",values,,,100,1638400,0,,,,,,6.10352e-05,,,,,,,,light,0 +boom,target_tail[ds-1524-5T],"quantile(0.99, target)",values,,,93,1267683,18,3.31039,3.31039,3.69267,,,0.944851,1.98422,0.204364,0.523994,-0.733754,0.142817,51.7326,2.00477e-06,heavy_inconclusive,0.647059 +boom,target_tail[ds-899-T],"quantile(0.99, target)",values,,,12,196608,144,2.3795,4.77602,4.77602,,,0.420344,3.31643,0.0820839,0.0526423,-0.643465,0.133538,64.5435,4.61242e-07,heavy_inconclusive,1 +google_2011,cpu_by_user,sum by (user) (cpu_rate),keys,count,300,518,2520773,17,1.22012,1.23997,1.27526,0.157436,2.33409,,,,,,,,,, +google_2011,cpu_by_user,sum by (user) (cpu_rate),keys,value,300,495,2520773,17,1.24604,1.30345,1.42414,0.1682,3.7868,,,,,,,,,, +google_2011,cpu_by_user,sum by (user) (cpu_rate),keys,count,900,518,2520773,7,1.22012,1.23997,1.25824,0.157436,2.33409,,,,,,,,,, +google_2011,cpu_by_user,sum by (user) (cpu_rate),keys,value,900,495,2520773,7,1.24604,1.30345,1.36946,0.1682,3.7868,,,,,,,,,, +google_2011,cpu_by_user,sum by (user) (cpu_rate),keys,count,3600,518,2520773,2,1.2314,1.23997,1.24591,0.157436,2.33409,,,,,,,,,, +google_2011,cpu_by_user,sum by (user) (cpu_rate),keys,value,3600,495,2520773,2,1.299,1.30345,1.30858,0.1682,3.7868,,,,,,,,,, +google_2011,cpu_by_user_priority,"sum by (user, priority) (cpu_rate)",keys,count,300,869,2520773,17,1.22497,1.24584,1.27931,0.151999,2.11869,,,,,,,,,, +google_2011,cpu_by_user_priority,"sum by (user, priority) (cpu_rate)",keys,value,300,840,2520773,17,1.26988,1.32416,1.43661,0.168118,3.41093,,,,,,,,,, +google_2011,cpu_by_user_priority,"sum by (user, priority) (cpu_rate)",keys,count,900,869,2520773,7,1.22497,1.24584,1.26245,0.151999,2.11869,,,,,,,,,, +google_2011,cpu_by_user_priority,"sum by (user, priority) (cpu_rate)",keys,value,900,840,2520773,7,1.26988,1.32416,1.38497,0.168118,3.41093,,,,,,,,,, +google_2011,cpu_by_user_priority,"sum by (user, priority) (cpu_rate)",keys,count,3600,869,2520773,2,1.23706,1.24584,1.25092,0.151999,2.11869,,,,,,,,,, +google_2011,cpu_by_user_priority,"sum by (user, priority) (cpu_rate)",keys,value,3600,840,2520773,2,1.31927,1.32416,1.32812,0.168118,3.41093,,,,,,,,,, +google_2011,cpu_by_priority,sum by (priority) (cpu_rate),keys,count,300,7,2520773,17,1.0334,1.10046,1.17431,0.32255,1.89497,,,,,,,,,, +google_2011,cpu_by_priority,sum by (priority) (cpu_rate),keys,value,300,7,2520773,17,1.43865,1.60501,1.75174,0.536005,2.03241,,,,,,,,,, +google_2011,cpu_by_priority,sum by (priority) (cpu_rate),keys,count,900,7,2520773,7,1.06809,1.10046,1.17431,0.32255,1.89497,,,,,,,,,, +google_2011,cpu_by_priority,sum by (priority) (cpu_rate),keys,value,900,7,2520773,7,1.49898,1.60501,1.7108,0.536005,2.03241,,,,,,,,,, +google_2011,cpu_by_priority,sum by (priority) (cpu_rate),keys,count,3600,7,2520773,2,1.08297,1.10046,1.1272,0.32255,1.89497,,,,,,,,,, +google_2011,cpu_by_priority,sum by (priority) (cpu_rate),keys,value,3600,7,2520773,2,1.59355,1.60501,1.64514,0.536005,2.03241,,,,,,,,,, +google_2011,cpu_by_job_id,sum by (job_id) (cpu_rate),keys,count,300,4852,2520773,17,1.1028,1.1028,1.1396,0.138099,1.68596,,,,,,,,,, +google_2011,cpu_by_job_id,sum by (job_id) (cpu_rate),keys,value,300,4741,2520773,17,1.14258,1.14339,1.22505,0.0488375,2.91631,,,,,,,,,, +google_2011,cpu_by_job_id,sum by (job_id) (cpu_rate),keys,count,900,4852,2520773,7,1.1028,1.1028,1.11909,0.138099,1.68596,,,,,,,,,, +google_2011,cpu_by_job_id,sum by (job_id) (cpu_rate),keys,value,900,4741,2520773,7,1.14339,1.14339,1.2012,0.0488375,2.91631,,,,,,,,,, +google_2011,cpu_by_job_id,sum by (job_id) (cpu_rate),keys,count,3600,4852,2520773,2,1.1028,1.1028,1.11042,0.138099,1.68596,,,,,,,,,, +google_2011,cpu_by_job_id,sum by (job_id) (cpu_rate),keys,value,3600,4741,2520773,2,1.14299,1.14339,1.17023,0.0488375,2.91631,,,,,,,,,, +google_2011,cpu_by_logical_job_name,sum by (logical_job_name) (cpu_rate),keys,count,300,4076,2520773,17,1.10016,1.10016,1.13977,0.138099,1.67481,,,,,,,,,, +google_2011,cpu_by_logical_job_name,sum by (logical_job_name) (cpu_rate),keys,value,300,3994,2520773,17,1.13736,1.13736,1.22246,0.0488375,2.95553,,,,,,,,,, +google_2011,cpu_by_logical_job_name,sum by (logical_job_name) (cpu_rate),keys,count,900,4076,2520773,7,1.10016,1.10016,1.11896,0.138099,1.67481,,,,,,,,,, +google_2011,cpu_by_logical_job_name,sum by (logical_job_name) (cpu_rate),keys,value,900,3994,2520773,7,1.13736,1.13736,1.19819,0.0488375,2.95553,,,,,,,,,, +google_2011,cpu_by_logical_job_name,sum by (logical_job_name) (cpu_rate),keys,count,3600,4076,2520773,2,1.10016,1.10016,1.11033,0.138099,1.67481,,,,,,,,,, +google_2011,cpu_by_logical_job_name,sum by (logical_job_name) (cpu_rate),keys,value,3600,3994,2520773,2,1.13736,1.13736,1.16633,0.0488375,2.95553,,,,,,,,,, +google_2011,cpu_by_scheduling_class,sum by (scheduling_class) (cpu_rate),keys,count,300,4,2520773,17,0.409689,0.582621,0.758605,0.381155,0.574297,,,,,,,,,, +google_2011,cpu_by_scheduling_class,sum by (scheduling_class) (cpu_rate),keys,value,300,4,2520773,17,0.373199,0.429641,0.984739,0.306212,0.565076,,,,,,,,,, +google_2011,cpu_by_scheduling_class,sum by (scheduling_class) (cpu_rate),keys,count,900,4,2520773,7,0.409689,0.582621,0.688766,0.381155,0.574297,,,,,,,,,, +google_2011,cpu_by_scheduling_class,sum by (scheduling_class) (cpu_rate),keys,value,900,4,2520773,7,0.385382,0.429641,0.750656,0.306212,0.565076,,,,,,,,,, +google_2011,cpu_by_scheduling_class,sum by (scheduling_class) (cpu_rate),keys,count,3600,4,2520773,2,0.509008,0.582621,0.632622,0.381155,0.574297,,,,,,,,,, +google_2011,cpu_by_scheduling_class,sum by (scheduling_class) (cpu_rate),keys,value,3600,4,2520773,2,0.429641,0.429641,0.515166,0.306212,0.565076,,,,,,,,,, +google_2011,cpu_by_machine_id,sum by (machine_id) (cpu_rate),keys,count,300,12478,2520773,17,0.207643,0.207643,0.246048,0.000191211,0.252654,,,,,,,,,, +google_2011,cpu_by_machine_id,sum by (machine_id) (cpu_rate),keys,value,300,12477,2520773,17,0.286387,0.286387,0.354508,0.000345691,0.399985,,,,,,,,,, +google_2011,cpu_by_machine_id,sum by (machine_id) (cpu_rate),keys,count,900,12478,2520773,7,0.207643,0.207643,0.238947,0.000191211,0.252654,,,,,,,,,, +google_2011,cpu_by_machine_id,sum by (machine_id) (cpu_rate),keys,value,900,12477,2520773,7,0.286387,0.286387,0.352387,0.000345691,0.399985,,,,,,,,,, +google_2011,cpu_by_machine_id,sum by (machine_id) (cpu_rate),keys,count,3600,12478,2520773,2,0.207112,0.207643,0.215858,0.000191211,0.252654,,,,,,,,,, +google_2011,cpu_by_machine_id,sum by (machine_id) (cpu_rate),keys,value,3600,12477,2520773,2,0.284414,0.286387,0.31254,0.000345691,0.399985,,,,,,,,,, +google_2011,cpu_p99,"quantile(0.99, cpu_rate)",values,,300,,2520773,17,2.60391,2.9174,14.4531,,,0.095295,0.04578,0.0423316,0.14383,-46.9071,3.19362e-13,851.96,6.06387e-88,lognormal, +google_2011,cpu_p99,"quantile(0.99, cpu_rate)",values,,900,,2520773,7,2.67306,2.9174,3.34021,,,0.095295,0.04578,0.0423316,0.14383,-46.9071,3.19362e-13,851.96,6.06387e-88,lognormal, +google_2011,cpu_p99,"quantile(0.99, cpu_rate)",values,,3600,,2520773,2,2.84976,2.9174,2.9174,,,0.095295,0.04578,0.0423316,0.14383,-46.9071,3.19362e-13,851.96,6.06387e-88,lognormal, +google_2011,memory_p99,"quantile(0.99, canonical_memory_usage)",values,,300,,2520773,17,1.77476,3.29427,4.33728,,,0.113868,0.05066,0.14122,0.15382,-34.9439,7.23912e-13,747.907,2.31647e-98,lognormal, +google_2011,memory_p99,"quantile(0.99, canonical_memory_usage)",values,,900,,2520773,7,1.80739,3.29427,3.29427,,,0.113868,0.05066,0.14122,0.15382,-34.9439,7.23912e-13,747.907,2.31647e-98,lognormal, +google_2011,memory_p99,"quantile(0.99, canonical_memory_usage)",values,,3600,,2520773,2,1.79867,3.29427,3.29427,,,0.113868,0.05066,0.14122,0.15382,-34.9439,7.23912e-13,747.907,2.31647e-98,lognormal, diff --git a/asap-tools/dataset-analysis/tests/test_fit_skew.py b/asap-tools/dataset-analysis/tests/test_fit_skew.py index 2c9f1ec7..5cf4654c 100644 --- a/asap-tools/dataset-analysis/tests/test_fit_skew.py +++ b/asap-tools/dataset-analysis/tests/test_fit_skew.py @@ -68,48 +68,45 @@ def test_recovers_pareto_alpha(self): tail = np.sum(x >= fit["xmin"]) self.assertGreaterEqual(tail, fit_skew.MIN_TAIL_SAMPLES) - def test_exponential_and_lognormal_rejected(self): - samples = { - "exponential": np.random.default_rng(11).exponential(1.0, 20_000), - "lognormal": np.random.default_rng(12).lognormal(0.0, 1.0, 20_000), - } - for name, x in samples.items(): - with self.subTest(name): - fit = fit_skew.fit_power_law(x, compare=True) - self.assertFalse(fit["power_law_ok"]) - self.assertEqual(fit["best_alt"], name) - self.assertTrue(np.isfinite(fit["alpha"])) - - def test_pareto_beats_exponential_but_not_lognormal(self): - # A lognormal with large sigma mimics a power-law tail, so even an exact - # Pareto(alpha=2) cannot significantly beat it: the result is - # inconclusive rather than a pass. - x = np.random.default_rng(13).pareto(1.0, 20_000) + 1.0 - fit = fit_skew.fit_power_law(x, compare=True) - self.assertGreater(fit["R_exponential"], 0) - self.assertLess(fit["p_exponential"], fit_skew.COMPARE_P_THRESHOLD) - self.assertFalse(fit["power_law_ok"]) - self.assertEqual(fit["best_alt"], fit_skew.INCONCLUSIVE) - - def test_best_alternative(self): - best = fit_skew.best_alternative - # The power law significantly beats both alternatives. + def test_tail_class_synthetic(self): + exponential = np.random.default_rng(11).exponential(1.0, 20_000) self.assertEqual( - best({"lognormal": (2.0, 0.05), "exponential": (3.0, 0.01)}), "" + fit_skew.fit_power_law(exponential, compare=True)["tail_class"], + fit_skew.TAIL_LIGHT, ) - # Winning one comparison without significance is not enough. - self.assertEqual( - best({"lognormal": (2.0, 0.5), "exponential": (3.0, 0.01)}), - fit_skew.INCONCLUSIVE, + # The KS-chosen tail of a lognormal(sigma=1) is its top few percent, + # where it decays too fast for the power law to beat an exponential, + # so it is classed light; only heavier lognormal tails reach + # lognormal or heavy_inconclusive. + lognormal = np.random.default_rng(12).lognormal(0.0, 1.0, 20_000) + fit = fit_skew.fit_power_law(lognormal, compare=True) + self.assertEqual(fit["tail_class"], fit_skew.TAIL_LIGHT) + self.assertTrue(np.isfinite(fit["alpha"])) + # A lognormal with large sigma mimics a power-law tail, so an exact + # Pareto(alpha=2) beats the exponential but not the lognormal. + pareto = np.random.default_rng(13).pareto(1.0, 20_000) + 1.0 + fit = fit_skew.fit_power_law(pareto, compare=True) + self.assertIn( + fit["tail_class"], + (fit_skew.TAIL_POWER_LAW, fit_skew.TAIL_HEAVY_INCONCLUSIVE), ) - self.assertEqual(best({}), fit_skew.INCONCLUSIVE) + + def test_tail_class_rule(self): + def classify(lognormal, exponential): + return fit_skew.tail_class( + {"lognormal": lognormal, "exponential": exponential} + ) + + beats_exp = (5.0, 0.01) + self.assertEqual(classify((2.0, 0.01), (5.0, 0.2)), fit_skew.TAIL_LIGHT) + self.assertEqual(classify((2.0, 0.01), (-5.0, 0.01)), fit_skew.TAIL_LIGHT) + self.assertEqual(classify((2.0, 0.01), beats_exp), fit_skew.TAIL_POWER_LAW) + self.assertEqual(classify((-2.0, 0.01), beats_exp), fit_skew.TAIL_LOGNORMAL) self.assertEqual( - best({"lognormal": (-1.0, 0.05), "exponential": (3.0, 0.01)}), "lognormal" + classify((-2.0, 0.5), beats_exp), fit_skew.TAIL_HEAVY_INCONCLUSIVE ) - # Both significantly better: the most negative R wins. self.assertEqual( - best({"lognormal": (-1.0, 0.01), "exponential": (-5.0, 0.01)}), - "exponential", + classify((2.0, 0.5), beats_exp), fit_skew.TAIL_HEAVY_INCONCLUSIVE ) def test_xmin_grid(self): @@ -137,7 +134,7 @@ def test_too_few_samples_is_nan(self): np.arange(1.0, fit_skew.MIN_TAIL_SAMPLES), compare=True ) self.assertTrue(np.isnan(fit["alpha"])) - self.assertNotIn("power_law_ok", fit) + self.assertNotIn("tail_class", fit) def key_window_frames(thetas, rng): @@ -241,61 +238,70 @@ def test_summarize_values_window_lengths(self): self.assertTrue(row["lower"] <= row["mle"] <= row["upper"]) -def boom_inputs(oks): - """Fake per-variate full fits (alpha = index + 2) with the given flags.""" - shifted = np.ones((len(oks), 10)) - jobs = [(np.ones(10), True) for _ in oks] +def boom_inputs(classes): + """Fake per-variate full fits (alpha = index + 2) with the given classes.""" + shifted = np.ones((len(classes), 10)) + jobs = [(np.ones(10), True) for _ in classes] fits = [ { "alpha": v + 2.0, "xmin": 1.0, "ks_d": 0.01, "tail_frac": 0.1, - "R_lognormal": 1.0 if ok else -3.0, - "p_lognormal": 0.5 if ok else 0.01, - "R_exponential": 2.0, + "R_lognormal": -1.0, + "p_lognormal": 0.5, + "R_exponential": -2.0 if cls == fit_skew.TAIL_LIGHT else 4.0, "p_exponential": 0.01, - "best_alt": "" if ok else "lognormal", - "power_law_ok": ok, + "tail_class": cls, } - for v, ok in enumerate(oks) + for v, cls in enumerate(classes) ] - return shifted, jobs, list(range(len(oks))), fits + return shifted, jobs, list(range(len(classes))), fits + + +LIGHT = fit_skew.TAIL_LIGHT +HEAVY = fit_skew.TAIL_HEAVY_INCONCLUSIVE class BoomSummaryTest(unittest.TestCase): - def summarize(self, oks): + def summarize(self, classes): q = {"id": "t", "promql": "quantile(0.99, target)"} - return fit_skew.summarize_boom_series("boom", q, "s", *boom_inputs(oks), None) + return fit_skew.summarize_boom_series( + "boom", q, "s", *boom_inputs(classes), None + ) - def test_alpha_over_passing_variates(self): - row = self.summarize([True, False, True, True]) + def test_alpha_over_non_light_variates(self): + row = self.summarize([HEAVY, LIGHT, HEAVY, fit_skew.TAIL_POWER_LAW]) + self.assertEqual(row["tail_class"], HEAVY) self.assertEqual(row["ok_frac"], 0.75) - self.assertTrue(row["power_law_ok"]) - self.assertEqual(row["best_alt"], "") - # Passing variates 0, 2, 3 have alpha 2, 4, 5. + # Non-light variates 0, 2, 3 have alpha 2, 4, 5. self.assertEqual(row["mle"], 4.0) self.assertTrue(row["lower"] <= row["mle"] <= row["upper"]) - self.assertEqual(row["R_lognormal"], 1.0) + # R/p come from the same non-light variates. + self.assertEqual(row["R_exponential"], 4.0) - def test_mostly_failing_series_has_no_alpha(self): - row = self.summarize([True, False, False, False]) + def test_majority_light_still_reports_heavy_alpha(self): + row = self.summarize([HEAVY, LIGHT, LIGHT, LIGHT]) + self.assertEqual(row["tail_class"], LIGHT) self.assertEqual(row["ok_frac"], 0.25) - self.assertFalse(row["power_law_ok"]) - self.assertEqual(row["best_alt"], "lognormal") + self.assertEqual(row["mle"], 2.0) + self.assertEqual(row["R_exponential"], 4.0) + + def test_all_light_has_no_alpha(self): + row = self.summarize([LIGHT, LIGHT]) + self.assertEqual(row["tail_class"], LIGHT) + self.assertEqual(row["ok_frac"], 0.0) self.assertNotIn("mle", row) - self.assertNotIn("lower", row) - # Diagnostics come from the failing variates, consistent with the flag. - self.assertEqual(row["R_lognormal"], -3.0) + self.assertTrue(np.isnan(row["R_exponential"])) def test_no_compared_variates(self): q = {"id": "t", "promql": "quantile(0.99, target)"} - shifted, jobs, owners, _ = boom_inputs([True]) + shifted, jobs, owners, _ = boom_inputs([LIGHT]) fits = [{"alpha": np.nan, "xmin": np.nan, "ks_d": np.nan}] row = fit_skew.summarize_boom_series( "boom", q, "s", shifted, jobs, owners, fits, None ) - self.assertFalse(row["power_law_ok"]) + self.assertEqual(row["tail_class"], "") self.assertTrue(np.isnan(row["ok_frac"])) From 61bfb9ce35030085e30c51c3056d358b43650533 Mon Sep 17 00:00:00 2001 From: zz_y Date: Tue, 29 Sep 2026 20:40:27 +0000 Subject: [PATCH 6/8] feat(asap-tools): add per-window K and row stats to skew summary K and rows were whole-sample totals repeated on every window length. Rename them to K_total/rows_total and add K_win_{min,median,max} and rows_win_{min,median,max} from the existing per-window aggregates (value queries get rows_win_* only), so the saturation study can read N and K at the sketch window and the query lookback. Write the summary with enough digits to keep row counts exact. Co-Authored-By: Claude Opus 5.5 --- asap-tools/dataset-analysis/README.md | 14 +- asap-tools/dataset-analysis/fit_skew.py | 44 ++- .../dataset-analysis/results/skew_summary.csv | 276 +++++++++--------- .../dataset-analysis/tests/test_fit_skew.py | 30 +- 4 files changed, 213 insertions(+), 151 deletions(-) diff --git a/asap-tools/dataset-analysis/README.md b/asap-tools/dataset-analysis/README.md index a2b5763b..9c282ce7 100644 --- a/asap-tools/dataset-analysis/README.md +++ b/asap-tools/dataset-analysis/README.md @@ -121,8 +121,12 @@ Citations: One row per (query, kind, weight, window length). The sketch-bench saturation study reads `dataset, query_id, kind, weight, window_len_s, lower, mle, upper` to pick the θ and α -range it sweeps. For value rows it should use only rows whose `tail_class` is -not `light`: a light tail decays at least exponentially, so its α is just the +range it sweeps. It takes the stream size per sketch window N from +`rows_win_*` and the key cardinality per window K from `K_win_*`, comparing +them at the sketch window x (the row whose `window_len_s` is x) and at the query +lookback S (the row whose `window_len_s` is S, or `*_total` for the whole +sample). `K_total` and `rows_total` are the same on every window length. For +value rows it should use only rows whose `tail_class` is not `light`: a light tail decays at least exponentially, so its α is just the slope of whatever sliver of the tail the fit picked and does not describe a power-law regime. @@ -132,8 +136,10 @@ power-law regime. | `kind` | `keys` (θ) or `values` (α) | | `weight` | `count` or `value` for key rows, empty for value rows | | `window_len_s` | window length the bounds were computed at (empty for BOOM) | -| `K` | distinct keys with positive weight (BOOM: variates) | -| `rows` | rows with non-null keys (values: finite values) | +| `K_total` | distinct keys with positive weight over the whole sample (BOOM: variates) | +| `rows_total` | rows with non-null keys over the whole sample (values: finite values) | +| `K_win_min`, `K_win_median`, `K_win_max` | key rows: distinct keys per window at this `window_len_s` | +| `rows_win_min`, `rows_win_median`, `rows_win_max` | rows per window at this `window_len_s` (value rows: positive values per window; empty for BOOM) | | `n_windows` | windows used for the bounds (BOOM: variate-chunk fits) | | `lower`, `mle`, `upper` | θ or α as defined above | | `top1_share`, `theta_ls` | key rows: share of the largest key, negated log-log least-squares slope | diff --git a/asap-tools/dataset-analysis/fit_skew.py b/asap-tools/dataset-analysis/fit_skew.py index d0f6aa8e..54bc118d 100644 --- a/asap-tools/dataset-analysis/fit_skew.py +++ b/asap-tools/dataset-analysis/fit_skew.py @@ -64,6 +64,8 @@ KEY_WEIGHTS = {"count", "value"} QUERY_KINDS = {"keys", "values"} +# Enough digits to keep row counts exact. +SUMMARY_FLOAT_FORMAT = "%.10g" SUMMARY_COLUMNS = [ "dataset", "query_id", @@ -71,8 +73,14 @@ "kind", "weight", "window_len_s", - "K", - "rows", + "K_total", + "rows_total", + "K_win_min", + "K_win_median", + "K_win_max", + "rows_win_min", + "rows_win_median", + "rows_win_max", "n_windows", "lower", "mle", @@ -396,6 +404,17 @@ def window_bounds( return min(candidates), max(candidates), len(windows) +def spread(prefix: str, per_window: Sequence[float]) -> Dict[str, float]: + """{prefix}_min, _median and _max over per-window values.""" + if not len(per_window): + return {} + return { + f"{prefix}_min": float(np.min(per_window)), + f"{prefix}_median": float(np.median(per_window)), + f"{prefix}_max": float(np.max(per_window)), + } + + def coarsen_keys(agg: pd.DataFrame, factor: int, group_by: List[str]) -> pd.DataFrame: """Merge every `factor` consecutive finest windows of a key aggregate.""" frame = agg.reset_index() @@ -561,6 +580,11 @@ def summarize_keys( out = [] for window_len in window_lengths: coarse = coarsen_keys(agg, window_len // window_lengths[0], q["group_by"]) + by_window = coarse.groupby(level=WINDOW_COL)[COUNT_COL] + window_stats = { + **spread("K_win", by_window.size().tolist()), + **spread("rows_win", by_window.sum().tolist()), + } for weight, col in columns.items(): estimates = [] for _, window in coarse.groupby(level=WINDOW_COL): @@ -577,8 +601,9 @@ def summarize_keys( "kind": "keys", "weight": weight, "window_len_s": window_len, - "K": len(keys), - "rows": rows, + "K_total": len(keys), + "rows_total": rows, + **window_stats, "n_windows": n_windows, "lower": lower, "mle": pooled[weight], @@ -617,8 +642,10 @@ def summarize_values( mle_sample = subsample(all_values) jobs = [(mle_sample, True)] job_window_lens = [0] + window_rows: Dict[int, List[int]] = {} for window_len in window_lengths: coarse = coarsen_values(finest, window_len // window_lengths[0]) + window_rows[window_len] = [len(x) for x in coarse.values()] for x in coarse.values(): if len(x) >= min_rows: jobs.append((subsample(x), False)) @@ -646,7 +673,8 @@ def summarize_values( "kind": "values", "weight": "", "window_len_s": window_len, - "rows": acc["n_finite"], + "rows_total": acc["n_finite"], + **spread("rows_win", window_rows[window_len]), "n_windows": n_windows, "lower": lower, "mle": mle_fit["alpha"], @@ -774,8 +802,8 @@ def summarize_boom_series( "promql": q["promql"], "kind": "values", "weight": "", - "K": len(shifted), - "rows": finite, + "K_total": len(shifted), + "rows_total": finite, "dropped_frac": 1.0 - np.sum(shifted > 0) / finite, "tail_class": max(sorted(set(classes)), key=classes.count) if classes else "", "ok_frac": len(chosen) / len(classes) if classes else np.nan, @@ -900,7 +928,7 @@ def main() -> None: rows.extend(analyze_dataset(cfg, args.data_root, pool, args, plot_dir)) args.summary.parent.mkdir(parents=True, exist_ok=True) summary = pd.DataFrame(rows).reindex(columns=SUMMARY_COLUMNS) - summary.to_csv(args.summary, index=False, float_format="%.6g") + summary.to_csv(args.summary, index=False, float_format=SUMMARY_FLOAT_FORMAT) log.info( "wrote %s (%d rows) in %.0fs", args.summary, len(rows), time.time() - start ) diff --git a/asap-tools/dataset-analysis/results/skew_summary.csv b/asap-tools/dataset-analysis/results/skew_summary.csv index 8422d58c..efd615cb 100644 --- a/asap-tools/dataset-analysis/results/skew_summary.csv +++ b/asap-tools/dataset-analysis/results/skew_summary.csv @@ -1,138 +1,138 @@ -dataset,query_id,promql,kind,weight,window_len_s,K,rows,n_windows,lower,mle,upper,top1_share,theta_ls,dropped_frac,xmin,ks_d,tail_frac,R_lognormal,p_lognormal,R_exponential,p_exponential,tail_class,ok_frac -alibaba_v2022,mcr_by_msname,sum by (msname) (providerrpc_mcr),keys,count,60,26077,90315535,30,1.34145,1.53568,1.90045,0.551844,1.35882,,,,,,,,,, -alibaba_v2022,mcr_by_msname,sum by (msname) (providerrpc_mcr),keys,value,60,17911,90315535,30,1.02886,1.11054,1.30697,0.18365,3.6235,,,,,,,,,, -alibaba_v2022,mcr_by_msname,sum by (msname) (providerrpc_mcr),keys,count,300,26077,90315535,6,1.45905,1.53568,1.66474,0.551844,1.35882,,,,,,,,,, -alibaba_v2022,mcr_by_msname,sum by (msname) (providerrpc_mcr),keys,value,300,17911,90315535,6,1.07345,1.11054,1.18124,0.18365,3.6235,,,,,,,,,, -alibaba_v2022,mcr_by_msname,sum by (msname) (providerrpc_mcr),keys,count,1800,26077,90315535,1,1.53568,1.53568,1.53568,0.551844,1.35882,,,,,,,,,, -alibaba_v2022,mcr_by_msname,sum by (msname) (providerrpc_mcr),keys,value,1800,17911,90315535,1,1.11054,1.11054,1.11054,0.18365,3.6235,,,,,,,,,, -alibaba_v2022,mcr_by_nodeid,sum by (nodeid) (providerrpc_mcr),keys,count,60,30776,90315535,30,1.06962,1.1256,1.22637,0.0299395,0.671771,,,,,,,,,, -alibaba_v2022,mcr_by_nodeid,sum by (nodeid) (providerrpc_mcr),keys,value,60,28319,90315535,30,0.629764,0.760365,0.985563,0.0103042,0.905303,,,,,,,,,, -alibaba_v2022,mcr_by_nodeid,sum by (nodeid) (providerrpc_mcr),keys,count,300,30776,90315535,6,1.11474,1.1256,1.17579,0.0299395,0.671771,,,,,,,,,, -alibaba_v2022,mcr_by_nodeid,sum by (nodeid) (providerrpc_mcr),keys,value,300,28319,90315535,6,0.711785,0.760365,0.858603,0.0103042,0.905303,,,,,,,,,, -alibaba_v2022,mcr_by_nodeid,sum by (nodeid) (providerrpc_mcr),keys,count,1800,30776,90315535,1,1.1256,1.1256,1.1256,0.0299395,0.671771,,,,,,,,,, -alibaba_v2022,mcr_by_nodeid,sum by (nodeid) (providerrpc_mcr),keys,value,1800,28319,90315535,1,0.760365,0.760365,0.760365,0.0103042,0.905303,,,,,,,,,, -alibaba_v2022,rt_p99_by_msname,"quantile by (msname) (0.99, providerrpc_rt)",keys,count,60,26077,90315535,30,1.34145,1.53568,1.90045,0.551844,1.35882,,,,,,,,,, -alibaba_v2022,rt_p99_by_msname,"quantile by (msname) (0.99, providerrpc_rt)",keys,value,60,17879,90315535,30,1.55788,2.06565,2.86274,0.883125,2.23262,,,,,,,,,, -alibaba_v2022,rt_p99_by_msname,"quantile by (msname) (0.99, providerrpc_rt)",keys,count,300,26077,90315535,6,1.45905,1.53568,1.66474,0.551844,1.35882,,,,,,,,,, -alibaba_v2022,rt_p99_by_msname,"quantile by (msname) (0.99, providerrpc_rt)",keys,value,300,17879,90315535,6,1.91457,2.06565,2.26485,0.883125,2.23262,,,,,,,,,, -alibaba_v2022,rt_p99_by_msname,"quantile by (msname) (0.99, providerrpc_rt)",keys,count,1800,26077,90315535,1,1.53568,1.53568,1.53568,0.551844,1.35882,,,,,,,,,, -alibaba_v2022,rt_p99_by_msname,"quantile by (msname) (0.99, providerrpc_rt)",keys,value,1800,17879,90315535,1,2.06565,2.06565,2.06565,0.883125,2.23262,,,,,,,,,, -alibaba_v2022,rt_p99_by_msname,"quantile by (msname) (0.99, providerrpc_rt)",values,,60,,90315535,30,2.26083,9.48921,19.3664,,,0.0733479,104.752,0.0722386,0.33763,20.9205,1.58403e-24,33305.7,0.0400746,power_law, -alibaba_v2022,rt_p99_by_msname,"quantile by (msname) (0.99, providerrpc_rt)",values,,300,,90315535,6,2.69795,9.48921,9.48921,,,0.0733479,104.752,0.0722386,0.33763,20.9205,1.58403e-24,33305.7,0.0400746,power_law, -alibaba_v2022,rt_p99_by_msname,"quantile by (msname) (0.99, providerrpc_rt)",values,,1800,,90315535,1,9.48921,9.48921,9.48921,,,0.0733479,104.752,0.0722386,0.33763,20.9205,1.58403e-24,33305.7,0.0400746,power_law, -alibaba_v2022,calls_by_rpctype,count by (rpctype) (rt),keys,count,60,6,127635817,30,1.25893,1.3204,1.38466,0.426987,2.23811,,,,,,,,,, -alibaba_v2022,calls_by_rpctype,count by (rpctype) (rt),keys,count,300,6,127635817,6,1.29467,1.3204,1.33952,0.426987,2.23811,,,,,,,,,, -alibaba_v2022,calls_by_rpctype,count by (rpctype) (rt),keys,count,1800,6,127635817,1,1.3204,1.3204,1.3204,0.426987,2.23811,,,,,,,,,, -alibaba_v2022,calls_by_service,count by (service) (rt),keys,count,60,399933,127635817,30,0.999766,1.0731,1.0731,0.0388438,1.59871,,,,,,,,,, -alibaba_v2022,calls_by_service,count by (service) (rt),keys,count,300,399933,127635817,6,1.03815,1.0731,1.0731,0.0388438,1.59871,,,,,,,,,, -alibaba_v2022,calls_by_service,count by (service) (rt),keys,count,1800,399933,127635817,1,1.0731,1.0731,1.0731,0.0388438,1.59871,,,,,,,,,, -alibaba_v2022,calls_by_um,count by (um) (rt),keys,count,60,15063,127635817,30,1.11269,1.14611,1.14611,0.128004,2.68552,,,,,,,,,, -alibaba_v2022,calls_by_um,count by (um) (rt),keys,count,300,15063,127635817,6,1.13005,1.14611,1.14611,0.128004,2.68552,,,,,,,,,, -alibaba_v2022,calls_by_um,count by (um) (rt),keys,count,1800,15063,127635817,1,1.14611,1.14611,1.14611,0.128004,2.68552,,,,,,,,,, -alibaba_v2022,calls_by_dm,count by (dm) (rt),keys,count,60,25155,127635817,30,1.09664,1.12579,1.12579,0.0709133,2.60259,,,,,,,,,, -alibaba_v2022,calls_by_dm,count by (dm) (rt),keys,count,300,25155,127635817,6,1.11312,1.12579,1.12579,0.0709133,2.60259,,,,,,,,,, -alibaba_v2022,calls_by_dm,count by (dm) (rt),keys,count,1800,25155,127635817,1,1.12579,1.12579,1.12579,0.0709133,2.60259,,,,,,,,,, -alibaba_v2022,calls_by_interface,count by (interface) (rt),keys,count,60,1.19888e+06,127635817,30,0.989149,1.06008,1.06008,0.0259165,1.28963,,,,,,,,,, -alibaba_v2022,calls_by_interface,count by (interface) (rt),keys,count,300,1.19888e+06,127635817,6,1.02446,1.06008,1.06008,0.0259165,1.28963,,,,,,,,,, -alibaba_v2022,calls_by_interface,count by (interface) (rt),keys,count,1800,1.19888e+06,127635817,1,1.06008,1.06008,1.06008,0.0259165,1.28963,,,,,,,,,, -alibaba_v2022,calls_by_um_dm,"count by (um, dm) (rt)",keys,count,60,99257,127635817,30,0.976609,1.02162,1.02162,0.0262826,2.34181,,,,,,,,,, -alibaba_v2022,calls_by_um_dm,"count by (um, dm) (rt)",keys,count,300,99257,127635817,6,0.998943,1.02162,1.02162,0.0262826,2.34181,,,,,,,,,, -alibaba_v2022,calls_by_um_dm,"count by (um, dm) (rt)",keys,count,1800,99257,127635817,1,1.02162,1.02162,1.02162,0.0262826,2.34181,,,,,,,,,, -alibaba_v2022,calls_by_service_um_dm,"count by (service, um, dm) (rt)",keys,count,60,1.27135e+06,127635817,30,0.91038,0.981876,0.981876,0.010094,1.68258,,,,,,,,,, -alibaba_v2022,calls_by_service_um_dm,"count by (service, um, dm) (rt)",keys,count,300,1.27135e+06,127635817,6,0.945969,0.981876,0.981876,0.010094,1.68258,,,,,,,,,, -alibaba_v2022,calls_by_service_um_dm,"count by (service, um, dm) (rt)",keys,count,1800,1.27135e+06,127635817,1,0.981876,0.981876,0.981876,0.010094,1.68258,,,,,,,,,, -alibaba_v2022,rt_p99_by_service,"quantile by (service) (0.99, rt)",keys,count,60,399933,127635817,30,0.999766,1.0731,1.0731,0.0388438,1.59871,,,,,,,,,, -alibaba_v2022,rt_p99_by_service,"quantile by (service) (0.99, rt)",keys,value,60,313796,127635817,30,1.12843,1.17197,1.18869,0.241919,2.3833,,,,,,,,,, -alibaba_v2022,rt_p99_by_service,"quantile by (service) (0.99, rt)",keys,count,300,399933,127635817,6,1.03815,1.0731,1.0731,0.0388438,1.59871,,,,,,,,,, -alibaba_v2022,rt_p99_by_service,"quantile by (service) (0.99, rt)",keys,value,300,313796,127635817,6,1.149,1.17197,1.17378,0.241919,2.3833,,,,,,,,,, -alibaba_v2022,rt_p99_by_service,"quantile by (service) (0.99, rt)",keys,count,1800,399933,127635817,1,1.0731,1.0731,1.0731,0.0388438,1.59871,,,,,,,,,, -alibaba_v2022,rt_p99_by_service,"quantile by (service) (0.99, rt)",keys,value,1800,313796,127635817,1,1.17197,1.17197,1.17197,0.241919,2.3833,,,,,,,,,, -alibaba_v2022,rt_p99_by_service,"quantile by (service) (0.99, rt)",values,,60,,125647293,30,2.10507,2.22496,2.39368,,,0.386496,54,0.0305356,0.04198,0.058631,0.574121,4657.66,1.18251e-37,heavy_inconclusive, -alibaba_v2022,rt_p99_by_service,"quantile by (service) (0.99, rt)",values,,300,,125647293,6,2.22251,2.22496,2.37091,,,0.386496,54,0.0305356,0.04198,0.058631,0.574121,4657.66,1.18251e-37,heavy_inconclusive, -alibaba_v2022,rt_p99_by_service,"quantile by (service) (0.99, rt)",values,,1800,,125647293,1,2.22496,2.22496,2.22496,,,0.386496,54,0.0305356,0.04198,0.058631,0.574121,4657.66,1.18251e-37,heavy_inconclusive, -alibaba_v2022,ms_cpu_by_msname,sum by (msname) (cpu_utilization),keys,count,60,28159,13987704,30,0.826067,0.826138,0.82617,0.0164781,1.26917,,,,,,,,,, -alibaba_v2022,ms_cpu_by_msname,sum by (msname) (cpu_utilization),keys,value,60,28158,13987704,30,0.891051,0.893458,0.897012,0.0092067,1.6656,,,,,,,,,, -alibaba_v2022,ms_cpu_by_msname,sum by (msname) (cpu_utilization),keys,count,300,28159,13987704,6,0.8261,0.826138,0.826145,0.0164781,1.26917,,,,,,,,,, -alibaba_v2022,ms_cpu_by_msname,sum by (msname) (cpu_utilization),keys,value,300,28158,13987704,6,0.891446,0.893458,0.895369,0.0092067,1.6656,,,,,,,,,, -alibaba_v2022,ms_cpu_by_msname,sum by (msname) (cpu_utilization),keys,count,1800,28159,13987704,1,0.826138,0.826138,0.826138,0.0164781,1.26917,,,,,,,,,, -alibaba_v2022,ms_cpu_by_msname,sum by (msname) (cpu_utilization),keys,value,1800,28158,13987704,1,0.893458,0.893458,0.893458,0.0092067,1.6656,,,,,,,,,, -alibaba_v2022,ms_cpu_p99,"quantile(0.99, cpu_utilization)",values,,60,,13987704,30,3.12623,5.54219,7.13806,,,2.97404e-05,0.462804,0.0489465,0.03156,-76.2721,2.03777e-16,-76.0488,9.72424e-30,light, -alibaba_v2022,ms_cpu_p99,"quantile(0.99, cpu_utilization)",values,,300,,13987704,6,5.24142,5.54219,6.13548,,,2.97404e-05,0.462804,0.0489465,0.03156,-76.2721,2.03777e-16,-76.0488,9.72424e-30,light, -alibaba_v2022,ms_cpu_p99,"quantile(0.99, cpu_utilization)",values,,1800,,13987704,1,5.54219,5.54219,5.54219,,,2.97404e-05,0.462804,0.0489465,0.03156,-76.2721,2.03777e-16,-76.0488,9.72424e-30,light, -alibaba_v2022,node_cpu_by_nodeid,sum by (nodeid) (cpu_utilization),keys,count,60,42554,1228782,29,3.68585e-06,0.00427455,0.00427455,2.36006e-05,0.00882373,,,,,,,,,, -alibaba_v2022,node_cpu_by_nodeid,sum by (nodeid) (cpu_utilization),keys,value,60,42552,1228782,29,0.302619,0.302619,0.32804,0.000107701,0.374094,,,,,,,,,, -alibaba_v2022,node_cpu_by_nodeid,sum by (nodeid) (cpu_utilization),keys,count,300,42554,1228782,6,0.00173761,0.00427455,0.00427455,2.36006e-05,0.00882373,,,,,,,,,, -alibaba_v2022,node_cpu_by_nodeid,sum by (nodeid) (cpu_utilization),keys,value,300,42552,1228782,6,0.302619,0.302619,0.311077,0.000107701,0.374094,,,,,,,,,, -alibaba_v2022,node_cpu_by_nodeid,sum by (nodeid) (cpu_utilization),keys,count,1800,42554,1228782,1,0.00427455,0.00427455,0.00427455,2.36006e-05,0.00882373,,,,,,,,,, -alibaba_v2022,node_cpu_by_nodeid,sum by (nodeid) (cpu_utilization),keys,value,1800,42552,1228782,1,0.302619,0.302619,0.302619,0.000107701,0.374094,,,,,,,,,, -alibaba_v2022,node_cpu_p99,"quantile(0.99, cpu_utilization)",values,,60,,1228782,29,5.55533,5.88868,6.15762,,,4.72012e-05,0.355012,0.0153465,0.06211,-3.90752,0.0576593,71.8823,3.08632e-08,lognormal, -alibaba_v2022,node_cpu_p99,"quantile(0.99, cpu_utilization)",values,,300,,1228782,6,5.69748,5.88868,5.99247,,,4.72012e-05,0.355012,0.0153465,0.06211,-3.90752,0.0576593,71.8823,3.08632e-08,lognormal, -alibaba_v2022,node_cpu_p99,"quantile(0.99, cpu_utilization)",values,,1800,,1228782,1,5.88868,5.88868,5.88868,,,4.72012e-05,0.355012,0.0153465,0.06211,-3.90752,0.0576593,71.8823,3.08632e-08,lognormal, -boom,target_tail[ds-2187-H],"quantile(0.99, target)",values,,,100,523100,900,1.67386,2.87982,5.44934,,,0.000191168,1.1365,0.0571967,0.133461,-0.751854,0.198545,81.9579,4.29716e-06,light,0.45 -boom,target_tail[ds-2394-D],"quantile(0.99, target)",values,,,73,10001,0,,,,,,0.185881,,,,,,,,, -boom,target_tail[ds-1135-5T],"quantile(0.99, target)",values,,,26,425984,63,2.07242,2.55527,4.46447,,,0.549368,1.30922,0.0957155,0.378019,-3.20217,0.0889076,233.826,9.588e-10,light,0.357143 -boom,target_tail[ds-1833-D],"quantile(0.99, target)",values,,,17,3689,0,,,,,,0.239631,,,,,,,,, -boom,target_tail[ds-2806-D],"quantile(0.99, target)",values,,,100,13700,0,,,,,,0.700365,,,,,,,,, -boom,target_tail[ds-2573-D],"quantile(0.99, target)",values,,,45,9765,0,7.82481,7.82481,7.82481,,,0.00798771,2.83257,0.223752,0.481481,-0.154993,0.181168,8.45051,8.1377e-05,light,0.244444 -boom,target_tail[ds-2222-30T],"quantile(0.99, target)",values,,,100,1045600,800,5.12108,27.1595,45.4353,,,0.570518,3.90768,0.138595,0.0361021,-0.364346,0.235456,16.7272,3.11047e-15,heavy_inconclusive,0.97 -boom,target_tail[ds-1914-30T],"quantile(0.99, target)",values,,,64,669504,0,,,,,,0.999177,,,,,,,,, -boom,target_tail[ds-2577-H],"quantile(0.99, target)",values,,,11,57541,40,2.35732,3.31861,7.11469,,,0.000191168,1.45191,0.045834,0.433748,-3.61922,0.287892,168.563,1.88161e-20,light,0.181818 -boom,target_tail[ds-2212-D],"quantile(0.99, target)",values,,,42,9114,0,2.09751,2.09751,2.09751,,,0.205508,0.172825,0.0786156,0.474181,-0.610425,0.380201,57.445,0.00363611,light,0.363636 -boom,target_tail[ds-2782-H],"quantile(0.99, target)",values,,,20,16500,0,,,,,,0.992364,,,,,,,,, -boom,target_tail[ds-1400-10S],"quantile(0.99, target)",values,,,75,1228800,680,3.66581,5.9273,8.60804,,,0.000139974,3.22594,0.0346188,0.1945,-0.502049,0.105243,67.4898,1.41433e-05,light,0.453333 -boom,target_tail[ds-2650-D],"quantile(0.99, target)",values,,,56,12152,0,2.37226,2.37226,2.37226,,,0.00477288,0.306035,0.0702522,0.481481,-0.434555,0.553246,23.5437,0.0370767,light,0.25 -boom,target_tail[ds-1316-10S],"quantile(0.99, target)",values,,,40,655360,800,1.39445,2.84118,3.78275,,,0.122093,2.27323,0.0380431,0.0316185,-1.52691,0.162568,48.8426,4.79386e-08,heavy_inconclusive,1 -boom,target_tail[ds-1558-5T],"quantile(0.99, target)",values,,,97,1589248,1195,2.85901,4.96551,14.9347,,,0.197184,2.03041,0.0845437,0.235309,0.0144614,0.147769,143.827,7.49471e-08,heavy_inconclusive,0.670103 -boom,target_tail[ds-1972-D],"quantile(0.99, target)",values,,,39,5343,0,,,,,,0.0557739,,,,,,,,, -boom,target_tail[ds-1840-D],"quantile(0.99, target)",values,,,100,21700,0,48.7089,48.7089,48.7089,,,0.00465438,5.80894,0.17295,0.50463,-0.155849,0.691138,15.2522,2.85103e-05,light,0.11 -boom,target_tail[ds-671-10S],"quantile(0.99, target)",values,,,100,1638400,0,,,,,,6.10352e-05,,,,,,,,light,0 -boom,target_tail[ds-1524-5T],"quantile(0.99, target)",values,,,93,1267683,18,3.31039,3.31039,3.69267,,,0.944851,1.98422,0.204364,0.523994,-0.733754,0.142817,51.7326,2.00477e-06,heavy_inconclusive,0.647059 -boom,target_tail[ds-899-T],"quantile(0.99, target)",values,,,12,196608,144,2.3795,4.77602,4.77602,,,0.420344,3.31643,0.0820839,0.0526423,-0.643465,0.133538,64.5435,4.61242e-07,heavy_inconclusive,1 -google_2011,cpu_by_user,sum by (user) (cpu_rate),keys,count,300,518,2520773,17,1.22012,1.23997,1.27526,0.157436,2.33409,,,,,,,,,, -google_2011,cpu_by_user,sum by (user) (cpu_rate),keys,value,300,495,2520773,17,1.24604,1.30345,1.42414,0.1682,3.7868,,,,,,,,,, -google_2011,cpu_by_user,sum by (user) (cpu_rate),keys,count,900,518,2520773,7,1.22012,1.23997,1.25824,0.157436,2.33409,,,,,,,,,, -google_2011,cpu_by_user,sum by (user) (cpu_rate),keys,value,900,495,2520773,7,1.24604,1.30345,1.36946,0.1682,3.7868,,,,,,,,,, -google_2011,cpu_by_user,sum by (user) (cpu_rate),keys,count,3600,518,2520773,2,1.2314,1.23997,1.24591,0.157436,2.33409,,,,,,,,,, -google_2011,cpu_by_user,sum by (user) (cpu_rate),keys,value,3600,495,2520773,2,1.299,1.30345,1.30858,0.1682,3.7868,,,,,,,,,, -google_2011,cpu_by_user_priority,"sum by (user, priority) (cpu_rate)",keys,count,300,869,2520773,17,1.22497,1.24584,1.27931,0.151999,2.11869,,,,,,,,,, -google_2011,cpu_by_user_priority,"sum by (user, priority) (cpu_rate)",keys,value,300,840,2520773,17,1.26988,1.32416,1.43661,0.168118,3.41093,,,,,,,,,, -google_2011,cpu_by_user_priority,"sum by (user, priority) (cpu_rate)",keys,count,900,869,2520773,7,1.22497,1.24584,1.26245,0.151999,2.11869,,,,,,,,,, -google_2011,cpu_by_user_priority,"sum by (user, priority) (cpu_rate)",keys,value,900,840,2520773,7,1.26988,1.32416,1.38497,0.168118,3.41093,,,,,,,,,, -google_2011,cpu_by_user_priority,"sum by (user, priority) (cpu_rate)",keys,count,3600,869,2520773,2,1.23706,1.24584,1.25092,0.151999,2.11869,,,,,,,,,, -google_2011,cpu_by_user_priority,"sum by (user, priority) (cpu_rate)",keys,value,3600,840,2520773,2,1.31927,1.32416,1.32812,0.168118,3.41093,,,,,,,,,, -google_2011,cpu_by_priority,sum by (priority) (cpu_rate),keys,count,300,7,2520773,17,1.0334,1.10046,1.17431,0.32255,1.89497,,,,,,,,,, -google_2011,cpu_by_priority,sum by (priority) (cpu_rate),keys,value,300,7,2520773,17,1.43865,1.60501,1.75174,0.536005,2.03241,,,,,,,,,, -google_2011,cpu_by_priority,sum by (priority) (cpu_rate),keys,count,900,7,2520773,7,1.06809,1.10046,1.17431,0.32255,1.89497,,,,,,,,,, -google_2011,cpu_by_priority,sum by (priority) (cpu_rate),keys,value,900,7,2520773,7,1.49898,1.60501,1.7108,0.536005,2.03241,,,,,,,,,, -google_2011,cpu_by_priority,sum by (priority) (cpu_rate),keys,count,3600,7,2520773,2,1.08297,1.10046,1.1272,0.32255,1.89497,,,,,,,,,, -google_2011,cpu_by_priority,sum by (priority) (cpu_rate),keys,value,3600,7,2520773,2,1.59355,1.60501,1.64514,0.536005,2.03241,,,,,,,,,, -google_2011,cpu_by_job_id,sum by (job_id) (cpu_rate),keys,count,300,4852,2520773,17,1.1028,1.1028,1.1396,0.138099,1.68596,,,,,,,,,, -google_2011,cpu_by_job_id,sum by (job_id) (cpu_rate),keys,value,300,4741,2520773,17,1.14258,1.14339,1.22505,0.0488375,2.91631,,,,,,,,,, -google_2011,cpu_by_job_id,sum by (job_id) (cpu_rate),keys,count,900,4852,2520773,7,1.1028,1.1028,1.11909,0.138099,1.68596,,,,,,,,,, -google_2011,cpu_by_job_id,sum by (job_id) (cpu_rate),keys,value,900,4741,2520773,7,1.14339,1.14339,1.2012,0.0488375,2.91631,,,,,,,,,, -google_2011,cpu_by_job_id,sum by (job_id) (cpu_rate),keys,count,3600,4852,2520773,2,1.1028,1.1028,1.11042,0.138099,1.68596,,,,,,,,,, -google_2011,cpu_by_job_id,sum by (job_id) (cpu_rate),keys,value,3600,4741,2520773,2,1.14299,1.14339,1.17023,0.0488375,2.91631,,,,,,,,,, -google_2011,cpu_by_logical_job_name,sum by (logical_job_name) (cpu_rate),keys,count,300,4076,2520773,17,1.10016,1.10016,1.13977,0.138099,1.67481,,,,,,,,,, -google_2011,cpu_by_logical_job_name,sum by (logical_job_name) (cpu_rate),keys,value,300,3994,2520773,17,1.13736,1.13736,1.22246,0.0488375,2.95553,,,,,,,,,, -google_2011,cpu_by_logical_job_name,sum by (logical_job_name) (cpu_rate),keys,count,900,4076,2520773,7,1.10016,1.10016,1.11896,0.138099,1.67481,,,,,,,,,, -google_2011,cpu_by_logical_job_name,sum by (logical_job_name) (cpu_rate),keys,value,900,3994,2520773,7,1.13736,1.13736,1.19819,0.0488375,2.95553,,,,,,,,,, -google_2011,cpu_by_logical_job_name,sum by (logical_job_name) (cpu_rate),keys,count,3600,4076,2520773,2,1.10016,1.10016,1.11033,0.138099,1.67481,,,,,,,,,, -google_2011,cpu_by_logical_job_name,sum by (logical_job_name) (cpu_rate),keys,value,3600,3994,2520773,2,1.13736,1.13736,1.16633,0.0488375,2.95553,,,,,,,,,, -google_2011,cpu_by_scheduling_class,sum by (scheduling_class) (cpu_rate),keys,count,300,4,2520773,17,0.409689,0.582621,0.758605,0.381155,0.574297,,,,,,,,,, -google_2011,cpu_by_scheduling_class,sum by (scheduling_class) (cpu_rate),keys,value,300,4,2520773,17,0.373199,0.429641,0.984739,0.306212,0.565076,,,,,,,,,, -google_2011,cpu_by_scheduling_class,sum by (scheduling_class) (cpu_rate),keys,count,900,4,2520773,7,0.409689,0.582621,0.688766,0.381155,0.574297,,,,,,,,,, -google_2011,cpu_by_scheduling_class,sum by (scheduling_class) (cpu_rate),keys,value,900,4,2520773,7,0.385382,0.429641,0.750656,0.306212,0.565076,,,,,,,,,, -google_2011,cpu_by_scheduling_class,sum by (scheduling_class) (cpu_rate),keys,count,3600,4,2520773,2,0.509008,0.582621,0.632622,0.381155,0.574297,,,,,,,,,, -google_2011,cpu_by_scheduling_class,sum by (scheduling_class) (cpu_rate),keys,value,3600,4,2520773,2,0.429641,0.429641,0.515166,0.306212,0.565076,,,,,,,,,, -google_2011,cpu_by_machine_id,sum by (machine_id) (cpu_rate),keys,count,300,12478,2520773,17,0.207643,0.207643,0.246048,0.000191211,0.252654,,,,,,,,,, -google_2011,cpu_by_machine_id,sum by (machine_id) (cpu_rate),keys,value,300,12477,2520773,17,0.286387,0.286387,0.354508,0.000345691,0.399985,,,,,,,,,, -google_2011,cpu_by_machine_id,sum by (machine_id) (cpu_rate),keys,count,900,12478,2520773,7,0.207643,0.207643,0.238947,0.000191211,0.252654,,,,,,,,,, -google_2011,cpu_by_machine_id,sum by (machine_id) (cpu_rate),keys,value,900,12477,2520773,7,0.286387,0.286387,0.352387,0.000345691,0.399985,,,,,,,,,, -google_2011,cpu_by_machine_id,sum by (machine_id) (cpu_rate),keys,count,3600,12478,2520773,2,0.207112,0.207643,0.215858,0.000191211,0.252654,,,,,,,,,, -google_2011,cpu_by_machine_id,sum by (machine_id) (cpu_rate),keys,value,3600,12477,2520773,2,0.284414,0.286387,0.31254,0.000345691,0.399985,,,,,,,,,, -google_2011,cpu_p99,"quantile(0.99, cpu_rate)",values,,300,,2520773,17,2.60391,2.9174,14.4531,,,0.095295,0.04578,0.0423316,0.14383,-46.9071,3.19362e-13,851.96,6.06387e-88,lognormal, -google_2011,cpu_p99,"quantile(0.99, cpu_rate)",values,,900,,2520773,7,2.67306,2.9174,3.34021,,,0.095295,0.04578,0.0423316,0.14383,-46.9071,3.19362e-13,851.96,6.06387e-88,lognormal, -google_2011,cpu_p99,"quantile(0.99, cpu_rate)",values,,3600,,2520773,2,2.84976,2.9174,2.9174,,,0.095295,0.04578,0.0423316,0.14383,-46.9071,3.19362e-13,851.96,6.06387e-88,lognormal, -google_2011,memory_p99,"quantile(0.99, canonical_memory_usage)",values,,300,,2520773,17,1.77476,3.29427,4.33728,,,0.113868,0.05066,0.14122,0.15382,-34.9439,7.23912e-13,747.907,2.31647e-98,lognormal, -google_2011,memory_p99,"quantile(0.99, canonical_memory_usage)",values,,900,,2520773,7,1.80739,3.29427,3.29427,,,0.113868,0.05066,0.14122,0.15382,-34.9439,7.23912e-13,747.907,2.31647e-98,lognormal, -google_2011,memory_p99,"quantile(0.99, canonical_memory_usage)",values,,3600,,2520773,2,1.79867,3.29427,3.29427,,,0.113868,0.05066,0.14122,0.15382,-34.9439,7.23912e-13,747.907,2.31647e-98,lognormal, +dataset,query_id,promql,kind,weight,window_len_s,K_total,rows_total,K_win_min,K_win_median,K_win_max,rows_win_min,rows_win_median,rows_win_max,n_windows,lower,mle,upper,top1_share,theta_ls,dropped_frac,xmin,ks_d,tail_frac,R_lognormal,p_lognormal,R_exponential,p_exponential,tail_class,ok_frac +alibaba_v2022,mcr_by_msname,sum by (msname) (providerrpc_mcr),keys,count,60,26077,90315535,25897,25913.5,25946,1851317,2620027,6116768,30,1.34145226,1.535683382,1.900453851,0.551844464,1.358823026,,,,,,,,,, +alibaba_v2022,mcr_by_msname,sum by (msname) (providerrpc_mcr),keys,value,60,17911,90315535,25897,25913.5,25946,1851317,2620027,6116768,30,1.02886251,1.110543808,1.306967015,0.183649676,3.623496783,,,,,,,,,, +alibaba_v2022,mcr_by_msname,sum by (msname) (providerrpc_mcr),keys,count,300,26077,90315535,25982,25999,26017,12598774,14510179.5,20040209,6,1.459050605,1.535683382,1.664745,0.551844464,1.358823026,,,,,,,,,, +alibaba_v2022,mcr_by_msname,sum by (msname) (providerrpc_mcr),keys,value,300,17911,90315535,25982,25999,26017,12598774,14510179.5,20040209,6,1.073448849,1.110543808,1.181235381,0.183649676,3.623496783,,,,,,,,,, +alibaba_v2022,mcr_by_msname,sum by (msname) (providerrpc_mcr),keys,count,1800,26077,90315535,26077,26077,26077,90315535,90315535,90315535,1,1.535683382,1.535683382,1.535683382,0.551844464,1.358823026,,,,,,,,,, +alibaba_v2022,mcr_by_msname,sum by (msname) (providerrpc_mcr),keys,value,1800,17911,90315535,26077,26077,26077,90315535,90315535,90315535,1,1.110543808,1.110543808,1.110543808,0.183649676,3.623496783,,,,,,,,,, +alibaba_v2022,mcr_by_nodeid,sum by (nodeid) (providerrpc_mcr),keys,count,60,30776,90315535,30741,30749,30761,1851317,2620027,6116768,30,1.069623945,1.125599263,1.22637178,0.02993950044,0.6717705283,,,,,,,,,, +alibaba_v2022,mcr_by_nodeid,sum by (nodeid) (providerrpc_mcr),keys,value,60,28319,90315535,30741,30749,30761,1851317,2620027,6116768,30,0.6297640693,0.7603646648,0.9855634538,0.01030423561,0.9053034762,,,,,,,,,, +alibaba_v2022,mcr_by_nodeid,sum by (nodeid) (providerrpc_mcr),keys,count,300,30776,90315535,30752,30757.5,30767,12598774,14510179.5,20040209,6,1.114742605,1.125599263,1.175793283,0.02993950044,0.6717705283,,,,,,,,,, +alibaba_v2022,mcr_by_nodeid,sum by (nodeid) (providerrpc_mcr),keys,value,300,28319,90315535,30752,30757.5,30767,12598774,14510179.5,20040209,6,0.7117850782,0.7603646648,0.8586025258,0.01030423561,0.9053034762,,,,,,,,,, +alibaba_v2022,mcr_by_nodeid,sum by (nodeid) (providerrpc_mcr),keys,count,1800,30776,90315535,30776,30776,30776,90315535,90315535,90315535,1,1.125599263,1.125599263,1.125599263,0.02993950044,0.6717705283,,,,,,,,,, +alibaba_v2022,mcr_by_nodeid,sum by (nodeid) (providerrpc_mcr),keys,value,1800,28319,90315535,30776,30776,30776,90315535,90315535,90315535,1,0.7603646648,0.7603646648,0.7603646648,0.01030423561,0.9053034762,,,,,,,,,, +alibaba_v2022,rt_p99_by_msname,"quantile by (msname) (0.99, providerrpc_rt)",keys,count,60,26077,90315535,25897,25913.5,25946,1851317,2620027,6116768,30,1.34145226,1.535683382,1.900453851,0.551844464,1.358823026,,,,,,,,,, +alibaba_v2022,rt_p99_by_msname,"quantile by (msname) (0.99, providerrpc_rt)",keys,value,60,17879,90315535,25897,25913.5,25946,1851317,2620027,6116768,30,1.557884845,2.065651001,2.862739376,0.8831246003,2.232622338,,,,,,,,,, +alibaba_v2022,rt_p99_by_msname,"quantile by (msname) (0.99, providerrpc_rt)",keys,count,300,26077,90315535,25982,25999,26017,12598774,14510179.5,20040209,6,1.459050605,1.535683382,1.664745,0.551844464,1.358823026,,,,,,,,,, +alibaba_v2022,rt_p99_by_msname,"quantile by (msname) (0.99, providerrpc_rt)",keys,value,300,17879,90315535,25982,25999,26017,12598774,14510179.5,20040209,6,1.914568868,2.065651001,2.264852064,0.8831246003,2.232622338,,,,,,,,,, +alibaba_v2022,rt_p99_by_msname,"quantile by (msname) (0.99, providerrpc_rt)",keys,count,1800,26077,90315535,26077,26077,26077,90315535,90315535,90315535,1,1.535683382,1.535683382,1.535683382,0.551844464,1.358823026,,,,,,,,,, +alibaba_v2022,rt_p99_by_msname,"quantile by (msname) (0.99, providerrpc_rt)",keys,value,1800,17879,90315535,26077,26077,26077,90315535,90315535,90315535,1,2.065651001,2.065651001,2.065651001,0.8831246003,2.232622338,,,,,,,,,, +alibaba_v2022,rt_p99_by_msname,"quantile by (msname) (0.99, providerrpc_rt)",values,,60,,90315535,,,,1628149,2398432.5,5822881,30,2.260827914,9.489211869,19.36642355,,,0.07334786867,104.7515152,0.07223857387,0.33763,20.92052971,1.584033129e-24,33305.70531,0.04007458342,power_law, +alibaba_v2022,rt_p99_by_msname,"quantile by (msname) (0.99, providerrpc_rt)",values,,300,,90315535,,,,11485019,13399225,18912878,6,2.69795252,9.489211869,9.489211869,,,0.07334786867,104.7515152,0.07223857387,0.33763,20.92052971,1.584033129e-24,33305.70531,0.04007458342,power_law, +alibaba_v2022,rt_p99_by_msname,"quantile by (msname) (0.99, providerrpc_rt)",values,,1800,,90315535,,,,83691083,83691083,83691083,1,9.489211869,9.489211869,9.489211869,,,0.07334786867,104.7515152,0.07223857387,0.33763,20.92052971,1.584033129e-24,33305.70531,0.04007458342,power_law, +alibaba_v2022,calls_by_rpctype,count by (rpctype) (rt),keys,count,60,6,127635817,6,6,6,4088165,4250906.5,4588482,30,1.258934174,1.320397372,1.384661933,0.4269873793,2.238106251,,,,,,,,,, +alibaba_v2022,calls_by_rpctype,count by (rpctype) (rt),keys,count,300,6,127635817,6,6,6,20898096,21181599,21989351,6,1.29467164,1.320397372,1.339517165,0.4269873793,2.238106251,,,,,,,,,, +alibaba_v2022,calls_by_rpctype,count by (rpctype) (rt),keys,count,1800,6,127635817,6,6,6,127635817,127635817,127635817,1,1.320397372,1.320397372,1.320397372,0.4269873793,2.238106251,,,,,,,,,, +alibaba_v2022,calls_by_service,count by (service) (rt),keys,count,60,399933,127635817,40487,41371,43871,4088165,4250906.5,4588482,30,0.9997655419,1.073097582,1.073097582,0.03884380667,1.598714967,,,,,,,,,, +alibaba_v2022,calls_by_service,count by (service) (rt),keys,count,300,399933,127635817,118742,120073,123896,20898096,21181599,21989351,6,1.038151807,1.073097582,1.073097582,0.03884380667,1.598714967,,,,,,,,,, +alibaba_v2022,calls_by_service,count by (service) (rt),keys,count,1800,399933,127635817,399933,399933,399933,127635817,127635817,127635817,1,1.073097582,1.073097582,1.073097582,0.03884380667,1.598714967,,,,,,,,,, +alibaba_v2022,calls_by_um,count by (um) (rt),keys,count,60,15063,127635817,6962,7225.5,7787,4088165,4250906.5,4588482,30,1.112686254,1.146113129,1.146113129,0.1280037797,2.685515774,,,,,,,,,, +alibaba_v2022,calls_by_um,count by (um) (rt),keys,count,300,15063,127635817,10377,10623.5,11246,20898096,21181599,21989351,6,1.130046063,1.146113129,1.146113129,0.1280037797,2.685515774,,,,,,,,,, +alibaba_v2022,calls_by_um,count by (um) (rt),keys,count,1800,15063,127635817,15063,15063,15063,127635817,127635817,127635817,1,1.146113129,1.146113129,1.146113129,0.1280037797,2.685515774,,,,,,,,,, +alibaba_v2022,calls_by_dm,count by (dm) (rt),keys,count,60,25155,127635817,11842,12302,13167,4088165,4250906.5,4588482,30,1.096635378,1.125786526,1.125786526,0.07091333932,2.602593178,,,,,,,,,, +alibaba_v2022,calls_by_dm,count by (dm) (rt),keys,count,300,25155,127635817,17523,17956.5,18966,20898096,21181599,21989351,6,1.113121733,1.125786526,1.125786526,0.07091333932,2.602593178,,,,,,,,,, +alibaba_v2022,calls_by_dm,count by (dm) (rt),keys,count,1800,25155,127635817,25155,25155,25155,127635817,127635817,127635817,1,1.125786526,1.125786526,1.125786526,0.07091333932,2.602593178,,,,,,,,,, +alibaba_v2022,calls_by_interface,count by (interface) (rt),keys,count,60,1198880,127635817,108417,114296,119515,4088165,4250906.5,4588482,30,0.9891494111,1.060081164,1.060081164,0.02591645572,1.289625511,,,,,,,,,, +alibaba_v2022,calls_by_interface,count by (interface) (rt),keys,count,300,1198880,127635817,304076,320266.5,331341,20898096,21181599,21989351,6,1.024459485,1.060081164,1.060081164,0.02591645572,1.289625511,,,,,,,,,, +alibaba_v2022,calls_by_interface,count by (interface) (rt),keys,count,1800,1198880,127635817,1198880,1198880,1198880,127635817,127635817,127635817,1,1.060081164,1.060081164,1.060081164,0.02591645572,1.289625511,,,,,,,,,, +alibaba_v2022,calls_by_um_dm,"count by (um, dm) (rt)",keys,count,60,99257,127635817,36740,38576.5,42279,4088165,4250906.5,4588482,30,0.9766087399,1.021624348,1.021624348,0.02628258336,2.341811039,,,,,,,,,, +alibaba_v2022,calls_by_um_dm,"count by (um, dm) (rt)",keys,count,300,99257,127635817,60535,62824.5,67160,20898096,21181599,21989351,6,0.9989432682,1.021624348,1.021624348,0.02628258336,2.341811039,,,,,,,,,, +alibaba_v2022,calls_by_um_dm,"count by (um, dm) (rt)",keys,count,1800,99257,127635817,99257,99257,99257,127635817,127635817,127635817,1,1.021624348,1.021624348,1.021624348,0.02628258336,2.341811039,,,,,,,,,, +alibaba_v2022,calls_by_service_um_dm,"count by (service, um, dm) (rt)",keys,count,60,1271349,127635817,178991,185802,197370,4088165,4250906.5,4588482,30,0.9103802226,0.9818761438,0.9818761438,0.0100940475,1.682584852,,,,,,,,,, +alibaba_v2022,calls_by_service_um_dm,"count by (service, um, dm) (rt)",keys,count,300,1271349,127635817,437380,452564,469896,20898096,21181599,21989351,6,0.9459693208,0.9818761438,0.9818761438,0.0100940475,1.682584852,,,,,,,,,, +alibaba_v2022,calls_by_service_um_dm,"count by (service, um, dm) (rt)",keys,count,1800,1271349,127635817,1271349,1271349,1271349,127635817,127635817,127635817,1,0.9818761438,0.9818761438,0.9818761438,0.0100940475,1.682584852,,,,,,,,,, +alibaba_v2022,rt_p99_by_service,"quantile by (service) (0.99, rt)",keys,count,60,399933,127635817,40487,41371,43871,4088165,4250906.5,4588482,30,0.9997655419,1.073097582,1.073097582,0.03884380667,1.598714967,,,,,,,,,, +alibaba_v2022,rt_p99_by_service,"quantile by (service) (0.99, rt)",keys,value,60,313796,127635817,40487,41371,43871,4088165,4250906.5,4588482,30,1.128425922,1.171970416,1.188693737,0.2419190472,2.383296717,,,,,,,,,, +alibaba_v2022,rt_p99_by_service,"quantile by (service) (0.99, rt)",keys,count,300,399933,127635817,118742,120073,123896,20898096,21181599,21989351,6,1.038151807,1.073097582,1.073097582,0.03884380667,1.598714967,,,,,,,,,, +alibaba_v2022,rt_p99_by_service,"quantile by (service) (0.99, rt)",keys,value,300,313796,127635817,118742,120073,123896,20898096,21181599,21989351,6,1.148996146,1.171970416,1.173781825,0.2419190472,2.383296717,,,,,,,,,, +alibaba_v2022,rt_p99_by_service,"quantile by (service) (0.99, rt)",keys,count,1800,399933,127635817,399933,399933,399933,127635817,127635817,127635817,1,1.073097582,1.073097582,1.073097582,0.03884380667,1.598714967,,,,,,,,,, +alibaba_v2022,rt_p99_by_service,"quantile by (service) (0.99, rt)",keys,value,1800,313796,127635817,399933,399933,399933,127635817,127635817,127635817,1,1.171970416,1.171970416,1.171970416,0.2419190472,2.383296717,,,,,,,,,, +alibaba_v2022,rt_p99_by_service,"quantile by (service) (0.99, rt)",values,,60,,125647293,,,,2454764,2557976.5,2778257,30,2.105068097,2.224958097,2.39368374,,,0.3864958157,54,0.03053561758,0.04198,0.05863097738,0.5741208187,4657.66376,1.182510951e-37,heavy_inconclusive, +alibaba_v2022,rt_p99_by_service,"quantile by (service) (0.99, rt)",values,,300,,125647293,,,,12453596,12802532,13318944,6,2.22250947,2.224958097,2.370910148,,,0.3864958157,54,0.03053561758,0.04198,0.05863097738,0.5741208187,4657.66376,1.182510951e-37,heavy_inconclusive, +alibaba_v2022,rt_p99_by_service,"quantile by (service) (0.99, rt)",values,,1800,,125647293,,,,77085140,77085140,77085140,1,2.224958097,2.224958097,2.224958097,,,0.3864958157,54,0.03053561758,0.04198,0.05863097738,0.5741208187,4657.66376,1.182510951e-37,heavy_inconclusive, +alibaba_v2022,ms_cpu_by_msname,sum by (msname) (cpu_utilization),keys,count,60,28159,13987704,28133,28146,28149,466064,466254.5,466859,30,0.8260669806,0.8261383394,0.8261696343,0.01647811535,1.269169573,,,,,,,,,, +alibaba_v2022,ms_cpu_by_msname,sum by (msname) (cpu_utilization),keys,value,60,28158,13987704,28133,28146,28149,466064,466254.5,466859,30,0.8910509911,0.8934578439,0.8970122008,0.009206699585,1.665602809,,,,,,,,,, +alibaba_v2022,ms_cpu_by_msname,sum by (msname) (cpu_utilization),keys,count,300,28159,13987704,28150,28152,28154,2331080,2331259,2331564,6,0.8260995665,0.8261383394,0.8261451562,0.01647811535,1.269169573,,,,,,,,,, +alibaba_v2022,ms_cpu_by_msname,sum by (msname) (cpu_utilization),keys,value,300,28158,13987704,28150,28152,28154,2331080,2331259,2331564,6,0.8914462982,0.8934578439,0.8953685744,0.009206699585,1.665602809,,,,,,,,,, +alibaba_v2022,ms_cpu_by_msname,sum by (msname) (cpu_utilization),keys,count,1800,28159,13987704,28159,28159,28159,13987704,13987704,13987704,1,0.8261383394,0.8261383394,0.8261383394,0.01647811535,1.269169573,,,,,,,,,, +alibaba_v2022,ms_cpu_by_msname,sum by (msname) (cpu_utilization),keys,value,1800,28158,13987704,28159,28159,28159,13987704,13987704,13987704,1,0.8934578439,0.8934578439,0.8934578439,0.009206699585,1.665602809,,,,,,,,,, +alibaba_v2022,ms_cpu_p99,"quantile(0.99, cpu_utilization)",values,,60,,13987704,,,,466043,466241.5,466848,30,3.126230756,5.542189257,7.138055355,,,2.974040629e-05,0.4628040123,0.04894648654,0.03156,-76.27208332,2.037768318e-16,-76.04881018,9.72424169e-30,light, +alibaba_v2022,ms_cpu_p99,"quantile(0.99, cpu_utilization)",values,,300,,13987704,,,,2331015,2331191,2331479,6,5.241415525,5.542189257,6.135478505,,,2.974040629e-05,0.4628040123,0.04894648654,0.03156,-76.27208332,2.037768318e-16,-76.04881018,9.72424169e-30,light, +alibaba_v2022,ms_cpu_p99,"quantile(0.99, cpu_utilization)",values,,1800,,13987704,,,,13987288,13987288,13987288,1,5.542189257,5.542189257,5.542189257,,,2.974040629e-05,0.4628040123,0.04894648654,0.03156,-76.27208332,2.037768318e-16,-76.04881018,9.72424169e-30,light, +alibaba_v2022,node_cpu_by_nodeid,sum by (nodeid) (cpu_utilization),keys,count,60,42554,1228782,42328,42371,42417,42328,42371,42417,29,3.68585149e-06,0.004274553455,0.004274553455,2.360060613e-05,0.008823732182,,,,,,,,,, +alibaba_v2022,node_cpu_by_nodeid,sum by (nodeid) (cpu_utilization),keys,value,60,42552,1228782,42328,42371,42417,42328,42371,42417,29,0.302619479,0.302619479,0.3280402723,0.0001077013099,0.374094025,,,,,,,,,, +alibaba_v2022,node_cpu_by_nodeid,sum by (nodeid) (cpu_utilization),keys,count,300,42554,1228782,42414,42455,42489,169332,211839.5,212034,6,0.001737612931,0.004274553455,0.004274553455,2.360060613e-05,0.008823732182,,,,,,,,,, +alibaba_v2022,node_cpu_by_nodeid,sum by (nodeid) (cpu_utilization),keys,value,300,42552,1228782,42414,42455,42489,169332,211839.5,212034,6,0.302619479,0.302619479,0.3110770983,0.0001077013099,0.374094025,,,,,,,,,, +alibaba_v2022,node_cpu_by_nodeid,sum by (nodeid) (cpu_utilization),keys,count,1800,42554,1228782,42554,42554,42554,1228782,1228782,1228782,1,0.004274553455,0.004274553455,0.004274553455,2.360060613e-05,0.008823732182,,,,,,,,,, +alibaba_v2022,node_cpu_by_nodeid,sum by (nodeid) (cpu_utilization),keys,value,1800,42552,1228782,42554,42554,42554,1228782,1228782,1228782,1,0.302619479,0.302619479,0.302619479,0.0001077013099,0.374094025,,,,,,,,,, +alibaba_v2022,node_cpu_p99,"quantile(0.99, cpu_utilization)",values,,60,,1228782,,,,42326,42369,42415,29,5.555331164,5.88867925,6.157617344,,,4.720121226e-05,0.3550121596,0.0153464518,0.06211,-3.907517359,0.05765929408,71.88226712,3.086317246e-08,lognormal, +alibaba_v2022,node_cpu_p99,"quantile(0.99, cpu_utilization)",values,,300,,1228782,,,,169324,211829.5,212024,6,5.697479577,5.88867925,5.992465538,,,4.720121226e-05,0.3550121596,0.0153464518,0.06211,-3.907517359,0.05765929408,71.88226712,3.086317246e-08,lognormal, +alibaba_v2022,node_cpu_p99,"quantile(0.99, cpu_utilization)",values,,1800,,1228782,,,,1228724,1228724,1228724,1,5.88867925,5.88867925,5.88867925,,,4.720121226e-05,0.3550121596,0.0153464518,0.06211,-3.907517359,0.05765929408,71.88226712,3.086317246e-08,lognormal, +boom,target_tail[ds-2187-H],"quantile(0.99, target)",values,,,100,523100,,,,,,,900,1.673862396,2.879820136,5.449343474,,,0.0001911680367,1.13650366,0.05719670041,0.1334608031,-0.7518535826,0.1985446789,81.95794065,4.297158362e-06,light,0.45 +boom,target_tail[ds-2394-D],"quantile(0.99, target)",values,,,73,10001,,,,,,,0,,,,,,0.1858814119,,,,,,,,, +boom,target_tail[ds-1135-5T],"quantile(0.99, target)",values,,,26,425984,,,,,,,63,2.072418608,2.555273335,4.464465828,,,0.5493680514,1.309216454,0.09571546402,0.3780193237,-3.202171683,0.08890763899,233.8257673,9.588002711e-10,light,0.3571428571 +boom,target_tail[ds-1833-D],"quantile(0.99, target)",values,,,17,3689,,,,,,,0,,,,,,0.2396313364,,,,,,,,, +boom,target_tail[ds-2806-D],"quantile(0.99, target)",values,,,100,13700,,,,,,,0,,,,,,0.7003649635,,,,,,,,, +boom,target_tail[ds-2573-D],"quantile(0.99, target)",values,,,45,9765,,,,,,,0,7.824807058,7.824807058,7.824807058,,,0.007987711214,2.832573324,0.2237516935,0.4814814815,-0.1549932255,0.1811684879,8.450514888,8.137699192e-05,light,0.2444444444 +boom,target_tail[ds-2222-30T],"quantile(0.99, target)",values,,,100,1045600,,,,,,,800,5.121075907,27.15946506,45.43533407,,,0.5705183627,3.907679107,0.138594883,0.03610214265,-0.3643459076,0.2354562876,16.72715255,3.110465898e-15,heavy_inconclusive,0.97 +boom,target_tail[ds-1914-30T],"quantile(0.99, target)",values,,,64,669504,,,,,,,0,,,,,,0.9991770027,,,,,,,,, +boom,target_tail[ds-2577-H],"quantile(0.99, target)",values,,,11,57541,,,,,,,40,2.357316003,3.318605295,7.114686774,,,0.0001911680367,1.451908794,0.04583397605,0.4337476099,-3.619220504,0.2878918275,168.5626824,1.8816055e-20,light,0.1818181818 +boom,target_tail[ds-2212-D],"quantile(0.99, target)",values,,,42,9114,,,,,,,0,2.097505042,2.097505042,2.097505042,,,0.2055080097,0.1728252252,0.07861559668,0.4741809117,-0.6104251813,0.3802005494,57.44497486,0.003636112868,light,0.3636363636 +boom,target_tail[ds-2782-H],"quantile(0.99, target)",values,,,20,16500,,,,,,,0,,,,,,0.9923636364,,,,,,,,, +boom,target_tail[ds-1400-10S],"quantile(0.99, target)",values,,,75,1228800,,,,,,,680,3.665809149,5.927304101,8.608042368,,,0.0001399739583,3.22594058,0.03461878105,0.1945003968,-0.5020486991,0.1052433657,67.48976464,1.414326313e-05,light,0.4533333333 +boom,target_tail[ds-2650-D],"quantile(0.99, target)",values,,,56,12152,,,,,,,0,2.372256328,2.372256328,2.372256328,,,0.004772876893,0.3060346595,0.07025218904,0.4814814815,-0.4345545346,0.5532457248,23.54371772,0.03707674656,light,0.25 +boom,target_tail[ds-1316-10S],"quantile(0.99, target)",values,,,40,655360,,,,,,,800,1.394454939,2.841176959,3.782745604,,,0.1220932007,2.273231677,0.03804312837,0.03161851893,-1.526906431,0.1625683967,48.84256082,4.793863342e-08,heavy_inconclusive,1 +boom,target_tail[ds-1558-5T],"quantile(0.99, target)",values,,,97,1589248,,,,,,,1195,2.859011495,4.965505023,14.93467462,,,0.1971838253,2.030408032,0.08454367574,0.2353085011,0.01446142949,0.1477685349,143.8265644,7.494706033e-08,heavy_inconclusive,0.6701030928 +boom,target_tail[ds-1972-D],"quantile(0.99, target)",values,,,39,5343,,,,,,,0,,,,,,0.05577390979,,,,,,,,, +boom,target_tail[ds-1840-D],"quantile(0.99, target)",values,,,100,21700,,,,,,,0,48.70890868,48.70890868,48.70890868,,,0.00465437788,5.808935183,0.1729496632,0.5046296296,-0.1558493932,0.6911382477,15.25220643,2.851033848e-05,light,0.11 +boom,target_tail[ds-671-10S],"quantile(0.99, target)",values,,,100,1638400,,,,,,,0,,,,,,6.103515625e-05,,,,,,,,light,0 +boom,target_tail[ds-1524-5T],"quantile(0.99, target)",values,,,93,1267683,,,,,,,18,3.310389413,3.310389413,3.692673948,,,0.944850566,1.984224252,0.2043641455,0.523993808,-0.7337541742,0.1428173664,51.73262359,2.004766276e-06,heavy_inconclusive,0.6470588235 +boom,target_tail[ds-899-T],"quantile(0.99, target)",values,,,12,196608,,,,,,,144,2.379500335,4.776016519,4.776016519,,,0.4203440348,3.316427802,0.0820839487,0.05264234598,-0.6434653813,0.1335383104,64.54346235,4.612421122e-07,heavy_inconclusive,1 +google_2011,cpu_by_user,sum by (user) (cpu_rate),keys,count,300,518,2520773,507,510,513,136616,145568,166103,17,1.220115177,1.23996806,1.275255465,0.1574362309,2.334090565,,,,,,,,,, +google_2011,cpu_by_user,sum by (user) (cpu_rate),keys,value,300,495,2520773,507,510,513,136616,145568,166103,17,1.24603505,1.30345187,1.424144835,0.1682000211,3.78680042,,,,,,,,,, +google_2011,cpu_by_user,sum by (user) (cpu_rate),keys,count,900,518,2520773,510,511,515,136616,432405,475713,7,1.220115177,1.23996806,1.258241918,0.1574362309,2.334090565,,,,,,,,,, +google_2011,cpu_by_user,sum by (user) (cpu_rate),keys,value,900,495,2520773,510,511,515,136616,432405,475713,7,1.24603505,1.30345187,1.369458807,0.1682000211,3.78680042,,,,,,,,,, +google_2011,cpu_by_user,sum by (user) (cpu_rate),keys,count,3600,518,2520773,514,514.5,515,999631,1260386.5,1521142,2,1.231395655,1.23996806,1.24591221,0.1574362309,2.334090565,,,,,,,,,, +google_2011,cpu_by_user,sum by (user) (cpu_rate),keys,value,3600,495,2520773,514,514.5,515,999631,1260386.5,1521142,2,1.299004723,1.30345187,1.308575375,0.1682000211,3.78680042,,,,,,,,,, +google_2011,cpu_by_user_priority,"sum by (user, priority) (cpu_rate)",keys,count,300,869,2520773,821,827,834,136616,145568,166103,17,1.224971871,1.245842046,1.279308156,0.1519994065,2.118691289,,,,,,,,,, +google_2011,cpu_by_user_priority,"sum by (user, priority) (cpu_rate)",keys,value,300,840,2520773,821,827,834,136616,145568,166103,17,1.269877913,1.324164419,1.436614074,0.1681176267,3.410932446,,,,,,,,,, +google_2011,cpu_by_user_priority,"sum by (user, priority) (cpu_rate)",keys,count,900,869,2520773,830,834,842,136616,432405,475713,7,1.224971871,1.245842046,1.262451768,0.1519994065,2.118691289,,,,,,,,,, +google_2011,cpu_by_user_priority,"sum by (user, priority) (cpu_rate)",keys,value,900,840,2520773,830,834,842,136616,432405,475713,7,1.269877913,1.324164419,1.384966721,0.1681176267,3.410932446,,,,,,,,,, +google_2011,cpu_by_user_priority,"sum by (user, priority) (cpu_rate)",keys,count,3600,869,2520773,850,851,852,999631,1260386.5,1521142,2,1.237062997,1.245842046,1.25092252,0.1519994065,2.118691289,,,,,,,,,, +google_2011,cpu_by_user_priority,"sum by (user, priority) (cpu_rate)",keys,value,3600,840,2520773,850,851,852,999631,1260386.5,1521142,2,1.319267171,1.324164419,1.328123309,0.1681176267,3.410932446,,,,,,,,,, +google_2011,cpu_by_priority,sum by (priority) (cpu_rate),keys,count,300,7,2520773,7,7,7,136616,145568,166103,17,1.033395762,1.100458821,1.174312489,0.3225498686,1.894965449,,,,,,,,,, +google_2011,cpu_by_priority,sum by (priority) (cpu_rate),keys,value,300,7,2520773,7,7,7,136616,145568,166103,17,1.438654738,1.605012701,1.751743738,0.5360046297,2.032407492,,,,,,,,,, +google_2011,cpu_by_priority,sum by (priority) (cpu_rate),keys,count,900,7,2520773,7,7,7,136616,432405,475713,7,1.068090328,1.100458821,1.174312489,0.3225498686,1.894965449,,,,,,,,,, +google_2011,cpu_by_priority,sum by (priority) (cpu_rate),keys,value,900,7,2520773,7,7,7,136616,432405,475713,7,1.498978566,1.605012701,1.710803,0.5360046297,2.032407492,,,,,,,,,, +google_2011,cpu_by_priority,sum by (priority) (cpu_rate),keys,count,3600,7,2520773,7,7,7,999631,1260386.5,1521142,2,1.08297446,1.100458821,1.127200352,0.3225498686,1.894965449,,,,,,,,,, +google_2011,cpu_by_priority,sum by (priority) (cpu_rate),keys,value,3600,7,2520773,7,7,7,999631,1260386.5,1521142,2,1.593554992,1.605012701,1.645136858,0.5360046297,2.032407492,,,,,,,,,, +google_2011,cpu_by_job_id,sum by (job_id) (cpu_rate),keys,count,300,4852,2520773,3999,4033,4069,136616,145568,166103,17,1.10280233,1.10280233,1.139601264,0.1380993053,1.685959941,,,,,,,,,, +google_2011,cpu_by_job_id,sum by (job_id) (cpu_rate),keys,value,300,4741,2520773,3999,4033,4069,136616,145568,166103,17,1.142583401,1.143387587,1.225051106,0.04883747247,2.916311489,,,,,,,,,, +google_2011,cpu_by_job_id,sum by (job_id) (cpu_rate),keys,count,900,4852,2520773,4033,4109,4193,136616,432405,475713,7,1.10280233,1.10280233,1.119091194,0.1380993053,1.685959941,,,,,,,,,, +google_2011,cpu_by_job_id,sum by (job_id) (cpu_rate),keys,value,900,4741,2520773,4033,4109,4193,136616,432405,475713,7,1.143387587,1.143387587,1.201204532,0.04883747247,2.916311489,,,,,,,,,, +google_2011,cpu_by_job_id,sum by (job_id) (cpu_rate),keys,count,3600,4852,2520773,4301,4411.5,4522,999631,1260386.5,1521142,2,1.10280233,1.10280233,1.110415978,0.1380993053,1.685959941,,,,,,,,,, +google_2011,cpu_by_job_id,sum by (job_id) (cpu_rate),keys,value,3600,4741,2520773,4301,4411.5,4522,999631,1260386.5,1521142,2,1.142992759,1.143387587,1.170229373,0.04883747247,2.916311489,,,,,,,,,, +google_2011,cpu_by_logical_job_name,sum by (logical_job_name) (cpu_rate),keys,count,300,4076,2520773,3599,3632,3670,136616,145568,166103,17,1.100157443,1.100157443,1.139773475,0.1380993053,1.674808823,,,,,,,,,, +google_2011,cpu_by_logical_job_name,sum by (logical_job_name) (cpu_rate),keys,value,300,3994,2520773,3599,3632,3670,136616,145568,166103,17,1.137364272,1.137364272,1.222463693,0.04883747247,2.955531246,,,,,,,,,, +google_2011,cpu_by_logical_job_name,sum by (logical_job_name) (cpu_rate),keys,count,900,4076,2520773,3632,3681,3764,136616,432405,475713,7,1.100157443,1.100157443,1.118962316,0.1380993053,1.674808823,,,,,,,,,, +google_2011,cpu_by_logical_job_name,sum by (logical_job_name) (cpu_rate),keys,value,900,3994,2520773,3632,3681,3764,136616,432405,475713,7,1.137364272,1.137364272,1.198192862,0.04883747247,2.955531246,,,,,,,,,, +google_2011,cpu_by_logical_job_name,sum by (logical_job_name) (cpu_rate),keys,count,3600,4076,2520773,3786,3865.5,3945,999631,1260386.5,1521142,2,1.100157443,1.100157443,1.110326676,0.1380993053,1.674808823,,,,,,,,,, +google_2011,cpu_by_logical_job_name,sum by (logical_job_name) (cpu_rate),keys,value,3600,3994,2520773,3786,3865.5,3945,999631,1260386.5,1521142,2,1.137364272,1.137364272,1.166334908,0.04883747247,2.955531246,,,,,,,,,, +google_2011,cpu_by_scheduling_class,sum by (scheduling_class) (cpu_rate),keys,count,300,4,2520773,4,4,4,136616,145568,166103,17,0.4096890076,0.5826207427,0.7586051394,0.3811549076,0.5742969456,,,,,,,,,, +google_2011,cpu_by_scheduling_class,sum by (scheduling_class) (cpu_rate),keys,value,300,4,2520773,4,4,4,136616,145568,166103,17,0.3731987046,0.4296407108,0.9847385735,0.3062121264,0.5650755731,,,,,,,,,, +google_2011,cpu_by_scheduling_class,sum by (scheduling_class) (cpu_rate),keys,count,900,4,2520773,4,4,4,136616,432405,475713,7,0.4096890076,0.5826207427,0.688766467,0.3811549076,0.5742969456,,,,,,,,,, +google_2011,cpu_by_scheduling_class,sum by (scheduling_class) (cpu_rate),keys,value,900,4,2520773,4,4,4,136616,432405,475713,7,0.3853822278,0.4296407108,0.7506561584,0.3062121264,0.5650755731,,,,,,,,,, +google_2011,cpu_by_scheduling_class,sum by (scheduling_class) (cpu_rate),keys,count,3600,4,2520773,4,4,4,999631,1260386.5,1521142,2,0.5090081589,0.5826207427,0.6326222715,0.3811549076,0.5742969456,,,,,,,,,, +google_2011,cpu_by_scheduling_class,sum by (scheduling_class) (cpu_rate),keys,value,3600,4,2520773,4,4,4,999631,1260386.5,1521142,2,0.4296407108,0.4296407108,0.5151663234,0.3062121264,0.5650755731,,,,,,,,,, +google_2011,cpu_by_machine_id,sum by (machine_id) (cpu_rate),keys,count,300,12478,2520773,12470,12474,12476,136616,145568,166103,17,0.2076429296,0.2076429296,0.246048195,0.000191211188,0.2526538379,,,,,,,,,, +google_2011,cpu_by_machine_id,sum by (machine_id) (cpu_rate),keys,value,300,12477,2520773,12470,12474,12476,136616,145568,166103,17,0.2863871442,0.2863871442,0.3545079855,0.000345690753,0.3999845952,,,,,,,,,, +google_2011,cpu_by_machine_id,sum by (machine_id) (cpu_rate),keys,count,900,12478,2520773,12473,12475,12476,136616,432405,475713,7,0.2076429296,0.2076429296,0.2389469664,0.000191211188,0.2526538379,,,,,,,,,, +google_2011,cpu_by_machine_id,sum by (machine_id) (cpu_rate),keys,value,900,12477,2520773,12473,12475,12476,136616,432405,475713,7,0.2863871442,0.2863871442,0.3523868085,0.000345690753,0.3999845952,,,,,,,,,, +google_2011,cpu_by_machine_id,sum by (machine_id) (cpu_rate),keys,count,3600,12478,2520773,12476,12476,12476,999631,1260386.5,1521142,2,0.2071122542,0.2076429296,0.2158581867,0.000191211188,0.2526538379,,,,,,,,,, +google_2011,cpu_by_machine_id,sum by (machine_id) (cpu_rate),keys,value,3600,12477,2520773,12476,12476,12476,999631,1260386.5,1521142,2,0.2844139376,0.2863871442,0.3125403084,0.000345690753,0.3999845952,,,,,,,,,, +google_2011,cpu_p99,"quantile(0.99, cpu_rate)",values,,300,,2520773,,,,126133,132019,146232,17,2.603912147,2.917403705,14.45311216,,,0.09529497499,0.04578,0.04233155135,0.14383,-46.90714986,3.193615919e-13,851.9603769,6.063873751e-88,lognormal, +google_2011,cpu_p99,"quantile(0.99, cpu_rate)",values,,900,,2520773,,,,126133,394800,423512,7,2.673058645,2.917403705,3.340213559,,,0.09529497499,0.04578,0.04233155135,0.14383,-46.90714986,3.193615919e-13,851.9603769,6.063873751e-88,lognormal, +google_2011,cpu_p99,"quantile(0.99, cpu_rate)",values,,3600,,2520773,,,,914192,1140278,1366364,2,2.849760024,2.917403705,2.917403705,,,0.09529497499,0.04578,0.04233155135,0.14383,-46.90714986,3.193615919e-13,851.9603769,6.063873751e-88,lognormal, +google_2011,memory_p99,"quantile(0.99, canonical_memory_usage)",values,,300,,2520773,,,,125080,129779,141433,17,1.774757531,3.294268519,4.337275342,,,0.1138678493,0.05066,0.1412197713,0.15382,-34.94390733,7.239118312e-13,747.9070106,2.316474087e-98,lognormal, +google_2011,memory_p99,"quantile(0.99, canonical_memory_usage)",values,,900,,2520773,,,,125080,387491,412288,7,1.807386797,3.294268519,3.294268519,,,0.1138678493,0.05066,0.1412197713,0.15382,-34.94390733,7.239118312e-13,747.9070106,2.316474087e-98,lognormal, +google_2011,memory_p99,"quantile(0.99, canonical_memory_usage)",values,,3600,,2520773,,,,899559,1116869,1334179,2,1.798673328,3.294268519,3.294268519,,,0.1138678493,0.05066,0.1412197713,0.15382,-34.94390733,7.239118312e-13,747.9070106,2.316474087e-98,lognormal, diff --git a/asap-tools/dataset-analysis/tests/test_fit_skew.py b/asap-tools/dataset-analysis/tests/test_fit_skew.py index 5cf4654c..16856313 100644 --- a/asap-tools/dataset-analysis/tests/test_fit_skew.py +++ b/asap-tools/dataset-analysis/tests/test_fit_skew.py @@ -197,7 +197,7 @@ def test_summarize_keys_skips_small_windows(self): self.assertAlmostEqual(row["lower"], 0.8, delta=ZIPF_TOLERANCE) self.assertAlmostEqual(row["upper"], 1.2, delta=ZIPF_TOLERANCE) self.assertTrue(row["lower"] <= row["mle"] <= row["upper"]) - self.assertEqual(row["K"], ZIPF_K) + self.assertEqual(row["K_total"], ZIPF_K) self.assertEqual(row["window_len_s"], 60) def test_summarize_keys_window_lengths(self): @@ -215,6 +215,32 @@ def test_summarize_keys_window_lengths(self): for row in (fine, coarse): self.assertTrue(row["lower"] <= row["mle"] <= row["upper"]) + def test_per_window_stats(self): + # Finest windows 0..3 with 3, 1, 2, 2 keys; key "a" appears in all. + frame = pd.DataFrame( + { + fit_skew.WINDOW_COL: [0, 0, 0, 1, 2, 2, 3, 3], + "k": ["a", "b", "c", "a", "a", "b", "a", "d"], + fit_skew.COUNT_COL: [5, 1, 1, 7, 2, 2, 1, 9], + } + ) + agg = fit_skew.merge_key_parts([frame], ["k"]) + fine, coarse = fit_skew.summarize_keys( + "test", COUNT_QUERY, agg, [60, 120], 1, 2, None + ) + self.assertEqual((fine["K_total"], fine["rows_total"]), (4, 28)) + self.assertEqual( + (fine["K_win_min"], fine["K_win_median"], fine["K_win_max"]), (1, 2, 3) + ) + self.assertEqual( + (fine["rows_win_min"], fine["rows_win_median"], fine["rows_win_max"]), + (4, 7, 10), + ) + # Merged windows {0,1} and {2,3}: keys {a,b,c} and {a,b,d}, rows 14 and 14. + self.assertEqual((coarse["K_win_min"], coarse["K_win_max"]), (3, 3)) + self.assertEqual((coarse["rows_win_min"], coarse["rows_win_max"]), (14, 14)) + self.assertEqual(coarse["K_total"], fine["K_total"]) + def test_coarsen_values(self): windows = {0: np.array([1.0]), 1: np.array([2.0]), 2: np.array([3.0])} coarse = fit_skew.coarsen_values(windows, 2) @@ -234,6 +260,8 @@ def test_summarize_values_window_lengths(self): rows = fit_skew.summarize_values("test", q, acc, [60, 240], pool, 1, None) self.assertEqual([r["window_len_s"] for r in rows], [60, 240]) self.assertEqual([r["n_windows"] for r in rows], [4, 1]) + self.assertEqual([r["rows_win_median"] for r in rows], [1000, 4000]) + self.assertNotIn("K_win_median", rows[0]) for row in rows: self.assertTrue(row["lower"] <= row["mle"] <= row["upper"]) From db0ce6499c4320fda58d52623a6b39eb8fbd6e3c Mon Sep 17 00:00:00 2001 From: zz_y Date: Tue, 29 Sep 2026 23:03:34 +0000 Subject: [PATCH 7/8] feat(asap-tools): extend skew analysis to longer lookback windows Fetch and analyze a longer sample: Google task_usage/task_events parts 0-119 (about 7 days), Alibaba CallGraph/MCRRTUpdate shards 0-119 (6 h), MSMetricsUpdate 0-47 and NodeMetricsUpdate 0-1 (1 day). Drop the 30-minute clip on Alibaba tables and let a table override the dataset's window_lengths_s, so window lengths reach 6 h (CallGraph, MSRTMCR), 1 day (MSMetrics, NodeMetrics) and 7 days (Google). Joins are loaded once per table instead of once per file, so the task_events join covers all 120 parts. Regenerate results/skew_summary.csv. Co-Authored-By: Claude Opus 5.5 --- asap-tools/dataset-analysis/README.md | 22 +- asap-tools/dataset-analysis/fetch_data.sh | 25 +- asap-tools/dataset-analysis/fit_skew.py | 21 +- .../queries/alibaba_v2022.yaml | 21 +- .../dataset-analysis/queries/google_2011.yaml | 9 +- .../dataset-analysis/results/skew_summary.csv | 334 ++++++++++++------ .../dataset-analysis/tests/test_fit_skew.py | 8 + 7 files changed, 286 insertions(+), 154 deletions(-) diff --git a/asap-tools/dataset-analysis/README.md b/asap-tools/dataset-analysis/README.md index 9c282ce7..7b7fa0b8 100644 --- a/asap-tools/dataset-analysis/README.md +++ b/asap-tools/dataset-analysis/README.md @@ -20,7 +20,7 @@ Two tasks: ```bash pip install -r requirements.txt -./fetch_data.sh /path/to/trace-data # ~5 GB; re-run to resume +./fetch_data.sh /path/to/trace-data # ~63 GB; re-run to resume python fit_skew.py --data-root /path/to/trace-data ``` @@ -36,8 +36,8 @@ This writes `results/skew_summary.csv` (committed) and plots to `out/` - `--workers N`: process pool size (default: all cores). Files and fits run in parallel. -A full run over the fetched data takes about 5 minutes with 48 workers on a -56-core machine (peak RSS of the main process about 3.6 GB). Alibaba archives are streamed with `tarfile`, not extracted. +A full run over the fetched data takes about 1.6 hours with 24 workers on a +56-core machine (peak RSS of the main process about 49 GB). Alibaba archives are streamed with `tarfile`, not extracted. Tests: `python -m unittest discover -s tests -p 'test_*.py'`. @@ -45,8 +45,9 @@ Tests: `python -m unittest discover -s tests -p 'test_*.py'`. | Dataset | Files | Tables | Window lengths | |---|---|---|---| -| Google ClusterData 2011-2 | `task_usage` and `task_events` part 0 of 500, all 500 `job_events` parts, `schema.csv` | `task_usage` joined with task and job attributes | 5, 15, 60 min | -| Alibaba microservices v2022 | `NodeMetricsUpdate_0`, `MSMetricsUpdate_0`, `CallGraph_0..9`, `MCRRTUpdate_0..9` (first 30 minutes) | `MSRTMCR`, `CallGraph`, `MSMetrics`, `NodeMetrics` | 1, 5, 30 min | +| Google ClusterData 2011-2 | `task_usage` and `task_events` parts 0..119 of 500 (about 7 days), all 500 `job_events` parts, `schema.csv` | `task_usage` joined with task and job attributes | 5 min, 15 min, 1 h, 6 h, 1 day, 7 days | +| Alibaba microservices v2022 | `CallGraph_0..119`, `MCRRTUpdate_0..119` (first 6 hours) | `CallGraph`, `MSRTMCR` | 1 min, 5 min, 30 min, 1 h, 6 h | +| | `MSMetricsUpdate_0..47`, `NodeMetricsUpdate_0..1` (first day) | `MSMetrics`, `NodeMetrics` | 1 min, 5 min, 30 min, 1 h, 6 h, 1 day | | Datadog BOOM | `dataset_taxonomy.json` and 20 multivariate series | per-series `target` | 20 equal chunks per series | Citations: @@ -170,15 +171,18 @@ rank-frequency with the lower/mle/upper θ lines, one per window length) and `p`, ...) are medians over the same variates; all are empty if every variate is light. - **Google join rule**: `task_usage` rows get `user`, `priority` and - `scheduling_class` from the last non-null `task_events` value for the same - `(job_id, task_index)`, and `logical_job_name` from the last non-null + `scheduling_class` from the last non-null value for the same + `(job_id, task_index)` over all 120 fetched `task_events` parts, and `logical_job_name` from the last non-null `job_events` value for the same `job_id` (both ordered by event time). - **Small counts bias θ upward**: θ is fitted to the *sorted observed* counts, so the long tail of keys seen once or twice is flatter than the true law and the order statistics exaggerate the head. Windows with few rows per key (short windows, high-cardinality keys) are most affected, which widens `upper`. -- Alibaba tables are clipped to the first 30 minutes (`max_time_secs`), the - span of the 10 CallGraph / MCRRTUpdate shards. CallGraph has malformed rows +- Each table covers its full downloaded span, so the longest window length + of a table is one window over the whole sample. A table's + `window_lengths_s` overrides the dataset's. MSMetrics and NodeMetrics + sample every 60 s, so a 1-minute window holds one sample per instance or + node. CallGraph has malformed rows (extra fields), which are skipped and counted in the log, and `rt` values of `None`, which are read as missing. diff --git a/asap-tools/dataset-analysis/fetch_data.sh b/asap-tools/dataset-analysis/fetch_data.sh index 244dae36..1512ed73 100755 --- a/asap-tools/dataset-analysis/fetch_data.sh +++ b/asap-tools/dataset-analysis/fetch_data.sh @@ -13,9 +13,15 @@ GOOGLE_URL=https://storage.googleapis.com/clusterdata-2011-2 ALIBABA_URL=https://aliopentrace.oss-cn-beijing.aliyuncs.com/v2022MicroservicesTraces BOOM_URL=https://huggingface.co/datasets/Datadog/BOOM/resolve/main +# task_usage parts cover about 1.4 hours each; 120 parts = about 7 days. +# task_events uses the same parts; job_events is read in full for job names. +GOOGLE_TASK_PARTS=120 GOOGLE_JOB_EVENT_PARTS=500 -# CallGraph and MCRRTUpdate shards each cover 3 minutes; 10 shards = 30 minutes. -ALIBABA_RPC_SHARDS=10 +# CallGraph and MCRRTUpdate shards cover 3 minutes each: 120 shards = 6 hours. +ALIBABA_RPC_SHARDS=120 +# MSMetricsUpdate shards cover 30 minutes, NodeMetricsUpdate 12 hours: 1 day. +ALIBABA_MS_SHARDS=48 +ALIBABA_NODE_SHARDS=2 BOOM_SERIES=( ds-2187-H ds-2394-D ds-1135-5T ds-1833-D ds-2806-D @@ -43,15 +49,22 @@ google_part() { G=$DATA_ROOT/google-2011 fetch "$GOOGLE_URL/schema.csv" "$G/schema.csv" -fetch "$GOOGLE_URL/task_usage/$(google_part 0)" "$G/task_usage/$(google_part 0)" -fetch "$GOOGLE_URL/task_events/$(google_part 0)" "$G/task_events/$(google_part 0)" +for ((i = 0; i < GOOGLE_TASK_PARTS; i++)); do + for t in task_usage task_events; do + fetch "$GOOGLE_URL/$t/$(google_part "$i")" "$G/$t/$(google_part "$i")" + done +done for ((i = 0; i < GOOGLE_JOB_EVENT_PARTS; i++)); do fetch "$GOOGLE_URL/job_events/$(google_part "$i")" "$G/job_events/$(google_part "$i")" done A=$DATA_ROOT/alibaba-v2022 -fetch "$ALIBABA_URL/NodeMetricsUpdate/NodeMetricsUpdate_0.tar.gz" "$A/NodeMetricsUpdate_0.tar.gz" -fetch "$ALIBABA_URL/MSMetricsUpdate/MSMetricsUpdate_0.tar.gz" "$A/MSMetricsUpdate_0.tar.gz" +for ((i = 0; i < ALIBABA_NODE_SHARDS; i++)); do + fetch "$ALIBABA_URL/NodeMetricsUpdate/NodeMetricsUpdate_$i.tar.gz" "$A/NodeMetricsUpdate_$i.tar.gz" +done +for ((i = 0; i < ALIBABA_MS_SHARDS; i++)); do + fetch "$ALIBABA_URL/MSMetricsUpdate/MSMetricsUpdate_$i.tar.gz" "$A/MSMetricsUpdate_$i.tar.gz" +done for ((i = 0; i < ALIBABA_RPC_SHARDS; i++)); do fetch "$ALIBABA_URL/CallGraph/CallGraph_$i.tar.gz" "$A/CallGraph_$i.tar.gz" fetch "$ALIBABA_URL/MCRRTUpdate/MCRRTUpdate_$i.tar.gz" "$A/MCRRTUpdate_$i.tar.gz" diff --git a/asap-tools/dataset-analysis/fit_skew.py b/asap-tools/dataset-analysis/fit_skew.py index 54bc118d..712cf206 100644 --- a/asap-tools/dataset-analysis/fit_skew.py +++ b/asap-tools/dataset-analysis/fit_skew.py @@ -150,6 +150,11 @@ def validate_window_lengths(lengths: Sequence[int], where: str) -> None: def validate_config(cfg: Dict[str, Any]) -> None: if "window_lengths_s" in cfg: validate_window_lengths(cfg["window_lengths_s"], cfg["dataset"]) + for name, table in cfg["tables"].items(): + if "window_lengths_s" in table: + validate_window_lengths( + table["window_lengths_s"], f"{cfg['dataset']}/{name}" + ) for q in cfg["queries"]: where = f"{cfg['dataset']}/{q['id']}" table = cfg["tables"].get(q["table"]) @@ -303,14 +308,13 @@ def add_values(acc: Dict[str, Any], windows: np.ndarray, values: np.ndarray) -> def aggregate_file(task: Tuple[Any, ...]) -> Dict[str, Any]: """Per-window key aggregates and positive values for one file.""" - data_root, table, path, queries, window_len_s, max_time_secs, max_rows = task + data_root, table, path, queries, window_len_s, joins, max_rows = task time_col = table["time_column"] value_cols = {q["value"] for q in queries if q.get("value")} join_cols = [c for j in table.get("joins", []) for c in j["columns"]] needed = {time_col} | value_cols needed |= {c for q in queries for c in q["group_by"] if c not in join_cols} needed |= {c for j in table.get("joins", []) for c in j["keys"]} - joins = [(j, load_join(data_root, table, j)) for j in table.get("joins", [])] key_parts: Dict[Tuple[str, str], List[pd.DataFrame]] = {} values: Dict[Tuple[str, str], Dict[str, Any]] = {} @@ -330,8 +334,6 @@ def aggregate_file(task: Tuple[Any, ...]) -> Dict[str, Any]: rows_read += len(frame) secs = frame[time_col] * table["time_unit_secs"] keep = secs.notna() - if max_time_secs is not None: - keep &= secs < max_time_secs frame = frame[keep].copy() frame[WINDOW_COL] = np.floor(secs[keep] / window_len_s).astype(np.int64) for join, lookup in joins: @@ -695,14 +697,17 @@ def analyze_table( args: argparse.Namespace, plot_dir: Optional[Path], ) -> List[Dict[str, Any]]: + window_lengths = table.get("window_lengths_s") or cfg["window_lengths_s"] + # Load each join once here rather than in every file task. + joins = [(j, load_join(data_root, table, j)) for j in table.get("joins", [])] tasks = [ ( data_root, table, path, queries, - cfg["window_lengths_s"][0], - cfg.get("max_time_secs"), + window_lengths[0], + joins, args.max_rows, ) for path in expand_files(data_root, table["files"]) @@ -726,7 +731,7 @@ def analyze_table( cfg["dataset"], q, agg, - cfg["window_lengths_s"], + window_lengths, args.min_window_rows, args.min_window_keys, plot_dir, @@ -743,7 +748,7 @@ def analyze_table( cfg["dataset"], q, acc, - cfg["window_lengths_s"], + window_lengths, pool, args.min_window_rows, plot_dir, diff --git a/asap-tools/dataset-analysis/queries/alibaba_v2022.yaml b/asap-tools/dataset-analysis/queries/alibaba_v2022.yaml index fb992253..ba997e19 100644 --- a/asap-tools/dataset-analysis/queries/alibaba_v2022.yaml +++ b/asap-tools/dataset-analysis/queries/alibaba_v2022.yaml @@ -1,35 +1,36 @@ -# Alibaba cluster-trace-microservices-v2022, first 30 minutes. +# Alibaba cluster-trace-microservices-v2022: first 6 hours of CallGraph and +# MCRRTUpdate, first day of MSMetricsUpdate and NodeMetricsUpdate. dataset: alibaba_v2022 -# Bounds are computed at each window length; the first is the finest. -window_lengths_s: [60, 300, 1800] -# NodeMetricsUpdate_0 covers 12 hours; clip every table to the 30 minutes -# covered by the CallGraph and MCRRTUpdate shards. -max_time_secs: 1800 +# Bounds are computed at each window length; the first is the finest. Tables +# without window_lengths_s use this one. +window_lengths_s: [60, 300, 1800, 3600, 21600] tables: MSRTMCR: format: alibaba_tar - files: ["alibaba-v2022/MCRRTUpdate_[0-9].tar.gz"] + files: ["alibaba-v2022/MCRRTUpdate_*.tar.gz"] time_column: timestamp time_unit_secs: 1.0e-3 label_columns: [msname, msinstanceid, nodeid] value_columns: [providerrpc_rt, providerrpc_mcr] CallGraph: format: alibaba_tar - files: ["alibaba-v2022/CallGraph_[0-9].tar.gz"] + files: ["alibaba-v2022/CallGraph_*.tar.gz"] time_column: timestamp time_unit_secs: 1.0e-3 label_columns: [traceid, service, rpc_id, rpctype, um, uminstanceid, interface, dm, dminstanceid] value_columns: [rt] MSMetrics: format: alibaba_tar - files: [alibaba-v2022/MSMetricsUpdate_0.tar.gz] + files: ["alibaba-v2022/MSMetricsUpdate_*.tar.gz"] + window_lengths_s: [60, 300, 1800, 3600, 21600, 86400] time_column: timestamp time_unit_secs: 1.0e-3 label_columns: [msname, msinstanceid, nodeid] value_columns: [cpu_utilization, memory_utilization] NodeMetrics: format: alibaba_tar - files: [alibaba-v2022/NodeMetricsUpdate_0.tar.gz] + files: ["alibaba-v2022/NodeMetricsUpdate_*.tar.gz"] + window_lengths_s: [60, 300, 1800, 3600, 21600, 86400] time_column: timestamp time_unit_secs: 1.0e-3 label_columns: [nodeid] diff --git a/asap-tools/dataset-analysis/queries/google_2011.yaml b/asap-tools/dataset-analysis/queries/google_2011.yaml index bc50c8ed..2fcfdd83 100644 --- a/asap-tools/dataset-analysis/queries/google_2011.yaml +++ b/asap-tools/dataset-analysis/queries/google_2011.yaml @@ -1,17 +1,18 @@ -# Google ClusterData 2011-2, shard 0 of task_usage joined with task attributes. +# Google ClusterData 2011-2: task_usage parts 0-119 (about 7 days) joined with +# task and job attributes. dataset: google_2011 # Bounds are computed at each window length; the first is the finest. -window_lengths_s: [300, 900, 3600] +window_lengths_s: [300, 900, 3600, 21600, 86400, 604800] tables: task_usage: format: google_csv schema: google-2011/schema.csv - files: [google-2011/task_usage/part-00000-of-00500.csv.gz] + files: ["google-2011/task_usage/part-*-of-00500.csv.gz"] time_column: start_time time_unit_secs: 1.0e-6 # Each join keeps the last event per key (sorted by sort_by) and left-joins it. joins: - - files: [google-2011/task_events/part-00000-of-00500.csv.gz] + - files: ["google-2011/task_events/part-*-of-00500.csv.gz"] keys: [job_id, task_index] sort_by: time columns: [user, priority, scheduling_class] diff --git a/asap-tools/dataset-analysis/results/skew_summary.csv b/asap-tools/dataset-analysis/results/skew_summary.csv index efd615cb..75be6389 100644 --- a/asap-tools/dataset-analysis/results/skew_summary.csv +++ b/asap-tools/dataset-analysis/results/skew_summary.csv @@ -1,73 +1,125 @@ dataset,query_id,promql,kind,weight,window_len_s,K_total,rows_total,K_win_min,K_win_median,K_win_max,rows_win_min,rows_win_median,rows_win_max,n_windows,lower,mle,upper,top1_share,theta_ls,dropped_frac,xmin,ks_d,tail_frac,R_lognormal,p_lognormal,R_exponential,p_exponential,tail_class,ok_frac -alibaba_v2022,mcr_by_msname,sum by (msname) (providerrpc_mcr),keys,count,60,26077,90315535,25897,25913.5,25946,1851317,2620027,6116768,30,1.34145226,1.535683382,1.900453851,0.551844464,1.358823026,,,,,,,,,, -alibaba_v2022,mcr_by_msname,sum by (msname) (providerrpc_mcr),keys,value,60,17911,90315535,25897,25913.5,25946,1851317,2620027,6116768,30,1.02886251,1.110543808,1.306967015,0.183649676,3.623496783,,,,,,,,,, -alibaba_v2022,mcr_by_msname,sum by (msname) (providerrpc_mcr),keys,count,300,26077,90315535,25982,25999,26017,12598774,14510179.5,20040209,6,1.459050605,1.535683382,1.664745,0.551844464,1.358823026,,,,,,,,,, -alibaba_v2022,mcr_by_msname,sum by (msname) (providerrpc_mcr),keys,value,300,17911,90315535,25982,25999,26017,12598774,14510179.5,20040209,6,1.073448849,1.110543808,1.181235381,0.183649676,3.623496783,,,,,,,,,, -alibaba_v2022,mcr_by_msname,sum by (msname) (providerrpc_mcr),keys,count,1800,26077,90315535,26077,26077,26077,90315535,90315535,90315535,1,1.535683382,1.535683382,1.535683382,0.551844464,1.358823026,,,,,,,,,, -alibaba_v2022,mcr_by_msname,sum by (msname) (providerrpc_mcr),keys,value,1800,17911,90315535,26077,26077,26077,90315535,90315535,90315535,1,1.110543808,1.110543808,1.110543808,0.183649676,3.623496783,,,,,,,,,, -alibaba_v2022,mcr_by_nodeid,sum by (nodeid) (providerrpc_mcr),keys,count,60,30776,90315535,30741,30749,30761,1851317,2620027,6116768,30,1.069623945,1.125599263,1.22637178,0.02993950044,0.6717705283,,,,,,,,,, -alibaba_v2022,mcr_by_nodeid,sum by (nodeid) (providerrpc_mcr),keys,value,60,28319,90315535,30741,30749,30761,1851317,2620027,6116768,30,0.6297640693,0.7603646648,0.9855634538,0.01030423561,0.9053034762,,,,,,,,,, -alibaba_v2022,mcr_by_nodeid,sum by (nodeid) (providerrpc_mcr),keys,count,300,30776,90315535,30752,30757.5,30767,12598774,14510179.5,20040209,6,1.114742605,1.125599263,1.175793283,0.02993950044,0.6717705283,,,,,,,,,, -alibaba_v2022,mcr_by_nodeid,sum by (nodeid) (providerrpc_mcr),keys,value,300,28319,90315535,30752,30757.5,30767,12598774,14510179.5,20040209,6,0.7117850782,0.7603646648,0.8586025258,0.01030423561,0.9053034762,,,,,,,,,, -alibaba_v2022,mcr_by_nodeid,sum by (nodeid) (providerrpc_mcr),keys,count,1800,30776,90315535,30776,30776,30776,90315535,90315535,90315535,1,1.125599263,1.125599263,1.125599263,0.02993950044,0.6717705283,,,,,,,,,, -alibaba_v2022,mcr_by_nodeid,sum by (nodeid) (providerrpc_mcr),keys,value,1800,28319,90315535,30776,30776,30776,90315535,90315535,90315535,1,0.7603646648,0.7603646648,0.7603646648,0.01030423561,0.9053034762,,,,,,,,,, -alibaba_v2022,rt_p99_by_msname,"quantile by (msname) (0.99, providerrpc_rt)",keys,count,60,26077,90315535,25897,25913.5,25946,1851317,2620027,6116768,30,1.34145226,1.535683382,1.900453851,0.551844464,1.358823026,,,,,,,,,, -alibaba_v2022,rt_p99_by_msname,"quantile by (msname) (0.99, providerrpc_rt)",keys,value,60,17879,90315535,25897,25913.5,25946,1851317,2620027,6116768,30,1.557884845,2.065651001,2.862739376,0.8831246003,2.232622338,,,,,,,,,, -alibaba_v2022,rt_p99_by_msname,"quantile by (msname) (0.99, providerrpc_rt)",keys,count,300,26077,90315535,25982,25999,26017,12598774,14510179.5,20040209,6,1.459050605,1.535683382,1.664745,0.551844464,1.358823026,,,,,,,,,, -alibaba_v2022,rt_p99_by_msname,"quantile by (msname) (0.99, providerrpc_rt)",keys,value,300,17879,90315535,25982,25999,26017,12598774,14510179.5,20040209,6,1.914568868,2.065651001,2.264852064,0.8831246003,2.232622338,,,,,,,,,, -alibaba_v2022,rt_p99_by_msname,"quantile by (msname) (0.99, providerrpc_rt)",keys,count,1800,26077,90315535,26077,26077,26077,90315535,90315535,90315535,1,1.535683382,1.535683382,1.535683382,0.551844464,1.358823026,,,,,,,,,, -alibaba_v2022,rt_p99_by_msname,"quantile by (msname) (0.99, providerrpc_rt)",keys,value,1800,17879,90315535,26077,26077,26077,90315535,90315535,90315535,1,2.065651001,2.065651001,2.065651001,0.8831246003,2.232622338,,,,,,,,,, -alibaba_v2022,rt_p99_by_msname,"quantile by (msname) (0.99, providerrpc_rt)",values,,60,,90315535,,,,1628149,2398432.5,5822881,30,2.260827914,9.489211869,19.36642355,,,0.07334786867,104.7515152,0.07223857387,0.33763,20.92052971,1.584033129e-24,33305.70531,0.04007458342,power_law, -alibaba_v2022,rt_p99_by_msname,"quantile by (msname) (0.99, providerrpc_rt)",values,,300,,90315535,,,,11485019,13399225,18912878,6,2.69795252,9.489211869,9.489211869,,,0.07334786867,104.7515152,0.07223857387,0.33763,20.92052971,1.584033129e-24,33305.70531,0.04007458342,power_law, -alibaba_v2022,rt_p99_by_msname,"quantile by (msname) (0.99, providerrpc_rt)",values,,1800,,90315535,,,,83691083,83691083,83691083,1,9.489211869,9.489211869,9.489211869,,,0.07334786867,104.7515152,0.07223857387,0.33763,20.92052971,1.584033129e-24,33305.70531,0.04007458342,power_law, -alibaba_v2022,calls_by_rpctype,count by (rpctype) (rt),keys,count,60,6,127635817,6,6,6,4088165,4250906.5,4588482,30,1.258934174,1.320397372,1.384661933,0.4269873793,2.238106251,,,,,,,,,, -alibaba_v2022,calls_by_rpctype,count by (rpctype) (rt),keys,count,300,6,127635817,6,6,6,20898096,21181599,21989351,6,1.29467164,1.320397372,1.339517165,0.4269873793,2.238106251,,,,,,,,,, -alibaba_v2022,calls_by_rpctype,count by (rpctype) (rt),keys,count,1800,6,127635817,6,6,6,127635817,127635817,127635817,1,1.320397372,1.320397372,1.320397372,0.4269873793,2.238106251,,,,,,,,,, -alibaba_v2022,calls_by_service,count by (service) (rt),keys,count,60,399933,127635817,40487,41371,43871,4088165,4250906.5,4588482,30,0.9997655419,1.073097582,1.073097582,0.03884380667,1.598714967,,,,,,,,,, -alibaba_v2022,calls_by_service,count by (service) (rt),keys,count,300,399933,127635817,118742,120073,123896,20898096,21181599,21989351,6,1.038151807,1.073097582,1.073097582,0.03884380667,1.598714967,,,,,,,,,, -alibaba_v2022,calls_by_service,count by (service) (rt),keys,count,1800,399933,127635817,399933,399933,399933,127635817,127635817,127635817,1,1.073097582,1.073097582,1.073097582,0.03884380667,1.598714967,,,,,,,,,, -alibaba_v2022,calls_by_um,count by (um) (rt),keys,count,60,15063,127635817,6962,7225.5,7787,4088165,4250906.5,4588482,30,1.112686254,1.146113129,1.146113129,0.1280037797,2.685515774,,,,,,,,,, -alibaba_v2022,calls_by_um,count by (um) (rt),keys,count,300,15063,127635817,10377,10623.5,11246,20898096,21181599,21989351,6,1.130046063,1.146113129,1.146113129,0.1280037797,2.685515774,,,,,,,,,, -alibaba_v2022,calls_by_um,count by (um) (rt),keys,count,1800,15063,127635817,15063,15063,15063,127635817,127635817,127635817,1,1.146113129,1.146113129,1.146113129,0.1280037797,2.685515774,,,,,,,,,, -alibaba_v2022,calls_by_dm,count by (dm) (rt),keys,count,60,25155,127635817,11842,12302,13167,4088165,4250906.5,4588482,30,1.096635378,1.125786526,1.125786526,0.07091333932,2.602593178,,,,,,,,,, -alibaba_v2022,calls_by_dm,count by (dm) (rt),keys,count,300,25155,127635817,17523,17956.5,18966,20898096,21181599,21989351,6,1.113121733,1.125786526,1.125786526,0.07091333932,2.602593178,,,,,,,,,, -alibaba_v2022,calls_by_dm,count by (dm) (rt),keys,count,1800,25155,127635817,25155,25155,25155,127635817,127635817,127635817,1,1.125786526,1.125786526,1.125786526,0.07091333932,2.602593178,,,,,,,,,, -alibaba_v2022,calls_by_interface,count by (interface) (rt),keys,count,60,1198880,127635817,108417,114296,119515,4088165,4250906.5,4588482,30,0.9891494111,1.060081164,1.060081164,0.02591645572,1.289625511,,,,,,,,,, -alibaba_v2022,calls_by_interface,count by (interface) (rt),keys,count,300,1198880,127635817,304076,320266.5,331341,20898096,21181599,21989351,6,1.024459485,1.060081164,1.060081164,0.02591645572,1.289625511,,,,,,,,,, -alibaba_v2022,calls_by_interface,count by (interface) (rt),keys,count,1800,1198880,127635817,1198880,1198880,1198880,127635817,127635817,127635817,1,1.060081164,1.060081164,1.060081164,0.02591645572,1.289625511,,,,,,,,,, -alibaba_v2022,calls_by_um_dm,"count by (um, dm) (rt)",keys,count,60,99257,127635817,36740,38576.5,42279,4088165,4250906.5,4588482,30,0.9766087399,1.021624348,1.021624348,0.02628258336,2.341811039,,,,,,,,,, -alibaba_v2022,calls_by_um_dm,"count by (um, dm) (rt)",keys,count,300,99257,127635817,60535,62824.5,67160,20898096,21181599,21989351,6,0.9989432682,1.021624348,1.021624348,0.02628258336,2.341811039,,,,,,,,,, -alibaba_v2022,calls_by_um_dm,"count by (um, dm) (rt)",keys,count,1800,99257,127635817,99257,99257,99257,127635817,127635817,127635817,1,1.021624348,1.021624348,1.021624348,0.02628258336,2.341811039,,,,,,,,,, -alibaba_v2022,calls_by_service_um_dm,"count by (service, um, dm) (rt)",keys,count,60,1271349,127635817,178991,185802,197370,4088165,4250906.5,4588482,30,0.9103802226,0.9818761438,0.9818761438,0.0100940475,1.682584852,,,,,,,,,, -alibaba_v2022,calls_by_service_um_dm,"count by (service, um, dm) (rt)",keys,count,300,1271349,127635817,437380,452564,469896,20898096,21181599,21989351,6,0.9459693208,0.9818761438,0.9818761438,0.0100940475,1.682584852,,,,,,,,,, -alibaba_v2022,calls_by_service_um_dm,"count by (service, um, dm) (rt)",keys,count,1800,1271349,127635817,1271349,1271349,1271349,127635817,127635817,127635817,1,0.9818761438,0.9818761438,0.9818761438,0.0100940475,1.682584852,,,,,,,,,, -alibaba_v2022,rt_p99_by_service,"quantile by (service) (0.99, rt)",keys,count,60,399933,127635817,40487,41371,43871,4088165,4250906.5,4588482,30,0.9997655419,1.073097582,1.073097582,0.03884380667,1.598714967,,,,,,,,,, -alibaba_v2022,rt_p99_by_service,"quantile by (service) (0.99, rt)",keys,value,60,313796,127635817,40487,41371,43871,4088165,4250906.5,4588482,30,1.128425922,1.171970416,1.188693737,0.2419190472,2.383296717,,,,,,,,,, -alibaba_v2022,rt_p99_by_service,"quantile by (service) (0.99, rt)",keys,count,300,399933,127635817,118742,120073,123896,20898096,21181599,21989351,6,1.038151807,1.073097582,1.073097582,0.03884380667,1.598714967,,,,,,,,,, -alibaba_v2022,rt_p99_by_service,"quantile by (service) (0.99, rt)",keys,value,300,313796,127635817,118742,120073,123896,20898096,21181599,21989351,6,1.148996146,1.171970416,1.173781825,0.2419190472,2.383296717,,,,,,,,,, -alibaba_v2022,rt_p99_by_service,"quantile by (service) (0.99, rt)",keys,count,1800,399933,127635817,399933,399933,399933,127635817,127635817,127635817,1,1.073097582,1.073097582,1.073097582,0.03884380667,1.598714967,,,,,,,,,, -alibaba_v2022,rt_p99_by_service,"quantile by (service) (0.99, rt)",keys,value,1800,313796,127635817,399933,399933,399933,127635817,127635817,127635817,1,1.171970416,1.171970416,1.171970416,0.2419190472,2.383296717,,,,,,,,,, -alibaba_v2022,rt_p99_by_service,"quantile by (service) (0.99, rt)",values,,60,,125647293,,,,2454764,2557976.5,2778257,30,2.105068097,2.224958097,2.39368374,,,0.3864958157,54,0.03053561758,0.04198,0.05863097738,0.5741208187,4657.66376,1.182510951e-37,heavy_inconclusive, -alibaba_v2022,rt_p99_by_service,"quantile by (service) (0.99, rt)",values,,300,,125647293,,,,12453596,12802532,13318944,6,2.22250947,2.224958097,2.370910148,,,0.3864958157,54,0.03053561758,0.04198,0.05863097738,0.5741208187,4657.66376,1.182510951e-37,heavy_inconclusive, -alibaba_v2022,rt_p99_by_service,"quantile by (service) (0.99, rt)",values,,1800,,125647293,,,,77085140,77085140,77085140,1,2.224958097,2.224958097,2.224958097,,,0.3864958157,54,0.03053561758,0.04198,0.05863097738,0.5741208187,4657.66376,1.182510951e-37,heavy_inconclusive, -alibaba_v2022,ms_cpu_by_msname,sum by (msname) (cpu_utilization),keys,count,60,28159,13987704,28133,28146,28149,466064,466254.5,466859,30,0.8260669806,0.8261383394,0.8261696343,0.01647811535,1.269169573,,,,,,,,,, -alibaba_v2022,ms_cpu_by_msname,sum by (msname) (cpu_utilization),keys,value,60,28158,13987704,28133,28146,28149,466064,466254.5,466859,30,0.8910509911,0.8934578439,0.8970122008,0.009206699585,1.665602809,,,,,,,,,, -alibaba_v2022,ms_cpu_by_msname,sum by (msname) (cpu_utilization),keys,count,300,28159,13987704,28150,28152,28154,2331080,2331259,2331564,6,0.8260995665,0.8261383394,0.8261451562,0.01647811535,1.269169573,,,,,,,,,, -alibaba_v2022,ms_cpu_by_msname,sum by (msname) (cpu_utilization),keys,value,300,28158,13987704,28150,28152,28154,2331080,2331259,2331564,6,0.8914462982,0.8934578439,0.8953685744,0.009206699585,1.665602809,,,,,,,,,, -alibaba_v2022,ms_cpu_by_msname,sum by (msname) (cpu_utilization),keys,count,1800,28159,13987704,28159,28159,28159,13987704,13987704,13987704,1,0.8261383394,0.8261383394,0.8261383394,0.01647811535,1.269169573,,,,,,,,,, -alibaba_v2022,ms_cpu_by_msname,sum by (msname) (cpu_utilization),keys,value,1800,28158,13987704,28159,28159,28159,13987704,13987704,13987704,1,0.8934578439,0.8934578439,0.8934578439,0.009206699585,1.665602809,,,,,,,,,, -alibaba_v2022,ms_cpu_p99,"quantile(0.99, cpu_utilization)",values,,60,,13987704,,,,466043,466241.5,466848,30,3.126230756,5.542189257,7.138055355,,,2.974040629e-05,0.4628040123,0.04894648654,0.03156,-76.27208332,2.037768318e-16,-76.04881018,9.72424169e-30,light, -alibaba_v2022,ms_cpu_p99,"quantile(0.99, cpu_utilization)",values,,300,,13987704,,,,2331015,2331191,2331479,6,5.241415525,5.542189257,6.135478505,,,2.974040629e-05,0.4628040123,0.04894648654,0.03156,-76.27208332,2.037768318e-16,-76.04881018,9.72424169e-30,light, -alibaba_v2022,ms_cpu_p99,"quantile(0.99, cpu_utilization)",values,,1800,,13987704,,,,13987288,13987288,13987288,1,5.542189257,5.542189257,5.542189257,,,2.974040629e-05,0.4628040123,0.04894648654,0.03156,-76.27208332,2.037768318e-16,-76.04881018,9.72424169e-30,light, -alibaba_v2022,node_cpu_by_nodeid,sum by (nodeid) (cpu_utilization),keys,count,60,42554,1228782,42328,42371,42417,42328,42371,42417,29,3.68585149e-06,0.004274553455,0.004274553455,2.360060613e-05,0.008823732182,,,,,,,,,, -alibaba_v2022,node_cpu_by_nodeid,sum by (nodeid) (cpu_utilization),keys,value,60,42552,1228782,42328,42371,42417,42328,42371,42417,29,0.302619479,0.302619479,0.3280402723,0.0001077013099,0.374094025,,,,,,,,,, -alibaba_v2022,node_cpu_by_nodeid,sum by (nodeid) (cpu_utilization),keys,count,300,42554,1228782,42414,42455,42489,169332,211839.5,212034,6,0.001737612931,0.004274553455,0.004274553455,2.360060613e-05,0.008823732182,,,,,,,,,, -alibaba_v2022,node_cpu_by_nodeid,sum by (nodeid) (cpu_utilization),keys,value,300,42552,1228782,42414,42455,42489,169332,211839.5,212034,6,0.302619479,0.302619479,0.3110770983,0.0001077013099,0.374094025,,,,,,,,,, -alibaba_v2022,node_cpu_by_nodeid,sum by (nodeid) (cpu_utilization),keys,count,1800,42554,1228782,42554,42554,42554,1228782,1228782,1228782,1,0.004274553455,0.004274553455,0.004274553455,2.360060613e-05,0.008823732182,,,,,,,,,, -alibaba_v2022,node_cpu_by_nodeid,sum by (nodeid) (cpu_utilization),keys,value,1800,42552,1228782,42554,42554,42554,1228782,1228782,1228782,1,0.302619479,0.302619479,0.302619479,0.0001077013099,0.374094025,,,,,,,,,, -alibaba_v2022,node_cpu_p99,"quantile(0.99, cpu_utilization)",values,,60,,1228782,,,,42326,42369,42415,29,5.555331164,5.88867925,6.157617344,,,4.720121226e-05,0.3550121596,0.0153464518,0.06211,-3.907517359,0.05765929408,71.88226712,3.086317246e-08,lognormal, -alibaba_v2022,node_cpu_p99,"quantile(0.99, cpu_utilization)",values,,300,,1228782,,,,169324,211829.5,212024,6,5.697479577,5.88867925,5.992465538,,,4.720121226e-05,0.3550121596,0.0153464518,0.06211,-3.907517359,0.05765929408,71.88226712,3.086317246e-08,lognormal, -alibaba_v2022,node_cpu_p99,"quantile(0.99, cpu_utilization)",values,,1800,,1228782,,,,1228724,1228724,1228724,1,5.88867925,5.88867925,5.88867925,,,4.720121226e-05,0.3550121596,0.0153464518,0.06211,-3.907517359,0.05765929408,71.88226712,3.086317246e-08,lognormal, +alibaba_v2022,mcr_by_msname,sum by (msname) (providerrpc_mcr),keys,count,60,26147,867646875,25807,25878,25946,1591245,2389637,6116768,360,1.292109539,1.443313195,1.900453851,0.4545719547,1.37444187,,,,,,,,,, +alibaba_v2022,mcr_by_msname,sum by (msname) (providerrpc_mcr),keys,value,60,18730,867646875,25807,25878,25946,1591245,2389637,6116768,360,1.027135195,1.101430346,1.306967015,0.1498488827,3.811405825,,,,,,,,,, +alibaba_v2022,mcr_by_msname,sum by (msname) (providerrpc_mcr),keys,count,300,26147,867646875,25889,25956,26017,9074361,12178641.5,20040209,72,1.33521834,1.443313195,1.664745,0.4545719547,1.37444187,,,,,,,,,, +alibaba_v2022,mcr_by_msname,sum by (msname) (providerrpc_mcr),keys,value,300,18730,867646875,25889,25956,26017,9074361,12178641.5,20040209,72,1.064293819,1.101430346,1.181235381,0.1498488827,3.811405825,,,,,,,,,, +alibaba_v2022,mcr_by_msname,sum by (msname) (providerrpc_mcr),keys,count,1800,26147,867646875,25996,26019,26077,60453570,74259468.5,90315535,12,1.372912545,1.443313195,1.535683382,0.4545719547,1.37444187,,,,,,,,,, +alibaba_v2022,mcr_by_msname,sum by (msname) (providerrpc_mcr),keys,value,1800,18730,867646875,25996,26019,26077,60453570,74259468.5,90315535,12,1.078854736,1.101430346,1.142123824,0.1498488827,3.811405825,,,,,,,,,, +alibaba_v2022,mcr_by_msname,sum by (msname) (providerrpc_mcr),keys,count,3600,26147,867646875,26028,26050,26092,125610875,146876167,166100193,6,1.38716722,1.443313195,1.499657657,0.4545719547,1.37444187,,,,,,,,,, +alibaba_v2022,mcr_by_msname,sum by (msname) (providerrpc_mcr),keys,value,3600,18730,867646875,26028,26050,26092,125610875,146876167,166100193,6,1.085147832,1.101430346,1.133104218,0.1498488827,3.811405825,,,,,,,,,, +alibaba_v2022,mcr_by_msname,sum by (msname) (providerrpc_mcr),keys,count,21600,26147,867646875,26147,26147,26147,867646875,867646875,867646875,1,1.443313195,1.443313195,1.443313195,0.4545719547,1.37444187,,,,,,,,,, +alibaba_v2022,mcr_by_msname,sum by (msname) (providerrpc_mcr),keys,value,21600,18730,867646875,26147,26147,26147,867646875,867646875,867646875,1,1.101430346,1.101430346,1.101430346,0.1498488827,3.811405825,,,,,,,,,, +alibaba_v2022,mcr_by_nodeid,sum by (nodeid) (providerrpc_mcr),keys,count,60,30825,867646875,30675,30713,30777,1591245,2389637,6116768,360,1.042832583,1.097553229,1.22637178,0.02685695145,0.6757970814,,,,,,,,,, +alibaba_v2022,mcr_by_nodeid,sum by (nodeid) (providerrpc_mcr),keys,value,60,28348,867646875,30675,30713,30777,1591245,2389637,6116768,360,0.6139118116,0.7429289939,0.9855634538,0.007415134693,0.9461668197,,,,,,,,,, +alibaba_v2022,mcr_by_nodeid,sum by (nodeid) (providerrpc_mcr),keys,count,300,30825,867646875,30689,30725,30783,9074361,12178641.5,20040209,72,1.067241266,1.097553229,1.175793283,0.02685695145,0.6757970814,,,,,,,,,, +alibaba_v2022,mcr_by_nodeid,sum by (nodeid) (providerrpc_mcr),keys,value,300,28348,867646875,30689,30725,30783,9074361,12178641.5,20040209,72,0.6938057305,0.7429289939,0.8586025258,0.007415134693,0.9461668197,,,,,,,,,, +alibaba_v2022,mcr_by_nodeid,sum by (nodeid) (providerrpc_mcr),keys,count,1800,30825,867646875,30703,30738.5,30790,60453570,74259468.5,90315535,12,1.078060475,1.097553229,1.125599263,0.02685695145,0.6757970814,,,,,,,,,, +alibaba_v2022,mcr_by_nodeid,sum by (nodeid) (providerrpc_mcr),keys,value,1800,28348,867646875,30703,30738.5,30790,60453570,74259468.5,90315535,12,0.7137216798,0.7429289939,0.8030588531,0.007415134693,0.9461668197,,,,,,,,,, +alibaba_v2022,mcr_by_nodeid,sum by (nodeid) (providerrpc_mcr),keys,count,3600,30825,867646875,30707,30748.5,30799,125610875,146876167,166100193,6,1.083590558,1.097553229,1.112654503,0.02685695145,0.6757970814,,,,,,,,,, +alibaba_v2022,mcr_by_nodeid,sum by (nodeid) (providerrpc_mcr),keys,value,3600,28348,867646875,30707,30748.5,30799,125610875,146876167,166100193,6,0.7215092607,0.7429289939,0.7873009321,0.007415134693,0.9461668197,,,,,,,,,, +alibaba_v2022,mcr_by_nodeid,sum by (nodeid) (providerrpc_mcr),keys,count,21600,30825,867646875,30825,30825,30825,867646875,867646875,867646875,1,1.097553229,1.097553229,1.097553229,0.02685695145,0.6757970814,,,,,,,,,, +alibaba_v2022,mcr_by_nodeid,sum by (nodeid) (providerrpc_mcr),keys,value,21600,28348,867646875,30825,30825,30825,867646875,867646875,867646875,1,0.7429289939,0.7429289939,0.7429289939,0.007415134693,0.9461668197,,,,,,,,,, +alibaba_v2022,rt_p99_by_msname,"quantile by (msname) (0.99, providerrpc_rt)",keys,count,60,26147,867646875,25807,25878,25946,1591245,2389637,6116768,360,1.292109539,1.443313195,1.900453851,0.4545719547,1.37444187,,,,,,,,,, +alibaba_v2022,rt_p99_by_msname,"quantile by (msname) (0.99, providerrpc_rt)",keys,value,60,18721,867646875,25807,25878,25946,1591245,2389637,6116768,360,1.557884845,1.970047387,2.862739376,0.8659870115,2.444903781,,,,,,,,,, +alibaba_v2022,rt_p99_by_msname,"quantile by (msname) (0.99, providerrpc_rt)",keys,count,300,26147,867646875,25889,25956,26017,9074361,12178641.5,20040209,72,1.33521834,1.443313195,1.664745,0.4545719547,1.37444187,,,,,,,,,, +alibaba_v2022,rt_p99_by_msname,"quantile by (msname) (0.99, providerrpc_rt)",keys,value,300,18721,867646875,25889,25956,26017,9074361,12178641.5,20040209,72,1.697749673,1.970047387,2.264852064,0.8659870115,2.444903781,,,,,,,,,, +alibaba_v2022,rt_p99_by_msname,"quantile by (msname) (0.99, providerrpc_rt)",keys,count,1800,26147,867646875,25996,26019,26077,60453570,74259468.5,90315535,12,1.372912545,1.443313195,1.535683382,0.4545719547,1.37444187,,,,,,,,,, +alibaba_v2022,rt_p99_by_msname,"quantile by (msname) (0.99, providerrpc_rt)",keys,value,1800,18721,867646875,25996,26019,26077,60453570,74259468.5,90315535,12,1.830981938,1.970047387,2.1089592,0.8659870115,2.444903781,,,,,,,,,, +alibaba_v2022,rt_p99_by_msname,"quantile by (msname) (0.99, providerrpc_rt)",keys,count,3600,26147,867646875,26028,26050,26092,125610875,146876167,166100193,6,1.38716722,1.443313195,1.499657657,0.4545719547,1.37444187,,,,,,,,,, +alibaba_v2022,rt_p99_by_msname,"quantile by (msname) (0.99, providerrpc_rt)",keys,value,3600,18721,867646875,26028,26050,26092,125610875,146876167,166100193,6,1.858441857,1.970047387,2.082403331,0.8659870115,2.444903781,,,,,,,,,, +alibaba_v2022,rt_p99_by_msname,"quantile by (msname) (0.99, providerrpc_rt)",keys,count,21600,26147,867646875,26147,26147,26147,867646875,867646875,867646875,1,1.443313195,1.443313195,1.443313195,0.4545719547,1.37444187,,,,,,,,,, +alibaba_v2022,rt_p99_by_msname,"quantile by (msname) (0.99, providerrpc_rt)",keys,value,21600,18721,867646875,26147,26147,26147,867646875,867646875,867646875,1,1.970047387,1.970047387,1.970047387,0.8659870115,2.444903781,,,,,,,,,, +alibaba_v2022,rt_p99_by_msname,"quantile by (msname) (0.99, providerrpc_rt)",values,,60,,867646875,,,,1348473,2151674.5,5822881,360,2.192390963,7.457410083,19.36642355,,,0.09788567037,125.5970899,0.06505872248,0.27596,5.736666427,1.341812375e-13,5081.471528,4.079119261e-10,power_law, +alibaba_v2022,rt_p99_by_msname,"quantile by (msname) (0.99, providerrpc_rt)",values,,300,,867646875,,,,7935828,10956963.5,18912878,72,2.23636518,7.457410083,10.90497987,,,0.09788567037,125.5970899,0.06505872248,0.27596,5.736666427,1.341812375e-13,5081.471528,4.079119261e-10,power_law, +alibaba_v2022,rt_p99_by_msname,"quantile by (msname) (0.99, providerrpc_rt)",values,,1800,,867646875,,,,53224900,67225030,83691083,12,2.730198916,7.457410083,9.489211869,,,0.09788567037,125.5970899,0.06505872248,0.27596,5.736666427,1.341812375e-13,5081.471528,4.079119261e-10,power_law, +alibaba_v2022,rt_p99_by_msname,"quantile by (msname) (0.99, providerrpc_rt)",values,,3600,,867646875,,,,111226757,132644430,152748684,6,2.440855062,7.457410083,8.500412331,,,0.09788567037,125.5970899,0.06505872248,0.27596,5.736666427,1.341812375e-13,5081.471528,4.079119261e-10,power_law, +alibaba_v2022,rt_p99_by_msname,"quantile by (msname) (0.99, providerrpc_rt)",values,,21600,,867646875,,,,782716679,782716679,782716679,1,7.457410083,7.457410083,7.457410083,,,0.09788567037,125.5970899,0.06505872248,0.27596,5.736666427,1.341812375e-13,5081.471528,4.079119261e-10,power_law, +alibaba_v2022,calls_by_rpctype,count by (rpctype) (rt),keys,count,60,6,1295335556,6,6,6,2706845,3569261.5,5401445,360,1.242285336,1.310265913,1.414859468,0.4283451021,2.257448052,,,,,,,,,, +alibaba_v2022,calls_by_rpctype,count by (rpctype) (rt),keys,count,300,6,1295335556,6,6,6,13940970,17777247,26594872,72,1.284747072,1.310265913,1.390048655,0.4283451021,2.257448052,,,,,,,,,, +alibaba_v2022,calls_by_rpctype,count by (rpctype) (rt),keys,count,1800,6,1295335556,6,6,6,84681326,106184673,132801413,12,1.293018604,1.310265913,1.361699093,0.4283451021,2.257448052,,,,,,,,,, +alibaba_v2022,calls_by_rpctype,count by (rpctype) (rt),keys,count,3600,6,1295335556,6,6,6,189237768,212483898.5,260437230,6,1.300721862,1.310265913,1.33752991,0.4283451021,2.257448052,,,,,,,,,, +alibaba_v2022,calls_by_rpctype,count by (rpctype) (rt),keys,count,21600,6,1295335556,6,6,6,1295335556,1295335556,1295335556,1,1.310265913,1.310265913,1.310265913,0.4283451021,2.257448052,,,,,,,,,, +alibaba_v2022,calls_by_service,count by (service) (rt),keys,count,60,2769176,1295335556,35446,40128.5,43871,2706845,3569261.5,5401445,360,0.9793500096,1.099337547,1.099337547,0.0630261268,1.274170165,,,,,,,,,, +alibaba_v2022,calls_by_service,count by (service) (rt),keys,count,300,2769176,1295335556,102583,119224.5,134711,13940970,17777247,26594872,72,1.021860887,1.099337547,1.099337547,0.0630261268,1.274170165,,,,,,,,,, +alibaba_v2022,calls_by_service,count by (service) (rt),keys,count,1800,2769176,1295335556,349448,403698.5,474596,84681326,106184673,132801413,12,1.059060366,1.099337547,1.099337547,0.0630261268,1.274170165,,,,,,,,,, +alibaba_v2022,calls_by_service,count by (service) (rt),keys,count,3600,2769176,1295335556,588050,638917,778557,189237768,212483898.5,260437230,6,1.07137182,1.099337547,1.099337547,0.0630261268,1.274170165,,,,,,,,,, +alibaba_v2022,calls_by_service,count by (service) (rt),keys,count,21600,2769176,1295335556,2769176,2769176,2769176,1295335556,1295335556,1295335556,1,1.099337547,1.099337547,1.099337547,0.0630261268,1.274170165,,,,,,,,,, +alibaba_v2022,calls_by_um,count by (um) (rt),keys,count,60,22016,1295335556,5007,6084,8501,2706845,3569261.5,5401445,360,1.093784378,1.185355196,1.208589263,0.1535391521,3.145206929,,,,,,,,,, +alibaba_v2022,calls_by_um,count by (um) (rt),keys,count,300,22016,1295335556,7830,9162,12410,13940970,17777247,26594872,72,1.114640501,1.185355196,1.216733292,0.1535391521,3.145206929,,,,,,,,,, +alibaba_v2022,calls_by_um,count by (um) (rt),keys,count,1800,22016,1295335556,11602,14176,16349,84681326,106184673,132801413,12,1.141913115,1.185355196,1.219337055,0.1535391521,3.145206929,,,,,,,,,, +alibaba_v2022,calls_by_um,count by (um) (rt),keys,count,3600,22016,1295335556,15412,15850,18110,189237768,212483898.5,260437230,6,1.147410093,1.185355196,1.207444538,0.1535391521,3.145206929,,,,,,,,,, +alibaba_v2022,calls_by_um,count by (um) (rt),keys,count,21600,22016,1295335556,22016,22016,22016,1295335556,1295335556,1295335556,1,1.185355196,1.185355196,1.185355196,0.1535391521,3.145206929,,,,,,,,,, +alibaba_v2022,calls_by_dm,count by (dm) (rt),keys,count,60,35550,1295335556,8788,10446.5,14067,2706845,3569261.5,5401445,360,1.096635378,1.157928672,1.157928672,0.07973378135,3.024759942,,,,,,,,,, +alibaba_v2022,calls_by_dm,count by (dm) (rt),keys,count,300,35550,1295335556,13704,15782,20389,13940970,17777247,26594872,72,1.113121733,1.157928672,1.160162669,0.07973378135,3.024759942,,,,,,,,,, +alibaba_v2022,calls_by_dm,count by (dm) (rt),keys,count,1800,35550,1295335556,20130,23431,26785,84681326,106184673,132801413,12,1.125786526,1.157928672,1.167151669,0.07973378135,3.024759942,,,,,,,,,, +alibaba_v2022,calls_by_dm,count by (dm) (rt),keys,count,3600,35550,1295335556,25512,26228,29583,189237768,212483898.5,260437230,6,1.132567656,1.157928672,1.16969281,0.07973378135,3.024759942,,,,,,,,,, +alibaba_v2022,calls_by_dm,count by (dm) (rt),keys,count,21600,35550,1295335556,35550,35550,35550,1295335556,1295335556,1295335556,1,1.157928672,1.157928672,1.157928672,0.07973378135,3.024759942,,,,,,,,,, +alibaba_v2022,calls_by_interface,count by (interface) (rt),keys,count,60,8655921,1295335556,76838,93821,139176,2706845,3569261.5,5401445,360,0.9891494111,1.097910713,1.097910713,0.02572182771,0.8643899176,,,,,,,,,, +alibaba_v2022,calls_by_interface,count by (interface) (rt),keys,count,300,8655921,1295335556,218939,263783.5,392357,13940970,17777247,26594872,72,1.024459485,1.097910713,1.097910713,0.02572182771,0.8643899176,,,,,,,,,, +alibaba_v2022,calls_by_interface,count by (interface) (rt),keys,count,1800,8655921,1295335556,839071,998851,1234611,84681326,106184673,132801413,12,1.060081164,1.097910713,1.097910713,0.02572182771,0.8643899176,,,,,,,,,, +alibaba_v2022,calls_by_interface,count by (interface) (rt),keys,count,3600,8655921,1295335556,1513235,1791716.5,2131776,189237768,212483898.5,260437230,6,1.070243628,1.097910713,1.097910713,0.02572182771,0.8643899176,,,,,,,,,, +alibaba_v2022,calls_by_interface,count by (interface) (rt),keys,count,21600,8655921,1295335556,8655921,8655921,8655921,1295335556,1295335556,1295335556,1,1.097910713,1.097910713,1.097910713,0.02572182771,0.8643899176,,,,,,,,,, +alibaba_v2022,calls_by_um_dm,"count by (um, dm) (rt)",keys,count,60,165895,1295335556,23787,30295,47939,2706845,3569261.5,5401445,360,0.9766087399,1.070642064,1.070642064,0.04140612504,2.721022211,,,,,,,,,, +alibaba_v2022,calls_by_um_dm,"count by (um, dm) (rt)",keys,count,300,165895,1295335556,40968,51379,77825,13940970,17777247,26594872,72,0.9989432682,1.070642064,1.072960909,0.04140612504,2.721022211,,,,,,,,,, +alibaba_v2022,calls_by_um_dm,"count by (um, dm) (rt)",keys,count,1800,165895,1295335556,68126,89327.5,111563,84681326,106184673,132801413,12,1.021624348,1.070642064,1.083869319,0.04140612504,2.721022211,,,,,,,,,, +alibaba_v2022,calls_by_um_dm,"count by (um, dm) (rt)",keys,count,3600,165895,1295335556,99442,104835.5,127688,189237768,212483898.5,260437230,6,1.02990045,1.070642064,1.084358656,0.04140612504,2.721022211,,,,,,,,,, +alibaba_v2022,calls_by_um_dm,"count by (um, dm) (rt)",keys,count,21600,165895,1295335556,165895,165895,165895,1295335556,1295335556,1295335556,1,1.070642064,1.070642064,1.070642064,0.04140612504,2.721022211,,,,,,,,,, +alibaba_v2022,calls_by_service_um_dm,"count by (service, um, dm) (rt)",keys,count,60,7963812,1295335556,131737,159178.5,239493,2706845,3569261.5,5401445,360,0.8917240947,1.022270823,1.022270823,0.01313775872,1.385250269,,,,,,,,,, +alibaba_v2022,calls_by_service_um_dm,"count by (service, um, dm) (rt)",keys,count,300,7963812,1295335556,320250,391694.5,578272,13940970,17777247,26594872,72,0.9323426164,1.022270823,1.022270823,0.01313775872,1.385250269,,,,,,,,,, +alibaba_v2022,calls_by_service_um_dm,"count by (service, um, dm) (rt)",keys,count,1800,7963812,1295335556,1007700,1260490,1406614,84681326,106184673,132801413,12,0.972825411,1.022270823,1.022270823,0.01313775872,1.385250269,,,,,,,,,, +alibaba_v2022,calls_by_service_um_dm,"count by (service, um, dm) (rt)",keys,count,3600,7963812,1295335556,1782159,1971965,2211657,189237768,212483898.5,260437230,6,0.9870472428,1.022270823,1.022270823,0.01313775872,1.385250269,,,,,,,,,, +alibaba_v2022,calls_by_service_um_dm,"count by (service, um, dm) (rt)",keys,count,21600,7963812,1295335556,7963812,7963812,7963812,1295335556,1295335556,1295335556,1,1.022270823,1.022270823,1.022270823,0.01313775872,1.385250269,,,,,,,,,, +alibaba_v2022,rt_p99_by_service,"quantile by (service) (0.99, rt)",keys,count,60,2769176,1295335556,35446,40128.5,43871,2706845,3569261.5,5401445,360,0.9793500096,1.099337547,1.099337547,0.0630261268,1.274170165,,,,,,,,,, +alibaba_v2022,rt_p99_by_service,"quantile by (service) (0.99, rt)",keys,value,60,2717104,1295335556,35446,40128.5,43871,2706845,3569261.5,5401445,360,1.096888247,1.179024529,1.606011761,0.2835197699,1.778216939,,,,,,,,,, +alibaba_v2022,rt_p99_by_service,"quantile by (service) (0.99, rt)",keys,count,300,2769176,1295335556,102583,119224.5,134711,13940970,17777247,26594872,72,1.021860887,1.099337547,1.099337547,0.0630261268,1.274170165,,,,,,,,,, +alibaba_v2022,rt_p99_by_service,"quantile by (service) (0.99, rt)",keys,value,300,2717104,1295335556,102583,119224.5,134711,13940970,17777247,26594872,72,1.115950521,1.179024529,1.280859084,0.2835197699,1.778216939,,,,,,,,,, +alibaba_v2022,rt_p99_by_service,"quantile by (service) (0.99, rt)",keys,count,1800,2769176,1295335556,349448,403698.5,474596,84681326,106184673,132801413,12,1.059060366,1.099337547,1.099337547,0.0630261268,1.274170165,,,,,,,,,, +alibaba_v2022,rt_p99_by_service,"quantile by (service) (0.99, rt)",keys,value,1800,2717104,1295335556,349448,403698.5,474596,84681326,106184673,132801413,12,1.145393833,1.179024529,1.212405991,0.2835197699,1.778216939,,,,,,,,,, +alibaba_v2022,rt_p99_by_service,"quantile by (service) (0.99, rt)",keys,count,3600,2769176,1295335556,588050,638917,778557,189237768,212483898.5,260437230,6,1.07137182,1.099337547,1.099337547,0.0630261268,1.274170165,,,,,,,,,, +alibaba_v2022,rt_p99_by_service,"quantile by (service) (0.99, rt)",keys,value,3600,2717104,1295335556,588050,638917,778557,189237768,212483898.5,260437230,6,1.159047436,1.179024529,1.197565897,0.2835197699,1.778216939,,,,,,,,,, +alibaba_v2022,rt_p99_by_service,"quantile by (service) (0.99, rt)",keys,count,21600,2769176,1295335556,2769176,2769176,2769176,1295335556,1295335556,1295335556,1,1.099337547,1.099337547,1.099337547,0.0630261268,1.274170165,,,,,,,,,, +alibaba_v2022,rt_p99_by_service,"quantile by (service) (0.99, rt)",keys,value,21600,2717104,1295335556,2769176,2769176,2769176,1295335556,1295335556,1295335556,1,1.179024529,1.179024529,1.179024529,0.2835197699,1.778216939,,,,,,,,,, +alibaba_v2022,rt_p99_by_service,"quantile by (service) (0.99, rt)",values,,60,,1270987041,,,,1545590,2102060,3311374,360,1.893692381,2.030679588,2.49525936,,,0.3996959565,19,0.03004561456,0.08535,-0.04015238608,0.9098821503,12193.79023,3.364578417e-57,heavy_inconclusive, +alibaba_v2022,rt_p99_by_service,"quantile by (service) (0.99, rt)",values,,300,,1270987041,,,,7884223,10466448.5,16264262,72,1.921842081,2.030679588,2.521827762,,,0.3996959565,19,0.03004561456,0.08535,-0.04015238608,0.9098821503,12193.79023,3.364578417e-57,heavy_inconclusive, +alibaba_v2022,rt_p99_by_service,"quantile by (service) (0.99, rt)",values,,1800,,1270987041,,,,48187644,62446248.5,80141038,12,1.973885276,2.030679588,2.361281435,,,0.3996959565,19,0.03004561456,0.08535,-0.04015238608,0.9098821503,12193.79023,3.364578417e-57,heavy_inconclusive, +alibaba_v2022,rt_p99_by_service,"quantile by (service) (0.99, rt)",values,,3600,,1270987041,,,,109397150,124881369.5,157226178,6,2.030679588,2.030679588,2.367919968,,,0.3996959565,19,0.03004561456,0.08535,-0.04015238608,0.9098821503,12193.79023,3.364578417e-57,heavy_inconclusive, +alibaba_v2022,rt_p99_by_service,"quantile by (service) (0.99, rt)",values,,21600,,1270987041,,,,762978660,762978660,762978660,1,2.030679588,2.030679588,2.030679588,,,0.3996959565,19,0.03004561456,0.08535,-0.04015238608,0.9098821503,12193.79023,3.364578417e-57,heavy_inconclusive, +alibaba_v2022,ms_cpu_by_msname,sum by (msname) (cpu_utilization),keys,count,60,28260,675424445,28130,28151,28166,465721,469692.5,471139,1440,0.8249291767,0.8256900161,0.8263595398,0.01642157177,1.279481397,,,,,,,,,, +alibaba_v2022,ms_cpu_by_msname,sum by (msname) (cpu_utilization),keys,value,60,28259,675424445,28130,28151,28166,465721,469692.5,471139,1440,0.8708682951,0.8893327869,0.9058773298,0.01026331486,1.71275427,,,,,,,,,, +alibaba_v2022,ms_cpu_by_msname,sum by (msname) (cpu_utilization),keys,count,300,28260,675424445,28147,28159.5,28171,2328999,2348464,2355294,288,0.8250495524,0.8256900161,0.8263469367,0.01642157177,1.279481397,,,,,,,,,, +alibaba_v2022,ms_cpu_by_msname,sum by (msname) (cpu_utilization),keys,value,300,28259,675424445,28147,28159.5,28171,2328999,2348464,2355294,288,0.8715262892,0.8893327869,0.905414951,0.01026331486,1.71275427,,,,,,,,,, +alibaba_v2022,ms_cpu_by_msname,sum by (msname) (cpu_utilization),keys,count,1800,28260,675424445,28156,28167.5,28178,13975561,14088565.5,14128896,48,0.8251627143,0.8256900161,0.8263140713,0.01642157177,1.279481397,,,,,,,,,, +alibaba_v2022,ms_cpu_by_msname,sum by (msname) (cpu_utilization),keys,value,1800,28259,675424445,28156,28167.5,28178,13975561,14088565.5,14128896,48,0.8727229776,0.8893327869,0.9043856162,0.01026331486,1.71275427,,,,,,,,,, +alibaba_v2022,ms_cpu_by_msname,sum by (msname) (cpu_utilization),keys,count,3600,28260,675424445,28161,28173,28183,27957228,28184867,28252925,24,0.8252488418,0.8256900161,0.8263148174,0.01642157177,1.279481397,,,,,,,,,, +alibaba_v2022,ms_cpu_by_msname,sum by (msname) (cpu_utilization),keys,value,3600,28259,675424445,28161,28173,28183,27957228,28184867,28252925,24,0.8732428329,0.8893327869,0.9039451145,0.01026331486,1.71275427,,,,,,,,,, +alibaba_v2022,ms_cpu_by_msname,sum by (msname) (cpu_utilization),keys,count,21600,28260,675424445,28179,28205.5,28210,167843477,169059041.5,169462885,4,0.8254300908,0.8256900161,0.8262450207,0.01642157177,1.279481397,,,,,,,,,, +alibaba_v2022,ms_cpu_by_msname,sum by (msname) (cpu_utilization),keys,value,21600,28259,675424445,28179,28205.5,28210,167843477,169059041.5,169462885,4,0.8781402663,0.8893327869,0.8992278067,0.01026331486,1.71275427,,,,,,,,,, +alibaba_v2022,ms_cpu_by_msname,sum by (msname) (cpu_utilization),keys,count,86400,28260,675424445,28260,28260,28260,675424445,675424445,675424445,1,0.8256900161,0.8256900161,0.8256900161,0.01642157177,1.279481397,,,,,,,,,, +alibaba_v2022,ms_cpu_by_msname,sum by (msname) (cpu_utilization),keys,value,86400,28259,675424445,28260,28260,28260,675424445,675424445,675424445,1,0.8893327869,0.8893327869,0.8893327869,0.01026331486,1.71275427,,,,,,,,,, +alibaba_v2022,ms_cpu_p99,"quantile(0.99, cpu_utilization)",values,,60,,675424445,,,,465709,469677,471127,1440,3.017631337,3.284197319,10.3330847,,,3.036461021e-05,0.2347216667,0.06413735873,0.26578,-1226.764811,1.056522957e-223,-1337.731878,2.263998704e-273,light, +alibaba_v2022,ms_cpu_p99,"quantile(0.99, cpu_utilization)",values,,300,,675424445,,,,2328934,2348383.5,2355229,288,3.028369143,3.284197319,8.178095105,,,3.036461021e-05,0.2347216667,0.06413735873,0.26578,-1226.764811,1.056522957e-223,-1337.731878,2.263998704e-273,light, +alibaba_v2022,ms_cpu_p99,"quantile(0.99, cpu_utilization)",values,,1800,,675424445,,,,13975151,14088116,14128503,48,3.103443433,3.284197319,6.830580725,,,3.036461021e-05,0.2347216667,0.06413735873,0.26578,-1226.764811,1.056522957e-223,-1337.731878,2.263998704e-273,light, +alibaba_v2022,ms_cpu_p99,"quantile(0.99, cpu_utilization)",values,,3600,,675424445,,,,27956442,28184004.5,28252146,24,3.203504221,3.284197319,6.855077435,,,3.036461021e-05,0.2347216667,0.06413735873,0.26578,-1226.764811,1.056522957e-223,-1337.731878,2.263998704e-273,light, +alibaba_v2022,ms_cpu_p99,"quantile(0.99, cpu_utilization)",values,,21600,,675424445,,,,167838800,169053622,169457892,4,3.284197319,3.284197319,6.189368402,,,3.036461021e-05,0.2347216667,0.06413735873,0.26578,-1226.764811,1.056522957e-223,-1337.731878,2.263998704e-273,light, +alibaba_v2022,ms_cpu_p99,"quantile(0.99, cpu_utilization)",values,,86400,,675424445,,,,675403936,675403936,675403936,1,3.284197319,3.284197319,3.284197319,,,3.036461021e-05,0.2347216667,0.06413735873,0.26578,-1226.764811,1.056522957e-223,-1337.731878,2.263998704e-273,light, +alibaba_v2022,node_cpu_by_nodeid,sum by (nodeid) (cpu_utilization),keys,count,60,43382,58460197,41795,42253,42900,41795,42253,42900,1379,3.612546385e-06,0.02250972512,0.02250972512,2.358869916e-05,0.07484077042,,,,,,,,,, +alibaba_v2022,node_cpu_by_nodeid,sum by (nodeid) (cpu_utilization),keys,value,60,43381,58460197,41795,42253,42900,41795,42253,42900,1379,0.2865167137,0.2865167137,0.353937895,9.702091431e-05,0.3892546546,,,,,,,,,, +alibaba_v2022,node_cpu_by_nodeid,sum by (nodeid) (cpu_utilization),keys,count,300,43382,58460197,42239,42332.5,42957,169332,211241,214431,276,0.001369408484,0.02250972512,0.02250972512,2.358869916e-05,0.07484077042,,,,,,,,,, +alibaba_v2022,node_cpu_by_nodeid,sum by (nodeid) (cpu_utilization),keys,value,300,43381,58460197,42239,42332.5,42957,169332,211241,214431,276,0.2854823814,0.2865167137,0.3413704436,9.702091431e-05,0.3892546546,,,,,,,,,, +alibaba_v2022,node_cpu_by_nodeid,sum by (nodeid) (cpu_utilization),keys,count,1800,43382,58460197,42352,42397.5,42996,1228782,1267277.5,1286400,46,0.002695275718,0.02250972512,0.02250972512,2.358869916e-05,0.07484077042,,,,,,,,,, +alibaba_v2022,node_cpu_by_nodeid,sum by (nodeid) (cpu_utilization),keys,value,1800,43381,58460197,42352,42397.5,42996,1228782,1267277.5,1286400,46,0.2818164573,0.2865167137,0.3343942102,9.702091431e-05,0.3892546546,,,,,,,,,, +alibaba_v2022,node_cpu_by_nodeid,sum by (nodeid) (cpu_utilization),keys,count,3600,43382,58460197,42376,42433,43021,2503748,2534184,2570715,23,0.003499846278,0.02250972512,0.02250972512,2.358869916e-05,0.07484077042,,,,,,,,,, +alibaba_v2022,node_cpu_by_nodeid,sum by (nodeid) (cpu_utilization),keys,value,3600,43381,58460197,42376,42433,43021,2503748,2534184,2570715,23,0.2805202205,0.2865167137,0.3302192401,9.702091431e-05,0.3892546546,,,,,,,,,, +alibaba_v2022,node_cpu_by_nodeid,sum by (nodeid) (cpu_utilization),keys,count,21600,43382,58460197,42526,42817,43131,12674023,15222728.5,15340717,4,0.007170304158,0.02250972512,0.02250972512,2.358869916e-05,0.07484077042,,,,,,,,,, +alibaba_v2022,node_cpu_by_nodeid,sum by (nodeid) (cpu_utilization),keys,value,21600,43381,58460197,42526,42817,43131,12674023,15222728.5,15340717,4,0.2817520704,0.2865167137,0.3116445407,9.702091431e-05,0.3892546546,,,,,,,,,, +alibaba_v2022,node_cpu_by_nodeid,sum by (nodeid) (cpu_utilization),keys,count,86400,43382,58460197,43382,43382,43382,58460197,58460197,58460197,1,0.02250972512,0.02250972512,0.02250972512,2.358869916e-05,0.07484077042,,,,,,,,,, +alibaba_v2022,node_cpu_by_nodeid,sum by (nodeid) (cpu_utilization),keys,value,86400,43381,58460197,43382,43382,43382,58460197,58460197,58460197,1,0.2865167137,0.2865167137,0.2865167137,9.702091431e-05,0.3892546546,,,,,,,,,, +alibaba_v2022,node_cpu_p99,"quantile(0.99, cpu_utilization)",values,,60,,58460197,,,,41793,42251,42898,1379,4.235679376,5.406249425,6.455573604,,,4.945245053e-05,0.3308919271,0.01534101513,0.08247,-4.440742688,0.04306283931,137.3406788,6.479126893e-16,lognormal, +alibaba_v2022,node_cpu_p99,"quantile(0.99, cpu_utilization)",values,,300,,58460197,,,,169324,211230,214421,276,4.295022072,5.406249425,6.299447518,,,4.945245053e-05,0.3308919271,0.01534101513,0.08247,-4.440742688,0.04306283931,137.3406788,6.479126893e-16,lognormal, +alibaba_v2022,node_cpu_p99,"quantile(0.99, cpu_utilization)",values,,1800,,58460197,,,,1228724,1267214.5,1286339,46,4.33068855,5.406249425,6.076082306,,,4.945245053e-05,0.3308919271,0.01534101513,0.08247,-4.440742688,0.04306283931,137.3406788,6.479126893e-16,lognormal, +alibaba_v2022,node_cpu_p99,"quantile(0.99, cpu_utilization)",values,,3600,,58460197,,,,2503630,2534059,2570595,23,4.332980693,5.406249425,6.232080556,,,4.945245053e-05,0.3308919271,0.01534101513,0.08247,-4.440742688,0.04306283931,137.3406788,6.479126893e-16,lognormal, +alibaba_v2022,node_cpu_p99,"quantile(0.99, cpu_utilization)",values,,21600,,58460197,,,,12673406,15221953,15339994,4,4.477964462,5.406249425,6.005084587,,,4.945245053e-05,0.3308919271,0.01534101513,0.08247,-4.440742688,0.04306283931,137.3406788,6.479126893e-16,lognormal, +alibaba_v2022,node_cpu_p99,"quantile(0.99, cpu_utilization)",values,,86400,,58460197,,,,58457306,58457306,58457306,1,5.406249425,5.406249425,5.406249425,,,4.945245053e-05,0.3308919271,0.01534101513,0.08247,-4.440742688,0.04306283931,137.3406788,6.479126893e-16,lognormal, boom,target_tail[ds-2187-H],"quantile(0.99, target)",values,,,100,523100,,,,,,,900,1.673862396,2.879820136,5.449343474,,,0.0001911680367,1.13650366,0.05719670041,0.1334608031,-0.7518535826,0.1985446789,81.95794065,4.297158362e-06,light,0.45 boom,target_tail[ds-2394-D],"quantile(0.99, target)",values,,,73,10001,,,,,,,0,,,,,,0.1858814119,,,,,,,,, boom,target_tail[ds-1135-5T],"quantile(0.99, target)",values,,,26,425984,,,,,,,63,2.072418608,2.555273335,4.464465828,,,0.5493680514,1.309216454,0.09571546402,0.3780193237,-3.202171683,0.08890763899,233.8257673,9.588002711e-10,light,0.3571428571 @@ -88,51 +140,99 @@ boom,target_tail[ds-1840-D],"quantile(0.99, target)",values,,,100,21700,,,,,,,0, boom,target_tail[ds-671-10S],"quantile(0.99, target)",values,,,100,1638400,,,,,,,0,,,,,,6.103515625e-05,,,,,,,,light,0 boom,target_tail[ds-1524-5T],"quantile(0.99, target)",values,,,93,1267683,,,,,,,18,3.310389413,3.310389413,3.692673948,,,0.944850566,1.984224252,0.2043641455,0.523993808,-0.7337541742,0.1428173664,51.73262359,2.004766276e-06,heavy_inconclusive,0.6470588235 boom,target_tail[ds-899-T],"quantile(0.99, target)",values,,,12,196608,,,,,,,144,2.379500335,4.776016519,4.776016519,,,0.4203440348,3.316427802,0.0820839487,0.05264234598,-0.6434653813,0.1335383104,64.54346235,4.612421122e-07,heavy_inconclusive,1 -google_2011,cpu_by_user,sum by (user) (cpu_rate),keys,count,300,518,2520773,507,510,513,136616,145568,166103,17,1.220115177,1.23996806,1.275255465,0.1574362309,2.334090565,,,,,,,,,, -google_2011,cpu_by_user,sum by (user) (cpu_rate),keys,value,300,495,2520773,507,510,513,136616,145568,166103,17,1.24603505,1.30345187,1.424144835,0.1682000211,3.78680042,,,,,,,,,, -google_2011,cpu_by_user,sum by (user) (cpu_rate),keys,count,900,518,2520773,510,511,515,136616,432405,475713,7,1.220115177,1.23996806,1.258241918,0.1574362309,2.334090565,,,,,,,,,, -google_2011,cpu_by_user,sum by (user) (cpu_rate),keys,value,900,495,2520773,510,511,515,136616,432405,475713,7,1.24603505,1.30345187,1.369458807,0.1682000211,3.78680042,,,,,,,,,, -google_2011,cpu_by_user,sum by (user) (cpu_rate),keys,count,3600,518,2520773,514,514.5,515,999631,1260386.5,1521142,2,1.231395655,1.23996806,1.24591221,0.1574362309,2.334090565,,,,,,,,,, -google_2011,cpu_by_user,sum by (user) (cpu_rate),keys,value,3600,495,2520773,514,514.5,515,999631,1260386.5,1521142,2,1.299004723,1.30345187,1.308575375,0.1682000211,3.78680042,,,,,,,,,, -google_2011,cpu_by_user_priority,"sum by (user, priority) (cpu_rate)",keys,count,300,869,2520773,821,827,834,136616,145568,166103,17,1.224971871,1.245842046,1.279308156,0.1519994065,2.118691289,,,,,,,,,, -google_2011,cpu_by_user_priority,"sum by (user, priority) (cpu_rate)",keys,value,300,840,2520773,821,827,834,136616,145568,166103,17,1.269877913,1.324164419,1.436614074,0.1681176267,3.410932446,,,,,,,,,, -google_2011,cpu_by_user_priority,"sum by (user, priority) (cpu_rate)",keys,count,900,869,2520773,830,834,842,136616,432405,475713,7,1.224971871,1.245842046,1.262451768,0.1519994065,2.118691289,,,,,,,,,, -google_2011,cpu_by_user_priority,"sum by (user, priority) (cpu_rate)",keys,value,900,840,2520773,830,834,842,136616,432405,475713,7,1.269877913,1.324164419,1.384966721,0.1681176267,3.410932446,,,,,,,,,, -google_2011,cpu_by_user_priority,"sum by (user, priority) (cpu_rate)",keys,count,3600,869,2520773,850,851,852,999631,1260386.5,1521142,2,1.237062997,1.245842046,1.25092252,0.1519994065,2.118691289,,,,,,,,,, -google_2011,cpu_by_user_priority,"sum by (user, priority) (cpu_rate)",keys,value,3600,840,2520773,850,851,852,999631,1260386.5,1521142,2,1.319267171,1.324164419,1.328123309,0.1681176267,3.410932446,,,,,,,,,, -google_2011,cpu_by_priority,sum by (priority) (cpu_rate),keys,count,300,7,2520773,7,7,7,136616,145568,166103,17,1.033395762,1.100458821,1.174312489,0.3225498686,1.894965449,,,,,,,,,, -google_2011,cpu_by_priority,sum by (priority) (cpu_rate),keys,value,300,7,2520773,7,7,7,136616,145568,166103,17,1.438654738,1.605012701,1.751743738,0.5360046297,2.032407492,,,,,,,,,, -google_2011,cpu_by_priority,sum by (priority) (cpu_rate),keys,count,900,7,2520773,7,7,7,136616,432405,475713,7,1.068090328,1.100458821,1.174312489,0.3225498686,1.894965449,,,,,,,,,, -google_2011,cpu_by_priority,sum by (priority) (cpu_rate),keys,value,900,7,2520773,7,7,7,136616,432405,475713,7,1.498978566,1.605012701,1.710803,0.5360046297,2.032407492,,,,,,,,,, -google_2011,cpu_by_priority,sum by (priority) (cpu_rate),keys,count,3600,7,2520773,7,7,7,999631,1260386.5,1521142,2,1.08297446,1.100458821,1.127200352,0.3225498686,1.894965449,,,,,,,,,, -google_2011,cpu_by_priority,sum by (priority) (cpu_rate),keys,value,3600,7,2520773,7,7,7,999631,1260386.5,1521142,2,1.593554992,1.605012701,1.645136858,0.5360046297,2.032407492,,,,,,,,,, -google_2011,cpu_by_job_id,sum by (job_id) (cpu_rate),keys,count,300,4852,2520773,3999,4033,4069,136616,145568,166103,17,1.10280233,1.10280233,1.139601264,0.1380993053,1.685959941,,,,,,,,,, -google_2011,cpu_by_job_id,sum by (job_id) (cpu_rate),keys,value,300,4741,2520773,3999,4033,4069,136616,145568,166103,17,1.142583401,1.143387587,1.225051106,0.04883747247,2.916311489,,,,,,,,,, -google_2011,cpu_by_job_id,sum by (job_id) (cpu_rate),keys,count,900,4852,2520773,4033,4109,4193,136616,432405,475713,7,1.10280233,1.10280233,1.119091194,0.1380993053,1.685959941,,,,,,,,,, -google_2011,cpu_by_job_id,sum by (job_id) (cpu_rate),keys,value,900,4741,2520773,4033,4109,4193,136616,432405,475713,7,1.143387587,1.143387587,1.201204532,0.04883747247,2.916311489,,,,,,,,,, -google_2011,cpu_by_job_id,sum by (job_id) (cpu_rate),keys,count,3600,4852,2520773,4301,4411.5,4522,999631,1260386.5,1521142,2,1.10280233,1.10280233,1.110415978,0.1380993053,1.685959941,,,,,,,,,, -google_2011,cpu_by_job_id,sum by (job_id) (cpu_rate),keys,value,3600,4741,2520773,4301,4411.5,4522,999631,1260386.5,1521142,2,1.142992759,1.143387587,1.170229373,0.04883747247,2.916311489,,,,,,,,,, -google_2011,cpu_by_logical_job_name,sum by (logical_job_name) (cpu_rate),keys,count,300,4076,2520773,3599,3632,3670,136616,145568,166103,17,1.100157443,1.100157443,1.139773475,0.1380993053,1.674808823,,,,,,,,,, -google_2011,cpu_by_logical_job_name,sum by (logical_job_name) (cpu_rate),keys,value,300,3994,2520773,3599,3632,3670,136616,145568,166103,17,1.137364272,1.137364272,1.222463693,0.04883747247,2.955531246,,,,,,,,,, -google_2011,cpu_by_logical_job_name,sum by (logical_job_name) (cpu_rate),keys,count,900,4076,2520773,3632,3681,3764,136616,432405,475713,7,1.100157443,1.100157443,1.118962316,0.1380993053,1.674808823,,,,,,,,,, -google_2011,cpu_by_logical_job_name,sum by (logical_job_name) (cpu_rate),keys,value,900,3994,2520773,3632,3681,3764,136616,432405,475713,7,1.137364272,1.137364272,1.198192862,0.04883747247,2.955531246,,,,,,,,,, -google_2011,cpu_by_logical_job_name,sum by (logical_job_name) (cpu_rate),keys,count,3600,4076,2520773,3786,3865.5,3945,999631,1260386.5,1521142,2,1.100157443,1.100157443,1.110326676,0.1380993053,1.674808823,,,,,,,,,, -google_2011,cpu_by_logical_job_name,sum by (logical_job_name) (cpu_rate),keys,value,3600,3994,2520773,3786,3865.5,3945,999631,1260386.5,1521142,2,1.137364272,1.137364272,1.166334908,0.04883747247,2.955531246,,,,,,,,,, -google_2011,cpu_by_scheduling_class,sum by (scheduling_class) (cpu_rate),keys,count,300,4,2520773,4,4,4,136616,145568,166103,17,0.4096890076,0.5826207427,0.7586051394,0.3811549076,0.5742969456,,,,,,,,,, -google_2011,cpu_by_scheduling_class,sum by (scheduling_class) (cpu_rate),keys,value,300,4,2520773,4,4,4,136616,145568,166103,17,0.3731987046,0.4296407108,0.9847385735,0.3062121264,0.5650755731,,,,,,,,,, -google_2011,cpu_by_scheduling_class,sum by (scheduling_class) (cpu_rate),keys,count,900,4,2520773,4,4,4,136616,432405,475713,7,0.4096890076,0.5826207427,0.688766467,0.3811549076,0.5742969456,,,,,,,,,, -google_2011,cpu_by_scheduling_class,sum by (scheduling_class) (cpu_rate),keys,value,900,4,2520773,4,4,4,136616,432405,475713,7,0.3853822278,0.4296407108,0.7506561584,0.3062121264,0.5650755731,,,,,,,,,, -google_2011,cpu_by_scheduling_class,sum by (scheduling_class) (cpu_rate),keys,count,3600,4,2520773,4,4,4,999631,1260386.5,1521142,2,0.5090081589,0.5826207427,0.6326222715,0.3811549076,0.5742969456,,,,,,,,,, -google_2011,cpu_by_scheduling_class,sum by (scheduling_class) (cpu_rate),keys,value,3600,4,2520773,4,4,4,999631,1260386.5,1521142,2,0.4296407108,0.4296407108,0.5151663234,0.3062121264,0.5650755731,,,,,,,,,, -google_2011,cpu_by_machine_id,sum by (machine_id) (cpu_rate),keys,count,300,12478,2520773,12470,12474,12476,136616,145568,166103,17,0.2076429296,0.2076429296,0.246048195,0.000191211188,0.2526538379,,,,,,,,,, -google_2011,cpu_by_machine_id,sum by (machine_id) (cpu_rate),keys,value,300,12477,2520773,12470,12474,12476,136616,145568,166103,17,0.2863871442,0.2863871442,0.3545079855,0.000345690753,0.3999845952,,,,,,,,,, -google_2011,cpu_by_machine_id,sum by (machine_id) (cpu_rate),keys,count,900,12478,2520773,12473,12475,12476,136616,432405,475713,7,0.2076429296,0.2076429296,0.2389469664,0.000191211188,0.2526538379,,,,,,,,,, -google_2011,cpu_by_machine_id,sum by (machine_id) (cpu_rate),keys,value,900,12477,2520773,12473,12475,12476,136616,432405,475713,7,0.2863871442,0.2863871442,0.3523868085,0.000345690753,0.3999845952,,,,,,,,,, -google_2011,cpu_by_machine_id,sum by (machine_id) (cpu_rate),keys,count,3600,12478,2520773,12476,12476,12476,999631,1260386.5,1521142,2,0.2071122542,0.2076429296,0.2158581867,0.000191211188,0.2526538379,,,,,,,,,, -google_2011,cpu_by_machine_id,sum by (machine_id) (cpu_rate),keys,value,3600,12477,2520773,12476,12476,12476,999631,1260386.5,1521142,2,0.2844139376,0.2863871442,0.3125403084,0.000345690753,0.3999845952,,,,,,,,,, -google_2011,cpu_p99,"quantile(0.99, cpu_rate)",values,,300,,2520773,,,,126133,132019,146232,17,2.603912147,2.917403705,14.45311216,,,0.09529497499,0.04578,0.04233155135,0.14383,-46.90714986,3.193615919e-13,851.9603769,6.063873751e-88,lognormal, -google_2011,cpu_p99,"quantile(0.99, cpu_rate)",values,,900,,2520773,,,,126133,394800,423512,7,2.673058645,2.917403705,3.340213559,,,0.09529497499,0.04578,0.04233155135,0.14383,-46.90714986,3.193615919e-13,851.9603769,6.063873751e-88,lognormal, -google_2011,cpu_p99,"quantile(0.99, cpu_rate)",values,,3600,,2520773,,,,914192,1140278,1366364,2,2.849760024,2.917403705,2.917403705,,,0.09529497499,0.04578,0.04233155135,0.14383,-46.90714986,3.193615919e-13,851.9603769,6.063873751e-88,lognormal, -google_2011,memory_p99,"quantile(0.99, canonical_memory_usage)",values,,300,,2520773,,,,125080,129779,141433,17,1.774757531,3.294268519,4.337275342,,,0.1138678493,0.05066,0.1412197713,0.15382,-34.94390733,7.239118312e-13,747.9070106,2.316474087e-98,lognormal, -google_2011,memory_p99,"quantile(0.99, canonical_memory_usage)",values,,900,,2520773,,,,125080,387491,412288,7,1.807386797,3.294268519,3.294268519,,,0.1138678493,0.05066,0.1412197713,0.15382,-34.94390733,7.239118312e-13,747.9070106,2.316474087e-98,lognormal, -google_2011,memory_p99,"quantile(0.99, canonical_memory_usage)",values,,3600,,2520773,,,,899559,1116869,1334179,2,1.798673328,3.294268519,3.294268519,,,0.1138678493,0.05066,0.1412197713,0.15382,-34.94390733,7.239118312e-13,747.9070106,2.316474087e-98,lognormal, +google_2011,cpu_by_user,sum by (user) (cpu_rate),keys,count,300,686,288357812,480,519,538,105373,137958,379702,2005,1.101644423,1.146256644,1.675767301,0.07984469656,2.530528113,,,,,,,,,, +google_2011,cpu_by_user,sum by (user) (cpu_rate),keys,value,300,665,288357812,480,519,538,105373,137958,379702,2005,1.188664169,1.235004601,1.459116669,0.1217389859,3.698174511,,,,,,,,,, +google_2011,cpu_by_user,sum by (user) (cpu_rate),keys,count,900,686,288357812,499,522,541,144348,414669,1107219,669,1.09894256,1.146256644,1.656865878,0.07984469656,2.530528113,,,,,,,,,, +google_2011,cpu_by_user,sum by (user) (cpu_rate),keys,value,900,665,288357812,499,522,541,144348,414669,1107219,669,1.192243124,1.235004601,1.446706437,0.1217389859,3.698174511,,,,,,,,,, +google_2011,cpu_by_user,sum by (user) (cpu_rate),keys,count,3600,686,288357812,508,528,548,320187,1656537.5,3991197,168,1.104088825,1.146256644,1.576274349,0.07984469656,2.530528113,,,,,,,,,, +google_2011,cpu_by_user,sum by (user) (cpu_rate),keys,value,3600,665,288357812,508,528,548,320187,1656537.5,3991197,168,1.206873258,1.235004601,1.355914172,0.1217389859,3.698174511,,,,,,,,,, +google_2011,cpu_by_user,sum by (user) (cpu_rate),keys,count,21600,686,288357812,530,545.5,567,7162383,10055874,18075740,28,1.116049101,1.146256644,1.402754532,0.07984469656,2.530528113,,,,,,,,,, +google_2011,cpu_by_user,sum by (user) (cpu_rate),keys,value,21600,665,288357812,530,545.5,567,7162383,10055874,18075740,28,1.208159362,1.235004601,1.302456453,0.1217389859,3.698174511,,,,,,,,,, +google_2011,cpu_by_user,sum by (user) (cpu_rate),keys,count,86400,686,288357812,555,589,601,33072538,39787317,54192657,7,1.127466928,1.146256644,1.220894717,0.07984469656,2.530528113,,,,,,,,,, +google_2011,cpu_by_user,sum by (user) (cpu_rate),keys,value,86400,665,288357812,555,589,601,33072538,39787317,54192657,7,1.225095589,1.235004601,1.26144315,0.1217389859,3.698174511,,,,,,,,,, +google_2011,cpu_by_user,sum by (user) (cpu_rate),keys,count,604800,686,288357812,686,686,686,288357812,288357812,288357812,1,1.146256644,1.146256644,1.146256644,0.07984469656,2.530528113,,,,,,,,,, +google_2011,cpu_by_user,sum by (user) (cpu_rate),keys,value,604800,665,288357812,686,686,686,288357812,288357812,288357812,1,1.235004601,1.235004601,1.235004601,0.1217389859,3.698174511,,,,,,,,,, +google_2011,cpu_by_user_priority,"sum by (user, priority) (cpu_rate)",keys,count,300,1356,288357812,788,838,880,105373,137958,379702,2005,1.123516501,1.15419467,1.65624668,0.07783297718,2.613510728,,,,,,,,,, +google_2011,cpu_by_user_priority,"sum by (user, priority) (cpu_rate)",keys,value,300,1326,288357812,788,838,880,105373,137958,379702,2005,1.215459225,1.258025912,1.466602293,0.121567009,3.607655725,,,,,,,,,, +google_2011,cpu_by_user_priority,"sum by (user, priority) (cpu_rate)",keys,count,900,1356,288357812,814,850,887,144348,414669,1107219,669,1.121772649,1.15419467,1.639682684,0.07783297718,2.613510728,,,,,,,,,, +google_2011,cpu_by_user_priority,"sum by (user, priority) (cpu_rate)",keys,value,900,1326,288357812,814,850,887,144348,414669,1107219,669,1.219042972,1.258025912,1.454793751,0.121567009,3.607655725,,,,,,,,,, +google_2011,cpu_by_user_priority,"sum by (user, priority) (cpu_rate)",keys,count,3600,1356,288357812,828,875,914,320187,1656537.5,3991197,168,1.126148344,1.15419467,1.561472156,0.07783297718,2.613510728,,,,,,,,,, +google_2011,cpu_by_user_priority,"sum by (user, priority) (cpu_rate)",keys,value,3600,1326,288357812,828,875,914,320187,1656537.5,3991197,168,1.231939015,1.258025912,1.368911492,0.121567009,3.607655725,,,,,,,,,, +google_2011,cpu_by_user_priority,"sum by (user, priority) (cpu_rate)",keys,count,21600,1356,288357812,905,944,988,7162383,10055874,18075740,28,1.132874568,1.15419467,1.397194966,0.07783297718,2.613510728,,,,,,,,,, +google_2011,cpu_by_user_priority,"sum by (user, priority) (cpu_rate)",keys,value,21600,1326,288357812,905,944,988,7162383,10055874,18075740,28,1.236530449,1.258025912,1.320540626,0.121567009,3.607655725,,,,,,,,,, +google_2011,cpu_by_user_priority,"sum by (user, priority) (cpu_rate)",keys,count,86400,1356,288357812,998,1083,1092,33072538,39787317,54192657,7,1.138899658,1.15419467,1.231033566,0.07783297718,2.613510728,,,,,,,,,, +google_2011,cpu_by_user_priority,"sum by (user, priority) (cpu_rate)",keys,value,86400,1326,288357812,998,1083,1092,33072538,39787317,54192657,7,1.249995933,1.258025912,1.28448382,0.121567009,3.607655725,,,,,,,,,, +google_2011,cpu_by_user_priority,"sum by (user, priority) (cpu_rate)",keys,count,604800,1356,288357812,1356,1356,1356,288357812,288357812,288357812,1,1.15419467,1.15419467,1.15419467,0.07783297718,2.613510728,,,,,,,,,, +google_2011,cpu_by_user_priority,"sum by (user, priority) (cpu_rate)",keys,value,604800,1326,288357812,1356,1356,1356,288357812,288357812,288357812,1,1.258025912,1.258025912,1.258025912,0.121567009,3.607655725,,,,,,,,,, +google_2011,cpu_by_priority,sum by (priority) (cpu_rate),keys,count,300,11,288357812,7,9,10,105373,137958,379702,2005,0.9875708441,1.371566014,2.184801397,0.3625884913,4.062229564,,,,,,,,,, +google_2011,cpu_by_priority,sum by (priority) (cpu_rate),keys,value,300,11,288357812,7,9,10,105373,137958,379702,2005,1.36454469,1.828458458,2.314749802,0.6034462731,4.306203284,,,,,,,,,, +google_2011,cpu_by_priority,sum by (priority) (cpu_rate),keys,count,900,11,288357812,7,9,10,144348,414669,1107219,669,1.026498567,1.371566014,2.18649282,0.3625884913,4.062229564,,,,,,,,,, +google_2011,cpu_by_priority,sum by (priority) (cpu_rate),keys,value,900,11,288357812,7,9,10,144348,414669,1107219,669,1.410928427,1.828458458,2.24468609,0.6034462731,4.306203284,,,,,,,,,, +google_2011,cpu_by_priority,sum by (priority) (cpu_rate),keys,count,3600,11,288357812,7,9,11,320187,1656537.5,3991197,168,1.039370258,1.371566014,2.005732819,0.3625884913,4.062229564,,,,,,,,,, +google_2011,cpu_by_priority,sum by (priority) (cpu_rate),keys,value,3600,11,288357812,7,9,11,320187,1656537.5,3991197,168,1.46324557,1.828458458,2.166802542,0.6034462731,4.306203284,,,,,,,,,, +google_2011,cpu_by_priority,sum by (priority) (cpu_rate),keys,count,21600,11,288357812,7,10,11,7162383,10055874,18075740,28,1.082379581,1.371566014,1.659260042,0.3625884913,4.062229564,,,,,,,,,, +google_2011,cpu_by_priority,sum by (priority) (cpu_rate),keys,value,21600,11,288357812,7,10,11,7162383,10055874,18075740,28,1.64830348,1.828458458,2.06863377,0.6034462731,4.306203284,,,,,,,,,, +google_2011,cpu_by_priority,sum by (priority) (cpu_rate),keys,count,86400,11,288357812,9,10,11,33072538,39787317,54192657,7,1.308326745,1.371566014,1.387850142,0.3625884913,4.062229564,,,,,,,,,, +google_2011,cpu_by_priority,sum by (priority) (cpu_rate),keys,value,86400,11,288357812,9,10,11,33072538,39787317,54192657,7,1.794292376,1.828458458,1.87167047,0.6034462731,4.306203284,,,,,,,,,, +google_2011,cpu_by_priority,sum by (priority) (cpu_rate),keys,count,604800,11,288357812,11,11,11,288357812,288357812,288357812,1,1.371566014,1.371566014,1.371566014,0.3625884913,4.062229564,,,,,,,,,, +google_2011,cpu_by_priority,sum by (priority) (cpu_rate),keys,value,604800,11,288357812,11,11,11,288357812,288357812,288357812,1,1.828458458,1.828458458,1.828458458,0.6034462731,4.306203284,,,,,,,,,, +google_2011,cpu_by_job_id,sum by (job_id) (cpu_rate),keys,count,300,149904,288357812,3736,4073,4329,105373,137958,379702,2005,1.017149621,1.102080327,1.503255855,0.05772714769,2.06447159,,,,,,,,,, +google_2011,cpu_by_job_id,sum by (job_id) (cpu_rate),keys,value,300,148594,288357812,3736,4073,4329,105373,137958,379702,2005,1.103163853,1.153824387,1.327898976,0.0430493823,2.930785652,,,,,,,,,, +google_2011,cpu_by_job_id,sum by (job_id) (cpu_rate),keys,count,900,149904,288357812,3917,4225,4583,144348,414669,1107219,669,1.014879108,1.102080327,1.489090246,0.05772714769,2.06447159,,,,,,,,,, +google_2011,cpu_by_job_id,sum by (job_id) (cpu_rate),keys,value,900,148594,288357812,3917,4225,4583,144348,414669,1107219,669,1.108907652,1.153824387,1.317638445,0.0430493823,2.930785652,,,,,,,,,, +google_2011,cpu_by_job_id,sum by (job_id) (cpu_rate),keys,count,3600,149904,288357812,4028,4864.5,5652,320187,1656537.5,3991197,168,1.015042145,1.102080327,1.40539214,0.05772714769,2.06447159,,,,,,,,,, +google_2011,cpu_by_job_id,sum by (job_id) (cpu_rate),keys,value,3600,148594,288357812,4028,4864.5,5652,320187,1656537.5,3991197,168,1.115181991,1.153824387,1.21611003,0.0430493823,2.930785652,,,,,,,,,, +google_2011,cpu_by_job_id,sum by (job_id) (cpu_rate),keys,count,21600,149904,288357812,7500,9295,10947,7162383,10055874,18075740,28,1.033709125,1.102080327,1.271991831,0.05772714769,2.06447159,,,,,,,,,, +google_2011,cpu_by_job_id,sum by (job_id) (cpu_rate),keys,value,21600,148594,288357812,7500,9295,10947,7162383,10055874,18075740,28,1.136324911,1.153824387,1.205966983,0.0430493823,2.930785652,,,,,,,,,, +google_2011,cpu_by_job_id,sum by (job_id) (cpu_rate),keys,count,86400,149904,288357812,21103,25450,26826,33072538,39787317,54192657,7,1.069863035,1.102080327,1.145083819,0.05772714769,2.06447159,,,,,,,,,, +google_2011,cpu_by_job_id,sum by (job_id) (cpu_rate),keys,value,86400,148594,288357812,21103,25450,26826,33072538,39787317,54192657,7,1.151826911,1.153824387,1.173624664,0.0430493823,2.930785652,,,,,,,,,, +google_2011,cpu_by_job_id,sum by (job_id) (cpu_rate),keys,count,604800,149904,288357812,149904,149904,149904,288357812,288357812,288357812,1,1.102080327,1.102080327,1.102080327,0.05772714769,2.06447159,,,,,,,,,, +google_2011,cpu_by_job_id,sum by (job_id) (cpu_rate),keys,value,604800,148594,288357812,149904,149904,149904,288357812,288357812,288357812,1,1.153824387,1.153824387,1.153824387,0.0430493823,2.930785652,,,,,,,,,, +google_2011,cpu_by_logical_job_name,sum by (logical_job_name) (cpu_rate),keys,count,300,17796,288357812,3314,3654,3869,105373,137958,379702,2005,1.021586211,1.086252759,1.514068393,0.05772714769,2.749505785,,,,,,,,,, +google_2011,cpu_by_logical_job_name,sum by (logical_job_name) (cpu_rate),keys,value,300,17686,288357812,3314,3654,3869,105373,137958,379702,2005,1.099326069,1.155715922,1.327207337,0.0619674051,3.460309727,,,,,,,,,, +google_2011,cpu_by_logical_job_name,sum by (logical_job_name) (cpu_rate),keys,count,900,17796,288357812,3416,3753,3988,144348,414669,1107219,669,1.017468949,1.086252759,1.496834886,0.05772714769,2.749505785,,,,,,,,,, +google_2011,cpu_by_logical_job_name,sum by (logical_job_name) (cpu_rate),keys,value,900,17686,288357812,3416,3753,3988,144348,414669,1107219,669,1.103914237,1.155715922,1.316868351,0.0619674051,3.460309727,,,,,,,,,, +google_2011,cpu_by_logical_job_name,sum by (logical_job_name) (cpu_rate),keys,count,3600,17796,288357812,3580,4071,4533,320187,1656537.5,3991197,168,1.017063701,1.086252759,1.419466178,0.05772714769,2.749505785,,,,,,,,,, +google_2011,cpu_by_logical_job_name,sum by (logical_job_name) (cpu_rate),keys,value,3600,17686,288357812,3580,4071,4533,320187,1656537.5,3991197,168,1.106589392,1.155715922,1.212971795,0.0619674051,3.460309727,,,,,,,,,, +google_2011,cpu_by_logical_job_name,sum by (logical_job_name) (cpu_rate),keys,count,21600,17796,288357812,4779,5419,5953,7162383,10055874,18075740,28,1.008901366,1.086252759,1.275156292,0.05772714769,2.749505785,,,,,,,,,, +google_2011,cpu_by_logical_job_name,sum by (logical_job_name) (cpu_rate),keys,value,21600,17686,288357812,4779,5419,5953,7162383,10055874,18075740,28,1.111948072,1.155715922,1.190877095,0.0619674051,3.460309727,,,,,,,,,, +google_2011,cpu_by_logical_job_name,sum by (logical_job_name) (cpu_rate),keys,count,86400,17796,288357812,7662,9003,9357,33072538,39787317,54192657,7,1.040704595,1.086252759,1.1437213,0.05772714769,2.749505785,,,,,,,,,, +google_2011,cpu_by_logical_job_name,sum by (logical_job_name) (cpu_rate),keys,value,86400,17686,288357812,7662,9003,9357,33072538,39787317,54192657,7,1.133024679,1.155715922,1.155715922,0.0619674051,3.460309727,,,,,,,,,, +google_2011,cpu_by_logical_job_name,sum by (logical_job_name) (cpu_rate),keys,count,604800,17796,288357812,17796,17796,17796,288357812,288357812,288357812,1,1.086252759,1.086252759,1.086252759,0.05772714769,2.749505785,,,,,,,,,, +google_2011,cpu_by_logical_job_name,sum by (logical_job_name) (cpu_rate),keys,value,604800,17686,288357812,17796,17796,17796,288357812,288357812,288357812,1,1.155715922,1.155715922,1.155715922,0.0619674051,3.460309727,,,,,,,,,, +google_2011,cpu_by_scheduling_class,sum by (scheduling_class) (cpu_rate),keys,count,300,4,288357812,4,4,4,105373,137958,379702,2005,0.1279176611,0.3979267591,2.03910581,0.3291290267,0.4087825709,,,,,,,,,, +google_2011,cpu_by_scheduling_class,sum by (scheduling_class) (cpu_rate),keys,value,300,4,288357812,4,4,4,105373,137958,379702,2005,0.09835771313,0.474743457,1.072402634,0.3377085349,0.5064505245,,,,,,,,,, +google_2011,cpu_by_scheduling_class,sum by (scheduling_class) (cpu_rate),keys,count,900,4,288357812,4,4,4,144348,414669,1107219,669,0.1348725538,0.3979267591,1.961837171,0.3291290267,0.4087825709,,,,,,,,,, +google_2011,cpu_by_scheduling_class,sum by (scheduling_class) (cpu_rate),keys,value,900,4,288357812,4,4,4,144348,414669,1107219,669,0.2009105107,0.474743457,0.9624884881,0.3377085349,0.5064505245,,,,,,,,,, +google_2011,cpu_by_scheduling_class,sum by (scheduling_class) (cpu_rate),keys,count,3600,4,288357812,4,4,4,320187,1656537.5,3991197,168,0.1401778557,0.3979267591,1.777533058,0.3291290267,0.4087825709,,,,,,,,,, +google_2011,cpu_by_scheduling_class,sum by (scheduling_class) (cpu_rate),keys,value,3600,4,288357812,4,4,4,320187,1656537.5,3991197,168,0.2212517864,0.474743457,0.803914756,0.3377085349,0.5064505245,,,,,,,,,, +google_2011,cpu_by_scheduling_class,sum by (scheduling_class) (cpu_rate),keys,count,21600,4,288357812,4,4,4,7162383,10055874,18075740,28,0.1703349758,0.3979267591,1.457599772,0.3291290267,0.4087825709,,,,,,,,,, +google_2011,cpu_by_scheduling_class,sum by (scheduling_class) (cpu_rate),keys,value,21600,4,288357812,4,4,4,7162383,10055874,18075740,28,0.333234169,0.474743457,0.7391113818,0.3377085349,0.5064505245,,,,,,,,,, +google_2011,cpu_by_scheduling_class,sum by (scheduling_class) (cpu_rate),keys,count,86400,4,288357812,4,4,4,33072538,39787317,54192657,7,0.2194518515,0.3979267591,0.915350797,0.3291290267,0.4087825709,,,,,,,,,, +google_2011,cpu_by_scheduling_class,sum by (scheduling_class) (cpu_rate),keys,value,86400,4,288357812,4,4,4,33072538,39787317,54192657,7,0.4156168181,0.474743457,0.5418025953,0.3377085349,0.5064505245,,,,,,,,,, +google_2011,cpu_by_scheduling_class,sum by (scheduling_class) (cpu_rate),keys,count,604800,4,288357812,4,4,4,288357812,288357812,288357812,1,0.3979267591,0.3979267591,0.3979267591,0.3291290267,0.4087825709,,,,,,,,,, +google_2011,cpu_by_scheduling_class,sum by (scheduling_class) (cpu_rate),keys,value,604800,4,288357812,4,4,4,288357812,288357812,288357812,1,0.474743457,0.474743457,0.474743457,0.3377085349,0.5064505245,,,,,,,,,, +google_2011,cpu_by_machine_id,sum by (machine_id) (cpu_rate),keys,count,300,12555,288357812,12450,12494,12513,105373,137958,379702,2005,0.1923715173,0.1923715173,0.4945129903,0.001366878176,0.2201118062,,,,,,,,,, +google_2011,cpu_by_machine_id,sum by (machine_id) (cpu_rate),keys,value,300,12555,288357812,12450,12494,12513,105373,137958,379702,2005,0.264742317,0.264742317,0.4631528705,0.0002457267992,0.3330981966,,,,,,,,,, +google_2011,cpu_by_machine_id,sum by (machine_id) (cpu_rate),keys,count,900,12555,288357812,12457,12496,12515,144348,414669,1107219,669,0.1923715173,0.1923715173,0.4616826191,0.001366878176,0.2201118062,,,,,,,,,, +google_2011,cpu_by_machine_id,sum by (machine_id) (cpu_rate),keys,value,900,12555,288357812,12457,12496,12515,144348,414669,1107219,669,0.264742317,0.264742317,0.4055136179,0.0002457267992,0.3330981966,,,,,,,,,, +google_2011,cpu_by_machine_id,sum by (machine_id) (cpu_rate),keys,count,3600,12555,288357812,12465,12499,12516,320187,1656537.5,3991197,168,0.1923715173,0.1923715173,0.4052306357,0.001366878176,0.2201118062,,,,,,,,,, +google_2011,cpu_by_machine_id,sum by (machine_id) (cpu_rate),keys,value,3600,12555,288357812,12465,12499,12516,320187,1656537.5,3991197,168,0.2583621019,0.264742317,0.3829611444,0.0002457267992,0.3330981966,,,,,,,,,, +google_2011,cpu_by_machine_id,sum by (machine_id) (cpu_rate),keys,count,21600,12555,288357812,12475,12506,12523,7162383,10055874,18075740,28,0.1923715173,0.1923715173,0.2816157868,0.001366878176,0.2201118062,,,,,,,,,, +google_2011,cpu_by_machine_id,sum by (machine_id) (cpu_rate),keys,value,21600,12555,288357812,12475,12506,12523,7162383,10055874,18075740,28,0.2514354822,0.264742317,0.3388644492,0.0002457267992,0.3330981966,,,,,,,,,, +google_2011,cpu_by_machine_id,sum by (machine_id) (cpu_rate),keys,count,86400,12555,288357812,12498,12519,12532,33072538,39787317,54192657,7,0.1923715173,0.1923715173,0.234647975,0.001366878176,0.2201118062,,,,,,,,,, +google_2011,cpu_by_machine_id,sum by (machine_id) (cpu_rate),keys,value,86400,12555,288357812,12498,12519,12532,33072538,39787317,54192657,7,0.264742317,0.264742317,0.2979730386,0.0002457267992,0.3330981966,,,,,,,,,, +google_2011,cpu_by_machine_id,sum by (machine_id) (cpu_rate),keys,count,604800,12555,288357812,12555,12555,12555,288357812,288357812,288357812,1,0.1923715173,0.1923715173,0.1923715173,0.001366878176,0.2201118062,,,,,,,,,, +google_2011,cpu_by_machine_id,sum by (machine_id) (cpu_rate),keys,value,604800,12555,288357812,12555,12555,12555,288357812,288357812,288357812,1,0.264742317,0.264742317,0.264742317,0.0002457267992,0.3330981966,,,,,,,,,, +google_2011,cpu_p99,"quantile(0.99, cpu_rate)",values,,300,,288357812,,,,95686,120112,277263,2005,2.279124043,2.936396571,19.19210676,,,0.1328455773,0.04242,0.02685661734,0.17457,-24.73069332,1.434333658e-07,1538.01025,1.635741883e-165,lognormal, +google_2011,cpu_p99,"quantile(0.99, cpu_rate)",values,,900,,288357812,,,,130897,360567,798863,669,2.280885566,2.936396571,19.08019024,,,0.1328455773,0.04242,0.02685661734,0.17457,-24.73069332,1.434333658e-07,1538.01025,1.635741883e-165,lognormal, +google_2011,cpu_p99,"quantile(0.99, cpu_rate)",values,,3600,,288357812,,,,291480,1439776,2906107,168,2.4328785,2.936396571,13.43398772,,,0.1328455773,0.04242,0.02685661734,0.17457,-24.73069332,1.434333658e-07,1538.01025,1.635741883e-165,lognormal, +google_2011,cpu_p99,"quantile(0.99, cpu_rate)",values,,21600,,288357812,,,,6461218,8561367.5,14120887,28,2.517160934,2.936396571,3.283876855,,,0.1328455773,0.04242,0.02685661734,0.17457,-24.73069332,1.434333658e-07,1538.01025,1.635741883e-165,lognormal, +google_2011,cpu_p99,"quantile(0.99, cpu_rate)",values,,86400,,288357812,,,,29740275,33942633,44337674,7,2.735084114,2.936396571,3.071839473,,,0.1328455773,0.04242,0.02685661734,0.17457,-24.73069332,1.434333658e-07,1538.01025,1.635741883e-165,lognormal, +google_2011,cpu_p99,"quantile(0.99, cpu_rate)",values,,604800,,288357812,,,,250050752,250050752,250050752,1,2.936396571,2.936396571,2.936396571,,,0.1328455773,0.04242,0.02685661734,0.17457,-24.73069332,1.434333658e-07,1538.01025,1.635741883e-165,lognormal, +google_2011,memory_p99,"quantile(0.99, canonical_memory_usage)",values,,300,,288357812,,,,94938,120433,225145,2005,1.644293145,2.229668963,16.90867609,,,0.1503744105,0.02472,0.1287170312,0.28626,-2868.277797,0,-2678.17958,1.157330677e-308,light, +google_2011,memory_p99,"quantile(0.99, canonical_memory_usage)",values,,900,,288357812,,,,129049,361263,639845,669,1.723177234,2.229668963,17.38833031,,,0.1503744105,0.02472,0.1287170312,0.28626,-2868.277797,0,-2678.17958,1.157330677e-308,light, +google_2011,memory_p99,"quantile(0.99, canonical_memory_usage)",values,,3600,,288357812,,,,290610,1443226,2367969,168,1.746363163,2.229668963,16.58716735,,,0.1503744105,0.02472,0.1287170312,0.28626,-2868.277797,0,-2678.17958,1.157330677e-308,light, +google_2011,memory_p99,"quantile(0.99, canonical_memory_usage)",values,,21600,,288357812,,,,6387427,8614701,12404521,28,1.773354456,2.229668963,4.8783361,,,0.1503744105,0.02472,0.1287170312,0.28626,-2868.277797,0,-2678.17958,1.157330677e-308,light, +google_2011,memory_p99,"quantile(0.99, canonical_memory_usage)",values,,86400,,288357812,,,,29285006,34419210,41000772,7,1.788672863,2.229668963,4.562265288,,,0.1503744105,0.02472,0.1287170312,0.28626,-2868.277797,0,-2678.17958,1.157330677e-308,light, +google_2011,memory_p99,"quantile(0.99, canonical_memory_usage)",values,,604800,,288357812,,,,244996176,244996176,244996176,1,2.229668963,2.229668963,2.229668963,,,0.1503744105,0.02472,0.1287170312,0.28626,-2868.277797,0,-2678.17958,1.157330677e-308,light, diff --git a/asap-tools/dataset-analysis/tests/test_fit_skew.py b/asap-tools/dataset-analysis/tests/test_fit_skew.py index 16856313..2b0dacfb 100644 --- a/asap-tools/dataset-analysis/tests/test_fit_skew.py +++ b/asap-tools/dataset-analysis/tests/test_fit_skew.py @@ -380,6 +380,14 @@ def test_window_lengths(self): with self.assertRaises(ValueError): fit_skew.validate_window_lengths(lengths, "d") + def test_table_window_lengths(self): + cfg = copy.deepcopy(VALID_CONFIG) + cfg["tables"]["t"]["window_lengths_s"] = [60, 86400] + fit_skew.validate_config(cfg) + cfg["tables"]["t"]["window_lengths_s"] = [60, 90] + with self.assertRaises(ValueError): + fit_skew.validate_config(cfg) + def test_value_weight_needs_value(self): cfg = copy.deepcopy(VALID_CONFIG) del cfg["queries"][0]["value"] From c4d82c0f1e40c9fa3a0d0eac792001eaf0142028 Mon Sep 17 00:00:00 2001 From: zz_y Date: Wed, 30 Sep 2026 18:57:26 +0000 Subject: [PATCH 8/8] feat(asap-tools): evaluate skew queries per step as instant and range queries Replace disjoint window lengths with Prometheus-style evaluation: every query is evaluated at each step of its table (step_s, the sampling period), in an instant form (latest sample per series, 5-minute lookback) and/or range forms (sliding window over the last S seconds). lower/upper are the min/max over evaluation times; mle pools all data. - Tables declare step_s and series_key; queries declare promql, promql_range and range (instant, 5m, 1h; CallGraph events: 1m, 5m, 1h). Google task_usage is stamped at end_time with a 5-minute step. - Range key sums use a banded sparse matrix over per-step key aggregates; value queries merge per-step uniform samples. - Instant aggregates are computed per file, with series boundary samples resolved across files; interleaved files fail loudly. - Add worst-case columns for the sketch-bench study (worst_theta_cms, worst_K, min_N, max_N, worst_alpha_rank, worst_alpha_memory) and per-query accuracy targets; cms_weight picks the counter-sketch weight. - Evaluations with no rows (trace gaps) are skipped for key and value queries alike. - Regenerate results/skew_summary.csv. Co-Authored-By: Claude Opus 5.5 --- asap-tools/dataset-analysis/README.md | 122 +-- asap-tools/dataset-analysis/fit_skew.py | 747 +++++++++++++----- .../queries/alibaba_v2022.yaml | 69 +- .../dataset-analysis/queries/google_2011.yaml | 36 +- .../dataset-analysis/results/skew_summary.csv | 376 ++++----- .../dataset-analysis/tests/test_fit_skew.py | 302 +++++-- 6 files changed, 1065 insertions(+), 587 deletions(-) diff --git a/asap-tools/dataset-analysis/README.md b/asap-tools/dataset-analysis/README.md index 7b7fa0b8..ded14b96 100644 --- a/asap-tools/dataset-analysis/README.md +++ b/asap-tools/dataset-analysis/README.md @@ -5,16 +5,17 @@ be run over a realistic range of skew rather than a single guessed value. Two tasks: -1. **Label query sets per dataset.** `queries/*.yaml` lists PromQL-style - queries over each trace (`sum by (user) (cpu_rate)`, - `count by (um, dm) (rt)`, `quantile(0.99, cpu_rate)`, ...), each with - the table, group-by labels and value column it reads. +1. **Label query sets per dataset.** `queries/*.yaml` lists PromQL queries + over each trace, each in an instant form (`sum by (user) (cpu_rate)`) + and/or a range form (`sum by (user) (sum_over_time(cpu_rate[5m]))`), + with the table, group-by labels and value column it reads. 2. **Lower / MLE / upper skew per distribution.** `fit_skew.py` fits - a discrete Zipf exponent θ to the rank-frequency of every key query's group-by key (weighted by row count and by value sum), and - a continuous power-law tail exponent α to every value query's column, - once on all data and once per time window, at several window lengths. + once on all data and once per evaluation time, the way Prometheus would + evaluate the query every `step_s` seconds. ## Running @@ -31,24 +32,25 @@ This writes `results/skew_summary.csv` (committed) and plots to `out/` - `--max-rows 300000`: rows read per file (BOOM: time steps per series) for a quick smoke run. - `--no-plots`, `--out DIR`, `--summary PATH`. -- `--min-window-rows` (default 200) and `--min-window-keys` (default 2): - windows below either threshold are skipped when computing the bounds. +- `--min-eval-rows` (default 200) and `--min-eval-keys` (default 2): + evaluations below either threshold are skipped when computing the bounds. - `--workers N`: process pool size (default: all cores). Files and fits run in parallel. -A full run over the fetched data takes about 1.6 hours with 24 workers on a -56-core machine (peak RSS of the main process about 49 GB). Alibaba archives are streamed with `tarfile`, not extracted. +A full run over the fetched data takes about 2 hours with 24 workers on a +56-core machine (peak RSS of the main process about 69 GB). Alibaba archives are streamed with `tarfile`, not extracted. Tests: `python -m unittest discover -s tests -p 'test_*.py'`. ## Datasets -| Dataset | Files | Tables | Window lengths | -|---|---|---|---| -| Google ClusterData 2011-2 | `task_usage` and `task_events` parts 0..119 of 500 (about 7 days), all 500 `job_events` parts, `schema.csv` | `task_usage` joined with task and job attributes | 5 min, 15 min, 1 h, 6 h, 1 day, 7 days | -| Alibaba microservices v2022 | `CallGraph_0..119`, `MCRRTUpdate_0..119` (first 6 hours) | `CallGraph`, `MSRTMCR` | 1 min, 5 min, 30 min, 1 h, 6 h | -| | `MSMetricsUpdate_0..47`, `NodeMetricsUpdate_0..1` (first day) | `MSMetrics`, `NodeMetrics` | 1 min, 5 min, 30 min, 1 h, 6 h, 1 day | -| Datadog BOOM | `dataset_taxonomy.json` and 20 multivariate series | per-series `target` | 20 equal chunks per series | +| Dataset | Files | Tables | Step | Ranges | +|---|---|---|---|---| +| Google ClusterData 2011-2 | `task_usage` and `task_events` parts 0..119 of 500 (about 7 days), all 500 `job_events` parts, `schema.csv` | `task_usage` joined with task and job attributes | 5 min | instant, 5m, 1h | +| Alibaba microservices v2022 | `MCRRTUpdate_0..119` (first 6 hours) | `MSRTMCR` | 1 min | instant, 5m, 1h | +| | `CallGraph_0..119` (first 6 hours) | `CallGraph` | 1 min | 1m, 5m, 1h (events, no instant) | +| | `MSMetricsUpdate_0..47`, `NodeMetricsUpdate_0..1` (first day) | `MSMetrics`, `NodeMetrics` | 1 min | instant, 5m, 1h | +| Datadog BOOM | `dataset_taxonomy.json` and 20 multivariate series | per-series `target` | none | 20 equal chunks per series | Citations: @@ -91,20 +93,37 @@ Citations: a grid of 50 quantiles from p50 to p99.9, restricted to candidates that keep at least 100 values in the tail. α therefore describes a tail between the top half and roughly the top 0.1% of the values; `tail_frac` says - which. A window needs at least 200 positive values to be fittable. + which. An evaluation needs at least 200 positive values to be fittable. - **mle**: the estimate on all data pooled. -- **lower / upper**: min / max over the set {every per-window estimate that +- **lower / upper**: min / max over the set {every per-evaluation estimate that passes the thresholds, mle}, so `lower <= mle <= upper` always. The pooled - and per-window fits have no fixed order: pooling adds rare keys to the tail + and per-evaluation fits have no fixed order: pooling adds rare keys to the tail and accumulates mass on persistent heavy keys, which usually steepens the pooled rank-frequency (most CallGraph queries), but it can also flatten it. -- **Window lengths**: each dataset YAML lists `window_lengths_s`, finest - first; every length must be a multiple of the finest. Data are read once - and aggregated per finest window; coarser windows sum the finest per-key - aggregates (key queries) or concatenate the finest windows' values before - subsampling (value queries). mle does not depend on the window length. +- **Evaluation**: each table has a `step_s` (its sampling period). A row + at time `t` belongs to step `ceil(t / step_s)`, so the evaluation at step + `w` (time `w * step_s`) sees rows in `((w - 1) * step_s, w * step_s]`. + Every query is evaluated at every step, as in a Prometheus range query + with that step: + - **range** (`5m`, `1h`, ...; a multiple of `step_s`): the rows of the + last `range / step_s` steps, i.e. a sliding window, not disjoint + windows. Only evaluations whose whole range lies in the data are used. + Key queries sum the per-step per-key aggregates; value queries merge + per-step uniform samples (at most 100,000 each) into a uniform sample + of the range. + - **instant**: one row per series (the table's `series_key`), its latest + sample at or before the evaluation time and at most 5 minutes old (the + Prometheus lookback; one step if `step_s` is longer). A series that + stops is still seen for up to 5 minutes. Needs files that are + consecutive time chunks; the run fails if a series' samples interleave + across files. Event tables (CallGraph) have no series and only range + forms. + + mle pools every row the query form sees: all rows for range forms, and + every (series, evaluation) pair for the instant form, so `rows_total` of + an instant row counts a series once per evaluation it is visible in. BOOM has no timestamps in this analysis and keeps its 20 equal chunks per - series (`window_len_s` is empty). + series (`range` is empty). - **tail_class**: the power law is compared with an exponential and a lognormal (`distribution_compare`, likelihood ratio `R` and p-value `p`; significant means `p < 0.1`). `light` if the power law does not @@ -120,13 +139,12 @@ Citations: ## Output: `results/skew_summary.csv` -One row per (query, kind, weight, window length). The sketch-bench saturation study reads -`dataset, query_id, kind, weight, window_len_s, lower, mle, upper` to pick the θ and α -range it sweeps. It takes the stream size per sketch window N from -`rows_win_*` and the key cardinality per window K from `K_win_*`, comparing -them at the sketch window x (the row whose `window_len_s` is x) and at the query -lookback S (the row whose `window_len_s` is S, or `*_total` for the whole -sample). `K_total` and `rows_total` are the same on every window length. For +One row per (query, kind, weight, range). The sketch-bench saturation study +reads the worst case per query: `worst_theta_cms` (key rows: the lowest θ of +the weight a per-key counter sketch sees, `cms_weight`), `worst_K`, +`min_N` and `max_N` for the key cardinality and stream size an evaluation +sees, and `worst_alpha_rank` / `worst_alpha_memory` for value rows, plus the +`target_*` accuracy it has to reach. For value rows it should use only rows whose `tail_class` is not `light`: a light tail decays at least exponentially, so its α is just the slope of whatever sliver of the tail the fit picked and does not describe a power-law regime. @@ -136,13 +154,18 @@ power-law regime. | `dataset`, `query_id`, `promql` | query identity (a query with both kinds gets a `keys` and a `values` row) | | `kind` | `keys` (θ) or `values` (α) | | `weight` | `count` or `value` for key rows, empty for value rows | -| `window_len_s` | window length the bounds were computed at (empty for BOOM) | +| `range`, `range_s` | `instant` or the range duration (`range_s` empty for instant and BOOM) | +| `step_s` | evaluation step of the table | | `K_total` | distinct keys with positive weight over the whole sample (BOOM: variates) | -| `rows_total` | rows with non-null keys over the whole sample (values: finite values) | -| `K_win_min`, `K_win_median`, `K_win_max` | key rows: distinct keys per window at this `window_len_s` | -| `rows_win_min`, `rows_win_median`, `rows_win_max` | rows per window at this `window_len_s` (value rows: positive values per window; empty for BOOM) | -| `n_windows` | windows used for the bounds (BOOM: variate-chunk fits) | +| `rows_total` | rows with non-null keys over the whole sample (values: finite values; instant: series-evaluations) | +| `K_win_min`, `K_win_median`, `K_win_max` | key rows: distinct keys per evaluation | +| `rows_win_min`, `rows_win_median`, `rows_win_max` | rows per evaluation (value rows: positive values; empty for BOOM) | +| `n_evals` | evaluations used for the bounds (BOOM: variate-chunk fits) | | `lower`, `mle`, `upper` | θ or α as defined above | +| `worst_theta_cms` | key rows whose weight is the query's `cms_weight`: `lower` | +| `worst_K`, `min_N`, `max_N` | `K_win_max`, `rows_win_min`, `rows_win_max` | +| `worst_alpha_rank`, `worst_alpha_memory` | value rows: `upper` (steepest tail, hardest for rank error) and `lower` (heaviest tail, largest value range) | +| `target_are_top100`, `target_precision_at_k`, `target_hll_rel_err`, `target_rank_err` | accuracy targets (defaults in `fit_skew.py`, overridden by a query's `targets`) | | `top1_share`, `theta_ls` | key rows: share of the largest key, negated log-log least-squares slope | | `dropped_frac` | value rows: fraction of finite values that were ≤ 0 | | `xmin`, `ks_d`, `tail_frac` | value rows: fitted `xmin`, KS distance of the tail, and fraction of the fitted sample at or above `xmin` | @@ -150,17 +173,17 @@ power-law regime. | `tail_class` | see Definitions (BOOM: majority class over variates) | | `ok_frac` | BOOM rows: share of variates whose `tail_class` is not `light` | -Plots in `out/`: `____rank___s.png` (log-log -rank-frequency with the lower/mle/upper θ lines, one per window length) and -`____ccdf.png` (empirical CCDF with the fitted α). +Plots in `out/`: `____rank___.png` (log-log +rank-frequency with the lower/mle/upper θ lines) and +`____ccdf__.png` (empirical CCDF with the fitted α). ## Caveats -- **θ depends on time scale.** A sketch sees the keys of one window of - length x, while a query aggregates over its lookback S (often many - windows). Short windows see fewer keys with noisier counts; long ones pool - more keys. Pick the row whose `window_len_s` matches the sketch window, and - compare it with mle (all data) for long lookbacks. +- **θ depends on the query form.** An instant query sees one sample per + series, so its count-weighted θ measures how series spread over keys; a + range query sees every row in its range. Short ranges see fewer keys with + noisier counts; long ones pool more keys. Use the row whose `range` + matches the query. - **BOOM** strips tags and z-scores each variate, so there is no key θ and the raw value scale is lost. α is fitted per variate on `x - min(x)` @@ -176,13 +199,10 @@ rank-frequency with the lower/mle/upper θ lines, one per window length) and `job_events` value for the same `job_id` (both ordered by event time). - **Small counts bias θ upward**: θ is fitted to the *sorted observed* counts, so the long tail of keys seen once or twice is flatter than the - true law and the order statistics exaggerate the head. Windows with few - rows per key (short windows, high-cardinality keys) are most affected, which + true law and the order statistics exaggerate the head. Evaluations with few + rows per key (short ranges, high-cardinality keys) are most affected, which widens `upper`. -- Each table covers its full downloaded span, so the longest window length - of a table is one window over the whole sample. A table's - `window_lengths_s` overrides the dataset's. MSMetrics and NodeMetrics - sample every 60 s, so a 1-minute window holds one sample per instance or - node. CallGraph has malformed rows +- Google `task_usage` rows measure 5-minute intervals and are stamped at + their `end_time`. CallGraph has malformed rows (extra fields), which are skipped and counted in the log, and `rt` values of `None`, which are read as missing. diff --git a/asap-tools/dataset-analysis/fit_skew.py b/asap-tools/dataset-analysis/fit_skew.py index 712cf206..181812db 100644 --- a/asap-tools/dataset-analysis/fit_skew.py +++ b/asap-tools/dataset-analysis/fit_skew.py @@ -2,9 +2,10 @@ """Fit label skew (Zipf theta) and value skew (power-law alpha) for trace query sets. Key queries fit a discrete Zipf exponent to the rank-frequency of the group-by -key; value queries fit a continuous power law to the queried column. Every fit -is repeated per window: lower/upper are the min/max over windows and mle is the -fit on all data. +key; value queries fit a continuous power law to the queried column. Every +query is evaluated at each step of its table, as an instant query (latest +sample per series) and/or as range queries over the last S seconds: lower/upper +are the min/max over evaluation times and mle is the fit on all data. """ import argparse @@ -12,6 +13,7 @@ import io import logging import os +import re import tarfile import time import warnings @@ -28,6 +30,7 @@ import yaml from matplotlib.figure import Figure from numpy.typing import ArrayLike +from scipy import sparse from scipy.optimize import minimize_scalar SCRIPT_DIR = Path(__file__).resolve().parent @@ -44,8 +47,8 @@ XMIN_GRID_QUANTILES = (0.5, 0.999) MIN_TAIL_SAMPLES = 100 SAMPLE_SEED = 0 -DEFAULT_MIN_WINDOW_ROWS = 200 -DEFAULT_MIN_WINDOW_KEYS = 2 +DEFAULT_MIN_EVAL_ROWS = 200 +DEFAULT_MIN_EVAL_KEYS = 2 # A likelihood-ratio comparison is significant when its p is below this. COMPARE_P_THRESHOLD = 0.1 TAIL_LIGHT = "light" @@ -54,11 +57,35 @@ TAIL_HEAVY_INCONCLUSIVE = "heavy_inconclusive" POWER_LAW_ALTERNATIVES = ("lognormal", "exponential") +INSTANT = "instant" +# An instant query sees a series' latest sample at most this old (Prometheus +# default), or one sampling period if that is longer. +PROMETHEUS_LOOKBACK_S = 300 +DURATION_UNITS_S = {"s": 1, "m": 60, "h": 3600, "d": 86400} +# Range key sums are materialized for this many evaluation times at a time. +EVAL_CHUNK = 32 +# Accuracy each sketch must reach on a query; a query's `targets` overrides. +DEFAULT_TARGETS = { + "are_top100": 0.05, # CMS / CountSketch mean relative error of the top 100 keys + "precision_at_k": 0.95, # top-k precision@k + "hll_rel_err": 0.02, # HLL relative cardinality error + "rank_err": 0.01, # KLL / DDSketch mean rank error +} + CSV_BLOCK_BYTES = 64 << 20 CSV_NULL_VALUES = ["", "None", "NULL", "NaN", "nan"] LABEL_TYPE = pa.dictionary(pa.int32(), pa.string()) -WINDOW_COL = "_window" +# Step index w holds timestamps in ((w - 1) * step_s, w * step_s], so the +# evaluation at t = w * step_s over range S sums steps w - S / step_s + 1 .. w. +STEP_COL = "_step" +TIME_COL = "_time_s" +# Label tuples are hashed to uint64; MISSING_KEY marks a null label. +KEY_COL = "_key" +SERIES_COL = "_series" +NEXT_COL = "_next_step" +FILE_COL = "_file" +MISSING_KEY = np.uint64(0) COUNT_COL = "count" VALUE_SUM_COL = "value_sum" KEY_WEIGHTS = {"count", "value"} @@ -72,7 +99,9 @@ "promql", "kind", "weight", - "window_len_s", + "range", + "range_s", + "step_s", "K_total", "rows_total", "K_win_min", @@ -81,10 +110,17 @@ "rows_win_min", "rows_win_median", "rows_win_max", - "n_windows", + "n_evals", "lower", "mle", "upper", + "worst_theta_cms", + "worst_K", + "min_N", + "max_N", + "worst_alpha_rank", + "worst_alpha_memory", + *(f"target_{name}" for name in DEFAULT_TARGETS), "top1_share", "theta_ls", "dropped_frac", @@ -116,6 +152,46 @@ def load_config(path: str) -> Dict[str, Any]: return cfg +def duration_secs(token: str) -> int: + """'5m' -> 300.""" + match = re.fullmatch(r"(\d+)([smhd])", token) + if match is None: + raise ValueError(f"bad duration {token!r}, expected e.g. 30s, 5m, 1h") + return int(match.group(1)) * DURATION_UNITS_S[match.group(2)] + + +def range_secs(token: str) -> float: + """Range duration in seconds; NaN for instant.""" + return np.nan if token == INSTANT else duration_secs(token) + + +def range_steps(token: str, step_s: int) -> int: + """Steps an evaluation covers: one for instant (per-evaluation aggregates).""" + return 1 if token == INSTANT else duration_secs(token) // step_s + + +def lookback_steps(table: Dict[str, Any]) -> int: + lookback_s = max(PROMETHEUS_LOOKBACK_S, table["step_s"]) + return -(-lookback_s // table["step_s"]) + + +def validate_ranges(q: Dict[str, Any], table: Dict[str, Any], where: str) -> None: + if not q.get("range"): + raise ValueError(f"{where}: range must list instant and/or durations") + for token in q["range"]: + if token == INSTANT: + if "series_key" not in table: + raise ValueError(f"{where}: instant needs a table series_key") + if "promql" not in q: + raise ValueError(f"{where}: instant needs promql") + continue + secs = duration_secs(token) + if secs % table["step_s"]: + raise ValueError(f"{where}: range {token} is not a multiple of step_s") + if "{range}" not in q.get("promql_range", ""): + raise ValueError(f"{where}: range queries need promql_range with {{range}}") + + def validate_query(q: Dict[str, Any], table: Dict[str, Any], where: str) -> None: if q["kind"] not in QUERY_KINDS: raise ValueError(f"{where}: kind must be one of {sorted(QUERY_KINDS)}") @@ -125,6 +201,11 @@ def validate_query(q: Dict[str, Any], table: Dict[str, Any], where: str) -> None value = q.get("value") if value is not None and value not in table["value_columns"]: raise ValueError(f"{where}: {value!r} is not a value column") + unknown = set(q.get("targets", {})) - set(DEFAULT_TARGETS) + if unknown: + raise ValueError(f"{where}: unknown targets {sorted(unknown)}") + if table.get("format") != "boom_arrow": + validate_ranges(q, table, where) if q["kind"] == "values": if value is None: raise ValueError(f"{where}: value queries need a value column") @@ -136,25 +217,19 @@ def validate_query(q: Dict[str, Any], table: Dict[str, Any], where: str) -> None raise ValueError(f"{where}: weights must be a subset of {KEY_WEIGHTS}") if "value" in weights and value is None: raise ValueError(f"{where}: weight 'value' needs a value column") - - -def validate_window_lengths(lengths: Sequence[int], where: str) -> None: - """Coarser windows are built by merging finest windows, so every length - must be a multiple of the first (finest) one.""" - if not lengths or list(lengths) != sorted(set(lengths)): - raise ValueError(f"{where}: window_lengths_s must be ascending and unique") - if any(length % lengths[0] for length in lengths): - raise ValueError(f"{where}: window_lengths_s must be multiples of the first") + if cms_weight(q) not in weights: + raise ValueError(f"{where}: cms_weight must be one of the weights") def validate_config(cfg: Dict[str, Any]) -> None: - if "window_lengths_s" in cfg: - validate_window_lengths(cfg["window_lengths_s"], cfg["dataset"]) for name, table in cfg["tables"].items(): - if "window_lengths_s" in table: - validate_window_lengths( - table["window_lengths_s"], f"{cfg['dataset']}/{name}" - ) + where = f"{cfg['dataset']}/{name}" + if table.get("format") == "boom_arrow": + continue + if not isinstance(table.get("step_s"), int) or table["step_s"] <= 0: + raise ValueError(f"{where}: step_s must be a positive integer") + if not set(table.get("series_key", [])) <= set(table["label_columns"]): + raise ValueError(f"{where}: series_key must be label columns") for q in cfg["queries"]: where = f"{cfg['dataset']}/{q['id']}" table = cfg["tables"].get(q["table"]) @@ -163,6 +238,22 @@ def validate_config(cfg: Dict[str, Any]) -> None: validate_query(q, table, where) +def cms_weight(q: Dict[str, Any]) -> str: + """Weight a per-key counter sketch sees: count for count-by, value for sum-by.""" + return q.get("cms_weight", "count") + + +def query_targets(q: Dict[str, Any]) -> Dict[str, float]: + targets = {**DEFAULT_TARGETS, **q.get("targets", {})} + return {f"target_{name}": value for name, value in targets.items()} + + +def range_promql(q: Dict[str, Any], token: str) -> str: + if token == INSTANT: + return q["promql"] + return q["promql_range"].format(range=token) + + def expand_files(data_root: str, patterns: Sequence[str]) -> List[str]: paths = [] for pattern in patterns: @@ -277,53 +368,234 @@ def query_key(q: Dict[str, Any]) -> Tuple[str, str]: return q["id"], q["kind"] -def merge_key_parts(parts: List[pd.DataFrame], group_by: List[str]) -> pd.DataFrame: - """Sum per-(window, key) counts and value sums; indexed by window and keys.""" - return pd.concat(parts, ignore_index=True).groupby([WINDOW_COL] + group_by).sum() +def has_range(q: Dict[str, Any]) -> bool: + return any(token != INSTANT for token in q["range"]) + + +def label_hash(frame: pd.DataFrame, cols: Sequence[str]) -> np.ndarray: + """uint64 hash of each row's label tuple, equal across batches and files.""" + return pd.util.hash_pandas_object(frame[list(cols)], index=False).to_numpy() + + +def key_hash(frame: pd.DataFrame, cols: Sequence[str]) -> np.ndarray: + """label_hash, with MISSING_KEY where any label is null (such rows are dropped).""" + hashes = label_hash(frame, cols) + hashes[frame[list(cols)].isna().any(axis=1).to_numpy()] = MISSING_KEY + return hashes + + +def group_col(q: Dict[str, Any]) -> str: + return f"{KEY_COL}:{','.join(q['group_by'])}" + + +def merge_key_parts(parts: List[pd.DataFrame]) -> pd.DataFrame: + """Sum per-(step, key) counts and value sums.""" + return ( + pd.concat(parts, ignore_index=True) + .groupby([STEP_COL, KEY_COL], sort=False) + .sum() + .reset_index() + ) def key_part(frame: pd.DataFrame, q: Dict[str, Any]) -> pd.DataFrame: - keys = [WINDOW_COL] + q["group_by"] + """Row count and clipped value sum per (step, key); frame carries KEY_COL.""" + frame = frame[frame[KEY_COL] != MISSING_KEY] + keys = [STEP_COL, KEY_COL] if "value" in q["weights"]: clipped = frame.assign(**{VALUE_SUM_COL: frame[q["value"]].clip(lower=0)}) - part = clipped.groupby(keys, observed=True, sort=False).agg( + part = clipped.groupby(keys, sort=False).agg( **{ COUNT_COL: (VALUE_SUM_COL, "size"), VALUE_SUM_COL: (VALUE_SUM_COL, "sum"), } ) else: - part = frame.groupby(keys, observed=True, sort=False).size().to_frame(COUNT_COL) - # Categories differ between batches, so merge on plain values. - return part.reset_index().astype({c: object for c in q["group_by"]}) + part = frame.groupby(keys, sort=False).size().to_frame(COUNT_COL) + return part.reset_index() -def add_values(acc: Dict[str, Any], windows: np.ndarray, values: np.ndarray) -> None: +def add_values(acc: Dict[str, Any], steps: np.ndarray, values: np.ndarray) -> None: finite = np.isfinite(values) positive = values > 0 acc["n_finite"] += int(finite.sum()) - for w in np.unique(windows[positive]): - acc["windows"].setdefault(int(w), []).append(values[positive & (windows == w)]) + for w in np.unique(steps[positive]): + acc["steps"].setdefault(int(w), []).append(values[positive & (steps == w)]) + + +def value_sample(x: np.ndarray) -> Tuple[int, np.ndarray]: + """(len(x), up to MAX_FIT_SAMPLES of x in random order): any prefix of the + sample is a uniform sample of x, which merge_samples relies on.""" + rng = np.random.default_rng(SAMPLE_SEED) + return len(x), x[rng.permutation(len(x))[:MAX_FIT_SAMPLES]] + + +def merge_samples(parts: Sequence[Tuple[int, np.ndarray]]) -> Tuple[int, np.ndarray]: + """Uniform sample of the union of value_sample parts: each part gives a + multivariate-hypergeometric share of its prefix.""" + counts = np.array([n for n, _ in parts], dtype=np.int64) + total = int(counts.sum()) + rng = np.random.default_rng(SAMPLE_SEED) + take = rng.multivariate_hypergeometric(counts, min(total, MAX_FIT_SAMPLES)) + merged = np.concatenate([x[:k] for (_, x), k in zip(parts, take)]) + return total, rng.permutation(merged) + + +def sample_steps(acc: Dict[str, Any]) -> Dict[str, Any]: + """Replace each step's value arrays by one value_sample.""" + steps = {w: value_sample(np.concatenate(xs)) for w, xs in acc["steps"].items()} + return {"n_finite": acc["n_finite"], "steps": steps} + + +def merge_step_samples(accs: Sequence[Dict[str, Any]]) -> Dict[str, Any]: + parts: Dict[int, List[Tuple[int, np.ndarray]]] = {} + for acc in accs: + for w, sample in acc["steps"].items(): + parts.setdefault(w, []).append(sample) + return { + "n_finite": sum(acc["n_finite"] for acc in accs), + "steps": {w: merge_samples(ps) for w, ps in parts.items()}, + } + + +def latest_per_step(rows: pd.DataFrame) -> pd.DataFrame: + """Each series' last sample in each step.""" + rows = rows.sort_values(TIME_COL, kind="stable") + return rows.drop_duplicates([SERIES_COL, STEP_COL], keep="last") + + +def latest_part( + frame: pd.DataFrame, series_key: List[str], queries: List[Dict[str, Any]] +) -> pd.DataFrame: + """Per (series, step) latest sample with the group keys and values the + instant queries need.""" + cols: Dict[str, Any] = { + SERIES_COL: label_hash(frame, series_key), + STEP_COL: frame[STEP_COL].to_numpy(), + TIME_COL: frame[TIME_COL].to_numpy(), + } + for q in queries: + if q["kind"] == "keys": + cols[group_col(q)] = key_hash(frame, q["group_by"]) + if q.get("value"): + cols[q["value"]] = frame[q["value"]].to_numpy(dtype=float) + return latest_per_step(pd.DataFrame(cols)) + + +def next_step_of_series(rows: pd.DataFrame) -> Tuple[np.ndarray, np.ndarray]: + """For rows sorted by (series, step): the series' next step (NaN if none) + and whether the row is the series' first.""" + series = rows[SERIES_COL].to_numpy() + steps = rows[STEP_COL].to_numpy() + same = series[1:] == series[:-1] + has_next = np.append(same, False) + next_step = np.where(has_next, np.append(steps[1:], 0), np.nan) + return next_step, ~np.append(False, same) + + +def split_instant( + rows: pd.DataFrame, queries: List[Dict[str, Any]], lookback: int +) -> Tuple[Dict[Tuple[str, str], Any], pd.DataFrame]: + """Instant aggregates of one file's latest samples, except each series' + first and last sample in the file, which are returned for resolve_boundaries + because another file may hold the same step or the next sample.""" + rows = latest_per_step(rows).sort_values([SERIES_COL, STEP_COL], kind="stable") + next_step, first = next_step_of_series(rows) + rows = rows.assign(**{NEXT_COL: next_step}) + interior = ~first & ~np.isnan(next_step) + return instant_parts(rows[interior], queries, lookback), rows[~interior] + + +def check_file_order(rows: pd.DataFrame) -> None: + """split_instant takes a series' next sample from the same file, so a + series' steps in one file must not interleave with its steps in another.""" + spans = ( + rows.groupby([SERIES_COL, FILE_COL])[STEP_COL] + .agg(["min", "max"]) + .reset_index() + .sort_values([SERIES_COL, "min", "max"]) + ) + series = spans[SERIES_COL].to_numpy() + lo, hi = spans["min"].to_numpy(), spans["max"].to_numpy() + overlap = (series[1:] == series[:-1]) & (lo[1:] < hi[:-1]) + if overlap.any(): + raise ValueError( + f"{int(overlap.sum())} series have samples interleaved across files; " + "instant evaluation needs files that are consecutive time chunks" + ) + + +def resolve_boundaries( + boundary: Sequence[pd.DataFrame], queries: List[Dict[str, Any]], lookback: int +) -> Dict[Tuple[str, str], Any]: + """Instant aggregates of the per-file first/last samples: keep the latest + sample per (series, step) over files, and take its next step as the + nearer of the in-file next step and the next boundary sample.""" + rows = pd.concat( + [b.assign(**{FILE_COL: i}) for i, b in enumerate(boundary)], ignore_index=True + ) + check_file_order(rows) + rows = rows.sort_values([SERIES_COL, STEP_COL, TIME_COL], kind="stable") + in_file_next = rows.groupby([SERIES_COL, STEP_COL])[NEXT_COL].transform("min") + rows = rows.assign(**{NEXT_COL: in_file_next}) + rows = rows.drop_duplicates([SERIES_COL, STEP_COL], keep="last") + next_step, _ = next_step_of_series(rows) + rows = rows.assign(**{NEXT_COL: np.fmin(rows[NEXT_COL].to_numpy(), next_step)}) + return instant_parts(rows, queries, lookback) + + +def instant_parts( + rows: pd.DataFrame, queries: List[Dict[str, Any]], lookback: int +) -> Dict[Tuple[str, str], Any]: + """Per-evaluation aggregates of latest samples. A sample at step w is its + series' latest for evaluations w .. min(next step, w + lookback) - 1, e.g. + with lookback 5 a series that stops after step 3 counts at steps 3..7.""" + start = rows[STEP_COL].to_numpy() + end = np.fmin(rows[NEXT_COL].to_numpy(), start + lookback).astype(np.int64) + reps = end - start + idx = np.repeat(np.arange(len(rows)), reps) + offsets = np.arange(len(idx)) - np.repeat(np.cumsum(reps) - reps, reps) + evals = rows.iloc[idx].assign(**{STEP_COL: start[idx] + offsets}) + out: Dict[Tuple[str, str], Any] = {} + for q in queries: + if q["kind"] == "keys": + out[query_key(q)] = key_part( + evals.rename(columns={group_col(q): KEY_COL}), q + ) + else: + acc: Dict[str, Any] = {"n_finite": 0, "steps": {}} + add_values( + acc, evals[STEP_COL].to_numpy(), evals[q["value"]].to_numpy(float) + ) + out[query_key(q)] = sample_steps(acc) + return out def aggregate_file(task: Tuple[Any, ...]) -> Dict[str, Any]: - """Per-window key aggregates and positive values for one file.""" - data_root, table, path, queries, window_len_s, joins, max_rows = task + """Per-step key aggregates and value samples (range queries) and instant + aggregates (instant queries) for one file.""" + data_root, table, path, queries, joins, max_rows = task time_col = table["time_column"] + range_queries = [q for q in queries if has_range(q)] + instant_queries = [q for q in queries if INSTANT in q["range"]] value_cols = {q["value"] for q in queries if q.get("value")} join_cols = [c for j in table.get("joins", []) for c in j["columns"]] needed = {time_col} | value_cols needed |= {c for q in queries for c in q["group_by"] if c not in join_cols} needed |= {c for j in table.get("joins", []) for c in j["keys"]} + if instant_queries: + needed |= set(table["series_key"]) key_parts: Dict[Tuple[str, str], List[pd.DataFrame]] = {} values: Dict[Tuple[str, str], Dict[str, Any]] = {} - for q in queries: + for q in range_queries: if q["kind"] == "keys": key_parts[query_key(q)] = [] else: - values[query_key(q)] = {"n_finite": 0, "windows": {}} + values[query_key(q)] = {"n_finite": 0, "steps": {}} + latest: List[pd.DataFrame] = [] rows_read = 0 + step_span = (np.inf, -np.inf) bad_rows: List[str] = [] frames = table_frames( data_root, table, path, sorted(needed), value_cols | {time_col}, bad_rows @@ -335,32 +607,42 @@ def aggregate_file(task: Tuple[Any, ...]) -> Dict[str, Any]: secs = frame[time_col] * table["time_unit_secs"] keep = secs.notna() frame = frame[keep].copy() - frame[WINDOW_COL] = np.floor(secs[keep] / window_len_s).astype(np.int64) + frame[TIME_COL] = secs[keep] + frame[STEP_COL] = np.ceil(secs[keep] / table["step_s"]).astype(np.int64) + if len(frame): + step_span = ( + min(step_span[0], frame[STEP_COL].min()), + max(step_span[1], frame[STEP_COL].max()), + ) for join, lookup in joins: frame = frame.astype({c: object for c in join["keys"]}) frame = frame.join(lookup, on=join["keys"]) - for q in queries: + for q in range_queries: if q["kind"] == "keys": - key_parts[query_key(q)].append(key_part(frame, q)) + keyed = frame.assign(**{KEY_COL: key_hash(frame, q["group_by"])}) + key_parts[query_key(q)].append(key_part(keyed, q)) else: add_values( values[query_key(q)], - frame[WINDOW_COL].to_numpy(), + frame[STEP_COL].to_numpy(), frame[q["value"]].to_numpy(dtype=float), ) + if instant_queries: + latest.append(latest_part(frame, table["series_key"], instant_queries)) if max_rows is not None and rows_read >= max_rows: break - keys = { - query_key(q): merge_key_parts(key_parts[query_key(q)], q["group_by"]) - for q in queries - if q["kind"] == "keys" - } - return { - "keys": keys, - "values": values, + out: Dict[str, Any] = { + "keys": {k: merge_key_parts(parts) for k, parts in key_parts.items()}, + "values": {k: sample_steps(acc) for k, acc in values.items()}, + "span": step_span, "rows_read": rows_read, "bad_rows": len(bad_rows), } + if instant_queries: + out["instant"], out["boundary"] = split_instant( + pd.concat(latest, ignore_index=True), instant_queries, lookback_steps(table) + ) + return out # ---------------------------------------------------------------- fitting @@ -397,7 +679,7 @@ def loglog_slope(weights: ArrayLike) -> float: def window_bounds( window_estimates: Sequence[float], pooled: float ) -> Tuple[float, float, int]: - """(lower, upper, n_windows): min and max over the finite per-window + """(lower, upper, n_evals): min and max over the finite per-window estimates together with the pooled estimate, so lower <= pooled <= upper.""" windows = [e for e in window_estimates if np.isfinite(e)] candidates = windows + ([pooled] if np.isfinite(pooled) else []) @@ -417,23 +699,6 @@ def spread(prefix: str, per_window: Sequence[float]) -> Dict[str, float]: } -def coarsen_keys(agg: pd.DataFrame, factor: int, group_by: List[str]) -> pd.DataFrame: - """Merge every `factor` consecutive finest windows of a key aggregate.""" - frame = agg.reset_index() - frame[WINDOW_COL] //= factor - return merge_key_parts([frame], group_by) - - -def coarsen_values( - windows: Dict[int, np.ndarray], factor: int -) -> Dict[int, np.ndarray]: - """Concatenate the values of every `factor` consecutive finest windows.""" - parts: Dict[int, List[np.ndarray]] = {} - for w, x in windows.items(): - parts.setdefault(w // factor, []).append(x) - return {w: np.concatenate(xs) for w, xs in parts.items()} - - def subsample(x: np.ndarray) -> np.ndarray: if len(x) <= MAX_FIT_SAMPLES: return x @@ -560,132 +825,185 @@ def plot_path(plot_dir: Path, dataset: str, name: str) -> Path: # ---------------------------------------------------------------- summaries +def rolling_key_sums( + agg: pd.DataFrame, columns: Sequence[str], n_steps: int, span: Tuple[int, int] +) -> Iterator[Dict[str, np.ndarray]]: + """For each evaluation step t in [first + n_steps - 1, last], the per-key + sums of `columns` over steps t - n_steps + 1 .. t (keys present only). + Computed as a banded 0/1 matrix times the sparse step x key matrix.""" + first, last = span + agg = agg[(agg[STEP_COL] >= first) & (agg[STEP_COL] <= last)] + n_total = last - first + 1 + n_evals = n_total - n_steps + 1 + if n_evals <= 0 or agg.empty: + return + _, key_idx = np.unique(agg[KEY_COL].to_numpy(), return_inverse=True) + coords = (agg[STEP_COL].to_numpy() - first, key_idx) + shape = (n_total, int(key_idx.max()) + 1) + mats = { + c: sparse.csr_matrix((agg[c].to_numpy(dtype=float), coords), shape=shape) + for c in columns + } + # Row e covers steps e .. e + n_steps - 1, i.e. evaluation first + e + n_steps - 1. + band_rows = np.repeat(np.arange(n_evals), n_steps) + band_cols = band_rows + np.tile(np.arange(n_steps), n_evals) + band = sparse.csr_matrix( + (np.ones(len(band_rows)), (band_rows, band_cols)), shape=(n_evals, n_total) + ) + for start in range(0, n_evals, EVAL_CHUNK): + chunk = { + c: (band[start : start + EVAL_CHUNK] @ m).tocsr() for c, m in mats.items() + } + for i in range(min(EVAL_CHUNK, n_evals - start)): + yield {c: m.data[m.indptr[i] : m.indptr[i + 1]] for c, m in chunk.items()} + + def summarize_keys( dataset: str, q: Dict[str, Any], + token: str, + step_s: int, agg: pd.DataFrame, - window_lengths: Sequence[int], + span: Tuple[int, int], min_rows: int, min_keys: int, plot_dir: Optional[Path], ) -> List[Dict[str, Any]]: - """One row per weight and window length; agg holds finest-window counts.""" + """One row per weight for one range; agg holds per-step key aggregates + (range queries) or per-evaluation ones (instant, one step each).""" + n_steps = range_steps(token, step_s) rows = int(agg[COUNT_COL].sum()) if rows == 0: raise ValueError(f"{dataset}/{q['id']}: no rows with non-null group keys") columns = {w: COUNT_COL if w == "count" else VALUE_SUM_COL for w in q["weights"]} per_key = {} for weight, col in columns.items(): - totals = agg.groupby(level=q["group_by"])[col].sum().to_numpy() + totals = agg.groupby(KEY_COL)[col].sum().to_numpy() per_key[weight] = np.sort(totals[totals > 0])[::-1] pooled = {weight: zipf_mle(w) for weight, w in per_key.items()} - out = [] - for window_len in window_lengths: - coarse = coarsen_keys(agg, window_len // window_lengths[0], q["group_by"]) - by_window = coarse.groupby(level=WINDOW_COL)[COUNT_COL] - window_stats = { - **spread("K_win", by_window.size().tolist()), - **spread("rows_win", by_window.sum().tolist()), - } + estimates: Dict[str, List[float]] = {weight: [] for weight in columns} + keys_per_eval, rows_per_eval = [], [] + for sums in rolling_key_sums(agg, sorted(set(columns.values())), n_steps, span): + counts = sums[COUNT_COL] + n_rows = counts.sum() + if n_rows == 0: + # No data in range (a gap in the trace), as summarize_values skips. + continue + keys_per_eval.append(int(np.sum(counts > 0))) + rows_per_eval.append(n_rows) for weight, col in columns.items(): - estimates = [] - for _, window in coarse.groupby(level=WINDOW_COL): - w = window[col].to_numpy() - if window[COUNT_COL].sum() >= min_rows and np.sum(w > 0) >= min_keys: - estimates.append(zipf_mle(w)) - lower, upper, n_windows = window_bounds(estimates, pooled[weight]) - keys = per_key[weight] - out.append( - { - "dataset": dataset, - "query_id": q["id"], - "promql": q["promql"], - "kind": "keys", - "weight": weight, - "window_len_s": window_len, - "K_total": len(keys), - "rows_total": rows, - **window_stats, - "n_windows": n_windows, - "lower": lower, - "mle": pooled[weight], - "upper": upper, - "top1_share": keys[0] / keys.sum() if len(keys) else np.nan, - "theta_ls": loglog_slope(keys), - } + w = sums[col] + if n_rows >= min_rows and np.sum(w > 0) >= min_keys: + estimates[weight].append(zipf_mle(w)) + eval_stats = { + **spread("K_win", keys_per_eval), + **spread("rows_win", rows_per_eval), + } + out = [] + for weight in columns: + lower, upper, n_evals = window_bounds(estimates[weight], pooled[weight]) + keys = per_key[weight] + out.append( + { + "dataset": dataset, + "query_id": q["id"], + "promql": range_promql(q, token), + "kind": "keys", + "weight": weight, + "range": token, + "range_s": range_secs(token), + "step_s": step_s, + "K_total": len(keys), + "rows_total": rows, + **eval_stats, + "n_evals": n_evals, + "lower": lower, + "mle": pooled[weight], + "upper": upper, + "worst_theta_cms": lower if weight == cms_weight(q) else np.nan, + "worst_K": eval_stats.get("K_win_max", np.nan), + "min_N": eval_stats.get("rows_win_min", np.nan), + "max_N": eval_stats.get("rows_win_max", np.nan), + **query_targets(q), + "top1_share": keys[0] / keys.sum() if len(keys) else np.nan, + "theta_ls": loglog_slope(keys), + } + ) + if plot_dir is not None and len(keys): + plot_rank_frequency( + keys, + {"lower": lower, "mle": pooled[weight], "upper": upper}, + f"{dataset}: {range_promql(q, token)} [{weight}]", + plot_path(plot_dir, dataset, f"{q['id']}__rank_{weight}__{token}"), ) - if plot_dir is not None and len(keys): - plot_rank_frequency( - keys, - {"lower": lower, "mle": pooled[weight], "upper": upper}, - f"{dataset}: {q['promql']} [{weight}, {window_len}s windows]", - plot_path( - plot_dir, dataset, f"{q['id']}__rank_{weight}__{window_len}s" - ), - ) return out def summarize_values( dataset: str, q: Dict[str, Any], + token: str, + step_s: int, acc: Dict[str, Any], - window_lengths: Sequence[int], + span: Tuple[int, int], pool: Any, min_rows: int, plot_dir: Optional[Path], -) -> List[Dict[str, Any]]: - """One row per window length; acc holds positive values per finest window. - Coarser windows concatenate the full finest-window values, then subsample.""" - finest = {w: np.concatenate(parts) for w, parts in acc["windows"].items()} - if not finest: +) -> Dict[str, Any]: + """Row for one range; acc holds a value_sample per step (range queries) + or per evaluation (instant). Each evaluation merges its steps' samples.""" + n_steps = range_steps(token, step_s) + steps = acc["steps"] + if not steps: raise ValueError(f"{dataset}/{q['id']}: no positive values") - all_values = np.concatenate(list(finest.values())) - mle_sample = subsample(all_values) + n_positive, mle_sample = merge_samples(list(steps.values())) jobs = [(mle_sample, True)] - job_window_lens = [0] - window_rows: Dict[int, List[int]] = {} - for window_len in window_lengths: - coarse = coarsen_values(finest, window_len // window_lengths[0]) - window_rows[window_len] = [len(x) for x in coarse.values()] - for x in coarse.values(): - if len(x) >= min_rows: - jobs.append((subsample(x), False)) - job_window_lens.append(window_len) + rows_per_eval = [] + first, last = span + for t in range(first + n_steps - 1, last + 1): + parts = [steps[s] for s in range(t - n_steps + 1, t + 1) if s in steps] + if not parts: + continue + n_t, sample = merge_samples(parts) + rows_per_eval.append(n_t) + if n_t >= min_rows: + jobs.append((sample, False)) fits = pool.starmap(fit_power_law, jobs) mle_fit = fits[0] if plot_dir is not None: plot_ccdf( mle_sample, mle_fit, - f"{dataset}: {q['value']} ({q['id']})", - plot_path(plot_dir, dataset, f"{q['id']}__ccdf"), - ) - out = [] - for window_len in window_lengths: - alphas = [ - f["alpha"] for f, wl in zip(fits, job_window_lens) if wl == window_len - ] - lower, upper, n_windows = window_bounds(alphas, mle_fit["alpha"]) - out.append( - { - "dataset": dataset, - "query_id": q["id"], - "promql": q["promql"], - "kind": "values", - "weight": "", - "window_len_s": window_len, - "rows_total": acc["n_finite"], - **spread("rows_win", window_rows[window_len]), - "n_windows": n_windows, - "lower": lower, - "mle": mle_fit["alpha"], - "upper": upper, - "dropped_frac": 1.0 - len(all_values) / acc["n_finite"], - **{k: v for k, v in mle_fit.items() if k != "alpha"}, - } + f"{dataset}: {range_promql(q, token)}", + plot_path(plot_dir, dataset, f"{q['id']}__ccdf__{token}"), ) - return out + lower, upper, n_evals = window_bounds( + [f["alpha"] for f in fits[1:]], mle_fit["alpha"] + ) + eval_stats = spread("rows_win", rows_per_eval) + return { + "dataset": dataset, + "query_id": q["id"], + "promql": range_promql(q, token), + "kind": "values", + "weight": "", + "range": token, + "range_s": range_secs(token), + "step_s": step_s, + "rows_total": acc["n_finite"], + **eval_stats, + "n_evals": n_evals, + "lower": lower, + "mle": mle_fit["alpha"], + "upper": upper, + "min_N": eval_stats.get("rows_win_min", np.nan), + "max_N": eval_stats.get("rows_win_max", np.nan), + "worst_alpha_rank": upper, + "worst_alpha_memory": lower, + **query_targets(q), + "dropped_frac": 1.0 - n_positive / acc["n_finite"], + **{k: v for k, v in mle_fit.items() if k != "alpha"}, + } def analyze_table( @@ -697,64 +1015,75 @@ def analyze_table( args: argparse.Namespace, plot_dir: Optional[Path], ) -> List[Dict[str, Any]]: - window_lengths = table.get("window_lengths_s") or cfg["window_lengths_s"] # Load each join once here rather than in every file task. joins = [(j, load_join(data_root, table, j)) for j in table.get("joins", [])] tasks = [ - ( - data_root, - table, - path, - queries, - window_lengths[0], - joins, - args.max_rows, - ) + (data_root, table, path, queries, joins, args.max_rows) for path in expand_files(data_root, table["files"]) ] partials = pool.map(aggregate_file, tasks) + span = ( + int(min(p["span"][0] for p in partials)), + int(max(p["span"][1] for p in partials)), + ) log.info( - "read %d rows (%d malformed rows skipped) from %d files", + "read %d rows (%d malformed rows skipped) from %d files, steps %d..%d", sum(p["rows_read"] for p in partials), sum(p["bad_rows"] for p in partials), len(partials), + *span, ) + instant_queries = [q for q in queries if INSTANT in q["range"]] + boundary: Dict[Tuple[str, str], Any] = {} + if instant_queries: + boundary = resolve_boundaries( + [p.pop("boundary") for p in partials], + instant_queries, + lookback_steps(table), + ) out: List[Dict[str, Any]] = [] for q in queries: key = query_key(q) - if q["kind"] == "keys": - agg = merge_key_parts( - [p["keys"][key].reset_index() for p in partials], q["group_by"] - ) - out.extend( - summarize_keys( - cfg["dataset"], - q, - agg, - window_lengths, - args.min_window_rows, - args.min_window_keys, - plot_dir, + merge: Any = merge_key_parts if q["kind"] == "keys" else merge_step_samples + # Pop parts as they are merged to free memory early. + per_step: Any = ( + merge([p[q["kind"]].pop(key) for p in partials]) if has_range(q) else None + ) + for token in q["range"]: + agg: Any + if token == INSTANT: + agg = merge([p["instant"].pop(key) for p in partials] + [boundary[key]]) + else: + agg = per_step + if q["kind"] == "keys": + out.extend( + summarize_keys( + cfg["dataset"], + q, + token, + table["step_s"], + agg, + span, + args.min_eval_rows, + args.min_eval_keys, + plot_dir, + ) ) - ) - else: - acc: Dict[str, Any] = {"n_finite": 0, "windows": {}} - for p in partials: - acc["n_finite"] += p["values"][key]["n_finite"] - for w, parts in p["values"][key]["windows"].items(): - acc["windows"].setdefault(w, []).extend(parts) - out.extend( - summarize_values( - cfg["dataset"], - q, - acc, - window_lengths, - pool, - args.min_window_rows, - plot_dir, + else: + out.append( + summarize_values( + cfg["dataset"], + q, + token, + table["step_s"], + agg, + span, + pool, + args.min_eval_rows, + plot_dir, + ) ) - ) - log.info("%s %s %s done", cfg["dataset"], q["id"], q["kind"]) + log.info("%s %s %s %s done", cfg["dataset"], q["id"], q["kind"], token) return out @@ -812,16 +1141,18 @@ def summarize_boom_series( "dropped_frac": 1.0 - np.sum(shifted > 0) / finite, "tail_class": max(sorted(set(classes)), key=classes.count) if classes else "", "ok_frac": len(chosen) / len(classes) if classes else np.nan, - "n_windows": 0, + "n_evals": 0, + **query_targets(q), } if chosen: bounds = [window_bounds(chunk_alphas[v], full[v]["alpha"]) for v in chosen] row.update( - n_windows=sum(b[2] for b in bounds), + n_evals=sum(b[2] for b in bounds), lower=median_or_nan([b[0] for b in bounds]), mle=median_or_nan([full[v]["alpha"] for v in chosen]), upper=median_or_nan([b[1] for b in bounds]), ) + row.update(worst_alpha_rank=row["upper"], worst_alpha_memory=row["lower"]) for col in ("xmin", "ks_d", "tail_frac") + tuple( f"{k}_{alt}" for alt in POWER_LAW_ALTERNATIVES for k in ("R", "p") ): @@ -855,7 +1186,7 @@ def analyze_boom( if args.max_rows is not None: variates = variates[:, : args.max_rows] shifted = variates - np.nanmin(variates, axis=1, keepdims=True) - jobs, owners = boom_fit_jobs(shifted, cfg["n_chunks"], args.min_window_rows) + jobs, owners = boom_fit_jobs(shifted, cfg["n_chunks"], args.min_eval_rows) fits = pool.starmap(fit_power_law, jobs) series = Path(path).parent.name out.append( @@ -904,16 +1235,16 @@ def parse_args(argv: Optional[Sequence[str]] = None) -> argparse.Namespace: help="rows read per file (BOOM: time steps per series), for smoke runs", ) parser.add_argument( - "--min-window-rows", + "--min-eval-rows", type=int, - default=DEFAULT_MIN_WINDOW_ROWS, - help="skip windows with fewer rows (values: fewer positive values)", + default=DEFAULT_MIN_EVAL_ROWS, + help="skip evaluations with fewer rows (values: fewer positive values)", ) parser.add_argument( - "--min-window-keys", + "--min-eval-keys", type=int, - default=DEFAULT_MIN_WINDOW_KEYS, - help="skip key-query windows with fewer distinct keys", + default=DEFAULT_MIN_EVAL_KEYS, + help="skip key-query evaluations with fewer distinct keys", ) parser.add_argument("--workers", type=int, default=os.cpu_count()) return parser.parse_args(argv) diff --git a/asap-tools/dataset-analysis/queries/alibaba_v2022.yaml b/asap-tools/dataset-analysis/queries/alibaba_v2022.yaml index ba997e19..7ce8a085 100644 --- a/asap-tools/dataset-analysis/queries/alibaba_v2022.yaml +++ b/asap-tools/dataset-analysis/queries/alibaba_v2022.yaml @@ -1,15 +1,21 @@ # Alibaba cluster-trace-microservices-v2022: first 6 hours of CallGraph and # MCRRTUpdate, first day of MSMetricsUpdate and NodeMetricsUpdate. +# +# Tables: step_s is the sampling period and the evaluation step; series_key +# (metric tables only) is the label set identifying one series. +# Queries: range lists `instant` and/or durations; promql is the instant form +# and promql_range the range form with {range} substituted. cms_weight is the +# key weight a per-key counter sketch sees (default count; value for sum-by). +# targets overrides the default accuracy targets in fit_skew.py. dataset: alibaba_v2022 -# Bounds are computed at each window length; the first is the finest. Tables -# without window_lengths_s use this one. -window_lengths_s: [60, 300, 1800, 3600, 21600] tables: MSRTMCR: format: alibaba_tar files: ["alibaba-v2022/MCRRTUpdate_*.tar.gz"] time_column: timestamp time_unit_secs: 1.0e-3 + step_s: 60 + series_key: [msname, msinstanceid, nodeid] label_columns: [msname, msinstanceid, nodeid] value_columns: [providerrpc_rt, providerrpc_mcr] CallGraph: @@ -17,130 +23,163 @@ tables: files: ["alibaba-v2022/CallGraph_*.tar.gz"] time_column: timestamp time_unit_secs: 1.0e-3 + step_s: 60 label_columns: [traceid, service, rpc_id, rpctype, um, uminstanceid, interface, dm, dminstanceid] value_columns: [rt] MSMetrics: format: alibaba_tar files: ["alibaba-v2022/MSMetricsUpdate_*.tar.gz"] - window_lengths_s: [60, 300, 1800, 3600, 21600, 86400] time_column: timestamp time_unit_secs: 1.0e-3 + step_s: 60 + series_key: [msname, msinstanceid, nodeid] label_columns: [msname, msinstanceid, nodeid] value_columns: [cpu_utilization, memory_utilization] NodeMetrics: format: alibaba_tar files: ["alibaba-v2022/NodeMetricsUpdate_*.tar.gz"] - window_lengths_s: [60, 300, 1800, 3600, 21600, 86400] time_column: timestamp time_unit_secs: 1.0e-3 + step_s: 60 + series_key: [nodeid] label_columns: [nodeid] value_columns: [cpu_utilization, memory_utilization] queries: - id: mcr_by_msname promql: sum by (msname) (providerrpc_mcr) + promql_range: sum by (msname) (sum_over_time(providerrpc_mcr[{range}])) + range: [instant, 5m, 1h] table: MSRTMCR kind: keys group_by: [msname] value: providerrpc_mcr weights: [count, value] + cms_weight: value - id: mcr_by_nodeid promql: sum by (nodeid) (providerrpc_mcr) + promql_range: sum by (nodeid) (sum_over_time(providerrpc_mcr[{range}])) + range: [instant, 5m, 1h] table: MSRTMCR kind: keys group_by: [nodeid] value: providerrpc_mcr weights: [count, value] + cms_weight: value - id: rt_p99_by_msname promql: quantile by (msname) (0.99, providerrpc_rt) + promql_range: quantile by (msname) (0.99, quantile_over_time(0.99, providerrpc_rt[{range}])) + range: [instant, 5m, 1h] table: MSRTMCR kind: keys group_by: [msname] value: providerrpc_rt weights: [count, value] - id: rt_p99_by_msname - promql: quantile by (msname) (0.99, providerrpc_rt) + promql: quantile(0.99, providerrpc_rt) + promql_range: quantile_over_time(0.99, providerrpc_rt[{range}]) + range: [instant, 5m, 1h] table: MSRTMCR kind: values group_by: [] value: providerrpc_rt + # CallGraph rows are events (one per call), so only range queries apply. - id: calls_by_rpctype - promql: count by (rpctype) (rt) + promql_range: sum by (rpctype) (count_over_time(rt[{range}])) + range: [1m, 5m, 1h] table: CallGraph kind: keys group_by: [rpctype] weights: [count] - id: calls_by_service - promql: count by (service) (rt) + promql_range: sum by (service) (count_over_time(rt[{range}])) + range: [1m, 5m, 1h] table: CallGraph kind: keys group_by: [service] weights: [count] - id: calls_by_um - promql: count by (um) (rt) + promql_range: sum by (um) (count_over_time(rt[{range}])) + range: [1m, 5m, 1h] table: CallGraph kind: keys group_by: [um] weights: [count] - id: calls_by_dm - promql: count by (dm) (rt) + promql_range: sum by (dm) (count_over_time(rt[{range}])) + range: [1m, 5m, 1h] table: CallGraph kind: keys group_by: [dm] weights: [count] - id: calls_by_interface - promql: count by (interface) (rt) + promql_range: sum by (interface) (count_over_time(rt[{range}])) + range: [1m, 5m, 1h] table: CallGraph kind: keys group_by: [interface] weights: [count] - id: calls_by_um_dm - promql: count by (um, dm) (rt) + promql_range: sum by (um, dm) (count_over_time(rt[{range}])) + range: [1m, 5m, 1h] table: CallGraph kind: keys group_by: [um, dm] weights: [count] - id: calls_by_service_um_dm - promql: count by (service, um, dm) (rt) + promql_range: sum by (service, um, dm) (count_over_time(rt[{range}])) + range: [1m, 5m, 1h] table: CallGraph kind: keys group_by: [service, um, dm] weights: [count] - id: rt_p99_by_service - promql: quantile by (service) (0.99, rt) + promql_range: quantile by (service) (0.99, quantile_over_time(0.99, rt[{range}])) + range: [1m, 5m, 1h] table: CallGraph kind: keys group_by: [service] value: rt weights: [count, value] - id: rt_p99_by_service - promql: quantile by (service) (0.99, rt) + promql_range: quantile_over_time(0.99, rt[{range}]) + range: [1m, 5m, 1h] table: CallGraph kind: values group_by: [] value: rt - id: ms_cpu_by_msname promql: sum by (msname) (cpu_utilization) + promql_range: sum by (msname) (sum_over_time(cpu_utilization[{range}])) + range: [instant, 5m, 1h] table: MSMetrics kind: keys group_by: [msname] value: cpu_utilization weights: [count, value] + cms_weight: value # Baseline: one key per node, expected to be close to uniform. - id: node_cpu_by_nodeid promql: sum by (nodeid) (cpu_utilization) + promql_range: sum by (nodeid) (sum_over_time(cpu_utilization[{range}])) + range: [instant, 5m, 1h] table: NodeMetrics kind: keys group_by: [nodeid] value: cpu_utilization weights: [count, value] + cms_weight: value - id: ms_cpu_p99 promql: quantile(0.99, cpu_utilization) + promql_range: quantile_over_time(0.99, cpu_utilization[{range}]) + range: [instant, 5m, 1h] table: MSMetrics kind: values group_by: [] value: cpu_utilization - id: node_cpu_p99 promql: quantile(0.99, cpu_utilization) + promql_range: quantile_over_time(0.99, cpu_utilization[{range}]) + range: [instant, 5m, 1h] table: NodeMetrics kind: values group_by: [] diff --git a/asap-tools/dataset-analysis/queries/google_2011.yaml b/asap-tools/dataset-analysis/queries/google_2011.yaml index 2fcfdd83..e2ba46bf 100644 --- a/asap-tools/dataset-analysis/queries/google_2011.yaml +++ b/asap-tools/dataset-analysis/queries/google_2011.yaml @@ -1,15 +1,16 @@ # Google ClusterData 2011-2: task_usage parts 0-119 (about 7 days) joined with -# task and job attributes. +# task and job attributes. Fields are described in alibaba_v2022.yaml. dataset: google_2011 -# Bounds are computed at each window length; the first is the finest. -window_lengths_s: [300, 900, 3600, 21600, 86400, 604800] tables: task_usage: format: google_csv schema: google-2011/schema.csv files: ["google-2011/task_usage/part-*-of-00500.csv.gz"] - time_column: start_time + # Each row measures a 5-minute interval; it is stamped at its end time. + time_column: end_time time_unit_secs: 1.0e-6 + step_s: 300 + series_key: [job_id, task_index, machine_id] # Each join keeps the last event per key (sorted by sort_by) and left-joins it. joins: - files: ["google-2011/task_events/part-*-of-00500.csv.gz"] @@ -20,67 +21,92 @@ tables: keys: [job_id] sort_by: time columns: [logical_job_name] - label_columns: [job_id, machine_id, user, priority, scheduling_class, logical_job_name] + label_columns: [job_id, task_index, machine_id, user, priority, scheduling_class, logical_job_name] value_columns: [cpu_rate, canonical_memory_usage] queries: - id: cpu_by_user promql: sum by (user) (cpu_rate) + promql_range: sum by (user) (sum_over_time(cpu_rate[{range}])) + range: [instant, 5m, 1h] table: task_usage kind: keys group_by: [user] value: cpu_rate weights: [count, value] + cms_weight: value - id: cpu_by_user_priority promql: sum by (user, priority) (cpu_rate) + promql_range: sum by (user, priority) (sum_over_time(cpu_rate[{range}])) + range: [instant, 5m, 1h] table: task_usage kind: keys group_by: [user, priority] value: cpu_rate weights: [count, value] + cms_weight: value - id: cpu_by_priority promql: sum by (priority) (cpu_rate) + promql_range: sum by (priority) (sum_over_time(cpu_rate[{range}])) + range: [instant, 5m, 1h] table: task_usage kind: keys group_by: [priority] value: cpu_rate weights: [count, value] + cms_weight: value - id: cpu_by_job_id promql: sum by (job_id) (cpu_rate) + promql_range: sum by (job_id) (sum_over_time(cpu_rate[{range}])) + range: [instant, 5m, 1h] table: task_usage kind: keys group_by: [job_id] value: cpu_rate weights: [count, value] + cms_weight: value - id: cpu_by_logical_job_name promql: sum by (logical_job_name) (cpu_rate) + promql_range: sum by (logical_job_name) (sum_over_time(cpu_rate[{range}])) + range: [instant, 5m, 1h] table: task_usage kind: keys group_by: [logical_job_name] value: cpu_rate weights: [count, value] + cms_weight: value - id: cpu_by_scheduling_class promql: sum by (scheduling_class) (cpu_rate) + promql_range: sum by (scheduling_class) (sum_over_time(cpu_rate[{range}])) + range: [instant, 5m, 1h] table: task_usage kind: keys group_by: [scheduling_class] value: cpu_rate weights: [count, value] + cms_weight: value # Baseline: one key per machine, expected to be close to uniform. - id: cpu_by_machine_id promql: sum by (machine_id) (cpu_rate) + promql_range: sum by (machine_id) (sum_over_time(cpu_rate[{range}])) + range: [instant, 5m, 1h] table: task_usage kind: keys group_by: [machine_id] value: cpu_rate weights: [count, value] + cms_weight: value - id: cpu_p99 promql: quantile(0.99, cpu_rate) + promql_range: quantile_over_time(0.99, cpu_rate[{range}]) + range: [instant, 5m, 1h] table: task_usage kind: values group_by: [] value: cpu_rate - id: memory_p99 promql: quantile(0.99, canonical_memory_usage) + promql_range: quantile_over_time(0.99, canonical_memory_usage[{range}]) + range: [instant, 5m, 1h] table: task_usage kind: values group_by: [] diff --git a/asap-tools/dataset-analysis/results/skew_summary.csv b/asap-tools/dataset-analysis/results/skew_summary.csv index 75be6389..3b27643c 100644 --- a/asap-tools/dataset-analysis/results/skew_summary.csv +++ b/asap-tools/dataset-analysis/results/skew_summary.csv @@ -1,238 +1,138 @@ -dataset,query_id,promql,kind,weight,window_len_s,K_total,rows_total,K_win_min,K_win_median,K_win_max,rows_win_min,rows_win_median,rows_win_max,n_windows,lower,mle,upper,top1_share,theta_ls,dropped_frac,xmin,ks_d,tail_frac,R_lognormal,p_lognormal,R_exponential,p_exponential,tail_class,ok_frac -alibaba_v2022,mcr_by_msname,sum by (msname) (providerrpc_mcr),keys,count,60,26147,867646875,25807,25878,25946,1591245,2389637,6116768,360,1.292109539,1.443313195,1.900453851,0.4545719547,1.37444187,,,,,,,,,, -alibaba_v2022,mcr_by_msname,sum by (msname) (providerrpc_mcr),keys,value,60,18730,867646875,25807,25878,25946,1591245,2389637,6116768,360,1.027135195,1.101430346,1.306967015,0.1498488827,3.811405825,,,,,,,,,, -alibaba_v2022,mcr_by_msname,sum by (msname) (providerrpc_mcr),keys,count,300,26147,867646875,25889,25956,26017,9074361,12178641.5,20040209,72,1.33521834,1.443313195,1.664745,0.4545719547,1.37444187,,,,,,,,,, -alibaba_v2022,mcr_by_msname,sum by (msname) (providerrpc_mcr),keys,value,300,18730,867646875,25889,25956,26017,9074361,12178641.5,20040209,72,1.064293819,1.101430346,1.181235381,0.1498488827,3.811405825,,,,,,,,,, -alibaba_v2022,mcr_by_msname,sum by (msname) (providerrpc_mcr),keys,count,1800,26147,867646875,25996,26019,26077,60453570,74259468.5,90315535,12,1.372912545,1.443313195,1.535683382,0.4545719547,1.37444187,,,,,,,,,, -alibaba_v2022,mcr_by_msname,sum by (msname) (providerrpc_mcr),keys,value,1800,18730,867646875,25996,26019,26077,60453570,74259468.5,90315535,12,1.078854736,1.101430346,1.142123824,0.1498488827,3.811405825,,,,,,,,,, -alibaba_v2022,mcr_by_msname,sum by (msname) (providerrpc_mcr),keys,count,3600,26147,867646875,26028,26050,26092,125610875,146876167,166100193,6,1.38716722,1.443313195,1.499657657,0.4545719547,1.37444187,,,,,,,,,, -alibaba_v2022,mcr_by_msname,sum by (msname) (providerrpc_mcr),keys,value,3600,18730,867646875,26028,26050,26092,125610875,146876167,166100193,6,1.085147832,1.101430346,1.133104218,0.1498488827,3.811405825,,,,,,,,,, -alibaba_v2022,mcr_by_msname,sum by (msname) (providerrpc_mcr),keys,count,21600,26147,867646875,26147,26147,26147,867646875,867646875,867646875,1,1.443313195,1.443313195,1.443313195,0.4545719547,1.37444187,,,,,,,,,, -alibaba_v2022,mcr_by_msname,sum by (msname) (providerrpc_mcr),keys,value,21600,18730,867646875,26147,26147,26147,867646875,867646875,867646875,1,1.101430346,1.101430346,1.101430346,0.1498488827,3.811405825,,,,,,,,,, -alibaba_v2022,mcr_by_nodeid,sum by (nodeid) (providerrpc_mcr),keys,count,60,30825,867646875,30675,30713,30777,1591245,2389637,6116768,360,1.042832583,1.097553229,1.22637178,0.02685695145,0.6757970814,,,,,,,,,, -alibaba_v2022,mcr_by_nodeid,sum by (nodeid) (providerrpc_mcr),keys,value,60,28348,867646875,30675,30713,30777,1591245,2389637,6116768,360,0.6139118116,0.7429289939,0.9855634538,0.007415134693,0.9461668197,,,,,,,,,, -alibaba_v2022,mcr_by_nodeid,sum by (nodeid) (providerrpc_mcr),keys,count,300,30825,867646875,30689,30725,30783,9074361,12178641.5,20040209,72,1.067241266,1.097553229,1.175793283,0.02685695145,0.6757970814,,,,,,,,,, -alibaba_v2022,mcr_by_nodeid,sum by (nodeid) (providerrpc_mcr),keys,value,300,28348,867646875,30689,30725,30783,9074361,12178641.5,20040209,72,0.6938057305,0.7429289939,0.8586025258,0.007415134693,0.9461668197,,,,,,,,,, -alibaba_v2022,mcr_by_nodeid,sum by (nodeid) (providerrpc_mcr),keys,count,1800,30825,867646875,30703,30738.5,30790,60453570,74259468.5,90315535,12,1.078060475,1.097553229,1.125599263,0.02685695145,0.6757970814,,,,,,,,,, -alibaba_v2022,mcr_by_nodeid,sum by (nodeid) (providerrpc_mcr),keys,value,1800,28348,867646875,30703,30738.5,30790,60453570,74259468.5,90315535,12,0.7137216798,0.7429289939,0.8030588531,0.007415134693,0.9461668197,,,,,,,,,, -alibaba_v2022,mcr_by_nodeid,sum by (nodeid) (providerrpc_mcr),keys,count,3600,30825,867646875,30707,30748.5,30799,125610875,146876167,166100193,6,1.083590558,1.097553229,1.112654503,0.02685695145,0.6757970814,,,,,,,,,, -alibaba_v2022,mcr_by_nodeid,sum by (nodeid) (providerrpc_mcr),keys,value,3600,28348,867646875,30707,30748.5,30799,125610875,146876167,166100193,6,0.7215092607,0.7429289939,0.7873009321,0.007415134693,0.9461668197,,,,,,,,,, -alibaba_v2022,mcr_by_nodeid,sum by (nodeid) (providerrpc_mcr),keys,count,21600,30825,867646875,30825,30825,30825,867646875,867646875,867646875,1,1.097553229,1.097553229,1.097553229,0.02685695145,0.6757970814,,,,,,,,,, -alibaba_v2022,mcr_by_nodeid,sum by (nodeid) (providerrpc_mcr),keys,value,21600,28348,867646875,30825,30825,30825,867646875,867646875,867646875,1,0.7429289939,0.7429289939,0.7429289939,0.007415134693,0.9461668197,,,,,,,,,, -alibaba_v2022,rt_p99_by_msname,"quantile by (msname) (0.99, providerrpc_rt)",keys,count,60,26147,867646875,25807,25878,25946,1591245,2389637,6116768,360,1.292109539,1.443313195,1.900453851,0.4545719547,1.37444187,,,,,,,,,, -alibaba_v2022,rt_p99_by_msname,"quantile by (msname) (0.99, providerrpc_rt)",keys,value,60,18721,867646875,25807,25878,25946,1591245,2389637,6116768,360,1.557884845,1.970047387,2.862739376,0.8659870115,2.444903781,,,,,,,,,, -alibaba_v2022,rt_p99_by_msname,"quantile by (msname) (0.99, providerrpc_rt)",keys,count,300,26147,867646875,25889,25956,26017,9074361,12178641.5,20040209,72,1.33521834,1.443313195,1.664745,0.4545719547,1.37444187,,,,,,,,,, -alibaba_v2022,rt_p99_by_msname,"quantile by (msname) (0.99, providerrpc_rt)",keys,value,300,18721,867646875,25889,25956,26017,9074361,12178641.5,20040209,72,1.697749673,1.970047387,2.264852064,0.8659870115,2.444903781,,,,,,,,,, -alibaba_v2022,rt_p99_by_msname,"quantile by (msname) (0.99, providerrpc_rt)",keys,count,1800,26147,867646875,25996,26019,26077,60453570,74259468.5,90315535,12,1.372912545,1.443313195,1.535683382,0.4545719547,1.37444187,,,,,,,,,, -alibaba_v2022,rt_p99_by_msname,"quantile by (msname) (0.99, providerrpc_rt)",keys,value,1800,18721,867646875,25996,26019,26077,60453570,74259468.5,90315535,12,1.830981938,1.970047387,2.1089592,0.8659870115,2.444903781,,,,,,,,,, -alibaba_v2022,rt_p99_by_msname,"quantile by (msname) (0.99, providerrpc_rt)",keys,count,3600,26147,867646875,26028,26050,26092,125610875,146876167,166100193,6,1.38716722,1.443313195,1.499657657,0.4545719547,1.37444187,,,,,,,,,, -alibaba_v2022,rt_p99_by_msname,"quantile by (msname) (0.99, providerrpc_rt)",keys,value,3600,18721,867646875,26028,26050,26092,125610875,146876167,166100193,6,1.858441857,1.970047387,2.082403331,0.8659870115,2.444903781,,,,,,,,,, -alibaba_v2022,rt_p99_by_msname,"quantile by (msname) (0.99, providerrpc_rt)",keys,count,21600,26147,867646875,26147,26147,26147,867646875,867646875,867646875,1,1.443313195,1.443313195,1.443313195,0.4545719547,1.37444187,,,,,,,,,, -alibaba_v2022,rt_p99_by_msname,"quantile by (msname) (0.99, providerrpc_rt)",keys,value,21600,18721,867646875,26147,26147,26147,867646875,867646875,867646875,1,1.970047387,1.970047387,1.970047387,0.8659870115,2.444903781,,,,,,,,,, -alibaba_v2022,rt_p99_by_msname,"quantile by (msname) (0.99, providerrpc_rt)",values,,60,,867646875,,,,1348473,2151674.5,5822881,360,2.192390963,7.457410083,19.36642355,,,0.09788567037,125.5970899,0.06505872248,0.27596,5.736666427,1.341812375e-13,5081.471528,4.079119261e-10,power_law, -alibaba_v2022,rt_p99_by_msname,"quantile by (msname) (0.99, providerrpc_rt)",values,,300,,867646875,,,,7935828,10956963.5,18912878,72,2.23636518,7.457410083,10.90497987,,,0.09788567037,125.5970899,0.06505872248,0.27596,5.736666427,1.341812375e-13,5081.471528,4.079119261e-10,power_law, -alibaba_v2022,rt_p99_by_msname,"quantile by (msname) (0.99, providerrpc_rt)",values,,1800,,867646875,,,,53224900,67225030,83691083,12,2.730198916,7.457410083,9.489211869,,,0.09788567037,125.5970899,0.06505872248,0.27596,5.736666427,1.341812375e-13,5081.471528,4.079119261e-10,power_law, -alibaba_v2022,rt_p99_by_msname,"quantile by (msname) (0.99, providerrpc_rt)",values,,3600,,867646875,,,,111226757,132644430,152748684,6,2.440855062,7.457410083,8.500412331,,,0.09788567037,125.5970899,0.06505872248,0.27596,5.736666427,1.341812375e-13,5081.471528,4.079119261e-10,power_law, -alibaba_v2022,rt_p99_by_msname,"quantile by (msname) (0.99, providerrpc_rt)",values,,21600,,867646875,,,,782716679,782716679,782716679,1,7.457410083,7.457410083,7.457410083,,,0.09788567037,125.5970899,0.06505872248,0.27596,5.736666427,1.341812375e-13,5081.471528,4.079119261e-10,power_law, -alibaba_v2022,calls_by_rpctype,count by (rpctype) (rt),keys,count,60,6,1295335556,6,6,6,2706845,3569261.5,5401445,360,1.242285336,1.310265913,1.414859468,0.4283451021,2.257448052,,,,,,,,,, -alibaba_v2022,calls_by_rpctype,count by (rpctype) (rt),keys,count,300,6,1295335556,6,6,6,13940970,17777247,26594872,72,1.284747072,1.310265913,1.390048655,0.4283451021,2.257448052,,,,,,,,,, -alibaba_v2022,calls_by_rpctype,count by (rpctype) (rt),keys,count,1800,6,1295335556,6,6,6,84681326,106184673,132801413,12,1.293018604,1.310265913,1.361699093,0.4283451021,2.257448052,,,,,,,,,, -alibaba_v2022,calls_by_rpctype,count by (rpctype) (rt),keys,count,3600,6,1295335556,6,6,6,189237768,212483898.5,260437230,6,1.300721862,1.310265913,1.33752991,0.4283451021,2.257448052,,,,,,,,,, -alibaba_v2022,calls_by_rpctype,count by (rpctype) (rt),keys,count,21600,6,1295335556,6,6,6,1295335556,1295335556,1295335556,1,1.310265913,1.310265913,1.310265913,0.4283451021,2.257448052,,,,,,,,,, -alibaba_v2022,calls_by_service,count by (service) (rt),keys,count,60,2769176,1295335556,35446,40128.5,43871,2706845,3569261.5,5401445,360,0.9793500096,1.099337547,1.099337547,0.0630261268,1.274170165,,,,,,,,,, -alibaba_v2022,calls_by_service,count by (service) (rt),keys,count,300,2769176,1295335556,102583,119224.5,134711,13940970,17777247,26594872,72,1.021860887,1.099337547,1.099337547,0.0630261268,1.274170165,,,,,,,,,, -alibaba_v2022,calls_by_service,count by (service) (rt),keys,count,1800,2769176,1295335556,349448,403698.5,474596,84681326,106184673,132801413,12,1.059060366,1.099337547,1.099337547,0.0630261268,1.274170165,,,,,,,,,, -alibaba_v2022,calls_by_service,count by (service) (rt),keys,count,3600,2769176,1295335556,588050,638917,778557,189237768,212483898.5,260437230,6,1.07137182,1.099337547,1.099337547,0.0630261268,1.274170165,,,,,,,,,, -alibaba_v2022,calls_by_service,count by (service) (rt),keys,count,21600,2769176,1295335556,2769176,2769176,2769176,1295335556,1295335556,1295335556,1,1.099337547,1.099337547,1.099337547,0.0630261268,1.274170165,,,,,,,,,, -alibaba_v2022,calls_by_um,count by (um) (rt),keys,count,60,22016,1295335556,5007,6084,8501,2706845,3569261.5,5401445,360,1.093784378,1.185355196,1.208589263,0.1535391521,3.145206929,,,,,,,,,, -alibaba_v2022,calls_by_um,count by (um) (rt),keys,count,300,22016,1295335556,7830,9162,12410,13940970,17777247,26594872,72,1.114640501,1.185355196,1.216733292,0.1535391521,3.145206929,,,,,,,,,, -alibaba_v2022,calls_by_um,count by (um) (rt),keys,count,1800,22016,1295335556,11602,14176,16349,84681326,106184673,132801413,12,1.141913115,1.185355196,1.219337055,0.1535391521,3.145206929,,,,,,,,,, -alibaba_v2022,calls_by_um,count by (um) (rt),keys,count,3600,22016,1295335556,15412,15850,18110,189237768,212483898.5,260437230,6,1.147410093,1.185355196,1.207444538,0.1535391521,3.145206929,,,,,,,,,, -alibaba_v2022,calls_by_um,count by (um) (rt),keys,count,21600,22016,1295335556,22016,22016,22016,1295335556,1295335556,1295335556,1,1.185355196,1.185355196,1.185355196,0.1535391521,3.145206929,,,,,,,,,, -alibaba_v2022,calls_by_dm,count by (dm) (rt),keys,count,60,35550,1295335556,8788,10446.5,14067,2706845,3569261.5,5401445,360,1.096635378,1.157928672,1.157928672,0.07973378135,3.024759942,,,,,,,,,, -alibaba_v2022,calls_by_dm,count by (dm) (rt),keys,count,300,35550,1295335556,13704,15782,20389,13940970,17777247,26594872,72,1.113121733,1.157928672,1.160162669,0.07973378135,3.024759942,,,,,,,,,, -alibaba_v2022,calls_by_dm,count by (dm) (rt),keys,count,1800,35550,1295335556,20130,23431,26785,84681326,106184673,132801413,12,1.125786526,1.157928672,1.167151669,0.07973378135,3.024759942,,,,,,,,,, -alibaba_v2022,calls_by_dm,count by (dm) (rt),keys,count,3600,35550,1295335556,25512,26228,29583,189237768,212483898.5,260437230,6,1.132567656,1.157928672,1.16969281,0.07973378135,3.024759942,,,,,,,,,, -alibaba_v2022,calls_by_dm,count by (dm) (rt),keys,count,21600,35550,1295335556,35550,35550,35550,1295335556,1295335556,1295335556,1,1.157928672,1.157928672,1.157928672,0.07973378135,3.024759942,,,,,,,,,, -alibaba_v2022,calls_by_interface,count by (interface) (rt),keys,count,60,8655921,1295335556,76838,93821,139176,2706845,3569261.5,5401445,360,0.9891494111,1.097910713,1.097910713,0.02572182771,0.8643899176,,,,,,,,,, -alibaba_v2022,calls_by_interface,count by (interface) (rt),keys,count,300,8655921,1295335556,218939,263783.5,392357,13940970,17777247,26594872,72,1.024459485,1.097910713,1.097910713,0.02572182771,0.8643899176,,,,,,,,,, -alibaba_v2022,calls_by_interface,count by (interface) (rt),keys,count,1800,8655921,1295335556,839071,998851,1234611,84681326,106184673,132801413,12,1.060081164,1.097910713,1.097910713,0.02572182771,0.8643899176,,,,,,,,,, -alibaba_v2022,calls_by_interface,count by (interface) (rt),keys,count,3600,8655921,1295335556,1513235,1791716.5,2131776,189237768,212483898.5,260437230,6,1.070243628,1.097910713,1.097910713,0.02572182771,0.8643899176,,,,,,,,,, -alibaba_v2022,calls_by_interface,count by (interface) (rt),keys,count,21600,8655921,1295335556,8655921,8655921,8655921,1295335556,1295335556,1295335556,1,1.097910713,1.097910713,1.097910713,0.02572182771,0.8643899176,,,,,,,,,, -alibaba_v2022,calls_by_um_dm,"count by (um, dm) (rt)",keys,count,60,165895,1295335556,23787,30295,47939,2706845,3569261.5,5401445,360,0.9766087399,1.070642064,1.070642064,0.04140612504,2.721022211,,,,,,,,,, -alibaba_v2022,calls_by_um_dm,"count by (um, dm) (rt)",keys,count,300,165895,1295335556,40968,51379,77825,13940970,17777247,26594872,72,0.9989432682,1.070642064,1.072960909,0.04140612504,2.721022211,,,,,,,,,, -alibaba_v2022,calls_by_um_dm,"count by (um, dm) (rt)",keys,count,1800,165895,1295335556,68126,89327.5,111563,84681326,106184673,132801413,12,1.021624348,1.070642064,1.083869319,0.04140612504,2.721022211,,,,,,,,,, -alibaba_v2022,calls_by_um_dm,"count by (um, dm) (rt)",keys,count,3600,165895,1295335556,99442,104835.5,127688,189237768,212483898.5,260437230,6,1.02990045,1.070642064,1.084358656,0.04140612504,2.721022211,,,,,,,,,, -alibaba_v2022,calls_by_um_dm,"count by (um, dm) (rt)",keys,count,21600,165895,1295335556,165895,165895,165895,1295335556,1295335556,1295335556,1,1.070642064,1.070642064,1.070642064,0.04140612504,2.721022211,,,,,,,,,, -alibaba_v2022,calls_by_service_um_dm,"count by (service, um, dm) (rt)",keys,count,60,7963812,1295335556,131737,159178.5,239493,2706845,3569261.5,5401445,360,0.8917240947,1.022270823,1.022270823,0.01313775872,1.385250269,,,,,,,,,, -alibaba_v2022,calls_by_service_um_dm,"count by (service, um, dm) (rt)",keys,count,300,7963812,1295335556,320250,391694.5,578272,13940970,17777247,26594872,72,0.9323426164,1.022270823,1.022270823,0.01313775872,1.385250269,,,,,,,,,, -alibaba_v2022,calls_by_service_um_dm,"count by (service, um, dm) (rt)",keys,count,1800,7963812,1295335556,1007700,1260490,1406614,84681326,106184673,132801413,12,0.972825411,1.022270823,1.022270823,0.01313775872,1.385250269,,,,,,,,,, -alibaba_v2022,calls_by_service_um_dm,"count by (service, um, dm) (rt)",keys,count,3600,7963812,1295335556,1782159,1971965,2211657,189237768,212483898.5,260437230,6,0.9870472428,1.022270823,1.022270823,0.01313775872,1.385250269,,,,,,,,,, -alibaba_v2022,calls_by_service_um_dm,"count by (service, um, dm) (rt)",keys,count,21600,7963812,1295335556,7963812,7963812,7963812,1295335556,1295335556,1295335556,1,1.022270823,1.022270823,1.022270823,0.01313775872,1.385250269,,,,,,,,,, -alibaba_v2022,rt_p99_by_service,"quantile by (service) (0.99, rt)",keys,count,60,2769176,1295335556,35446,40128.5,43871,2706845,3569261.5,5401445,360,0.9793500096,1.099337547,1.099337547,0.0630261268,1.274170165,,,,,,,,,, -alibaba_v2022,rt_p99_by_service,"quantile by (service) (0.99, rt)",keys,value,60,2717104,1295335556,35446,40128.5,43871,2706845,3569261.5,5401445,360,1.096888247,1.179024529,1.606011761,0.2835197699,1.778216939,,,,,,,,,, -alibaba_v2022,rt_p99_by_service,"quantile by (service) (0.99, rt)",keys,count,300,2769176,1295335556,102583,119224.5,134711,13940970,17777247,26594872,72,1.021860887,1.099337547,1.099337547,0.0630261268,1.274170165,,,,,,,,,, -alibaba_v2022,rt_p99_by_service,"quantile by (service) (0.99, rt)",keys,value,300,2717104,1295335556,102583,119224.5,134711,13940970,17777247,26594872,72,1.115950521,1.179024529,1.280859084,0.2835197699,1.778216939,,,,,,,,,, -alibaba_v2022,rt_p99_by_service,"quantile by (service) (0.99, rt)",keys,count,1800,2769176,1295335556,349448,403698.5,474596,84681326,106184673,132801413,12,1.059060366,1.099337547,1.099337547,0.0630261268,1.274170165,,,,,,,,,, -alibaba_v2022,rt_p99_by_service,"quantile by (service) (0.99, rt)",keys,value,1800,2717104,1295335556,349448,403698.5,474596,84681326,106184673,132801413,12,1.145393833,1.179024529,1.212405991,0.2835197699,1.778216939,,,,,,,,,, -alibaba_v2022,rt_p99_by_service,"quantile by (service) (0.99, rt)",keys,count,3600,2769176,1295335556,588050,638917,778557,189237768,212483898.5,260437230,6,1.07137182,1.099337547,1.099337547,0.0630261268,1.274170165,,,,,,,,,, -alibaba_v2022,rt_p99_by_service,"quantile by (service) (0.99, rt)",keys,value,3600,2717104,1295335556,588050,638917,778557,189237768,212483898.5,260437230,6,1.159047436,1.179024529,1.197565897,0.2835197699,1.778216939,,,,,,,,,, -alibaba_v2022,rt_p99_by_service,"quantile by (service) (0.99, rt)",keys,count,21600,2769176,1295335556,2769176,2769176,2769176,1295335556,1295335556,1295335556,1,1.099337547,1.099337547,1.099337547,0.0630261268,1.274170165,,,,,,,,,, -alibaba_v2022,rt_p99_by_service,"quantile by (service) (0.99, rt)",keys,value,21600,2717104,1295335556,2769176,2769176,2769176,1295335556,1295335556,1295335556,1,1.179024529,1.179024529,1.179024529,0.2835197699,1.778216939,,,,,,,,,, -alibaba_v2022,rt_p99_by_service,"quantile by (service) (0.99, rt)",values,,60,,1270987041,,,,1545590,2102060,3311374,360,1.893692381,2.030679588,2.49525936,,,0.3996959565,19,0.03004561456,0.08535,-0.04015238608,0.9098821503,12193.79023,3.364578417e-57,heavy_inconclusive, -alibaba_v2022,rt_p99_by_service,"quantile by (service) (0.99, rt)",values,,300,,1270987041,,,,7884223,10466448.5,16264262,72,1.921842081,2.030679588,2.521827762,,,0.3996959565,19,0.03004561456,0.08535,-0.04015238608,0.9098821503,12193.79023,3.364578417e-57,heavy_inconclusive, -alibaba_v2022,rt_p99_by_service,"quantile by (service) (0.99, rt)",values,,1800,,1270987041,,,,48187644,62446248.5,80141038,12,1.973885276,2.030679588,2.361281435,,,0.3996959565,19,0.03004561456,0.08535,-0.04015238608,0.9098821503,12193.79023,3.364578417e-57,heavy_inconclusive, -alibaba_v2022,rt_p99_by_service,"quantile by (service) (0.99, rt)",values,,3600,,1270987041,,,,109397150,124881369.5,157226178,6,2.030679588,2.030679588,2.367919968,,,0.3996959565,19,0.03004561456,0.08535,-0.04015238608,0.9098821503,12193.79023,3.364578417e-57,heavy_inconclusive, -alibaba_v2022,rt_p99_by_service,"quantile by (service) (0.99, rt)",values,,21600,,1270987041,,,,762978660,762978660,762978660,1,2.030679588,2.030679588,2.030679588,,,0.3996959565,19,0.03004561456,0.08535,-0.04015238608,0.9098821503,12193.79023,3.364578417e-57,heavy_inconclusive, -alibaba_v2022,ms_cpu_by_msname,sum by (msname) (cpu_utilization),keys,count,60,28260,675424445,28130,28151,28166,465721,469692.5,471139,1440,0.8249291767,0.8256900161,0.8263595398,0.01642157177,1.279481397,,,,,,,,,, -alibaba_v2022,ms_cpu_by_msname,sum by (msname) (cpu_utilization),keys,value,60,28259,675424445,28130,28151,28166,465721,469692.5,471139,1440,0.8708682951,0.8893327869,0.9058773298,0.01026331486,1.71275427,,,,,,,,,, -alibaba_v2022,ms_cpu_by_msname,sum by (msname) (cpu_utilization),keys,count,300,28260,675424445,28147,28159.5,28171,2328999,2348464,2355294,288,0.8250495524,0.8256900161,0.8263469367,0.01642157177,1.279481397,,,,,,,,,, -alibaba_v2022,ms_cpu_by_msname,sum by (msname) (cpu_utilization),keys,value,300,28259,675424445,28147,28159.5,28171,2328999,2348464,2355294,288,0.8715262892,0.8893327869,0.905414951,0.01026331486,1.71275427,,,,,,,,,, -alibaba_v2022,ms_cpu_by_msname,sum by (msname) (cpu_utilization),keys,count,1800,28260,675424445,28156,28167.5,28178,13975561,14088565.5,14128896,48,0.8251627143,0.8256900161,0.8263140713,0.01642157177,1.279481397,,,,,,,,,, -alibaba_v2022,ms_cpu_by_msname,sum by (msname) (cpu_utilization),keys,value,1800,28259,675424445,28156,28167.5,28178,13975561,14088565.5,14128896,48,0.8727229776,0.8893327869,0.9043856162,0.01026331486,1.71275427,,,,,,,,,, -alibaba_v2022,ms_cpu_by_msname,sum by (msname) (cpu_utilization),keys,count,3600,28260,675424445,28161,28173,28183,27957228,28184867,28252925,24,0.8252488418,0.8256900161,0.8263148174,0.01642157177,1.279481397,,,,,,,,,, -alibaba_v2022,ms_cpu_by_msname,sum by (msname) (cpu_utilization),keys,value,3600,28259,675424445,28161,28173,28183,27957228,28184867,28252925,24,0.8732428329,0.8893327869,0.9039451145,0.01026331486,1.71275427,,,,,,,,,, -alibaba_v2022,ms_cpu_by_msname,sum by (msname) (cpu_utilization),keys,count,21600,28260,675424445,28179,28205.5,28210,167843477,169059041.5,169462885,4,0.8254300908,0.8256900161,0.8262450207,0.01642157177,1.279481397,,,,,,,,,, -alibaba_v2022,ms_cpu_by_msname,sum by (msname) (cpu_utilization),keys,value,21600,28259,675424445,28179,28205.5,28210,167843477,169059041.5,169462885,4,0.8781402663,0.8893327869,0.8992278067,0.01026331486,1.71275427,,,,,,,,,, -alibaba_v2022,ms_cpu_by_msname,sum by (msname) (cpu_utilization),keys,count,86400,28260,675424445,28260,28260,28260,675424445,675424445,675424445,1,0.8256900161,0.8256900161,0.8256900161,0.01642157177,1.279481397,,,,,,,,,, -alibaba_v2022,ms_cpu_by_msname,sum by (msname) (cpu_utilization),keys,value,86400,28259,675424445,28260,28260,28260,675424445,675424445,675424445,1,0.8893327869,0.8893327869,0.8893327869,0.01026331486,1.71275427,,,,,,,,,, -alibaba_v2022,ms_cpu_p99,"quantile(0.99, cpu_utilization)",values,,60,,675424445,,,,465709,469677,471127,1440,3.017631337,3.284197319,10.3330847,,,3.036461021e-05,0.2347216667,0.06413735873,0.26578,-1226.764811,1.056522957e-223,-1337.731878,2.263998704e-273,light, -alibaba_v2022,ms_cpu_p99,"quantile(0.99, cpu_utilization)",values,,300,,675424445,,,,2328934,2348383.5,2355229,288,3.028369143,3.284197319,8.178095105,,,3.036461021e-05,0.2347216667,0.06413735873,0.26578,-1226.764811,1.056522957e-223,-1337.731878,2.263998704e-273,light, -alibaba_v2022,ms_cpu_p99,"quantile(0.99, cpu_utilization)",values,,1800,,675424445,,,,13975151,14088116,14128503,48,3.103443433,3.284197319,6.830580725,,,3.036461021e-05,0.2347216667,0.06413735873,0.26578,-1226.764811,1.056522957e-223,-1337.731878,2.263998704e-273,light, -alibaba_v2022,ms_cpu_p99,"quantile(0.99, cpu_utilization)",values,,3600,,675424445,,,,27956442,28184004.5,28252146,24,3.203504221,3.284197319,6.855077435,,,3.036461021e-05,0.2347216667,0.06413735873,0.26578,-1226.764811,1.056522957e-223,-1337.731878,2.263998704e-273,light, -alibaba_v2022,ms_cpu_p99,"quantile(0.99, cpu_utilization)",values,,21600,,675424445,,,,167838800,169053622,169457892,4,3.284197319,3.284197319,6.189368402,,,3.036461021e-05,0.2347216667,0.06413735873,0.26578,-1226.764811,1.056522957e-223,-1337.731878,2.263998704e-273,light, -alibaba_v2022,ms_cpu_p99,"quantile(0.99, cpu_utilization)",values,,86400,,675424445,,,,675403936,675403936,675403936,1,3.284197319,3.284197319,3.284197319,,,3.036461021e-05,0.2347216667,0.06413735873,0.26578,-1226.764811,1.056522957e-223,-1337.731878,2.263998704e-273,light, -alibaba_v2022,node_cpu_by_nodeid,sum by (nodeid) (cpu_utilization),keys,count,60,43382,58460197,41795,42253,42900,41795,42253,42900,1379,3.612546385e-06,0.02250972512,0.02250972512,2.358869916e-05,0.07484077042,,,,,,,,,, -alibaba_v2022,node_cpu_by_nodeid,sum by (nodeid) (cpu_utilization),keys,value,60,43381,58460197,41795,42253,42900,41795,42253,42900,1379,0.2865167137,0.2865167137,0.353937895,9.702091431e-05,0.3892546546,,,,,,,,,, -alibaba_v2022,node_cpu_by_nodeid,sum by (nodeid) (cpu_utilization),keys,count,300,43382,58460197,42239,42332.5,42957,169332,211241,214431,276,0.001369408484,0.02250972512,0.02250972512,2.358869916e-05,0.07484077042,,,,,,,,,, -alibaba_v2022,node_cpu_by_nodeid,sum by (nodeid) (cpu_utilization),keys,value,300,43381,58460197,42239,42332.5,42957,169332,211241,214431,276,0.2854823814,0.2865167137,0.3413704436,9.702091431e-05,0.3892546546,,,,,,,,,, -alibaba_v2022,node_cpu_by_nodeid,sum by (nodeid) (cpu_utilization),keys,count,1800,43382,58460197,42352,42397.5,42996,1228782,1267277.5,1286400,46,0.002695275718,0.02250972512,0.02250972512,2.358869916e-05,0.07484077042,,,,,,,,,, -alibaba_v2022,node_cpu_by_nodeid,sum by (nodeid) (cpu_utilization),keys,value,1800,43381,58460197,42352,42397.5,42996,1228782,1267277.5,1286400,46,0.2818164573,0.2865167137,0.3343942102,9.702091431e-05,0.3892546546,,,,,,,,,, -alibaba_v2022,node_cpu_by_nodeid,sum by (nodeid) (cpu_utilization),keys,count,3600,43382,58460197,42376,42433,43021,2503748,2534184,2570715,23,0.003499846278,0.02250972512,0.02250972512,2.358869916e-05,0.07484077042,,,,,,,,,, -alibaba_v2022,node_cpu_by_nodeid,sum by (nodeid) (cpu_utilization),keys,value,3600,43381,58460197,42376,42433,43021,2503748,2534184,2570715,23,0.2805202205,0.2865167137,0.3302192401,9.702091431e-05,0.3892546546,,,,,,,,,, -alibaba_v2022,node_cpu_by_nodeid,sum by (nodeid) (cpu_utilization),keys,count,21600,43382,58460197,42526,42817,43131,12674023,15222728.5,15340717,4,0.007170304158,0.02250972512,0.02250972512,2.358869916e-05,0.07484077042,,,,,,,,,, -alibaba_v2022,node_cpu_by_nodeid,sum by (nodeid) (cpu_utilization),keys,value,21600,43381,58460197,42526,42817,43131,12674023,15222728.5,15340717,4,0.2817520704,0.2865167137,0.3116445407,9.702091431e-05,0.3892546546,,,,,,,,,, -alibaba_v2022,node_cpu_by_nodeid,sum by (nodeid) (cpu_utilization),keys,count,86400,43382,58460197,43382,43382,43382,58460197,58460197,58460197,1,0.02250972512,0.02250972512,0.02250972512,2.358869916e-05,0.07484077042,,,,,,,,,, -alibaba_v2022,node_cpu_by_nodeid,sum by (nodeid) (cpu_utilization),keys,value,86400,43381,58460197,43382,43382,43382,58460197,58460197,58460197,1,0.2865167137,0.2865167137,0.2865167137,9.702091431e-05,0.3892546546,,,,,,,,,, -alibaba_v2022,node_cpu_p99,"quantile(0.99, cpu_utilization)",values,,60,,58460197,,,,41793,42251,42898,1379,4.235679376,5.406249425,6.455573604,,,4.945245053e-05,0.3308919271,0.01534101513,0.08247,-4.440742688,0.04306283931,137.3406788,6.479126893e-16,lognormal, -alibaba_v2022,node_cpu_p99,"quantile(0.99, cpu_utilization)",values,,300,,58460197,,,,169324,211230,214421,276,4.295022072,5.406249425,6.299447518,,,4.945245053e-05,0.3308919271,0.01534101513,0.08247,-4.440742688,0.04306283931,137.3406788,6.479126893e-16,lognormal, -alibaba_v2022,node_cpu_p99,"quantile(0.99, cpu_utilization)",values,,1800,,58460197,,,,1228724,1267214.5,1286339,46,4.33068855,5.406249425,6.076082306,,,4.945245053e-05,0.3308919271,0.01534101513,0.08247,-4.440742688,0.04306283931,137.3406788,6.479126893e-16,lognormal, -alibaba_v2022,node_cpu_p99,"quantile(0.99, cpu_utilization)",values,,3600,,58460197,,,,2503630,2534059,2570595,23,4.332980693,5.406249425,6.232080556,,,4.945245053e-05,0.3308919271,0.01534101513,0.08247,-4.440742688,0.04306283931,137.3406788,6.479126893e-16,lognormal, -alibaba_v2022,node_cpu_p99,"quantile(0.99, cpu_utilization)",values,,21600,,58460197,,,,12673406,15221953,15339994,4,4.477964462,5.406249425,6.005084587,,,4.945245053e-05,0.3308919271,0.01534101513,0.08247,-4.440742688,0.04306283931,137.3406788,6.479126893e-16,lognormal, -alibaba_v2022,node_cpu_p99,"quantile(0.99, cpu_utilization)",values,,86400,,58460197,,,,58457306,58457306,58457306,1,5.406249425,5.406249425,5.406249425,,,4.945245053e-05,0.3308919271,0.01534101513,0.08247,-4.440742688,0.04306283931,137.3406788,6.479126893e-16,lognormal, -boom,target_tail[ds-2187-H],"quantile(0.99, target)",values,,,100,523100,,,,,,,900,1.673862396,2.879820136,5.449343474,,,0.0001911680367,1.13650366,0.05719670041,0.1334608031,-0.7518535826,0.1985446789,81.95794065,4.297158362e-06,light,0.45 -boom,target_tail[ds-2394-D],"quantile(0.99, target)",values,,,73,10001,,,,,,,0,,,,,,0.1858814119,,,,,,,,, -boom,target_tail[ds-1135-5T],"quantile(0.99, target)",values,,,26,425984,,,,,,,63,2.072418608,2.555273335,4.464465828,,,0.5493680514,1.309216454,0.09571546402,0.3780193237,-3.202171683,0.08890763899,233.8257673,9.588002711e-10,light,0.3571428571 -boom,target_tail[ds-1833-D],"quantile(0.99, target)",values,,,17,3689,,,,,,,0,,,,,,0.2396313364,,,,,,,,, -boom,target_tail[ds-2806-D],"quantile(0.99, target)",values,,,100,13700,,,,,,,0,,,,,,0.7003649635,,,,,,,,, -boom,target_tail[ds-2573-D],"quantile(0.99, target)",values,,,45,9765,,,,,,,0,7.824807058,7.824807058,7.824807058,,,0.007987711214,2.832573324,0.2237516935,0.4814814815,-0.1549932255,0.1811684879,8.450514888,8.137699192e-05,light,0.2444444444 -boom,target_tail[ds-2222-30T],"quantile(0.99, target)",values,,,100,1045600,,,,,,,800,5.121075907,27.15946506,45.43533407,,,0.5705183627,3.907679107,0.138594883,0.03610214265,-0.3643459076,0.2354562876,16.72715255,3.110465898e-15,heavy_inconclusive,0.97 -boom,target_tail[ds-1914-30T],"quantile(0.99, target)",values,,,64,669504,,,,,,,0,,,,,,0.9991770027,,,,,,,,, -boom,target_tail[ds-2577-H],"quantile(0.99, target)",values,,,11,57541,,,,,,,40,2.357316003,3.318605295,7.114686774,,,0.0001911680367,1.451908794,0.04583397605,0.4337476099,-3.619220504,0.2878918275,168.5626824,1.8816055e-20,light,0.1818181818 -boom,target_tail[ds-2212-D],"quantile(0.99, target)",values,,,42,9114,,,,,,,0,2.097505042,2.097505042,2.097505042,,,0.2055080097,0.1728252252,0.07861559668,0.4741809117,-0.6104251813,0.3802005494,57.44497486,0.003636112868,light,0.3636363636 -boom,target_tail[ds-2782-H],"quantile(0.99, target)",values,,,20,16500,,,,,,,0,,,,,,0.9923636364,,,,,,,,, -boom,target_tail[ds-1400-10S],"quantile(0.99, target)",values,,,75,1228800,,,,,,,680,3.665809149,5.927304101,8.608042368,,,0.0001399739583,3.22594058,0.03461878105,0.1945003968,-0.5020486991,0.1052433657,67.48976464,1.414326313e-05,light,0.4533333333 -boom,target_tail[ds-2650-D],"quantile(0.99, target)",values,,,56,12152,,,,,,,0,2.372256328,2.372256328,2.372256328,,,0.004772876893,0.3060346595,0.07025218904,0.4814814815,-0.4345545346,0.5532457248,23.54371772,0.03707674656,light,0.25 -boom,target_tail[ds-1316-10S],"quantile(0.99, target)",values,,,40,655360,,,,,,,800,1.394454939,2.841176959,3.782745604,,,0.1220932007,2.273231677,0.03804312837,0.03161851893,-1.526906431,0.1625683967,48.84256082,4.793863342e-08,heavy_inconclusive,1 -boom,target_tail[ds-1558-5T],"quantile(0.99, target)",values,,,97,1589248,,,,,,,1195,2.859011495,4.965505023,14.93467462,,,0.1971838253,2.030408032,0.08454367574,0.2353085011,0.01446142949,0.1477685349,143.8265644,7.494706033e-08,heavy_inconclusive,0.6701030928 -boom,target_tail[ds-1972-D],"quantile(0.99, target)",values,,,39,5343,,,,,,,0,,,,,,0.05577390979,,,,,,,,, -boom,target_tail[ds-1840-D],"quantile(0.99, target)",values,,,100,21700,,,,,,,0,48.70890868,48.70890868,48.70890868,,,0.00465437788,5.808935183,0.1729496632,0.5046296296,-0.1558493932,0.6911382477,15.25220643,2.851033848e-05,light,0.11 -boom,target_tail[ds-671-10S],"quantile(0.99, target)",values,,,100,1638400,,,,,,,0,,,,,,6.103515625e-05,,,,,,,,light,0 -boom,target_tail[ds-1524-5T],"quantile(0.99, target)",values,,,93,1267683,,,,,,,18,3.310389413,3.310389413,3.692673948,,,0.944850566,1.984224252,0.2043641455,0.523993808,-0.7337541742,0.1428173664,51.73262359,2.004766276e-06,heavy_inconclusive,0.6470588235 -boom,target_tail[ds-899-T],"quantile(0.99, target)",values,,,12,196608,,,,,,,144,2.379500335,4.776016519,4.776016519,,,0.4203440348,3.316427802,0.0820839487,0.05264234598,-0.6434653813,0.1335383104,64.54346235,4.612421122e-07,heavy_inconclusive,1 -google_2011,cpu_by_user,sum by (user) (cpu_rate),keys,count,300,686,288357812,480,519,538,105373,137958,379702,2005,1.101644423,1.146256644,1.675767301,0.07984469656,2.530528113,,,,,,,,,, -google_2011,cpu_by_user,sum by (user) (cpu_rate),keys,value,300,665,288357812,480,519,538,105373,137958,379702,2005,1.188664169,1.235004601,1.459116669,0.1217389859,3.698174511,,,,,,,,,, -google_2011,cpu_by_user,sum by (user) (cpu_rate),keys,count,900,686,288357812,499,522,541,144348,414669,1107219,669,1.09894256,1.146256644,1.656865878,0.07984469656,2.530528113,,,,,,,,,, -google_2011,cpu_by_user,sum by (user) (cpu_rate),keys,value,900,665,288357812,499,522,541,144348,414669,1107219,669,1.192243124,1.235004601,1.446706437,0.1217389859,3.698174511,,,,,,,,,, -google_2011,cpu_by_user,sum by (user) (cpu_rate),keys,count,3600,686,288357812,508,528,548,320187,1656537.5,3991197,168,1.104088825,1.146256644,1.576274349,0.07984469656,2.530528113,,,,,,,,,, -google_2011,cpu_by_user,sum by (user) (cpu_rate),keys,value,3600,665,288357812,508,528,548,320187,1656537.5,3991197,168,1.206873258,1.235004601,1.355914172,0.1217389859,3.698174511,,,,,,,,,, -google_2011,cpu_by_user,sum by (user) (cpu_rate),keys,count,21600,686,288357812,530,545.5,567,7162383,10055874,18075740,28,1.116049101,1.146256644,1.402754532,0.07984469656,2.530528113,,,,,,,,,, -google_2011,cpu_by_user,sum by (user) (cpu_rate),keys,value,21600,665,288357812,530,545.5,567,7162383,10055874,18075740,28,1.208159362,1.235004601,1.302456453,0.1217389859,3.698174511,,,,,,,,,, -google_2011,cpu_by_user,sum by (user) (cpu_rate),keys,count,86400,686,288357812,555,589,601,33072538,39787317,54192657,7,1.127466928,1.146256644,1.220894717,0.07984469656,2.530528113,,,,,,,,,, -google_2011,cpu_by_user,sum by (user) (cpu_rate),keys,value,86400,665,288357812,555,589,601,33072538,39787317,54192657,7,1.225095589,1.235004601,1.26144315,0.1217389859,3.698174511,,,,,,,,,, -google_2011,cpu_by_user,sum by (user) (cpu_rate),keys,count,604800,686,288357812,686,686,686,288357812,288357812,288357812,1,1.146256644,1.146256644,1.146256644,0.07984469656,2.530528113,,,,,,,,,, -google_2011,cpu_by_user,sum by (user) (cpu_rate),keys,value,604800,665,288357812,686,686,686,288357812,288357812,288357812,1,1.235004601,1.235004601,1.235004601,0.1217389859,3.698174511,,,,,,,,,, -google_2011,cpu_by_user_priority,"sum by (user, priority) (cpu_rate)",keys,count,300,1356,288357812,788,838,880,105373,137958,379702,2005,1.123516501,1.15419467,1.65624668,0.07783297718,2.613510728,,,,,,,,,, -google_2011,cpu_by_user_priority,"sum by (user, priority) (cpu_rate)",keys,value,300,1326,288357812,788,838,880,105373,137958,379702,2005,1.215459225,1.258025912,1.466602293,0.121567009,3.607655725,,,,,,,,,, -google_2011,cpu_by_user_priority,"sum by (user, priority) (cpu_rate)",keys,count,900,1356,288357812,814,850,887,144348,414669,1107219,669,1.121772649,1.15419467,1.639682684,0.07783297718,2.613510728,,,,,,,,,, -google_2011,cpu_by_user_priority,"sum by (user, priority) (cpu_rate)",keys,value,900,1326,288357812,814,850,887,144348,414669,1107219,669,1.219042972,1.258025912,1.454793751,0.121567009,3.607655725,,,,,,,,,, -google_2011,cpu_by_user_priority,"sum by (user, priority) (cpu_rate)",keys,count,3600,1356,288357812,828,875,914,320187,1656537.5,3991197,168,1.126148344,1.15419467,1.561472156,0.07783297718,2.613510728,,,,,,,,,, -google_2011,cpu_by_user_priority,"sum by (user, priority) (cpu_rate)",keys,value,3600,1326,288357812,828,875,914,320187,1656537.5,3991197,168,1.231939015,1.258025912,1.368911492,0.121567009,3.607655725,,,,,,,,,, -google_2011,cpu_by_user_priority,"sum by (user, priority) (cpu_rate)",keys,count,21600,1356,288357812,905,944,988,7162383,10055874,18075740,28,1.132874568,1.15419467,1.397194966,0.07783297718,2.613510728,,,,,,,,,, -google_2011,cpu_by_user_priority,"sum by (user, priority) (cpu_rate)",keys,value,21600,1326,288357812,905,944,988,7162383,10055874,18075740,28,1.236530449,1.258025912,1.320540626,0.121567009,3.607655725,,,,,,,,,, -google_2011,cpu_by_user_priority,"sum by (user, priority) (cpu_rate)",keys,count,86400,1356,288357812,998,1083,1092,33072538,39787317,54192657,7,1.138899658,1.15419467,1.231033566,0.07783297718,2.613510728,,,,,,,,,, -google_2011,cpu_by_user_priority,"sum by (user, priority) (cpu_rate)",keys,value,86400,1326,288357812,998,1083,1092,33072538,39787317,54192657,7,1.249995933,1.258025912,1.28448382,0.121567009,3.607655725,,,,,,,,,, -google_2011,cpu_by_user_priority,"sum by (user, priority) (cpu_rate)",keys,count,604800,1356,288357812,1356,1356,1356,288357812,288357812,288357812,1,1.15419467,1.15419467,1.15419467,0.07783297718,2.613510728,,,,,,,,,, -google_2011,cpu_by_user_priority,"sum by (user, priority) (cpu_rate)",keys,value,604800,1326,288357812,1356,1356,1356,288357812,288357812,288357812,1,1.258025912,1.258025912,1.258025912,0.121567009,3.607655725,,,,,,,,,, -google_2011,cpu_by_priority,sum by (priority) (cpu_rate),keys,count,300,11,288357812,7,9,10,105373,137958,379702,2005,0.9875708441,1.371566014,2.184801397,0.3625884913,4.062229564,,,,,,,,,, -google_2011,cpu_by_priority,sum by (priority) (cpu_rate),keys,value,300,11,288357812,7,9,10,105373,137958,379702,2005,1.36454469,1.828458458,2.314749802,0.6034462731,4.306203284,,,,,,,,,, -google_2011,cpu_by_priority,sum by (priority) (cpu_rate),keys,count,900,11,288357812,7,9,10,144348,414669,1107219,669,1.026498567,1.371566014,2.18649282,0.3625884913,4.062229564,,,,,,,,,, -google_2011,cpu_by_priority,sum by (priority) (cpu_rate),keys,value,900,11,288357812,7,9,10,144348,414669,1107219,669,1.410928427,1.828458458,2.24468609,0.6034462731,4.306203284,,,,,,,,,, -google_2011,cpu_by_priority,sum by (priority) (cpu_rate),keys,count,3600,11,288357812,7,9,11,320187,1656537.5,3991197,168,1.039370258,1.371566014,2.005732819,0.3625884913,4.062229564,,,,,,,,,, -google_2011,cpu_by_priority,sum by (priority) (cpu_rate),keys,value,3600,11,288357812,7,9,11,320187,1656537.5,3991197,168,1.46324557,1.828458458,2.166802542,0.6034462731,4.306203284,,,,,,,,,, -google_2011,cpu_by_priority,sum by (priority) (cpu_rate),keys,count,21600,11,288357812,7,10,11,7162383,10055874,18075740,28,1.082379581,1.371566014,1.659260042,0.3625884913,4.062229564,,,,,,,,,, -google_2011,cpu_by_priority,sum by (priority) (cpu_rate),keys,value,21600,11,288357812,7,10,11,7162383,10055874,18075740,28,1.64830348,1.828458458,2.06863377,0.6034462731,4.306203284,,,,,,,,,, -google_2011,cpu_by_priority,sum by (priority) (cpu_rate),keys,count,86400,11,288357812,9,10,11,33072538,39787317,54192657,7,1.308326745,1.371566014,1.387850142,0.3625884913,4.062229564,,,,,,,,,, -google_2011,cpu_by_priority,sum by (priority) (cpu_rate),keys,value,86400,11,288357812,9,10,11,33072538,39787317,54192657,7,1.794292376,1.828458458,1.87167047,0.6034462731,4.306203284,,,,,,,,,, -google_2011,cpu_by_priority,sum by (priority) (cpu_rate),keys,count,604800,11,288357812,11,11,11,288357812,288357812,288357812,1,1.371566014,1.371566014,1.371566014,0.3625884913,4.062229564,,,,,,,,,, -google_2011,cpu_by_priority,sum by (priority) (cpu_rate),keys,value,604800,11,288357812,11,11,11,288357812,288357812,288357812,1,1.828458458,1.828458458,1.828458458,0.6034462731,4.306203284,,,,,,,,,, -google_2011,cpu_by_job_id,sum by (job_id) (cpu_rate),keys,count,300,149904,288357812,3736,4073,4329,105373,137958,379702,2005,1.017149621,1.102080327,1.503255855,0.05772714769,2.06447159,,,,,,,,,, -google_2011,cpu_by_job_id,sum by (job_id) (cpu_rate),keys,value,300,148594,288357812,3736,4073,4329,105373,137958,379702,2005,1.103163853,1.153824387,1.327898976,0.0430493823,2.930785652,,,,,,,,,, -google_2011,cpu_by_job_id,sum by (job_id) (cpu_rate),keys,count,900,149904,288357812,3917,4225,4583,144348,414669,1107219,669,1.014879108,1.102080327,1.489090246,0.05772714769,2.06447159,,,,,,,,,, -google_2011,cpu_by_job_id,sum by (job_id) (cpu_rate),keys,value,900,148594,288357812,3917,4225,4583,144348,414669,1107219,669,1.108907652,1.153824387,1.317638445,0.0430493823,2.930785652,,,,,,,,,, -google_2011,cpu_by_job_id,sum by (job_id) (cpu_rate),keys,count,3600,149904,288357812,4028,4864.5,5652,320187,1656537.5,3991197,168,1.015042145,1.102080327,1.40539214,0.05772714769,2.06447159,,,,,,,,,, -google_2011,cpu_by_job_id,sum by (job_id) (cpu_rate),keys,value,3600,148594,288357812,4028,4864.5,5652,320187,1656537.5,3991197,168,1.115181991,1.153824387,1.21611003,0.0430493823,2.930785652,,,,,,,,,, -google_2011,cpu_by_job_id,sum by (job_id) (cpu_rate),keys,count,21600,149904,288357812,7500,9295,10947,7162383,10055874,18075740,28,1.033709125,1.102080327,1.271991831,0.05772714769,2.06447159,,,,,,,,,, -google_2011,cpu_by_job_id,sum by (job_id) (cpu_rate),keys,value,21600,148594,288357812,7500,9295,10947,7162383,10055874,18075740,28,1.136324911,1.153824387,1.205966983,0.0430493823,2.930785652,,,,,,,,,, -google_2011,cpu_by_job_id,sum by (job_id) (cpu_rate),keys,count,86400,149904,288357812,21103,25450,26826,33072538,39787317,54192657,7,1.069863035,1.102080327,1.145083819,0.05772714769,2.06447159,,,,,,,,,, -google_2011,cpu_by_job_id,sum by (job_id) (cpu_rate),keys,value,86400,148594,288357812,21103,25450,26826,33072538,39787317,54192657,7,1.151826911,1.153824387,1.173624664,0.0430493823,2.930785652,,,,,,,,,, -google_2011,cpu_by_job_id,sum by (job_id) (cpu_rate),keys,count,604800,149904,288357812,149904,149904,149904,288357812,288357812,288357812,1,1.102080327,1.102080327,1.102080327,0.05772714769,2.06447159,,,,,,,,,, -google_2011,cpu_by_job_id,sum by (job_id) (cpu_rate),keys,value,604800,148594,288357812,149904,149904,149904,288357812,288357812,288357812,1,1.153824387,1.153824387,1.153824387,0.0430493823,2.930785652,,,,,,,,,, -google_2011,cpu_by_logical_job_name,sum by (logical_job_name) (cpu_rate),keys,count,300,17796,288357812,3314,3654,3869,105373,137958,379702,2005,1.021586211,1.086252759,1.514068393,0.05772714769,2.749505785,,,,,,,,,, -google_2011,cpu_by_logical_job_name,sum by (logical_job_name) (cpu_rate),keys,value,300,17686,288357812,3314,3654,3869,105373,137958,379702,2005,1.099326069,1.155715922,1.327207337,0.0619674051,3.460309727,,,,,,,,,, -google_2011,cpu_by_logical_job_name,sum by (logical_job_name) (cpu_rate),keys,count,900,17796,288357812,3416,3753,3988,144348,414669,1107219,669,1.017468949,1.086252759,1.496834886,0.05772714769,2.749505785,,,,,,,,,, -google_2011,cpu_by_logical_job_name,sum by (logical_job_name) (cpu_rate),keys,value,900,17686,288357812,3416,3753,3988,144348,414669,1107219,669,1.103914237,1.155715922,1.316868351,0.0619674051,3.460309727,,,,,,,,,, -google_2011,cpu_by_logical_job_name,sum by (logical_job_name) (cpu_rate),keys,count,3600,17796,288357812,3580,4071,4533,320187,1656537.5,3991197,168,1.017063701,1.086252759,1.419466178,0.05772714769,2.749505785,,,,,,,,,, -google_2011,cpu_by_logical_job_name,sum by (logical_job_name) (cpu_rate),keys,value,3600,17686,288357812,3580,4071,4533,320187,1656537.5,3991197,168,1.106589392,1.155715922,1.212971795,0.0619674051,3.460309727,,,,,,,,,, -google_2011,cpu_by_logical_job_name,sum by (logical_job_name) (cpu_rate),keys,count,21600,17796,288357812,4779,5419,5953,7162383,10055874,18075740,28,1.008901366,1.086252759,1.275156292,0.05772714769,2.749505785,,,,,,,,,, -google_2011,cpu_by_logical_job_name,sum by (logical_job_name) (cpu_rate),keys,value,21600,17686,288357812,4779,5419,5953,7162383,10055874,18075740,28,1.111948072,1.155715922,1.190877095,0.0619674051,3.460309727,,,,,,,,,, -google_2011,cpu_by_logical_job_name,sum by (logical_job_name) (cpu_rate),keys,count,86400,17796,288357812,7662,9003,9357,33072538,39787317,54192657,7,1.040704595,1.086252759,1.1437213,0.05772714769,2.749505785,,,,,,,,,, -google_2011,cpu_by_logical_job_name,sum by (logical_job_name) (cpu_rate),keys,value,86400,17686,288357812,7662,9003,9357,33072538,39787317,54192657,7,1.133024679,1.155715922,1.155715922,0.0619674051,3.460309727,,,,,,,,,, -google_2011,cpu_by_logical_job_name,sum by (logical_job_name) (cpu_rate),keys,count,604800,17796,288357812,17796,17796,17796,288357812,288357812,288357812,1,1.086252759,1.086252759,1.086252759,0.05772714769,2.749505785,,,,,,,,,, -google_2011,cpu_by_logical_job_name,sum by (logical_job_name) (cpu_rate),keys,value,604800,17686,288357812,17796,17796,17796,288357812,288357812,288357812,1,1.155715922,1.155715922,1.155715922,0.0619674051,3.460309727,,,,,,,,,, -google_2011,cpu_by_scheduling_class,sum by (scheduling_class) (cpu_rate),keys,count,300,4,288357812,4,4,4,105373,137958,379702,2005,0.1279176611,0.3979267591,2.03910581,0.3291290267,0.4087825709,,,,,,,,,, -google_2011,cpu_by_scheduling_class,sum by (scheduling_class) (cpu_rate),keys,value,300,4,288357812,4,4,4,105373,137958,379702,2005,0.09835771313,0.474743457,1.072402634,0.3377085349,0.5064505245,,,,,,,,,, -google_2011,cpu_by_scheduling_class,sum by (scheduling_class) (cpu_rate),keys,count,900,4,288357812,4,4,4,144348,414669,1107219,669,0.1348725538,0.3979267591,1.961837171,0.3291290267,0.4087825709,,,,,,,,,, -google_2011,cpu_by_scheduling_class,sum by (scheduling_class) (cpu_rate),keys,value,900,4,288357812,4,4,4,144348,414669,1107219,669,0.2009105107,0.474743457,0.9624884881,0.3377085349,0.5064505245,,,,,,,,,, -google_2011,cpu_by_scheduling_class,sum by (scheduling_class) (cpu_rate),keys,count,3600,4,288357812,4,4,4,320187,1656537.5,3991197,168,0.1401778557,0.3979267591,1.777533058,0.3291290267,0.4087825709,,,,,,,,,, -google_2011,cpu_by_scheduling_class,sum by (scheduling_class) (cpu_rate),keys,value,3600,4,288357812,4,4,4,320187,1656537.5,3991197,168,0.2212517864,0.474743457,0.803914756,0.3377085349,0.5064505245,,,,,,,,,, -google_2011,cpu_by_scheduling_class,sum by (scheduling_class) (cpu_rate),keys,count,21600,4,288357812,4,4,4,7162383,10055874,18075740,28,0.1703349758,0.3979267591,1.457599772,0.3291290267,0.4087825709,,,,,,,,,, -google_2011,cpu_by_scheduling_class,sum by (scheduling_class) (cpu_rate),keys,value,21600,4,288357812,4,4,4,7162383,10055874,18075740,28,0.333234169,0.474743457,0.7391113818,0.3377085349,0.5064505245,,,,,,,,,, -google_2011,cpu_by_scheduling_class,sum by (scheduling_class) (cpu_rate),keys,count,86400,4,288357812,4,4,4,33072538,39787317,54192657,7,0.2194518515,0.3979267591,0.915350797,0.3291290267,0.4087825709,,,,,,,,,, -google_2011,cpu_by_scheduling_class,sum by (scheduling_class) (cpu_rate),keys,value,86400,4,288357812,4,4,4,33072538,39787317,54192657,7,0.4156168181,0.474743457,0.5418025953,0.3377085349,0.5064505245,,,,,,,,,, -google_2011,cpu_by_scheduling_class,sum by (scheduling_class) (cpu_rate),keys,count,604800,4,288357812,4,4,4,288357812,288357812,288357812,1,0.3979267591,0.3979267591,0.3979267591,0.3291290267,0.4087825709,,,,,,,,,, -google_2011,cpu_by_scheduling_class,sum by (scheduling_class) (cpu_rate),keys,value,604800,4,288357812,4,4,4,288357812,288357812,288357812,1,0.474743457,0.474743457,0.474743457,0.3377085349,0.5064505245,,,,,,,,,, -google_2011,cpu_by_machine_id,sum by (machine_id) (cpu_rate),keys,count,300,12555,288357812,12450,12494,12513,105373,137958,379702,2005,0.1923715173,0.1923715173,0.4945129903,0.001366878176,0.2201118062,,,,,,,,,, -google_2011,cpu_by_machine_id,sum by (machine_id) (cpu_rate),keys,value,300,12555,288357812,12450,12494,12513,105373,137958,379702,2005,0.264742317,0.264742317,0.4631528705,0.0002457267992,0.3330981966,,,,,,,,,, -google_2011,cpu_by_machine_id,sum by (machine_id) (cpu_rate),keys,count,900,12555,288357812,12457,12496,12515,144348,414669,1107219,669,0.1923715173,0.1923715173,0.4616826191,0.001366878176,0.2201118062,,,,,,,,,, -google_2011,cpu_by_machine_id,sum by (machine_id) (cpu_rate),keys,value,900,12555,288357812,12457,12496,12515,144348,414669,1107219,669,0.264742317,0.264742317,0.4055136179,0.0002457267992,0.3330981966,,,,,,,,,, -google_2011,cpu_by_machine_id,sum by (machine_id) (cpu_rate),keys,count,3600,12555,288357812,12465,12499,12516,320187,1656537.5,3991197,168,0.1923715173,0.1923715173,0.4052306357,0.001366878176,0.2201118062,,,,,,,,,, -google_2011,cpu_by_machine_id,sum by (machine_id) (cpu_rate),keys,value,3600,12555,288357812,12465,12499,12516,320187,1656537.5,3991197,168,0.2583621019,0.264742317,0.3829611444,0.0002457267992,0.3330981966,,,,,,,,,, -google_2011,cpu_by_machine_id,sum by (machine_id) (cpu_rate),keys,count,21600,12555,288357812,12475,12506,12523,7162383,10055874,18075740,28,0.1923715173,0.1923715173,0.2816157868,0.001366878176,0.2201118062,,,,,,,,,, -google_2011,cpu_by_machine_id,sum by (machine_id) (cpu_rate),keys,value,21600,12555,288357812,12475,12506,12523,7162383,10055874,18075740,28,0.2514354822,0.264742317,0.3388644492,0.0002457267992,0.3330981966,,,,,,,,,, -google_2011,cpu_by_machine_id,sum by (machine_id) (cpu_rate),keys,count,86400,12555,288357812,12498,12519,12532,33072538,39787317,54192657,7,0.1923715173,0.1923715173,0.234647975,0.001366878176,0.2201118062,,,,,,,,,, -google_2011,cpu_by_machine_id,sum by (machine_id) (cpu_rate),keys,value,86400,12555,288357812,12498,12519,12532,33072538,39787317,54192657,7,0.264742317,0.264742317,0.2979730386,0.0002457267992,0.3330981966,,,,,,,,,, -google_2011,cpu_by_machine_id,sum by (machine_id) (cpu_rate),keys,count,604800,12555,288357812,12555,12555,12555,288357812,288357812,288357812,1,0.1923715173,0.1923715173,0.1923715173,0.001366878176,0.2201118062,,,,,,,,,, -google_2011,cpu_by_machine_id,sum by (machine_id) (cpu_rate),keys,value,604800,12555,288357812,12555,12555,12555,288357812,288357812,288357812,1,0.264742317,0.264742317,0.264742317,0.0002457267992,0.3330981966,,,,,,,,,, -google_2011,cpu_p99,"quantile(0.99, cpu_rate)",values,,300,,288357812,,,,95686,120112,277263,2005,2.279124043,2.936396571,19.19210676,,,0.1328455773,0.04242,0.02685661734,0.17457,-24.73069332,1.434333658e-07,1538.01025,1.635741883e-165,lognormal, -google_2011,cpu_p99,"quantile(0.99, cpu_rate)",values,,900,,288357812,,,,130897,360567,798863,669,2.280885566,2.936396571,19.08019024,,,0.1328455773,0.04242,0.02685661734,0.17457,-24.73069332,1.434333658e-07,1538.01025,1.635741883e-165,lognormal, -google_2011,cpu_p99,"quantile(0.99, cpu_rate)",values,,3600,,288357812,,,,291480,1439776,2906107,168,2.4328785,2.936396571,13.43398772,,,0.1328455773,0.04242,0.02685661734,0.17457,-24.73069332,1.434333658e-07,1538.01025,1.635741883e-165,lognormal, -google_2011,cpu_p99,"quantile(0.99, cpu_rate)",values,,21600,,288357812,,,,6461218,8561367.5,14120887,28,2.517160934,2.936396571,3.283876855,,,0.1328455773,0.04242,0.02685661734,0.17457,-24.73069332,1.434333658e-07,1538.01025,1.635741883e-165,lognormal, -google_2011,cpu_p99,"quantile(0.99, cpu_rate)",values,,86400,,288357812,,,,29740275,33942633,44337674,7,2.735084114,2.936396571,3.071839473,,,0.1328455773,0.04242,0.02685661734,0.17457,-24.73069332,1.434333658e-07,1538.01025,1.635741883e-165,lognormal, -google_2011,cpu_p99,"quantile(0.99, cpu_rate)",values,,604800,,288357812,,,,250050752,250050752,250050752,1,2.936396571,2.936396571,2.936396571,,,0.1328455773,0.04242,0.02685661734,0.17457,-24.73069332,1.434333658e-07,1538.01025,1.635741883e-165,lognormal, -google_2011,memory_p99,"quantile(0.99, canonical_memory_usage)",values,,300,,288357812,,,,94938,120433,225145,2005,1.644293145,2.229668963,16.90867609,,,0.1503744105,0.02472,0.1287170312,0.28626,-2868.277797,0,-2678.17958,1.157330677e-308,light, -google_2011,memory_p99,"quantile(0.99, canonical_memory_usage)",values,,900,,288357812,,,,129049,361263,639845,669,1.723177234,2.229668963,17.38833031,,,0.1503744105,0.02472,0.1287170312,0.28626,-2868.277797,0,-2678.17958,1.157330677e-308,light, -google_2011,memory_p99,"quantile(0.99, canonical_memory_usage)",values,,3600,,288357812,,,,290610,1443226,2367969,168,1.746363163,2.229668963,16.58716735,,,0.1503744105,0.02472,0.1287170312,0.28626,-2868.277797,0,-2678.17958,1.157330677e-308,light, -google_2011,memory_p99,"quantile(0.99, canonical_memory_usage)",values,,21600,,288357812,,,,6387427,8614701,12404521,28,1.773354456,2.229668963,4.8783361,,,0.1503744105,0.02472,0.1287170312,0.28626,-2868.277797,0,-2678.17958,1.157330677e-308,light, -google_2011,memory_p99,"quantile(0.99, canonical_memory_usage)",values,,86400,,288357812,,,,29285006,34419210,41000772,7,1.788672863,2.229668963,4.562265288,,,0.1503744105,0.02472,0.1287170312,0.28626,-2868.277797,0,-2678.17958,1.157330677e-308,light, -google_2011,memory_p99,"quantile(0.99, canonical_memory_usage)",values,,604800,,288357812,,,,244996176,244996176,244996176,1,2.229668963,2.229668963,2.229668963,,,0.1503744105,0.02472,0.1287170312,0.28626,-2868.277797,0,-2678.17958,1.157330677e-308,light, +dataset,query_id,promql,kind,weight,range,range_s,step_s,K_total,rows_total,K_win_min,K_win_median,K_win_max,rows_win_min,rows_win_median,rows_win_max,n_evals,lower,mle,upper,worst_theta_cms,worst_K,min_N,max_N,worst_alpha_rank,worst_alpha_memory,target_are_top100,target_precision_at_k,target_hll_rel_err,target_rank_err,top1_share,theta_ls,dropped_frac,xmin,ks_d,tail_frac,R_lognormal,p_lognormal,R_exponential,p_exponential,tail_class,ok_frac +alibaba_v2022,mcr_by_msname,sum by (msname) (providerrpc_mcr),keys,count,instant,,60,26147,188487731,25889,25958,26019,511654,517405.5,521344,360,0.825078553,0.8257464425,0.8262605267,,26019,511654,521344,,,0.05,0.95,0.02,0.01,0.005095726894,1.349104357,,,,,,,,,, +alibaba_v2022,mcr_by_msname,sum by (msname) (providerrpc_mcr),keys,value,instant,,60,18730,188487731,25889,25958,26019,511654,517405.5,521344,360,0.9838294103,1.002188064,1.011853042,0.9838294103,26019,511654,521344,,,0.05,0.95,0.02,0.01,0.03789945576,3.805505342,,,,,,,,,, +alibaba_v2022,mcr_by_msname,sum by (msname) (sum_over_time(providerrpc_mcr[5m])),keys,count,5m,300,60,26147,867646875,25889,25958,26019,8899080,12088243.5,20040209,356,1.328445287,1.443313195,1.664745,,26019,8899080,20040209,,,0.05,0.95,0.02,0.01,0.4545719547,1.37444187,,,,,,,,,, +alibaba_v2022,mcr_by_msname,sum by (msname) (sum_over_time(providerrpc_mcr[5m])),keys,value,5m,300,60,18730,867646875,25889,25958,26019,8899080,12088243.5,20040209,356,1.058947546,1.101430346,1.181235381,1.058947546,26019,8899080,20040209,,,0.05,0.95,0.02,0.01,0.1498488827,3.811405825,,,,,,,,,, +alibaba_v2022,mcr_by_msname,sum by (msname) (sum_over_time(providerrpc_mcr[1h])),keys,count,1h,3600,60,26147,867646875,26028,26051,26094,125327081,139361791,166100193,301,1.386390161,1.443313195,1.499657657,,26094,125327081,166100193,,,0.05,0.95,0.02,0.01,0.4545719547,1.37444187,,,,,,,,,, +alibaba_v2022,mcr_by_msname,sum by (msname) (sum_over_time(providerrpc_mcr[1h])),keys,value,1h,3600,60,18730,867646875,26028,26051,26094,125327081,139361791,166100193,301,1.080487406,1.101430346,1.13802497,1.080487406,26094,125327081,166100193,,,0.05,0.95,0.02,0.01,0.1498488827,3.811405825,,,,,,,,,, +alibaba_v2022,mcr_by_nodeid,sum by (nodeid) (providerrpc_mcr),keys,count,instant,,60,30825,188487731,30686,30726,30783,511654,517405.5,521344,360,0.3328414645,0.3344975088,0.3344975088,,30783,511654,521344,,,0.05,0.95,0.02,0.01,0.0001346559793,0.5851563748,,,,,,,,,, +alibaba_v2022,mcr_by_nodeid,sum by (nodeid) (providerrpc_mcr),keys,value,instant,,60,28348,188487731,30686,30726,30783,511654,517405.5,521344,360,0.4702333583,0.4945285204,0.5382725596,0.4702333583,30783,511654,521344,,,0.05,0.95,0.02,0.01,0.0006887262111,0.9051588471,,,,,,,,,, +alibaba_v2022,mcr_by_nodeid,sum by (nodeid) (sum_over_time(providerrpc_mcr[5m])),keys,count,5m,300,60,30825,867646875,30686,30724,30783,8899080,12088243.5,20040209,356,1.063438048,1.097553229,1.175793283,,30783,8899080,20040209,,,0.05,0.95,0.02,0.01,0.02685695145,0.6757970814,,,,,,,,,, +alibaba_v2022,mcr_by_nodeid,sum by (nodeid) (sum_over_time(providerrpc_mcr[5m])),keys,value,5m,300,60,28348,867646875,30686,30724,30783,8899080,12088243.5,20040209,356,0.6840111645,0.7429289939,0.8586025258,0.6840111645,30783,8899080,20040209,,,0.05,0.95,0.02,0.01,0.007415134693,0.9461668197,,,,,,,,,, +alibaba_v2022,mcr_by_nodeid,sum by (nodeid) (sum_over_time(providerrpc_mcr[1h])),keys,count,1h,3600,60,30825,867646875,30705,30744,30799,125327081,139361791,166100193,301,1.083318419,1.097553229,1.112654503,,30799,125327081,166100193,,,0.05,0.95,0.02,0.01,0.02685695145,0.6757970814,,,,,,,,,, +alibaba_v2022,mcr_by_nodeid,sum by (nodeid) (sum_over_time(providerrpc_mcr[1h])),keys,value,1h,3600,60,28348,867646875,30705,30744,30799,125327081,139361791,166100193,301,0.7146426913,0.7429289939,0.7950597902,0.7146426913,30799,125327081,166100193,,,0.05,0.95,0.02,0.01,0.007415134693,0.9461668197,,,,,,,,,, +alibaba_v2022,rt_p99_by_msname,"quantile by (msname) (0.99, providerrpc_rt)",keys,count,instant,,60,26147,188487731,25889,25958,26019,511654,517405.5,521344,360,0.825078553,0.8257464425,0.8262605267,0.825078553,26019,511654,521344,,,0.05,0.95,0.02,0.01,0.005095726894,1.349104357,,,,,,,,,, +alibaba_v2022,rt_p99_by_msname,"quantile by (msname) (0.99, providerrpc_rt)",keys,value,instant,,60,18721,188487731,25889,25958,26019,511654,517405.5,521344,360,0.9704918171,0.9962931964,1.113884125,,26019,511654,521344,,,0.05,0.95,0.02,0.01,0.07232418839,2.43660772,,,,,,,,,, +alibaba_v2022,rt_p99_by_msname,"quantile by (msname) (0.99, quantile_over_time(0.99, providerrpc_rt[5m]))",keys,count,5m,300,60,26147,867646875,25889,25958,26019,8899080,12088243.5,20040209,356,1.328445287,1.443313195,1.664745,1.328445287,26019,8899080,20040209,,,0.05,0.95,0.02,0.01,0.4545719547,1.37444187,,,,,,,,,, +alibaba_v2022,rt_p99_by_msname,"quantile by (msname) (0.99, quantile_over_time(0.99, providerrpc_rt[5m]))",keys,value,5m,300,60,18721,867646875,25889,25958,26019,8899080,12088243.5,20040209,356,1.685770501,1.970047387,2.341149975,,26019,8899080,20040209,,,0.05,0.95,0.02,0.01,0.8659870115,2.444903781,,,,,,,,,, +alibaba_v2022,rt_p99_by_msname,"quantile by (msname) (0.99, quantile_over_time(0.99, providerrpc_rt[1h]))",keys,count,1h,3600,60,26147,867646875,26028,26051,26094,125327081,139361791,166100193,301,1.386390161,1.443313195,1.499657657,1.386390161,26094,125327081,166100193,,,0.05,0.95,0.02,0.01,0.4545719547,1.37444187,,,,,,,,,, +alibaba_v2022,rt_p99_by_msname,"quantile by (msname) (0.99, quantile_over_time(0.99, providerrpc_rt[1h]))",keys,value,1h,3600,60,18721,867646875,26028,26051,26094,125327081,139361791,166100193,301,1.845706718,1.970047387,2.084916758,,26094,125327081,166100193,,,0.05,0.95,0.02,0.01,0.8659870115,2.444903781,,,,,,,,,, +alibaba_v2022,rt_p99_by_msname,"quantile(0.99, providerrpc_rt)",values,,instant,,60,,188487731,,,,371197,381090,401372,360,2.327272661,2.697295887,2.917634682,,,371197,401372,2.917634682,2.327272661,0.05,0.95,0.02,0.01,,,0.2611442174,152.5468286,0.02861841946,0.06211,-0.4219459635,0.5136902768,4951.538918,0.003338755863,heavy_inconclusive, +alibaba_v2022,rt_p99_by_msname,"quantile_over_time(0.99, providerrpc_rt[5m])",values,,5m,300,60,,867646875,,,,7751463,10923938.5,18912878,356,2.152247068,2.725233624,12.67166397,,,7751463,18912878,12.67166397,2.152247068,0.05,0.95,0.02,0.01,,,0.09788567037,653.418334,0.0512169711,0.001,-0.3066099099,0.615141357,10.22728826,0.09405626913,heavy_inconclusive, +alibaba_v2022,rt_p99_by_msname,"quantile_over_time(0.99, providerrpc_rt[1h])",values,,1h,3600,60,,867646875,,,,110947221,125117066,152748684,301,2.521861465,2.725233624,9.27532118,,,110947221,152748684,9.27532118,2.521861465,0.05,0.95,0.02,0.01,,,0.09788567037,653.418334,0.0512169711,0.001,-0.3066099099,0.615141357,10.22728826,0.09405626913,heavy_inconclusive, +alibaba_v2022,calls_by_rpctype,sum by (rpctype) (count_over_time(rt[1m])),keys,count,1m,60,60,6,1295335556,6,6,6,64,3564367,5401423,360,1.242292116,1.310265913,1.41486647,1.242292116,6,64,5401423,,,0.05,0.95,0.02,0.01,0.4283451021,2.257448052,,,,,,,,,, +alibaba_v2022,calls_by_rpctype,sum by (rpctype) (count_over_time(rt[5m])),keys,count,5m,300,60,6,1295335556,6,6,6,13888129,17749395,26594881,357,1.272106881,1.310265913,1.391208048,1.272106881,6,13888129,26594881,,,0.05,0.95,0.02,0.01,0.4283451021,2.257448052,,,,,,,,,, +alibaba_v2022,calls_by_rpctype,sum by (rpctype) (count_over_time(rt[1h])),keys,count,1h,3600,60,6,1295335556,6,6,6,185233013,204992179,260437245,302,1.298551553,1.310265913,1.337741437,1.298551553,6,185233013,260437245,,,0.05,0.95,0.02,0.01,0.4283451021,2.257448052,,,,,,,,,, +alibaba_v2022,calls_by_service,sum by (service) (count_over_time(rt[1m])),keys,count,1m,60,60,2769176,1295335556,30,40120,43871,64,3564367,5401423,360,0.9793470382,1.099337547,1.099337547,0.9793470382,43871,64,5401423,,,0.05,0.95,0.02,0.01,0.0630261268,1.274170165,,,,,,,,,, +alibaba_v2022,calls_by_service,sum by (service) (count_over_time(rt[5m])),keys,count,5m,300,60,2769176,1295335556,102106,119394,136321,13888129,17749395,26594881,357,1.021367206,1.099337547,1.099337547,1.021367206,136321,13888129,26594881,,,0.05,0.95,0.02,0.01,0.0630261268,1.274170165,,,,,,,,,, +alibaba_v2022,calls_by_service,sum by (service) (count_over_time(rt[1h])),keys,count,1h,3600,60,2769176,1295335556,559964,639248,785894,185233013,204992179,260437245,302,1.071178148,1.099337547,1.099337547,1.071178148,785894,185233013,260437245,,,0.05,0.95,0.02,0.01,0.0630261268,1.274170165,,,,,,,,,, +alibaba_v2022,calls_by_um,sum by (um) (count_over_time(rt[1m])),keys,count,1m,60,60,22016,1295335556,27,6081,8501,64,3564367,5401423,360,1.093784502,1.185355196,1.208596563,1.093784502,8501,64,5401423,,,0.05,0.95,0.02,0.01,0.1535391521,3.145206929,,,,,,,,,, +alibaba_v2022,calls_by_um,sum by (um) (count_over_time(rt[5m])),keys,count,5m,300,60,22016,1295335556,7830,9168,12512,13888129,17749395,26594881,357,1.113014015,1.185355196,1.216728802,1.113014015,12512,13888129,26594881,,,0.05,0.95,0.02,0.01,0.1535391521,3.145206929,,,,,,,,,, +alibaba_v2022,calls_by_um,sum by (um) (count_over_time(rt[1h])),keys,count,1h,3600,60,22016,1295335556,15346,15828,18110,185233013,204992179,260437245,302,1.147118456,1.185355196,1.208155885,1.147118456,18110,185233013,260437245,,,0.05,0.95,0.02,0.01,0.1535391521,3.145206929,,,,,,,,,, +alibaba_v2022,calls_by_dm,sum by (dm) (count_over_time(rt[1m])),keys,count,1m,60,60,35550,1295335556,35,10420,14067,64,3564367,5401423,360,1.096641576,1.157928672,1.157928672,1.096641576,14067,64,5401423,,,0.05,0.95,0.02,0.01,0.07973378135,3.024759942,,,,,,,,,, +alibaba_v2022,calls_by_dm,sum by (dm) (count_over_time(rt[5m])),keys,count,5m,300,60,35550,1295335556,13705,15785,20479,13888129,17749395,26594881,357,1.112039296,1.157928672,1.160544083,1.112039296,20479,13888129,26594881,,,0.05,0.95,0.02,0.01,0.07973378135,3.024759942,,,,,,,,,, +alibaba_v2022,calls_by_dm,sum by (dm) (count_over_time(rt[1h])),keys,count,1h,3600,60,35550,1295335556,25442,26156.5,29583,185233013,204992179,260437245,302,1.132430313,1.157928672,1.16981668,1.132430313,29583,185233013,260437245,,,0.05,0.95,0.02,0.01,0.07973378135,3.024759942,,,,,,,,,, +alibaba_v2022,calls_by_interface,sum by (interface) (count_over_time(rt[1m])),keys,count,1m,60,60,8655921,1295335556,46,93480,139177,64,3564367,5401423,360,0.9891497351,1.097910713,1.097910713,0.9891497351,139177,64,5401423,,,0.05,0.95,0.02,0.01,0.02572182771,0.8643899176,,,,,,,,,, +alibaba_v2022,calls_by_interface,sum by (interface) (count_over_time(rt[5m])),keys,count,5m,300,60,8655921,1295335556,218334,263943,392354,13888129,17749395,26594881,357,1.021672522,1.097910713,1.097910713,1.021672522,392354,13888129,26594881,,,0.05,0.95,0.02,0.01,0.02572182771,0.8643899176,,,,,,,,,, +alibaba_v2022,calls_by_interface,sum by (interface) (count_over_time(rt[1h])),keys,count,1h,3600,60,8655921,1295335556,1506702,1717590,2131776,185233013,204992179,260437245,302,1.070025164,1.097910713,1.097910713,1.070025164,2131776,185233013,260437245,,,0.05,0.95,0.02,0.01,0.02572182771,0.8643899176,,,,,,,,,, +alibaba_v2022,calls_by_um_dm,"sum by (um, dm) (count_over_time(rt[1m]))",keys,count,1m,60,60,165895,1295335556,47,30289,47939,64,3564367,5401423,360,0.9766069583,1.070642064,1.070642064,0.9766069583,47939,64,5401423,,,0.05,0.95,0.02,0.01,0.04140612504,2.721022211,,,,,,,,,, +alibaba_v2022,calls_by_um_dm,"sum by (um, dm) (count_over_time(rt[5m]))",keys,count,5m,300,60,165895,1295335556,40953,51206,78195,13888129,17749395,26594881,357,0.9959293238,1.070642064,1.072961931,0.9959293238,78195,13888129,26594881,,,0.05,0.95,0.02,0.01,0.04140612504,2.721022211,,,,,,,,,, +alibaba_v2022,calls_by_um_dm,"sum by (um, dm) (count_over_time(rt[1h]))",keys,count,1h,3600,60,165895,1295335556,98924,103769,127687,185233013,204992179,260437245,302,1.029614959,1.070642064,1.084624121,1.029614959,127687,185233013,260437245,,,0.05,0.95,0.02,0.01,0.04140612504,2.721022211,,,,,,,,,, +alibaba_v2022,calls_by_service_um_dm,"sum by (service, um, dm) (count_over_time(rt[1m]))",keys,count,1m,60,60,7963812,1295335556,50,159173,239493,64,3564367,5401423,360,0.8917234928,1.022270823,1.022270823,0.8917234928,239493,64,5401423,,,0.05,0.95,0.02,0.01,0.01313775872,1.385250269,,,,,,,,,, +alibaba_v2022,calls_by_service_um_dm,"sum by (service, um, dm) (count_over_time(rt[5m]))",keys,count,5m,300,60,7963812,1295335556,319216,390377,582262,13888129,17749395,26594881,357,0.9320852478,1.022270823,1.022270823,0.9320852478,582262,13888129,26594881,,,0.05,0.95,0.02,0.01,0.01313775872,1.385250269,,,,,,,,,, +alibaba_v2022,calls_by_service_um_dm,"sum by (service, um, dm) (count_over_time(rt[1h]))",keys,count,1h,3600,60,7963812,1295335556,1713602,1986192.5,2221976,185233013,204992179,260437245,302,0.9867997632,1.022270823,1.022270823,0.9867997632,2221976,185233013,260437245,,,0.05,0.95,0.02,0.01,0.01313775872,1.385250269,,,,,,,,,, +alibaba_v2022,rt_p99_by_service,"quantile by (service) (0.99, quantile_over_time(0.99, rt[1m]))",keys,count,1m,60,60,2769176,1295335556,30,40120,43871,64,3564367,5401423,360,0.9793470382,1.099337547,1.099337547,0.9793470382,43871,64,5401423,,,0.05,0.95,0.02,0.01,0.0630261268,1.274170165,,,,,,,,,, +alibaba_v2022,rt_p99_by_service,"quantile by (service) (0.99, quantile_over_time(0.99, rt[1m]))",keys,value,1m,60,60,2717104,1295335556,30,40120,43871,64,3564367,5401423,360,1.096890188,1.179024529,1.606016772,,43871,64,5401423,,,0.05,0.95,0.02,0.01,0.2835197699,1.778216939,,,,,,,,,, +alibaba_v2022,rt_p99_by_service,"quantile by (service) (0.99, quantile_over_time(0.99, rt[5m]))",keys,count,5m,300,60,2769176,1295335556,102106,119394,136321,13888129,17749395,26594881,357,1.021367206,1.099337547,1.099337547,1.021367206,136321,13888129,26594881,,,0.05,0.95,0.02,0.01,0.0630261268,1.274170165,,,,,,,,,, +alibaba_v2022,rt_p99_by_service,"quantile by (service) (0.99, quantile_over_time(0.99, rt[5m]))",keys,value,5m,300,60,2717104,1295335556,102106,119394,136321,13888129,17749395,26594881,357,1.115950417,1.179024529,1.28406221,,136321,13888129,26594881,,,0.05,0.95,0.02,0.01,0.2835197699,1.778216939,,,,,,,,,, +alibaba_v2022,rt_p99_by_service,"quantile by (service) (0.99, quantile_over_time(0.99, rt[1h]))",keys,count,1h,3600,60,2769176,1295335556,559964,639248,785894,185233013,204992179,260437245,302,1.071178148,1.099337547,1.099337547,1.071178148,785894,185233013,260437245,,,0.05,0.95,0.02,0.01,0.0630261268,1.274170165,,,,,,,,,, +alibaba_v2022,rt_p99_by_service,"quantile by (service) (0.99, quantile_over_time(0.99, rt[1h]))",keys,value,1h,3600,60,2717104,1295335556,559964,639248,785894,185233013,204992179,260437245,302,1.159047439,1.179024529,1.199256386,,785894,185233013,260437245,,,0.05,0.95,0.02,0.01,0.2835197699,1.778216939,,,,,,,,,, +alibaba_v2022,rt_p99_by_service,"quantile_over_time(0.99, rt[1m])",values,,1m,60,60,,1270987041,,,,43,2097984,3311360,360,1.891474819,2.029339494,2.46113073,,,43,3311360,2.46113073,1.891474819,0.05,0.95,0.02,0.01,,,0.3996959565,17,0.03031811014,0.09527,-0.6373337002,0.6539354026,13183.39466,1.699185041e-56,heavy_inconclusive, +alibaba_v2022,rt_p99_by_service,"quantile_over_time(0.99, rt[5m])",values,,5m,300,60,,1270987041,,,,7881752,10442357,16264263,357,1.957358515,2.029339494,2.429250439,,,7881752,16264263,2.429250439,1.957358515,0.05,0.95,0.02,0.01,,,0.3996959565,17,0.03031811014,0.09527,-0.6373337002,0.6539354026,13183.39466,1.699185041e-56,heavy_inconclusive, +alibaba_v2022,rt_p99_by_service,"quantile_over_time(0.99, rt[1h])",values,,1h,3600,60,,1270987041,,,,106821507,119913902,157226182,302,2.007578773,2.029339494,2.297062459,,,106821507,157226182,2.297062459,2.007578773,0.05,0.95,0.02,0.01,,,0.3996959565,17,0.03031811014,0.09527,-0.6373337002,0.6539354026,13183.39466,1.699185041e-56,heavy_inconclusive, +alibaba_v2022,ms_cpu_by_msname,sum by (msname) (cpu_utilization),keys,count,instant,,60,28260,677928534,28143,28159,28171,465931,470224,471603,1440,0.8251239317,0.8257044743,0.8263779532,,28171,465931,471603,,,0.05,0.95,0.02,0.01,0.01642566353,1.278838704,,,,,,,,,, +alibaba_v2022,ms_cpu_by_msname,sum by (msname) (cpu_utilization),keys,value,instant,,60,28259,677928534,28143,28159,28171,465931,470224,471603,1440,0.8708920197,0.8894428844,0.9061510436,0.8708920197,28171,465931,471603,,,0.05,0.95,0.02,0.01,0.01023773901,1.713144009,,,,,,,,,, +alibaba_v2022,ms_cpu_by_msname,sum by (msname) (sum_over_time(cpu_utilization[5m])),keys,count,5m,300,60,28260,675424445,28145,28159,28171,2328999,2348472.5,2355461,1436,0.8250307623,0.8256900161,0.8263540837,,28171,2328999,2355461,,,0.05,0.95,0.02,0.01,0.01642157177,1.279481397,,,,,,,,,, +alibaba_v2022,ms_cpu_by_msname,sum by (msname) (sum_over_time(cpu_utilization[5m])),keys,value,5m,300,60,28259,675424445,28145,28159,28171,2328999,2348472.5,2355461,1436,0.8715262892,0.8893327869,0.9055036603,0.8715262892,28171,2328999,2355461,,,0.05,0.95,0.02,0.01,0.01026331486,1.71275427,,,,,,,,,, +alibaba_v2022,ms_cpu_by_msname,sum by (msname) (sum_over_time(cpu_utilization[1h])),keys,count,1h,3600,60,28260,675424445,28158,28173,28184,27957228,28183500,28254558,1381,0.8252466649,0.8256900161,0.8263148174,,28184,27957228,28254558,,,0.05,0.95,0.02,0.01,0.01642157177,1.279481397,,,,,,,,,, +alibaba_v2022,ms_cpu_by_msname,sum by (msname) (sum_over_time(cpu_utilization[1h])),keys,value,1h,3600,60,28259,675424445,28158,28173,28184,27957228,28183500,28254558,1381,0.8731117944,0.8893327869,0.9040277038,0.8731117944,28184,27957228,28254558,,,0.05,0.95,0.02,0.01,0.01026331486,1.71275427,,,,,,,,,, +alibaba_v2022,ms_cpu_p99,"quantile(0.99, cpu_utilization)",values,,instant,,60,,677928534,,,,465917,470208.5,471589,1440,3.01821605,6.167318107,10.1539801,,,465917,471589,10.1539801,3.01821605,0.05,0.95,0.02,0.01,,,3.964134662e-05,0.5721030984,0.06483467076,0.03156,-139.6838326,1.843295234e-28,-102.9144993,2.130182551e-79,light, +alibaba_v2022,ms_cpu_p99,"quantile_over_time(0.99, cpu_utilization[5m])",values,,5m,300,60,,675424445,,,,2328934,2348401.5,2355395,1436,3.030257924,6.355302868,10.0474611,,,2328934,2355395,10.0474611,3.030257924,0.05,0.95,0.02,0.01,,,3.036461021e-05,0.5741396769,0.05959687717,0.03156,-132.3740985,4.881332668e-27,-97.32785636,1.956182046e-75,light, +alibaba_v2022,ms_cpu_p99,"quantile_over_time(0.99, cpu_utilization[1h])",values,,1h,3600,60,,675424445,,,,27956442,28182559,28253774,1381,3.09158951,6.355302868,7.052208747,,,27956442,28253774,7.052208747,3.09158951,0.05,0.95,0.02,0.01,,,3.036461021e-05,0.5741396769,0.05959687717,0.03156,-132.3740985,4.881332668e-27,-97.32785636,1.956182046e-75,light, +alibaba_v2022,node_cpu_by_nodeid,sum by (nodeid) (cpu_utilization),keys,count,instant,,60,43382,58923660,42235,42333,42957,42235,42333,42957,1383,3.673105566e-06,0.02052130964,0.02052130964,,42957,42235,42957,,,0.05,0.95,0.02,0.01,2.353893156e-05,0.06043580555,,,,,,,,,, +alibaba_v2022,node_cpu_by_nodeid,sum by (nodeid) (cpu_utilization),keys,value,instant,,60,43381,58923660,42235,42333,42957,42235,42333,42957,1383,0.2864927327,0.2864927327,0.3554983787,0.2864927327,42957,42235,42957,,,0.05,0.95,0.02,0.01,9.71328786e-05,0.3768673766,,,,,,,,,, +alibaba_v2022,node_cpu_by_nodeid,sum by (nodeid) (sum_over_time(cpu_utilization[5m])),keys,count,5m,300,60,43382,58460197,42235,42333,42957,42235,211242,214454,1379,3.673105566e-06,0.02250972512,0.02250972512,,42957,42235,214454,,,0.05,0.95,0.02,0.01,2.358869916e-05,0.07484077042,,,,,,,,,, +alibaba_v2022,node_cpu_by_nodeid,sum by (nodeid) (sum_over_time(cpu_utilization[5m])),keys,value,5m,300,60,43381,58460197,42235,42333,42957,42235,211242,214454,1379,0.2852500855,0.2865167137,0.3417391972,0.2852500855,42957,42235,214454,,,0.05,0.95,0.02,0.01,9.702091431e-05,0.3892546546,,,,,,,,,, +alibaba_v2022,node_cpu_by_nodeid,sum by (nodeid) (sum_over_time(cpu_utilization[1h])),keys,count,1h,3600,60,43382,58460197,42235,42424,43027,42235,2534282,2570715,1379,3.673105566e-06,0.02250972512,0.02250972512,,43027,42235,2570715,,,0.05,0.95,0.02,0.01,2.358869916e-05,0.07484077042,,,,,,,,,, +alibaba_v2022,node_cpu_by_nodeid,sum by (nodeid) (sum_over_time(cpu_utilization[1h])),keys,value,1h,3600,60,43381,58460197,42235,42424,43027,42235,2534282,2570715,1379,0.2800713326,0.2865167137,0.3302192401,0.2800713326,43027,42235,2570715,,,0.05,0.95,0.02,0.01,9.702091431e-05,0.3892546546,,,,,,,,,, +alibaba_v2022,node_cpu_p99,"quantile(0.99, cpu_utilization)",values,,instant,,60,,58923660,,,,42233,42331,42955,1383,4.226872374,5.481659723,6.443423228,,,42233,42955,6.443423228,4.226872374,0.05,0.95,0.02,0.01,,,4.979324095e-05,0.3420009998,0.01588971021,0.07229,-3.277517211,0.07361697995,115.7009555,1.534003298e-14,lognormal, +alibaba_v2022,node_cpu_p99,"quantile_over_time(0.99, cpu_utilization[5m])",values,,5m,300,60,,58460197,,,,42233,211232,214444,1379,4.271156891,5.401433245,6.368754462,,,42233,214444,6.368754462,4.271156891,0.05,0.95,0.02,0.01,,,4.945245053e-05,0.330743608,0.01881783954,0.08247,-4.380360956,0.0419334074,139.060049,1.566767944e-16,lognormal, +alibaba_v2022,node_cpu_p99,"quantile_over_time(0.99, cpu_utilization[1h])",values,,1h,3600,60,,58460197,,,,42233,2534156,2570595,1379,4.365719214,5.401433245,6.246543807,,,42233,2570595,6.246543807,4.365719214,0.05,0.95,0.02,0.01,,,4.945245053e-05,0.330743608,0.01881783954,0.08247,-4.380360956,0.0419334074,139.060049,1.566767944e-16,lognormal, +boom,target_tail[ds-2187-H],"quantile(0.99, target)",values,,,,,100,523100,,,,,,,900,1.673862396,2.879820136,5.449343474,,,,,5.449343474,1.673862396,0.05,0.95,0.02,0.01,,,0.0001911680367,1.13650366,0.05719670041,0.1334608031,-0.7518535826,0.1985446789,81.95794065,4.297158362e-06,light,0.45 +boom,target_tail[ds-2394-D],"quantile(0.99, target)",values,,,,,73,10001,,,,,,,0,,,,,,,,,,0.05,0.95,0.02,0.01,,,0.1858814119,,,,,,,,, +boom,target_tail[ds-1135-5T],"quantile(0.99, target)",values,,,,,26,425984,,,,,,,63,2.072418608,2.555273335,4.464465828,,,,,4.464465828,2.072418608,0.05,0.95,0.02,0.01,,,0.5493680514,1.309216454,0.09571546402,0.3780193237,-3.202171683,0.08890763899,233.8257673,9.588002711e-10,light,0.3571428571 +boom,target_tail[ds-1833-D],"quantile(0.99, target)",values,,,,,17,3689,,,,,,,0,,,,,,,,,,0.05,0.95,0.02,0.01,,,0.2396313364,,,,,,,,, +boom,target_tail[ds-2806-D],"quantile(0.99, target)",values,,,,,100,13700,,,,,,,0,,,,,,,,,,0.05,0.95,0.02,0.01,,,0.7003649635,,,,,,,,, +boom,target_tail[ds-2573-D],"quantile(0.99, target)",values,,,,,45,9765,,,,,,,0,7.824807058,7.824807058,7.824807058,,,,,7.824807058,7.824807058,0.05,0.95,0.02,0.01,,,0.007987711214,2.832573324,0.2237516935,0.4814814815,-0.1549932255,0.1811684879,8.450514888,8.137699192e-05,light,0.2444444444 +boom,target_tail[ds-2222-30T],"quantile(0.99, target)",values,,,,,100,1045600,,,,,,,800,5.121075907,27.15946506,45.43533407,,,,,45.43533407,5.121075907,0.05,0.95,0.02,0.01,,,0.5705183627,3.907679107,0.138594883,0.03610214265,-0.3643459076,0.2354562876,16.72715255,3.110465898e-15,heavy_inconclusive,0.97 +boom,target_tail[ds-1914-30T],"quantile(0.99, target)",values,,,,,64,669504,,,,,,,0,,,,,,,,,,0.05,0.95,0.02,0.01,,,0.9991770027,,,,,,,,, +boom,target_tail[ds-2577-H],"quantile(0.99, target)",values,,,,,11,57541,,,,,,,40,2.357316003,3.318605295,7.114686774,,,,,7.114686774,2.357316003,0.05,0.95,0.02,0.01,,,0.0001911680367,1.451908794,0.04583397605,0.4337476099,-3.619220504,0.2878918275,168.5626824,1.8816055e-20,light,0.1818181818 +boom,target_tail[ds-2212-D],"quantile(0.99, target)",values,,,,,42,9114,,,,,,,0,2.097505042,2.097505042,2.097505042,,,,,2.097505042,2.097505042,0.05,0.95,0.02,0.01,,,0.2055080097,0.1728252252,0.07861559668,0.4741809117,-0.6104251813,0.3802005494,57.44497486,0.003636112868,light,0.3636363636 +boom,target_tail[ds-2782-H],"quantile(0.99, target)",values,,,,,20,16500,,,,,,,0,,,,,,,,,,0.05,0.95,0.02,0.01,,,0.9923636364,,,,,,,,, +boom,target_tail[ds-1400-10S],"quantile(0.99, target)",values,,,,,75,1228800,,,,,,,680,3.665809149,5.927304101,8.608042368,,,,,8.608042368,3.665809149,0.05,0.95,0.02,0.01,,,0.0001399739583,3.22594058,0.03461878105,0.1945003968,-0.5020486991,0.1052433657,67.48976464,1.414326313e-05,light,0.4533333333 +boom,target_tail[ds-2650-D],"quantile(0.99, target)",values,,,,,56,12152,,,,,,,0,2.372256328,2.372256328,2.372256328,,,,,2.372256328,2.372256328,0.05,0.95,0.02,0.01,,,0.004772876893,0.3060346595,0.07025218904,0.4814814815,-0.4345545346,0.5532457248,23.54371772,0.03707674656,light,0.25 +boom,target_tail[ds-1316-10S],"quantile(0.99, target)",values,,,,,40,655360,,,,,,,800,1.394454939,2.841176959,3.782745604,,,,,3.782745604,1.394454939,0.05,0.95,0.02,0.01,,,0.1220932007,2.273231677,0.03804312837,0.03161851893,-1.526906431,0.1625683967,48.84256082,4.793863342e-08,heavy_inconclusive,1 +boom,target_tail[ds-1558-5T],"quantile(0.99, target)",values,,,,,97,1589248,,,,,,,1195,2.859011495,4.965505023,14.93467462,,,,,14.93467462,2.859011495,0.05,0.95,0.02,0.01,,,0.1971838253,2.030408032,0.08454367574,0.2353085011,0.01446142949,0.1477685349,143.8265644,7.494706033e-08,heavy_inconclusive,0.6701030928 +boom,target_tail[ds-1972-D],"quantile(0.99, target)",values,,,,,39,5343,,,,,,,0,,,,,,,,,,0.05,0.95,0.02,0.01,,,0.05577390979,,,,,,,,, +boom,target_tail[ds-1840-D],"quantile(0.99, target)",values,,,,,100,21700,,,,,,,0,48.70890868,48.70890868,48.70890868,,,,,48.70890868,48.70890868,0.05,0.95,0.02,0.01,,,0.00465437788,5.808935183,0.1729496632,0.5046296296,-0.1558493932,0.6911382477,15.25220643,2.851033848e-05,light,0.11 +boom,target_tail[ds-671-10S],"quantile(0.99, target)",values,,,,,100,1638400,,,,,,,0,,,,,,,,,,0.05,0.95,0.02,0.01,,,6.103515625e-05,,,,,,,,light,0 +boom,target_tail[ds-1524-5T],"quantile(0.99, target)",values,,,,,93,1267683,,,,,,,18,3.310389413,3.310389413,3.692673948,,,,,3.692673948,3.310389413,0.05,0.95,0.02,0.01,,,0.944850566,1.984224252,0.2043641455,0.523993808,-0.7337541742,0.1428173664,51.73262359,2.004766276e-06,heavy_inconclusive,0.6470588235 +boom,target_tail[ds-899-T],"quantile(0.99, target)",values,,,,,12,196608,,,,,,,144,2.379500335,4.776016519,4.776016519,,,,,4.776016519,2.379500335,0.05,0.95,0.02,0.01,,,0.4203440348,3.316427802,0.0820839487,0.05264234598,-0.6434653813,0.1335383104,64.54346235,4.612421122e-07,heavy_inconclusive,1 +google_2011,cpu_by_user,sum by (user) (cpu_rate),keys,count,instant,,300,686,254393256,480,519,538,100546,126200,212533,2005,1.11463296,1.148419293,1.413295054,,538,100546,212533,,,0.05,0.95,0.02,0.01,0.07735343817,2.565160441,,,,,,,,,, +google_2011,cpu_by_user,sum by (user) (cpu_rate),keys,value,instant,,300,656,254393256,480,519,538,100546,126200,212533,2005,1.193602067,1.244075542,1.482299462,1.193602067,538,100546,212533,,,0.05,0.95,0.02,0.01,0.1261323528,3.723521859,,,,,,,,,, +google_2011,cpu_by_user,sum by (user) (sum_over_time(cpu_rate[5m])),keys,count,5m,300,300,686,288357812,480,519,538,105373,137958,379702,2005,1.101644423,1.146256644,1.675767301,,538,105373,379702,,,0.05,0.95,0.02,0.01,0.07984469656,2.530528113,,,,,,,,,, +google_2011,cpu_by_user,sum by (user) (sum_over_time(cpu_rate[5m])),keys,value,5m,300,300,665,288357812,480,519,538,105373,137958,379702,2005,1.188664169,1.235004601,1.459116669,1.188664169,538,105373,379702,,,0.05,0.95,0.02,0.01,0.1217389859,3.698174511,,,,,,,,,, +google_2011,cpu_by_user,sum by (user) (sum_over_time(cpu_rate[1h])),keys,count,1h,3600,300,686,288357812,507,528,548,1310788,1663612,4179680,1994,1.103070785,1.146256644,1.596141868,,548,1310788,4179680,,,0.05,0.95,0.02,0.01,0.07984469656,2.530528113,,,,,,,,,, +google_2011,cpu_by_user,sum by (user) (sum_over_time(cpu_rate[1h])),keys,value,1h,3600,300,665,288357812,507,528,548,1310788,1663612,4179680,1994,1.198936994,1.235004601,1.357764519,1.198936994,548,1310788,4179680,,,0.05,0.95,0.02,0.01,0.1217389859,3.698174511,,,,,,,,,, +google_2011,cpu_by_user_priority,"sum by (user, priority) (cpu_rate)",keys,count,instant,,300,1356,254393256,788,838,880,100546,126200,212533,2005,1.133137437,1.15789991,1.405238475,,880,100546,212533,,,0.05,0.95,0.02,0.01,0.07636852606,2.71359643,,,,,,,,,, +google_2011,cpu_by_user_priority,"sum by (user, priority) (cpu_rate)",keys,value,instant,,300,1294,254393256,788,838,880,100546,126200,212533,2005,1.220156306,1.266536663,1.486342061,1.220156306,880,100546,212533,,,0.05,0.95,0.02,0.01,0.1259520722,3.694609415,,,,,,,,,, +google_2011,cpu_by_user_priority,"sum by (user, priority) (sum_over_time(cpu_rate[5m]))",keys,count,5m,300,300,1356,288357812,788,838,880,105373,137958,379702,2005,1.123516501,1.15419467,1.65624668,,880,105373,379702,,,0.05,0.95,0.02,0.01,0.07783297718,2.613510728,,,,,,,,,, +google_2011,cpu_by_user_priority,"sum by (user, priority) (sum_over_time(cpu_rate[5m]))",keys,value,5m,300,300,1326,288357812,788,838,880,105373,137958,379702,2005,1.215459225,1.258025912,1.466602293,1.215459225,880,105373,379702,,,0.05,0.95,0.02,0.01,0.121567009,3.607655725,,,,,,,,,, +google_2011,cpu_by_user_priority,"sum by (user, priority) (sum_over_time(cpu_rate[1h]))",keys,count,1h,3600,300,1356,288357812,836,875,918,1310788,1663612,4179680,1994,1.125128087,1.15419467,1.580642019,,918,1310788,4179680,,,0.05,0.95,0.02,0.01,0.07783297718,2.613510728,,,,,,,,,, +google_2011,cpu_by_user_priority,"sum by (user, priority) (sum_over_time(cpu_rate[1h]))",keys,value,1h,3600,300,1326,288357812,836,875,918,1310788,1663612,4179680,1994,1.225676891,1.258025912,1.376433035,1.225676891,918,1310788,4179680,,,0.05,0.95,0.02,0.01,0.121567009,3.607655725,,,,,,,,,, +google_2011,cpu_by_priority,sum by (priority) (cpu_rate),keys,count,instant,,300,11,254393256,7,9,10,100546,126200,212533,2005,1.041417612,1.417093333,1.693290433,,10,100546,212533,,,0.05,0.95,0.02,0.01,0.3956743531,4.248710668,,,,,,,,,, +google_2011,cpu_by_priority,sum by (priority) (cpu_rate),keys,value,instant,,300,11,254393256,7,9,10,100546,126200,212533,2005,1.467698146,1.878339954,2.361124179,1.467698146,10,100546,212533,,,0.05,0.95,0.02,0.01,0.6262266935,4.720397597,,,,,,,,,, +google_2011,cpu_by_priority,sum by (priority) (sum_over_time(cpu_rate[5m])),keys,count,5m,300,300,11,288357812,7,9,10,105373,137958,379702,2005,0.9875708441,1.371566014,2.184801397,,10,105373,379702,,,0.05,0.95,0.02,0.01,0.3625884913,4.062229564,,,,,,,,,, +google_2011,cpu_by_priority,sum by (priority) (sum_over_time(cpu_rate[5m])),keys,value,5m,300,300,11,288357812,7,9,10,105373,137958,379702,2005,1.36454469,1.828458458,2.314749802,1.36454469,10,105373,379702,,,0.05,0.95,0.02,0.01,0.6034462731,4.306203284,,,,,,,,,, +google_2011,cpu_by_priority,sum by (priority) (sum_over_time(cpu_rate[1h])),keys,count,1h,3600,300,11,288357812,7,9,11,1310788,1663612,4179680,1994,1.032055526,1.371566014,2.061975815,,11,1310788,4179680,,,0.05,0.95,0.02,0.01,0.3625884913,4.062229564,,,,,,,,,, +google_2011,cpu_by_priority,sum by (priority) (sum_over_time(cpu_rate[1h])),keys,value,1h,3600,300,11,288357812,7,9,11,1310788,1663612,4179680,1994,1.446809389,1.828458458,2.17016232,1.446809389,11,1310788,4179680,,,0.05,0.95,0.02,0.01,0.6034462731,4.306203284,,,,,,,,,, +google_2011,cpu_by_job_id,sum by (job_id) (cpu_rate),keys,count,instant,,300,149904,254393256,3736,4073,4329,100546,126200,212533,2005,1.018094917,1.111840032,1.287598425,,4329,100546,212533,,,0.05,0.95,0.02,0.01,0.03853351757,2.264320313,,,,,,,,,, +google_2011,cpu_by_job_id,sum by (job_id) (cpu_rate),keys,value,instant,,300,84343,254393256,3736,4073,4329,100546,126200,212533,2005,1.105104651,1.151146338,1.33690346,1.105104651,4329,100546,212533,,,0.05,0.95,0.02,0.01,0.04569306047,3.285347569,,,,,,,,,, +google_2011,cpu_by_job_id,sum by (job_id) (sum_over_time(cpu_rate[5m])),keys,count,5m,300,300,149904,288357812,3736,4073,4329,105373,137958,379702,2005,1.017149621,1.102080327,1.503255855,,4329,105373,379702,,,0.05,0.95,0.02,0.01,0.05772714769,2.06447159,,,,,,,,,, +google_2011,cpu_by_job_id,sum by (job_id) (sum_over_time(cpu_rate[5m])),keys,value,5m,300,300,148594,288357812,3736,4073,4329,105373,137958,379702,2005,1.103163853,1.153824387,1.327898976,1.103163853,4329,105373,379702,,,0.05,0.95,0.02,0.01,0.0430493823,2.930785652,,,,,,,,,, +google_2011,cpu_by_job_id,sum by (job_id) (sum_over_time(cpu_rate[1h])),keys,count,1h,3600,300,149904,288357812,4370,4862,5682,1310788,1663612,4179680,1994,1.007087334,1.102080327,1.424299342,,5682,1310788,4179680,,,0.05,0.95,0.02,0.01,0.05772714769,2.06447159,,,,,,,,,, +google_2011,cpu_by_job_id,sum by (job_id) (sum_over_time(cpu_rate[1h])),keys,value,1h,3600,300,148594,288357812,4370,4862,5682,1310788,1663612,4179680,1994,1.11335546,1.153824387,1.233694396,1.11335546,5682,1310788,4179680,,,0.05,0.95,0.02,0.01,0.0430493823,2.930785652,,,,,,,,,, +google_2011,cpu_by_logical_job_name,sum by (logical_job_name) (cpu_rate),keys,count,instant,,300,17796,254393256,3314,3654,3869,100546,126200,212533,2005,1.02248213,1.089261918,1.289781084,,3869,100546,212533,,,0.05,0.95,0.02,0.01,0.0415626073,3.000008214,,,,,,,,,, +google_2011,cpu_by_logical_job_name,sum by (logical_job_name) (cpu_rate),keys,value,instant,,300,15463,254393256,3314,3654,3869,100546,126200,212533,2005,1.101552401,1.157491198,1.336405436,1.101552401,3869,100546,212533,,,0.05,0.95,0.02,0.01,0.0657728459,3.747414902,,,,,,,,,, +google_2011,cpu_by_logical_job_name,sum by (logical_job_name) (sum_over_time(cpu_rate[5m])),keys,count,5m,300,300,17796,288357812,3314,3654,3869,105373,137958,379702,2005,1.021586211,1.086252759,1.514068393,,3869,105373,379702,,,0.05,0.95,0.02,0.01,0.05772714769,2.749505785,,,,,,,,,, +google_2011,cpu_by_logical_job_name,sum by (logical_job_name) (sum_over_time(cpu_rate[5m])),keys,value,5m,300,300,17686,288357812,3314,3654,3869,105373,137958,379702,2005,1.099326069,1.155715922,1.327207337,1.099326069,3869,105373,379702,,,0.05,0.95,0.02,0.01,0.0619674051,3.460309727,,,,,,,,,, +google_2011,cpu_by_logical_job_name,sum by (logical_job_name) (sum_over_time(cpu_rate[1h])),keys,count,1h,3600,300,17796,288357812,3731,4062,4535,1310788,1663612,4179680,1994,1.008349617,1.086252759,1.43851047,,4535,1310788,4179680,,,0.05,0.95,0.02,0.01,0.05772714769,2.749505785,,,,,,,,,, +google_2011,cpu_by_logical_job_name,sum by (logical_job_name) (sum_over_time(cpu_rate[1h])),keys,value,1h,3600,300,17686,288357812,3731,4062,4535,1310788,1663612,4179680,1994,1.102961084,1.155715922,1.231968728,1.102961084,4535,1310788,4179680,,,0.05,0.95,0.02,0.01,0.0619674051,3.460309727,,,,,,,,,, +google_2011,cpu_by_scheduling_class,sum by (scheduling_class) (cpu_rate),keys,count,instant,,300,4,254393256,4,4,4,100546,126200,212533,2005,0.1342594637,0.2571920412,1.259619862,,4,100546,212533,,,0.05,0.95,0.02,0.01,0.2933255707,0.2655223102,,,,,,,,,, +google_2011,cpu_by_scheduling_class,sum by (scheduling_class) (cpu_rate),keys,value,instant,,300,4,254393256,4,4,4,100546,126200,212533,2005,0.134651854,0.5570643761,1.118978684,0.134651854,4,100546,212533,,,0.05,0.95,0.02,0.01,0.352956055,0.5956980856,,,,,,,,,, +google_2011,cpu_by_scheduling_class,sum by (scheduling_class) (sum_over_time(cpu_rate[5m])),keys,count,5m,300,300,4,288357812,4,4,4,105373,137958,379702,2005,0.1279176611,0.3979267591,2.03910581,,4,105373,379702,,,0.05,0.95,0.02,0.01,0.3291290267,0.4087825709,,,,,,,,,, +google_2011,cpu_by_scheduling_class,sum by (scheduling_class) (sum_over_time(cpu_rate[5m])),keys,value,5m,300,300,4,288357812,4,4,4,105373,137958,379702,2005,0.09835771313,0.474743457,1.072402634,0.09835771313,4,105373,379702,,,0.05,0.95,0.02,0.01,0.3377085349,0.5064505245,,,,,,,,,, +google_2011,cpu_by_scheduling_class,sum by (scheduling_class) (sum_over_time(cpu_rate[1h])),keys,count,1h,3600,300,4,288357812,4,4,4,1310788,1663612,4179680,1994,0.1312536567,0.3979267591,1.873488766,,4,1310788,4179680,,,0.05,0.95,0.02,0.01,0.3291290267,0.4087825709,,,,,,,,,, +google_2011,cpu_by_scheduling_class,sum by (scheduling_class) (sum_over_time(cpu_rate[1h])),keys,value,1h,3600,300,4,288357812,4,4,4,1310788,1663612,4179680,1994,0.2164418871,0.474743457,0.866047153,0.2164418871,4,1310788,4179680,,,0.05,0.95,0.02,0.01,0.3377085349,0.5064505245,,,,,,,,,, +google_2011,cpu_by_machine_id,sum by (machine_id) (cpu_rate),keys,count,instant,,300,12555,254393256,12450,12494,12513,100546,126200,212533,2005,0.2002784015,0.2002784015,0.3641132007,,12513,100546,212533,,,0.05,0.95,0.02,0.01,0.0002062279513,0.2345071156,,,,,,,,,, +google_2011,cpu_by_machine_id,sum by (machine_id) (cpu_rate),keys,value,instant,,300,12555,254393256,12450,12494,12513,100546,126200,212533,2005,0.2760861204,0.2760861204,0.4809930696,0.2760861204,12513,100546,212533,,,0.05,0.95,0.02,0.01,0.0002508010797,0.3495270925,,,,,,,,,, +google_2011,cpu_by_machine_id,sum by (machine_id) (sum_over_time(cpu_rate[5m])),keys,count,5m,300,300,12555,288357812,12450,12494,12513,105373,137958,379702,2005,0.1923715173,0.1923715173,0.4945129903,,12513,105373,379702,,,0.05,0.95,0.02,0.01,0.001366878176,0.2201118062,,,,,,,,,, +google_2011,cpu_by_machine_id,sum by (machine_id) (sum_over_time(cpu_rate[5m])),keys,value,5m,300,300,12555,288357812,12450,12494,12513,105373,137958,379702,2005,0.264742317,0.264742317,0.4631528705,0.264742317,12513,105373,379702,,,0.05,0.95,0.02,0.01,0.0002457267992,0.3330981966,,,,,,,,,, +google_2011,cpu_by_machine_id,sum by (machine_id) (sum_over_time(cpu_rate[1h])),keys,count,1h,3600,300,12555,288357812,12464,12499,12517,1310788,1663612,4179680,1994,0.1923715173,0.1923715173,0.4151173444,,12517,1310788,4179680,,,0.05,0.95,0.02,0.01,0.001366878176,0.2201118062,,,,,,,,,, +google_2011,cpu_by_machine_id,sum by (machine_id) (sum_over_time(cpu_rate[1h])),keys,value,1h,3600,300,12555,288357812,12464,12499,12517,1310788,1663612,4179680,1994,0.2554549929,0.264742317,0.3833340129,0.2554549929,12517,1310788,4179680,,,0.05,0.95,0.02,0.01,0.0002457267992,0.3330981966,,,,,,,,,, +google_2011,cpu_p99,"quantile(0.99, cpu_rate)",values,,instant,,300,,254393256,,,,91155,110621,138139,2005,2.251147561,2.886080738,21.48065083,,,91155,138139,21.48065083,2.251147561,0.05,0.95,0.02,0.01,,,0.1204071935,0.04236,0.02938791912,0.18458,-36.31165363,1.412366445e-10,1571.498664,1.004172398e-168,lognormal, +google_2011,cpu_p99,"quantile_over_time(0.99, cpu_rate[5m])",values,,5m,300,300,,288357812,,,,95686,120112,277263,2005,2.275868657,2.915934134,20.27861172,,,95686,277263,20.27861172,2.275868657,0.05,0.95,0.02,0.01,,,0.1328455773,0.04242,0.02767439641,0.17435,-26.37966239,8.600621204e-08,1545.518962,3.118557454e-133,lognormal, +google_2011,cpu_p99,"quantile_over_time(0.99, cpu_rate[1h])",values,,1h,3600,300,,288357812,,,,1200321,1434201.5,3021637,1994,2.320001561,2.915934134,16.29186648,,,1200321,3021637,16.29186648,2.320001561,0.05,0.95,0.02,0.01,,,0.1328455773,0.04242,0.02767439641,0.17435,-26.37966239,8.600621204e-08,1545.518962,3.118557454e-133,lognormal, +google_2011,memory_p99,"quantile(0.99, canonical_memory_usage)",values,,instant,,300,,254393256,,,,91239,113206,136461,2005,1.702567801,4.302722325,17.21791254,,,91239,136461,17.21791254,1.702567801,0.05,0.95,0.02,0.01,,,0.110901973,0.1195,0.1178449732,0.04182,-129.8619128,2.92376938e-16,-130.6899204,1.249790439e-13,light, +google_2011,memory_p99,"quantile_over_time(0.99, canonical_memory_usage[5m])",values,,5m,300,300,,288357812,,,,94938,120433,225145,2005,1.644191691,2.215617498,17.45458006,,,94938,225145,17.45458006,1.644191691,0.05,0.95,0.02,0.01,,,0.1503744105,0.0242,0.128213286,0.2863,-3016.902833,0,-2853.875617,0,light, +google_2011,memory_p99,"quantile_over_time(0.99, canonical_memory_usage[1h])",values,,1h,3600,300,,288357812,,,,1188516,1445212.5,2446753,1994,1.732888435,2.215617498,16.09107673,,,1188516,2446753,16.09107673,1.732888435,0.05,0.95,0.02,0.01,,,0.1503744105,0.0242,0.128213286,0.2863,-3016.902833,0,-2853.875617,0,light, diff --git a/asap-tools/dataset-analysis/tests/test_fit_skew.py b/asap-tools/dataset-analysis/tests/test_fit_skew.py index 2b0dacfb..ee6cd898 100644 --- a/asap-tools/dataset-analysis/tests/test_fit_skew.py +++ b/asap-tools/dataset-analysis/tests/test_fit_skew.py @@ -137,27 +137,40 @@ def test_too_few_samples_is_nan(self): self.assertNotIn("tail_class", fit) -def key_window_frames(thetas, rng): - """Finest-window key count frames, one Zipf window per theta.""" - frames = [ +def key_step_frames(thetas, rng): + """Per-step key count frames, one Zipf distribution per step.""" + return [ pd.DataFrame( { - fit_skew.WINDOW_COL: window, - "k": np.arange(ZIPF_K).astype(str).astype(object), + fit_skew.STEP_COL: step, + fit_skew.KEY_COL: np.arange(1, ZIPF_K + 1, dtype=np.uint64), fit_skew.COUNT_COL: zipf_counts(theta, rng), } ) - for window, theta in enumerate(thetas) + for step, theta in enumerate(thetas) ] - return frames COUNT_QUERY = { "id": "q", "promql": "count by (k) (x)", + "promql_range": "sum by (k) (count_over_time(x[{range}]))", "group_by": ["k"], "weights": ["count"], } +VALUE_QUERY = { + "id": "v", + "promql": "quantile(0.99, x)", + "promql_range": "quantile_over_time(0.99, x[{range}])", + "value": "x", +} + + +def summarize_counts(frames, token, span, min_keys=2): + agg = fit_skew.merge_key_parts(frames) + return fit_skew.summarize_keys( + "test", COUNT_QUERY, token, 60, agg, span, 1, min_keys, None + ) class WindowBoundsTest(unittest.TestCase): @@ -183,89 +196,198 @@ def test_nothing_finite(self): self.assertTrue(np.isnan(lower) and np.isnan(upper)) self.assertEqual(n, 0) - def test_summarize_keys_skips_small_windows(self): - frames = key_window_frames((0.8, 1.2), np.random.default_rng(5)) - # Window 2 has too few keys to be fitted. + +class RangeEvaluationTest(unittest.TestCase): + def test_skips_small_evaluations(self): + frames = key_step_frames((0.8, 1.2), np.random.default_rng(5)) + # Step 2 has too few keys to be fitted. frames.append( pd.DataFrame( - {fit_skew.WINDOW_COL: 2, "k": ["0", "1"], fit_skew.COUNT_COL: [1e6, 1]} + { + fit_skew.STEP_COL: 2, + fit_skew.KEY_COL: np.array([1, 2], dtype=np.uint64), + fit_skew.COUNT_COL: [1e6, 1], + } ) ) - agg = fit_skew.merge_key_parts(frames, ["k"]) - (row,) = fit_skew.summarize_keys("test", COUNT_QUERY, agg, [60], 1, 10, None) - self.assertEqual(row["n_windows"], 2) + (row,) = summarize_counts(frames, "1m", (0, 2), min_keys=10) + self.assertEqual(row["n_evals"], 2) + self.assertEqual(row["range_s"], 60) + self.assertEqual(row["promql"], "sum by (k) (count_over_time(x[1m]))") self.assertAlmostEqual(row["lower"], 0.8, delta=ZIPF_TOLERANCE) self.assertAlmostEqual(row["upper"], 1.2, delta=ZIPF_TOLERANCE) self.assertTrue(row["lower"] <= row["mle"] <= row["upper"]) self.assertEqual(row["K_total"], ZIPF_K) - self.assertEqual(row["window_len_s"], 60) - - def test_summarize_keys_window_lengths(self): - frames = key_window_frames((0.8, 1.2, 0.8, 1.2), np.random.default_rng(6)) - agg = fit_skew.merge_key_parts(frames, ["k"]) - fine, coarse = fit_skew.summarize_keys( - "test", COUNT_QUERY, agg, [60, 120], 1, 2, None - ) - self.assertEqual((fine["window_len_s"], coarse["window_len_s"]), (60, 120)) - self.assertEqual((fine["n_windows"], coarse["n_windows"]), (4, 2)) - self.assertEqual(fine["mle"], coarse["mle"]) - # Merging a 0.8 and a 1.2 window gives something in between. - self.assertGreater(coarse["lower"], fine["lower"]) - self.assertLess(coarse["upper"], fine["upper"]) - for row in (fine, coarse): - self.assertTrue(row["lower"] <= row["mle"] <= row["upper"]) - def test_per_window_stats(self): - # Finest windows 0..3 with 3, 1, 2, 2 keys; key "a" appears in all. + def test_sliding_ranges(self): + # A 2-step range is evaluated at every step once it is full (3 times + # over 4 steps), not over disjoint windows. + frames = key_step_frames((0.8, 1.2, 0.8, 1.2), np.random.default_rng(6)) + (one,) = summarize_counts(frames, "1m", (0, 3)) + (two,) = summarize_counts(frames, "2m", (0, 3)) + self.assertEqual((one["n_evals"], two["n_evals"]), (4, 3)) + self.assertEqual(one["mle"], two["mle"]) + # Merging a 0.8 and a 1.2 step gives something in between. + self.assertGreater(two["lower"], one["lower"]) + self.assertLess(two["upper"], one["upper"]) + + def test_per_evaluation_stats(self): + # Steps 0..3 with 3, 1, 2, 2 keys; key 1 appears in all. frame = pd.DataFrame( { - fit_skew.WINDOW_COL: [0, 0, 0, 1, 2, 2, 3, 3], - "k": ["a", "b", "c", "a", "a", "b", "a", "d"], + fit_skew.STEP_COL: [0, 0, 0, 1, 2, 2, 3, 3], + fit_skew.KEY_COL: np.array([1, 2, 3, 1, 1, 2, 1, 4], dtype=np.uint64), fit_skew.COUNT_COL: [5, 1, 1, 7, 2, 2, 1, 9], } ) - agg = fit_skew.merge_key_parts([frame], ["k"]) - fine, coarse = fit_skew.summarize_keys( - "test", COUNT_QUERY, agg, [60, 120], 1, 2, None - ) - self.assertEqual((fine["K_total"], fine["rows_total"]), (4, 28)) + (one,) = summarize_counts([frame], "1m", (0, 3)) + (two,) = summarize_counts([frame], "2m", (0, 3)) + self.assertEqual((one["K_total"], one["rows_total"]), (4, 28)) self.assertEqual( - (fine["K_win_min"], fine["K_win_median"], fine["K_win_max"]), (1, 2, 3) + (one["K_win_min"], one["K_win_median"], one["K_win_max"]), (1, 2, 3) ) self.assertEqual( - (fine["rows_win_min"], fine["rows_win_median"], fine["rows_win_max"]), + (one["rows_win_min"], one["rows_win_median"], one["rows_win_max"]), (4, 7, 10), ) - # Merged windows {0,1} and {2,3}: keys {a,b,c} and {a,b,d}, rows 14 and 14. - self.assertEqual((coarse["K_win_min"], coarse["K_win_max"]), (3, 3)) - self.assertEqual((coarse["rows_win_min"], coarse["rows_win_max"]), (14, 14)) - self.assertEqual(coarse["K_total"], fine["K_total"]) - - def test_coarsen_values(self): - windows = {0: np.array([1.0]), 1: np.array([2.0]), 2: np.array([3.0])} - coarse = fit_skew.coarsen_values(windows, 2) - self.assertEqual(sorted(coarse), [0, 1]) - np.testing.assert_array_equal(coarse[0], [1.0, 2.0]) - np.testing.assert_array_equal(coarse[1], [3.0]) - - def test_summarize_values_window_lengths(self): + # Ranges {0,1}, {1,2}, {2,3}: keys {1,2,3}, {1,2}, {1,2,4}; rows 14, 11, 14. + self.assertEqual((two["K_win_min"], two["K_win_max"]), (2, 3)) + self.assertEqual((two["rows_win_min"], two["rows_win_max"]), (11, 14)) + self.assertLessEqual(set(one), set(fit_skew.SUMMARY_COLUMNS)) + + def test_empty_steps_inside_span(self): + # Steps 1 and 2 have no rows; a 1-step range there is not evaluated. + frame = pd.DataFrame( + { + fit_skew.STEP_COL: [0, 0, 3, 3], + fit_skew.KEY_COL: np.array([1, 2, 1, 2], dtype=np.uint64), + fit_skew.COUNT_COL: [3, 1, 3, 1], + } + ) + (row,) = summarize_counts([frame], "1m", (0, 3)) + self.assertEqual(row["n_evals"], 2) + # Empty evaluations are gaps, not evaluations that saw zero rows. + self.assertEqual((row["rows_win_min"], row["K_win_min"]), (4, 2)) + + def test_merge_samples_is_uniform(self): + # Two parts, 10x apart in size, merged into a sample capped at + # MAX_FIT_SAMPLES: each part's share follows its size. + big = fit_skew.value_sample(np.zeros(10 * fit_skew.MAX_FIT_SAMPLES)) + small = fit_skew.value_sample(np.ones(fit_skew.MAX_FIT_SAMPLES)) + total, merged = fit_skew.merge_samples([big, small]) + self.assertEqual(total, 11 * fit_skew.MAX_FIT_SAMPLES) + self.assertEqual(len(merged), fit_skew.MAX_FIT_SAMPLES) + self.assertAlmostEqual(merged.mean(), 1 / 11, delta=0.01) + + def test_summarize_values_ranges(self): rng = np.random.default_rng(7) acc = { "n_finite": 4000, - "windows": {w: [rng.pareto(1.5, 1000) + 1.0] for w in range(4)}, + "steps": { + w: fit_skew.value_sample(rng.pareto(1.5, 1000) + 1.0) for w in range(4) + }, } - q = {"id": "v", "promql": "quantile(0.99, x)", "value": "x"} + rows = [] # One thread: redirect_stdout in fit_power_law is process-wide. with ThreadPool(1) as pool: - rows = fit_skew.summarize_values("test", q, acc, [60, 240], pool, 1, None) - self.assertEqual([r["window_len_s"] for r in rows], [60, 240]) - self.assertEqual([r["n_windows"] for r in rows], [4, 1]) + for token in ("1m", "4m"): + rows.append( + fit_skew.summarize_values( + "test", VALUE_QUERY, token, 60, acc, (0, 3), pool, 1, None + ) + ) + self.assertEqual([r["n_evals"] for r in rows], [4, 1]) self.assertEqual([r["rows_win_median"] for r in rows], [1000, 4000]) self.assertNotIn("K_win_median", rows[0]) + self.assertLessEqual(set(rows[0]), set(fit_skew.SUMMARY_COLUMNS)) for row in rows: self.assertTrue(row["lower"] <= row["mle"] <= row["upper"]) +def latest_rows(samples): + """(series, time_s) pairs -> latest_part-style rows with step = ceil(t / 60).""" + series, times = zip(*samples) + times = np.array(times, dtype=float) + return pd.DataFrame( + { + fit_skew.SERIES_COL: np.array(series, dtype=np.uint64), + fit_skew.STEP_COL: np.ceil(times / 60).astype(np.int64), + fit_skew.TIME_COL: times, + "_key:k": np.array(series, dtype=np.uint64), + } + ) + + +INSTANT_QUERY = {**COUNT_QUERY, "kind": "keys", "range": ["instant"]} +INSTANT_KEY = fit_skew.query_key(INSTANT_QUERY) + + +def instant_counts(parts): + """{(step, key): count} from instant_parts outputs.""" + agg = fit_skew.merge_key_parts([p[INSTANT_KEY] for p in parts]) + return { + (int(s), int(k)): int(c) + for s, k, c in agg[ + [fit_skew.STEP_COL, fit_skew.KEY_COL, fit_skew.COUNT_COL] + ].itertuples(index=False) + } + + +def split_files(files, lookback): + """instant parts computed per file then merged via resolve_boundaries.""" + parts, boundary = [], [] + for samples in files: + inner, edge = fit_skew.split_instant( + latest_rows(samples), [INSTANT_QUERY], lookback + ) + parts.append(inner) + boundary.append(edge) + parts.append(fit_skew.resolve_boundaries(boundary, [INSTANT_QUERY], lookback)) + return instant_counts(parts) + + +class InstantEvaluationTest(unittest.TestCase): + def test_lookback_carries_last_sample(self): + # Series 1 is sampled at steps 1 and 2 then stops: with a 3-step + # lookback it is still seen at steps 3 and 4, not at 5. + counts = split_files([[(1, 60), (1, 120)]], lookback=3) + self.assertEqual(sorted(counts), [(1, 1), (2, 1), (3, 1), (4, 1)]) + + def test_gap_shorter_than_lookback(self): + # Samples at steps 1 and 3: step 2 still sees the step-1 sample once. + counts = split_files([[(1, 60), (1, 180)]], lookback=5) + self.assertEqual(counts[(2, 1)], 1) + self.assertEqual(counts[(3, 1)], 1) + + def test_latest_sample_per_step(self): + # Two samples in step 1 count once. + counts = split_files([[(1, 30), (1, 55)]], lookback=1) + self.assertEqual(counts, {(1, 1): 1}) + + def test_split_across_files_matches_one_file(self): + rng = np.random.default_rng(8) + samples = [ + (int(series), float(t)) + for series in range(1, 6) + for t in np.sort(rng.choice(np.arange(1, 1200), 15, replace=False)) + ] + samples.sort(key=lambda st: st[1]) + whole = split_files([samples], lookback=5) + # Consecutive time chunks, cut inside a step so step 10 spans both files. + cut = [s for s in samples if s[1] <= 570], [s for s in samples if s[1] > 570] + self.assertEqual(split_files(list(cut), lookback=5), whole) + + def test_interleaved_files_fail(self): + files = [[(1, 60), (1, 300)], [(1, 180)]] + with self.assertRaises(ValueError): + split_files(files, lookback=5) + + def test_lookback_steps(self): + self.assertEqual(fit_skew.lookback_steps({"step_s": 60}), 5) + # A sampling period longer than 5 minutes is one step. + self.assertEqual(fit_skew.lookback_steps({"step_s": 600}), 1) + + def boom_inputs(classes): """Fake per-variate full fits (alpha = index + 2) with the given classes.""" shifted = np.ones((len(classes), 10)) @@ -305,6 +427,12 @@ def test_alpha_over_non_light_variates(self): # Non-light variates 0, 2, 3 have alpha 2, 4, 5. self.assertEqual(row["mle"], 4.0) self.assertTrue(row["lower"] <= row["mle"] <= row["upper"]) + self.assertEqual( + (row["worst_alpha_memory"], row["worst_alpha_rank"]), + (row["lower"], row["upper"]), + ) + # Every summary field must be a CSV column, or it is silently dropped. + self.assertLessEqual(set(row), set(fit_skew.SUMMARY_COLUMNS)) # R/p come from the same non-light variates. self.assertEqual(row["R_exponential"], 4.0) @@ -336,7 +464,12 @@ def test_no_compared_variates(self): VALID_CONFIG = { "dataset": "d", "tables": { - "t": {"label_columns": ["a", "b"], "value_columns": ["v"]}, + "t": { + "label_columns": ["a", "b"], + "value_columns": ["v"], + "step_s": 60, + "series_key": ["a", "b"], + }, }, "queries": [ { @@ -346,8 +479,19 @@ def test_no_compared_variates(self): "group_by": ["a"], "value": "v", "weights": ["count", "value"], + "promql": "count by (a) (v)", + "promql_range": "sum by (a) (count_over_time(v[{range}]))", + "range": ["instant", "5m"], + }, + { + "id": "vals", + "table": "t", + "kind": "values", + "group_by": [], + "value": "v", + "promql": "quantile(0.99, v)", + "range": ["instant"], }, - {"id": "vals", "table": "t", "kind": "values", "group_by": [], "value": "v"}, ], } @@ -373,21 +517,39 @@ def test_invalid(self): with self.assertRaises(ValueError): fit_skew.validate_config(cfg) - def test_window_lengths(self): - fit_skew.validate_window_lengths([60, 300, 1800], "d") - for lengths in ([], [300, 60], [60, 60], [60, 90]): - with self.subTest(lengths=lengths): + def test_bad_ranges(self): + cases = { + "no range": [], + "bad duration": ["5x"], + "not a multiple of step_s": ["90s"], + } + for name, ranges in cases.items(): + with self.subTest(name): + cfg = copy.deepcopy(VALID_CONFIG) + cfg["queries"][0]["range"] = ranges with self.assertRaises(ValueError): - fit_skew.validate_window_lengths(lengths, "d") + fit_skew.validate_config(cfg) - def test_table_window_lengths(self): + def test_range_needs_promql_range(self): cfg = copy.deepcopy(VALID_CONFIG) - cfg["tables"]["t"]["window_lengths_s"] = [60, 86400] - fit_skew.validate_config(cfg) - cfg["tables"]["t"]["window_lengths_s"] = [60, 90] + cfg["queries"][1]["range"] = ["5m"] with self.assertRaises(ValueError): fit_skew.validate_config(cfg) + def test_instant_needs_series_key(self): + cfg = copy.deepcopy(VALID_CONFIG) + del cfg["tables"]["t"]["series_key"] + with self.assertRaises(ValueError): + fit_skew.validate_config(cfg) + + def test_bad_step(self): + for step in (None, 0, 1.5): + with self.subTest(step=step): + cfg = copy.deepcopy(VALID_CONFIG) + cfg["tables"]["t"]["step_s"] = step + with self.assertRaises(ValueError): + fit_skew.validate_config(cfg) + def test_value_weight_needs_value(self): cfg = copy.deepcopy(VALID_CONFIG) del cfg["queries"][0]["value"]