[DTrace-devel] [PATCH 54/61] Pass signatures into dt_aggregate_[l]lquantized[sum|zero]()
eugene.loh at oracle.com
eugene.loh at oracle.com
Fri Jul 8 14:45:38 UTC 2022
From: Eugene Loh <eugene.loh at oracle.com>
In legacy DTrace, aggregation signatures for lquantize() and llquantize()
were prepended to the aggregation data. In the BPF port, this is no
longer the case. New mechanisms were put in place.
Nevertheless, functions dt_aggregate_[l]lquantized[sum|zero]() still
expected the legacy behavior.
Have dt_aggregate_valcmp() extract the signatures and pass them to
dt_aggregate_[l]lquantizedcmp(), which then relay the signatures to
dt_aggregate_[l]lquantized[sum|zero](), which now expect the signatures
as explicit arguments.
The associated tests used to XFAIL because aggregations keys were not
supported. Once support was introduced, the tests would XFAIL due to
core dumps due to extracting aggregation signatures from bogus data.
Signed-off-by: Eugene Loh <eugene.loh at oracle.com>
---
libdtrace/dt_aggregate.c | 69 ++++++++++++------------
test/unittest/aggs/tst.llquantize_sort.d | 3 +-
test/unittest/aggs/tst.llquantsortkey.d | 3 +-
test/unittest/aggs/tst.llquantsortsum.d | 3 +-
test/unittest/aggs/tst.llquantsortzero.d | 3 +-
5 files changed, 38 insertions(+), 43 deletions(-)
diff --git a/libdtrace/dt_aggregate.c b/libdtrace/dt_aggregate.c
index bfb32b02..d97c4b5f 100644
--- a/libdtrace/dt_aggregate.c
+++ b/libdtrace/dt_aggregate.c
@@ -80,12 +80,11 @@ dt_aggregate_stddevcmp(int64_t *lhs, int64_t *rhs)
}
static long double
-dt_aggregate_lquantizedsum(int64_t *lquanta)
+dt_aggregate_lquantizedsum(int64_t *lquanta, int64_t sig)
{
- int64_t arg = *lquanta++;
- int32_t base = DTRACE_LQUANTIZE_BASE(arg);
- uint16_t step = DTRACE_LQUANTIZE_STEP(arg);
- uint16_t levels = DTRACE_LQUANTIZE_LEVELS(arg), i;
+ int32_t base = DTRACE_LQUANTIZE_BASE(sig);
+ uint16_t step = DTRACE_LQUANTIZE_STEP(sig);
+ uint16_t levels = DTRACE_LQUANTIZE_LEVELS(sig), i;
long double total = (long double)lquanta[0] * (long double)(base - 1);
for (i = 0; i < levels; base += step, i++)
@@ -96,12 +95,11 @@ dt_aggregate_lquantizedsum(int64_t *lquanta)
}
static int64_t
-dt_aggregate_lquantizedzero(int64_t *lquanta)
+dt_aggregate_lquantizedzero(int64_t *lquanta, int64_t sig)
{
- int64_t arg = *lquanta++;
- int32_t base = DTRACE_LQUANTIZE_BASE(arg);
- uint16_t step = DTRACE_LQUANTIZE_STEP(arg);
- uint16_t levels = DTRACE_LQUANTIZE_LEVELS(arg), i;
+ int32_t base = DTRACE_LQUANTIZE_BASE(sig);
+ uint16_t step = DTRACE_LQUANTIZE_STEP(sig);
+ uint16_t levels = DTRACE_LQUANTIZE_LEVELS(sig), i;
if (base - 1 == 0)
return lquanta[0];
@@ -120,10 +118,10 @@ dt_aggregate_lquantizedzero(int64_t *lquanta)
}
static int
-dt_aggregate_lquantizedcmp(int64_t *lhs, int64_t *rhs)
+dt_aggregate_lquantizedcmp(int64_t *lhs, int64_t *rhs, int64_t lsig, int64_t rsig)
{
- long double lsum = dt_aggregate_lquantizedsum(lhs);
- long double rsum = dt_aggregate_lquantizedsum(rhs);
+ long double lsum = dt_aggregate_lquantizedsum(lhs, lsig);
+ long double rsum = dt_aggregate_lquantizedsum(rhs, rsig);
int64_t lzero, rzero;
if (lsum < rsum)
@@ -138,8 +136,8 @@ dt_aggregate_lquantizedcmp(int64_t *lhs, int64_t *rhs)
* the range of the linear quantization), then this will be judged a
* tie and will be resolved based on the key comparison.
*/
- lzero = dt_aggregate_lquantizedzero(lhs);
- rzero = dt_aggregate_lquantizedzero(rhs);
+ lzero = dt_aggregate_lquantizedzero(lhs, lsig);
+ rzero = dt_aggregate_lquantizedzero(rhs, rsig);
if (lzero < rzero)
return DT_LESSTHAN;
@@ -152,13 +150,12 @@ dt_aggregate_lquantizedcmp(int64_t *lhs, int64_t *rhs)
/* called by dt_aggregate_llquantizedcmp() */
static long double
-dt_aggregate_llquantizedsum(int64_t *llquanta)
+dt_aggregate_llquantizedsum(int64_t *llquanta, int64_t sig)
{
- int64_t arg = *llquanta++;
- int factor = DTRACE_LLQUANTIZE_FACTOR(arg);
- int lmag = DTRACE_LLQUANTIZE_LMAG(arg);
- int hmag = DTRACE_LLQUANTIZE_HMAG(arg);
- int steps = DTRACE_LLQUANTIZE_STEPS(arg);
+ int factor = DTRACE_LLQUANTIZE_FACTOR(sig);
+ int lmag = DTRACE_LLQUANTIZE_LMAG(sig);
+ int hmag = DTRACE_LLQUANTIZE_HMAG(sig);
+ int steps = DTRACE_LLQUANTIZE_STEPS(sig);
int steps_factor = steps / factor;
int bin0 = 1 + (hmag-lmag+1) * (steps-steps_factor);
@@ -191,13 +188,12 @@ dt_aggregate_llquantizedsum(int64_t *llquanta)
/* called by dt_aggregate_llquantizedcmp() */
static int64_t
-dt_aggregate_llquantizedzero(int64_t *llquanta)
+dt_aggregate_llquantizedzero(int64_t *llquanta, int64_t sig)
{
- int64_t arg = *llquanta++;
- uint16_t factor = DTRACE_LLQUANTIZE_FACTOR(arg);
- uint16_t lmag = DTRACE_LLQUANTIZE_LMAG(arg);
- uint16_t hmag = DTRACE_LLQUANTIZE_HMAG(arg);
- uint16_t steps = DTRACE_LLQUANTIZE_STEPS(arg);
+ uint16_t factor = DTRACE_LLQUANTIZE_FACTOR(sig);
+ uint16_t lmag = DTRACE_LLQUANTIZE_LMAG(sig);
+ uint16_t hmag = DTRACE_LLQUANTIZE_HMAG(sig);
+ uint16_t steps = DTRACE_LLQUANTIZE_STEPS(sig);
uint16_t underflow_bin = 1 + (hmag-lmag+1) * (steps-steps/factor);
/*
@@ -213,10 +209,10 @@ dt_aggregate_llquantizedzero(int64_t *llquanta)
* Other behavior is also reasonable.
*/
static int
-dt_aggregate_llquantizedcmp(int64_t *lhs, int64_t *rhs)
+dt_aggregate_llquantizedcmp(int64_t *lhs, int64_t *rhs, int64_t lsig, int64_t rsig)
{
- long double lsum = dt_aggregate_llquantizedsum(lhs);
- long double rsum = dt_aggregate_llquantizedsum(rhs);
+ long double lsum = dt_aggregate_llquantizedsum(lhs, lsig);
+ long double rsum = dt_aggregate_llquantizedsum(rhs, rsig);
int64_t lzero, rzero;
if (lsum < rsum)
@@ -231,8 +227,8 @@ dt_aggregate_llquantizedcmp(int64_t *lhs, int64_t *rhs)
* the range of the linear quantization), then this will be judged a
* tie and will be resolved based on the key comparison.
*/
- lzero = dt_aggregate_llquantizedzero(lhs);
- rzero = dt_aggregate_llquantizedzero(rhs);
+ lzero = dt_aggregate_llquantizedzero(lhs, lsig);
+ rzero = dt_aggregate_llquantizedzero(rhs, rsig);
if (lzero < rzero)
return DT_LESSTHAN;
@@ -800,7 +796,7 @@ dt_aggregate_valcmp(const void *lhs, const void *rhs)
caddr_t ldata = lh->dtahe_data.dtada_data;
caddr_t rdata = rh->dtahe_data.dtada_data;
dtrace_recdesc_t *lrec, *rrec;
- int64_t *laddr, *raddr;
+ int64_t *laddr, *raddr, lsig, rsig;
int rval, i;
if ((rval = dt_aggregate_hashcmp(lhs, rhs)) != 0)
@@ -835,6 +831,9 @@ dt_aggregate_valcmp(const void *lhs, const void *rhs)
laddr = (int64_t *)(uintptr_t)(ldata + lrec->dtrd_offset);
raddr = (int64_t *)(uintptr_t)(rdata + rrec->dtrd_offset);
+ lsig = lagg->dtagd_sig;
+ rsig = ragg->dtagd_sig;
+
switch (lrec->dtrd_action) {
case DT_AGG_AVG:
rval = dt_aggregate_averagecmp(laddr, raddr);
@@ -849,11 +848,11 @@ dt_aggregate_valcmp(const void *lhs, const void *rhs)
break;
case DT_AGG_LQUANTIZE:
- rval = dt_aggregate_lquantizedcmp(laddr, raddr);
+ rval = dt_aggregate_lquantizedcmp(laddr, raddr, lsig, rsig);
break;
case DT_AGG_LLQUANTIZE:
- rval = dt_aggregate_llquantizedcmp(laddr, raddr);
+ rval = dt_aggregate_llquantizedcmp(laddr, raddr, lsig, rsig);
break;
case DT_AGG_COUNT:
diff --git a/test/unittest/aggs/tst.llquantize_sort.d b/test/unittest/aggs/tst.llquantize_sort.d
index 5bf2735f..a0ad648c 100644
--- a/test/unittest/aggs/tst.llquantize_sort.d
+++ b/test/unittest/aggs/tst.llquantize_sort.d
@@ -1,10 +1,9 @@
/*
* Oracle Linux DTrace.
- * Copyright (c) 2017, 2020, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2022, Oracle and/or its affiliates. All rights reserved.
* Licensed under the Universal Permissive License v 1.0 as shown at
* http://oss.oracle.com/licenses/upl.
*/
-/* @@xfail: dtv2 */
/*
* ASSERTION:
diff --git a/test/unittest/aggs/tst.llquantsortkey.d b/test/unittest/aggs/tst.llquantsortkey.d
index dd3296de..43cc6461 100644
--- a/test/unittest/aggs/tst.llquantsortkey.d
+++ b/test/unittest/aggs/tst.llquantsortkey.d
@@ -1,10 +1,9 @@
/*
* Oracle Linux DTrace.
- * Copyright (c) 2013, 2020, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2013, 2022, Oracle and/or its affiliates. All rights reserved.
* Licensed under the Universal Permissive License v 1.0 as shown at
* http://oss.oracle.com/licenses/upl.
*/
-/* @@xfail: dtv2 */
/*
* ASSERTION:
diff --git a/test/unittest/aggs/tst.llquantsortsum.d b/test/unittest/aggs/tst.llquantsortsum.d
index fbbb931b..7294c50b 100644
--- a/test/unittest/aggs/tst.llquantsortsum.d
+++ b/test/unittest/aggs/tst.llquantsortsum.d
@@ -1,10 +1,9 @@
/*
* Oracle Linux DTrace.
- * Copyright (c) 2013, 2020, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2013, 2022, Oracle and/or its affiliates. All rights reserved.
* Licensed under the Universal Permissive License v 1.0 as shown at
* http://oss.oracle.com/licenses/upl.
*/
-/* @@xfail: dtv2 */
/*
* ASSERTION:
diff --git a/test/unittest/aggs/tst.llquantsortzero.d b/test/unittest/aggs/tst.llquantsortzero.d
index 91b30ccd..4bfc7f09 100644
--- a/test/unittest/aggs/tst.llquantsortzero.d
+++ b/test/unittest/aggs/tst.llquantsortzero.d
@@ -1,10 +1,9 @@
/*
* Oracle Linux DTrace.
- * Copyright (c) 2013, 2020, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2013, 2022, Oracle and/or its affiliates. All rights reserved.
* Licensed under the Universal Permissive License v 1.0 as shown at
* http://oss.oracle.com/licenses/upl.
*/
-/* @@xfail: dtv2 */
/*
* ASSERTION:
--
2.18.4
More information about the DTrace-devel
mailing list