Changeset: 4a2599b5f972 for MonetDB
URL: https://dev.monetdb.org/hg/MonetDB?cmd=changeset;node=4a2599b5f972
Modified Files:
        gdk/gdk_analytic_func.c
        sql/backends/monet5/sql_rank.c
Branch: window-tunning
Log Message:

Hack to reduce code explosion. Don't duplicate algorithm code, jump to the 
algorithm body on the last iteration


diffs (truncated from 493 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
@@ -941,12 +941,17 @@ GDKanalyticallead(BAT *r, BAT *b, BAT *p
                TPE *restrict bp = (TPE*)Tloc(b, 0), *restrict rb = 
(TPE*)Tloc(r, 0); \
                if (p) {                                        \
                        for (; i < cnt; i++) {          \
-                               if (np[i])                      \
-                                       
ANALYTICAL_MIN_MAX_CALC_FIXED_##IMP(TPE, MIN_MAX); \
+                               if (np[i])      {               \
+minmaxfixed##TPE##IMP: \
+                                       
ANALYTICAL_MIN_MAX_CALC_FIXED_##IMP(TPE, MIN_MAX);      \
+                               } \
                        }                                               \
                }               \
-               i = cnt;                                        \
-               ANALYTICAL_MIN_MAX_CALC_FIXED_##IMP(TPE, MIN_MAX);      \
+               if (!last) { /* hack to reduce code explosion, there's no need 
to duplicate the code to iterate each partition */ \
+                       last = true; \
+                       i = cnt; \
+                       goto minmaxfixed##TPE##IMP; \
+               } \
        } while (0)
 
 #ifdef HAVE_HGE
@@ -983,12 +988,17 @@ GDKanalyticallead(BAT *r, BAT *b, BAT *p
                default: {                                                      
\
                        if (p) {                                                
\
                                for (; i < cnt; i++) {                  \
-                                       if (np[i])                      \
-                                               
ANALYTICAL_MIN_MAX_CALC_VARSIZED_##IMP(GT_LT); \
+                               if (np[i])      {               \
+minmaxvarsized##IMP: \
+                                       
ANALYTICAL_MIN_MAX_CALC_VARSIZED_##IMP(GT_LT);  \
+                               } \
                                }                                               
\
                        }                                       \
-                       i = cnt;                                        \
-                       ANALYTICAL_MIN_MAX_CALC_VARSIZED_##IMP(GT_LT);  \
+                       if (!last) { \
+                               last = true; \
+                               i = cnt; \
+                               goto minmaxvarsized##IMP; \
+                       } \
                }                                                               
\
                }                                                               
\
        } while (0)
@@ -1006,6 +1016,7 @@ GDKanalytical##OP(BAT *r, BAT *p, BAT *o
        int (*atomcmp)(const void *, const void *) = ATOMcompare(tpe); \
        void *segment_tree = NULL; \
        gdk_return res = GDK_SUCCEED; \
+       bool last = false ; \
        \
        if (cnt > 0) {  \
                switch (frame_type) {           \
@@ -1273,12 +1284,17 @@ ANALYTICAL_MIN_MAX(max, MAX, <)
                TPE *restrict bp = (TPE*) bheap; \
                if (p) {                                        \
                        for (; i < cnt; i++) {          \
-                               if (np[i])                      \
+                               if (np[i])      {               \
+count##TPE##IMP: \
                                        ANALYTICAL_COUNT_FIXED_##IMP(TPE); \
+                               } \
                        }                                               \
                }       \
-               i = cnt;                        \
-               ANALYTICAL_COUNT_FIXED_##IMP(TPE);      \
+               if (!last) { \
+                       last = true; \
+                       i = cnt; \
+                       goto count##TPE##IMP; \
+               } \
        } while (0)
 
 #ifdef HAVE_HGE
@@ -1315,12 +1331,17 @@ ANALYTICAL_MIN_MAX(max, MAX, <)
                default: {                                                      
\
                        if (p) {                                                
\
                                for (; i < cnt; i++) {                  \
-                                       if (np[i])                      \
-                                               ANALYTICAL_COUNT_OTHERS_##IMP; \
+                                       if (np[i])      {               \
+countothers##IMP: \
+                                               ANALYTICAL_COUNT_OTHERS_##IMP;  
\
+                                       } \
                                }                                               
\
                        }       \
-                       i = cnt;                                \
-                       ANALYTICAL_COUNT_OTHERS_##IMP;  \
+                       if (!last) { \
+                               last = true; \
+                               i = cnt; \
+                               goto countothers##IMP; \
+                       } \
                }                                                               
\
                }                                                               
\
        } while (0)
@@ -1339,6 +1360,7 @@ GDKanalyticalcount(BAT *r, BAT *p, BAT *
        BATiter bpi = bat_iterator(b);
        void *segment_tree = NULL;
        gdk_return res = GDK_SUCCEED;
+       bool last = false;
 
        if (cnt > 0) {
                switch (frame_type) {
@@ -1511,12 +1533,17 @@ cleanup:
                TPE2 *restrict rb = (TPE2*)Tloc(r, 0); \
                if (p) {                                        \
                        for (; i < cnt; i++) {          \
-                               if (np[i])                      \
+                               if (np[i])      {               \
+sum##TPE1##TPE2##IMP: \
                                        IMP(TPE1, TPE2);        \
-                       }                                               \
+                               } \
+                       }       \
                }       \
-               i = cnt;                                        \
-               IMP(TPE1, TPE2);        \
+               if (!last) { \
+                       last = true; \
+                       i = cnt; \
+                       goto sum##TPE1##TPE2##IMP; \
+               } \
        } while (0)
 
 #ifdef HAVE_HGE
@@ -1646,6 +1673,7 @@ GDKanalyticalsumothers(BAT *r, BAT *p, b
        BUN nils = 0;
        void *segment_tree = NULL;
        gdk_return res = GDK_SUCCEED;
+       bool last = false;
 
        ANALYTICAL_SUM_BRANCHES(OTHERS);
 
@@ -1673,6 +1701,7 @@ GDKanalyticalsum(BAT *r, BAT *p, BAT *o,
        bit *np = p ? Tloc(p, 0) : NULL, *op = o ? Tloc(o, 0) : NULL;
        int abort_on_error = 1;
        BUN nils = 0;
+       bool last = false;
 
        if (cnt > 0) {
                switch (frame_type) {
@@ -2017,12 +2046,17 @@ GDKanalyticalsum(BAT *r, BAT *p, BAT *o,
                TPE2 *restrict rb = (TPE2*)Tloc(r, 0); \
                if (p) {                                        \
                        for (; i < cnt; i++) {          \
-                               if (np[i])                      \
+                               if (np[i])      {               \
+prod##TPE1##TPE2##IMP: \
                                        IMP(TPE1, TPE2, TPE3_OR_REAL_IMP);      
\
+                               } \
                        }                                               \
                }       \
-               i = cnt;                                        \
-               IMP(TPE1, TPE2, TPE3_OR_REAL_IMP);      \
+               if (!last) { \
+                       last = true; \
+                       i = cnt; \
+                       goto prod##TPE1##TPE2##IMP; \
+               } \
        } while (0)
 
 #ifdef HAVE_HGE
@@ -2173,6 +2207,7 @@ GDKanalyticalprod(BAT *r, BAT *p, BAT *o
        BUN nils = 0;
        void *segment_tree = NULL;
        gdk_return res = GDK_SUCCEED;
+       bool last = false;
 
        if (cnt > 0) {
                switch (frame_type) {
@@ -2221,16 +2256,16 @@ nosupport:
 #endif
 
 /* average on integers */
-#define ANALYTICAL_AVERAGE_CALC_NUM_STEP1(TPE, IMP, PART, ARG) \
+#define ANALYTICAL_AVERAGE_CALC_NUM_STEP1(TPE, IMP, ARG) \
        if (!is_##TPE##_nil(ARG)) {             \
-               ADD_WITH_CHECK(ARG, sum, LNG_HGE, sum, GDK_LNG_HGE_max, goto 
avg_overflow##TPE##IMP##PART); \
+               ADD_WITH_CHECK(ARG, sum, LNG_HGE, sum, GDK_LNG_HGE_max, goto 
avg_overflow##TPE##IMP); \
                /* count only when no overflow occurs */ \
                n++;                            \
        }
 
-#define ANALYTICAL_AVERAGE_CALC_NUM_STEP2(TPE, IMP, PART) \
+#define ANALYTICAL_AVERAGE_CALC_NUM_STEP2(TPE, IMP) \
                        if (0) {                                        \
-avg_overflow##TPE##IMP##PART:                                                  
\
+avg_overflow##TPE##IMP:                                                        
\
                                assert(n > 0);                          \
                                if (sum >= 0) {                         \
                                        a = (TPE) (sum / n);            \
@@ -2245,15 +2280,15 @@ avg_overflow##TPE##IMP##PART:                           
                        \
                                        }                               \
                                }
 
-#define ANALYTICAL_AVG_IMP_NUM_UNBOUNDED_TILL_CURRENT_ROW(TPE, IMP, PART) \
+#define ANALYTICAL_AVG_IMP_NUM_UNBOUNDED_TILL_CURRENT_ROW(TPE, IMP) \
        do { \
                TPE a = 0; \
                dbl curval = dbl_nil;   \
                for (; k < i;) { \
                        j = k; \
                        do {    \
-                               ANALYTICAL_AVERAGE_CALC_NUM_STEP1(TPE, IMP, 
PART, bp[k]) \
-                               ANALYTICAL_AVERAGE_CALC_NUM_STEP2(TPE, IMP, 
PART) \
+                               ANALYTICAL_AVERAGE_CALC_NUM_STEP1(TPE, IMP, 
bp[k]) \
+                               ANALYTICAL_AVERAGE_CALC_NUM_STEP2(TPE, IMP) \
                                        while (k < i && !op[k]) { \
                                                TPE v = bp[k++];                
        \
                                                if (is_##TPE##_nil(v))          
\
@@ -2261,12 +2296,12 @@ avg_overflow##TPE##IMP##PART:                           
                        \
                                                AVERAGE_ITER(TPE, v, a, rr, n); 
\
                                        }                                       
\
                                        curval = a + (dbl) rr / n;              
\
-                                       goto calc_done##TPE##IMP##PART;         
        \
+                                       goto calc_done##TPE##IMP;               
        \
                                }                                               
\
                                k++; \
                        } while (k < i && !op[k]);      \
                        curval = n > 0 ? (dbl) sum / n : dbl_nil;       \
-calc_done##TPE##IMP##PART: \
+calc_done##TPE##IMP: \
                        for (; j < k; j++) \
                                rb[j] = curval; \
                        has_nils |= (n == 0);           \
@@ -2275,14 +2310,14 @@ calc_done##TPE##IMP##PART: \
                sum = 0;                        \
        } while (0)
 
-#define ANALYTICAL_AVG_IMP_NUM_CURRENT_ROW_TILL_UNBOUNDED(TPE, IMP, PART) \
+#define ANALYTICAL_AVG_IMP_NUM_CURRENT_ROW_TILL_UNBOUNDED(TPE, IMP) \
        do { \
                TPE a = 0; \
                dbl curval = dbl_nil;   \
                l = i - 1; \
                for (j = l; ; j--) { \
-                       ANALYTICAL_AVERAGE_CALC_NUM_STEP1(TPE, IMP, PART, 
bp[j]) \
-                       ANALYTICAL_AVERAGE_CALC_NUM_STEP2(TPE, IMP, PART) \
+                       ANALYTICAL_AVERAGE_CALC_NUM_STEP1(TPE, IMP, bp[j]) \
+                       ANALYTICAL_AVERAGE_CALC_NUM_STEP2(TPE, IMP) \
                                while (!(op[j] || j == k)) { \
                                        TPE v = bp[j--];                        
\
                                        if (is_##TPE##_nil(v))          \
@@ -2290,11 +2325,11 @@ calc_done##TPE##IMP##PART: \
                                        AVERAGE_ITER(TPE, v, a, rr, n); \
                                }                                       \
                                curval = a + (dbl) rr / n;              \
-                               goto calc_done##TPE##IMP##PART;                 
\
+                               goto calc_done##TPE##IMP;                       
\
                        }       \
                        if (op[j] || j == k) {  \
                                curval = n > 0 ? (dbl) sum / n : dbl_nil;       
\
-calc_done##TPE##IMP##PART: \
+calc_done##TPE##IMP: \
                                for (; ; l--) { \
                                        rb[l] = curval; \
                                        if (l == j)     \
@@ -2311,13 +2346,13 @@ calc_done##TPE##IMP##PART: \
                k = i; \
        } while (0)
 
-#define ANALYTICAL_AVG_IMP_NUM_ALL_ROWS(TPE, IMP, PART)        \
+#define ANALYTICAL_AVG_IMP_NUM_ALL_ROWS(TPE, IMP)      \
        do { \
                TPE a = 0; \
                for (; j < i; j++) { \
                        TPE v = bp[j]; \
-                       ANALYTICAL_AVERAGE_CALC_NUM_STEP1(TPE, IMP, PART, v) \
-                       ANALYTICAL_AVERAGE_CALC_NUM_STEP2(TPE, IMP, PART) \
+                       ANALYTICAL_AVERAGE_CALC_NUM_STEP1(TPE, IMP, v) \
+                       ANALYTICAL_AVERAGE_CALC_NUM_STEP2(TPE, IMP) \
                                for (; j < i; j++) { \
                                        v = bp[j];                      \
                                        if (is_##TPE##_nil(v))          \
@@ -2325,11 +2360,11 @@ calc_done##TPE##IMP##PART: \
                                        AVERAGE_ITER(TPE, v, a, rr, n); \
                                }                                       \
                                curval = a + (dbl) rr / n;              \
-                               goto calc_done##TPE##IMP##PART;                 
\
+                               goto calc_done##TPE##IMP;                       
\
                        }       \
                } \
                curval = n > 0 ? (dbl) sum / n : dbl_nil;       \
-calc_done##TPE##IMP##PART: \
+calc_done##TPE##IMP: \
                for (; k < i; k++) \
                        rb[k] = curval; \
                has_nils |= (n == 0);           \
@@ -2337,7 +2372,7 @@ calc_done##TPE##IMP##PART: \
                sum = 0;                        \
        } while (0)
 
-#define ANALYTICAL_AVG_IMP_NUM_CURRENT_ROW(TPE, IMP, PART)     \
+#define ANALYTICAL_AVG_IMP_NUM_CURRENT_ROW(TPE, IMP)   \
        do { \
                for (; k < i; k++) { \
                        TPE v = bp[k]; \
_______________________________________________
checkin-list mailing list
checkin-list@monetdb.org
https://www.monetdb.org/mailman/listinfo/checkin-list

Reply via email to