Changeset: 52eb4938ea71 for MonetDB
URL: https://dev.monetdb.org/hg/MonetDB?cmd=changeset;node=52eb4938ea71
Modified Files:
gdk/gdk_analytic_func.c
Branch: window-tunning
Log Message:
More cleanup, I had to undo one of the previous commits because it was becoming
difficult to manage many nested macros
diffs (truncated from 612 to 300 lines):
diff --git a/gdk/gdk_analytic_func.c b/gdk/gdk_analytic_func.c
--- a/gdk/gdk_analytic_func.c
+++ b/gdk/gdk_analytic_func.c
@@ -793,16 +793,10 @@ GDKanalyticallead(BAT *r, BAT *b, BAT *p
#define ANALYTICAL_MIN_MAX_CALC_FIXED_UNBOUNDED_TILL_CURRENT_ROW(TPE,
NAN_CHECK, MIN_MAX) \
do { \
- TPE curval = TPE##_nil; \
for (; k < i;) { \
TPE v = bp[k]; \
+ TPE curval = v; \
j = k++; \
- if (!is_##TPE##_nil(v)) { \
- if (is_##TPE##_nil(curval)) \
- curval = v; \
- else \
- curval = MIN_MAX(v, curval); \
- } \
while (k < i && (bp[k] == v NAN_CHECK(TPE, k))) { \
k++; \
if (!is_##TPE##_nil(bp[k])) { \
@@ -820,16 +814,10 @@ GDKanalyticallead(BAT *r, BAT *b, BAT *p
#define ANALYTICAL_MIN_MAX_CALC_FIXED_CURRENT_ROW_TILL_UNBOUNDED(TPE,
NAN_CHECK, MIN_MAX) \
do { \
- TPE curval = TPE##_nil; \
for (j = i - 1; j >= k; ) { \
TPE v = bp[j]; \
+ TPE curval = v; \
l = j--; \
- if (!is_##TPE##_nil(v)) { \
- if (is_##TPE##_nil(curval)) \
- curval = v; \
- else \
- curval = MIN_MAX(v, curval); \
- } \
while (j >= k && (bp[j] == v NAN_CHECK(TPE, j))) { \
j--; \
if (!is_##TPE##_nil(bp[j])) { \
@@ -898,16 +886,9 @@ GDKanalyticallead(BAT *r, BAT *b, BAT *p
#define ANALYTICAL_MIN_MAX_CALC_VARSIZED_UNBOUNDED_TILL_CURRENT_ROW(GT_LT)
\
do { \
- void *curval = (void*) nil; \
for (; k < i;) { \
- void *next = BUNtail(bpi, k); \
+ void *next = BUNtail(bpi, k), *curval = next; \
j = k++; \
- if (atomcmp(next, nil) != 0) { \
- if (atomcmp(curval, nil) == 0) \
- curval = next; \
- else \
- curval = atomcmp(next, curval) GT_LT 0
? curval : next; \
- } \
while (k < i && atomcmp(BUNtail(bpi, k), next) == 0) { \
k++; \
void *nnext = BUNtail(bpi, k); \
@@ -927,16 +908,9 @@ GDKanalyticallead(BAT *r, BAT *b, BAT *p
#define ANALYTICAL_MIN_MAX_CALC_VARSIZED_CURRENT_ROW_TILL_UNBOUNDED(GT_LT)
\
do { \
- void *curval = (void*) nil; \
for (j = i - 1; j >= k; ) { \
- void *next = BUNtail(bpi, j); \
+ void *next = BUNtail(bpi, j), *curval = next; \
l = j--; \
- if (atomcmp(next, nil) != 0) { \
- if (atomcmp(curval, nil) == 0) \
- curval = next; \
- else \
- curval = atomcmp(next, curval) GT_LT 0
? curval : next; \
- } \
while (j >= k && atomcmp(BUNtail(bpi, j), next) == 0) {
\
j--; \
void *nnext = BUNtail(bpi, j); \
@@ -1490,16 +1464,10 @@ GDKanalyticalcount(BAT *r, BAT *p, BAT *
/* sum on fixed size integers */
#define ANALYTICAL_SUM_IMP_NUM_UNBOUNDED_TILL_CURRENT_ROW(TPE1, TPE2) \
do { \
- TPE2 curval = TPE2##_nil; \
for (; k < i;) { \
TPE1 v = bp[k]; \
+ TPE2 curval = is_##TPE1##_nil(v) ? TPE2##_nil : (TPE2)
v; \
j = k++; \
- if (!is_##TPE1##_nil(v)) { \
- if (is_##TPE2##_nil(curval)) \
- curval = (TPE2) v; \
- else \
- ADD_WITH_CHECK(v, curval, TPE2, curval,
GDK_##TPE2##_max, goto calc_overflow); \
- } \
while (k < i && bp[k] == v) { \
k++; \
if (!is_##TPE1##_nil(bp[k])) { \
@@ -1517,16 +1485,10 @@ GDKanalyticalcount(BAT *r, BAT *p, BAT *
#define ANALYTICAL_SUM_IMP_NUM_CURRENT_ROW_TILL_UNBOUNDED(TPE1, TPE2) \
do { \
- TPE2 curval = TPE2##_nil; \
for (j = i - 1; j >= k; ) { \
TPE1 v = bp[j]; \
+ TPE2 curval = is_##TPE1##_nil(v) ? TPE2##_nil : (TPE2)
v; \
l = j--; \
- if (!is_##TPE1##_nil(v)) { \
- if (is_##TPE2##_nil(curval)) \
- curval = (TPE2) v; \
- else \
- ADD_WITH_CHECK(v, curval, TPE2, curval,
GDK_##TPE2##_max, goto calc_overflow); \
- } \
while (j >= k && bp[j] == v) { \
j--; \
if (!is_##TPE1##_nil(bp[j])) { \
@@ -1600,16 +1562,10 @@ GDKanalyticalcount(BAT *r, BAT *p, BAT *
/* sum on floating-points */
#define ANALYTICAL_SUM_IMP_FP_UNBOUNDED_TILL_CURRENT_ROW(TPE1, TPE2) /* TODO
go through a version of dofsum which returns the current partials */ \
do { \
- TPE2 curval = TPE2##_nil; \
for (; k < i;) { \
TPE1 v = bp[k]; \
+ TPE2 curval = is_##TPE1##_nil(v) ? TPE2##_nil : (TPE2)
v; \
j = k++; \
- if (!is_##TPE1##_nil(v)) { \
- if (is_##TPE2##_nil(curval)) \
- curval = (TPE2) v; \
- else \
- ADD_WITH_CHECK(v, curval, TPE2, curval,
GDK_##TPE2##_max, goto calc_overflow); \
- } \
while (k < i && (bp[k] == v NAN_CHECK(TPE1, k))) { \
k++; \
if (!is_##TPE1##_nil(bp[k])) { \
@@ -1627,16 +1583,10 @@ GDKanalyticalcount(BAT *r, BAT *p, BAT *
#define ANALYTICAL_SUM_IMP_FP_CURRENT_ROW_TILL_UNBOUNDED(TPE1, TPE2) /* TODO
go through a version of dofsum which returns the current partials */ \
do { \
- TPE2 curval = TPE2##_nil; \
for (j = i - 1; j >= k; ) { \
TPE1 v = bp[j]; \
+ TPE2 curval = is_##TPE1##_nil(v) ? TPE2##_nil : (TPE2)
v; \
l = j--; \
- if (!is_##TPE1##_nil(v)) { \
- if (is_##TPE2##_nil(curval)) \
- curval = (TPE2) v; \
- else \
- ADD_WITH_CHECK(v, curval, TPE2, curval,
GDK_##TPE2##_max, goto calc_overflow); \
- } \
while (j >= k && (bp[j] == v NAN_CHECK(TPE1, j))) { \
j--; \
if (!is_##TPE1##_nil(bp[j])) { \
@@ -1882,80 +1832,150 @@ GDKanalyticalsum(BAT *r, BAT *p, BAT *b,
}
/* product on integers */
-#define PROD_NUM(TPE1, TPE2, TPE3) \
+#define PROD_NUM(TPE1, TPE2, TPE3, ARG) \
do { \
- if (!is_##TPE1##_nil(v)) { \
+ if (!is_##TPE1##_nil(ARG)) { \
if (is_##TPE2##_nil(curval)) \
- curval = (TPE2) v; \
+ curval = (TPE2) ARG; \
else \
- MUL4_WITH_CHECK(v, curval, TPE2, curval,
GDK_##TPE2##_max, TPE3, goto calc_overflow); \
+ MUL4_WITH_CHECK(ARG, curval, TPE2, curval,
GDK_##TPE2##_max, TPE3, goto calc_overflow); \
} \
} while(0)
-/* product on integers while checking for overflows on the output */
-#define PROD_NUM_LIMIT(TPE1, TPE2, REAL_IMP) \
- do { \
- if (!is_##TPE1##_nil(v)) { \
- if (is_##TPE2##_nil(curval)) \
- curval = (TPE2) v; \
- else \
- REAL_IMP(v, curval, curval, GDK_##TPE2##_max,
goto calc_overflow); \
- } \
- } while(0)
-
-/* product on floating-points */
-#define PROD_FP(TPE1, TPE2, ARG3) \
- do { \
- if (!is_##TPE1##_nil(v)) { \
- if (is_##TPE2##_nil(curval)) { \
- curval = (TPE2) v; \
- } else if (ABSOLUTE(curval) > 1 && GDK_##TPE2##_max /
ABSOLUTE(v) < ABSOLUTE(curval)) { \
- if (abort_on_error) \
- goto calc_overflow; \
- curval = TPE2##_nil; \
- nils++; \
- } else { \
- curval *= v; \
- } \
- } \
- } while(0)
-
-#define ANALYTICAL_PROD_CALC_NUM_UNBOUNDED_TILL_CURRENT_ROW(TPE1, TPE2,
REAL_IMP) \
+#define ANALYTICAL_PROD_CALC_NUM_UNBOUNDED_TILL_CURRENT_ROW(TPE1, TPE2, TPE3) \
do { \
- TPE2 curval = TPE2##_nil; \
- for (; k < i; k++) { \
+ for (; k < i;) { \
TPE1 v = bp[k]; \
- REAL_IMP; \
- rb[k] = curval; \
+ TPE2 curval = is_##TPE1##_nil(v) ? TPE2##_nil : (TPE2)
v; \
+ j = k++; \
+ while (k < i && bp[k] == v) { \
+ k++; \
+ PROD_NUM(TPE1, TPE2, TPE3, bp[k]); \
+ } \
+ for (; j < k; j++) \
+ rb[j] = curval; \
has_nils |= is_##TPE2##_nil(curval); \
} \
} while (0)
-#define ANALYTICAL_PROD_CALC_NUM_CURRENT_ROW_TILL_UNBOUNDED(TPE1, TPE2,
REAL_IMP) \
+#define ANALYTICAL_PROD_CALC_NUM_CURRENT_ROW_TILL_UNBOUNDED(TPE1, TPE2, TPE3) \
do { \
- TPE2 curval = TPE2##_nil; \
- for (j = i - 1; j >= k; j--) { \
+ for (j = i - 1; j >= k; ) { \
TPE1 v = bp[j]; \
- REAL_IMP; \
- rb[j] = curval; \
+ TPE2 curval = is_##TPE1##_nil(v) ? TPE2##_nil : (TPE2)
v; \
+ l = j--; \
+ while (j >= k && bp[j] == v) { \
+ j--; \
+ PROD_NUM(TPE1, TPE2, TPE3, bp[j]); \
+ } \
+ m = MAX(k, j); \
+ for (; l >= m; l--) \
+ rb[l] = curval; \
has_nils |= is_##TPE2##_nil(curval); \
- } \
+ } \
k = i; \
} while (0)
-#define ANALYTICAL_PROD_CALC_NUM_ALL_ROWS(TPE1, TPE2, REAL_IMP) \
+#define ANALYTICAL_PROD_CALC_NUM_ALL_ROWS(TPE1, TPE2, TPE3) \
do { \
TPE2 curval = TPE2##_nil; \
for (; j < i; j++) { \
TPE1 v = bp[j]; \
- REAL_IMP; \
+ PROD_NUM(TPE1, TPE2, TPE3, v); \
} \
for (; k < i; k++) \
rb[k] = curval; \
has_nils |= is_##TPE2##_nil(curval); \
} while (0)
-#define ANALYTICAL_PROD_CALC_NUM_CURRENT_ROW(TPE1, TPE2, REAL_IMP) \
+#define ANALYTICAL_PROD_CALC_NUM_CURRENT_ROW(TPE1, TPE2, TPE3) \
+ do { \
+ for (; k < i; k++) { \
+ TPE1 v = bp[k]; \
+ if (is_##TPE1##_nil(v)) { \
+ rb[k] = TPE2##_nil; \
+ has_nils = true; \
+ } else { \
+ rb[k] = (TPE2) v; \
+ } \
+ } \
+ } while (0)
+
+#define ANALYTICAL_PROD_CALC_NUM_OTHERS(TPE1, TPE2, TPE3) \
+ do { \
+ TPE2 curval = TPE2##_nil; \
+ for (; k < i; k++) { \
+ TPE1 *bs = bp + start[k], *be = bp + end[k];
\
+ for (; bs < be; bs++) { \
+ TPE1 v = *bs; \
+ PROD_NUM(TPE1, TPE2, TPE3, v); \
+ } \
+ rb[k] = curval; \
+ if (is_##TPE2##_nil(curval)) \
+ has_nils = true; \
+ else \
+ curval = TPE2##_nil; /* For the next
iteration */ \
+ } \
+ } while (0)
+
+/* product on integers while checking for overflows on the output */
+#define PROD_NUM_LIMIT(TPE1, TPE2, REAL_IMP, ARG) \
+ do { \
+ if (!is_##TPE1##_nil(ARG)) { \
+ if (is_##TPE2##_nil(curval)) \
+ curval = (TPE2) ARG; \
+ else \
+ REAL_IMP(ARG, curval, curval, GDK_##TPE2##_max,
goto calc_overflow); \
+ } \
+ } while(0)
+
+#define ANALYTICAL_PROD_CALC_NUM_LIMIT_UNBOUNDED_TILL_CURRENT_ROW(TPE1, TPE2,
REAL_IMP) \
+ do { \
+ for (; k < i;) { \
+ TPE1 v = bp[k]; \
+ TPE2 curval = is_##TPE1##_nil(v) ? TPE2##_nil : (TPE2)
v; \
+ j = k++; \
_______________________________________________
checkin-list mailing list
[email protected]
https://www.monetdb.org/mailman/listinfo/checkin-list
