Changeset: d1d06e1336c5 for MonetDB
URL: http://dev.monetdb.org/hg/MonetDB?cmd=changeset;node=d1d06e1336c5
Modified Files:
        clients/Tests/exports.stable.out
        gdk/gdk.h
        gdk/gdk_imprints.c
        gdk/gdk_project.c
        monetdb5/modules/mal/projectionpath.c
        sql/server/rel_optimizer.c
Branch: rdf
Log Message:

More merge with default


diffs (truncated from 1023 to 300 lines):

diff --git a/clients/Tests/exports.stable.out b/clients/Tests/exports.stable.out
--- a/clients/Tests/exports.stable.out
+++ b/clients/Tests/exports.stable.out
@@ -154,6 +154,7 @@ gdk_return BATprintcolumns(stream *s, in
 gdk_return BATprintf(stream *f, BAT *b);
 gdk_return BATprod(void *res, int tp, BAT *b, BAT *s, int skip_nils, int 
abort_on_error, int nil_if_empty);
 BAT *BATproject(BAT *l, BAT *r);
+BAT *BATprojectchain(BAT **bats);
 gdk_return BATrangejoin(BAT **r1p, BAT **r2p, BAT *l, BAT *rl, BAT *rh, BAT 
*sl, BAT *sr, int li, int hi, BUN estimate);
 gdk_return BATreplace(BAT *b, BAT *p, BAT *n, bit force);
 void BATroles(BAT *b, const char *hnme, const char *tnme);
diff --git a/gdk/gdk.h b/gdk/gdk.h
--- a/gdk/gdk.h
+++ b/gdk/gdk.h
@@ -2969,6 +2969,7 @@ gdk_export gdk_return BATjoin(BAT **r1p,
 gdk_export gdk_return BATbandjoin(BAT **r1p, BAT **r2p, BAT *l, BAT *r, BAT 
*sl, BAT *sr, const void *c1, const void *c2, int li, int hi, BUN estimate);
 gdk_export gdk_return BATrangejoin(BAT **r1p, BAT **r2p, BAT *l, BAT *rl, BAT 
*rh, BAT *sl, BAT *sr, int li, int hi, BUN estimate);
 gdk_export BAT *BATproject(BAT *l, BAT *r);
+gdk_export BAT *BATprojectchain(BAT **bats);
 
 gdk_export BAT *BATslice(BAT *b, BUN low, BUN high);
 
diff --git a/gdk/gdk_imprints.c b/gdk/gdk_imprints.c
--- a/gdk/gdk_imprints.c
+++ b/gdk/gdk_imprints.c
@@ -31,372 +31,110 @@
        }                                       \
 } while (0)
 
-/* binary search */
-#define check(Z,X,W) if ((X) >= bins[W] && (X) < bins[W+1]) (Z) = W;
-#define left(Z,X,W)  if ((X) < bins[W+1])
-#define right(Z,X,W) if ((X) >= bins[W])
 
-#define GETBIN64(Z,X)                                          \
-       right(Z,X,32) {                                         \
-               right(Z,X,48) {                                 \
-                       right(Z,X,56) {                         \
-                               right(Z,X,60){                  \
-                                       right(Z,X,62) {         \
-                                               Z = 62;         \
-                                               right(Z,X,63) { \
-                                                       Z = 63; \
-                                               }               \
-                                       }                       \
-                                       check(Z,X,61)           \
-                                       left(Z,X,60) {          \
-                                               Z = 60;         \
-                                       }                       \
-                               }                               \
-                               check(Z,X,59)                   \
-                               left(Z,X,58) {                  \
-                                       right(Z,X,58) {         \
-                                               Z = 58;         \
-                                       }                       \
-                                       check(Z,X,57)           \
-                                       left(Z,X,56) {          \
-                                               Z = 56;         \
-                                       }                       \
-                               }                               \
-                       }                                       \
-                       check(Z,X,55)                           \
-                       left(Z,X,54) {                          \
-                               right(Z,X,52){                  \
-                                       right(Z,X,54) {         \
-                                               Z = 54;         \
-                                       }                       \
-                                       check(Z,X,53)           \
-                                       left(Z,X,52) {          \
-                                               Z = 52;         \
-                                       }                       \
-                               }                               \
-                               check(Z,X,51)                   \
-                               left(Z,X,50) {                  \
-                                       right(Z,X,50) {         \
-                                               Z = 50;         \
-                                       }                       \
-                                       check(Z,X,49)           \
-                                       left(Z,X,48) {          \
-                                               Z = 48;         \
-                                       }                       \
-                               }                               \
-                       }                                       \
-               }                                               \
-               check(Z,X,47)                                   \
-               left(Z,X,46) {                                  \
-                       right(Z,X,40) {                         \
-                               right(Z,X,44){                  \
-                                       right(Z,X,46) {         \
-                                               Z = 46;         \
-                                       }                       \
-                                       check(Z,X,45)           \
-                                       left(Z,X,44) {          \
-                                               Z = 44;         \
-                                       }                       \
-                               }                               \
-                               check(Z,X,43)                   \
-                               left(Z,X,42) {                  \
-                                       right(Z,X,42) {         \
-                                               Z = 42;         \
-                                       }                       \
-                                       check(Z,X,41)           \
-                                       left(Z,X,40) {          \
-                                               Z = 40;         \
-                                       }                       \
-                               }                               \
-                       }                                       \
-                       check(Z,X,39)                           \
-                       left(Z,X,38) {                          \
-                               right(Z,X,36){                  \
-                                       right(Z,X,38) {         \
-                                               Z = 38;         \
-                                       }                       \
-                                       check(Z,X,37)           \
-                                       left(Z,X,36) {          \
-                                               Z = 36;         \
-                                       }                       \
-                               }                               \
-                               check(Z,X,35)                   \
-                               left(Z,X,34) {                  \
-                                       right(Z,X,34) {         \
-                                               Z = 34;         \
-                                       }                       \
-                                       check(Z,X,33)           \
-                                       left(Z,X,32) {          \
-                                               Z = 32;         \
-                                       }                       \
-                               }                               \
-                       }                                       \
-               }                                               \
-       }                                                       \
-       check(Z,X,31)                                           \
-       left(Z,X,30) {                                          \
-               right(Z,X,16) {                                 \
-                       right(Z,X,24) {                         \
-                               right(Z,X,28){                  \
-                                       right(Z,X,30) {         \
-                                               Z = 30;         \
-                                       }                       \
-                                       check(Z,X,29)           \
-                                       left(Z,X,28) {          \
-                                               Z = 28;         \
-                                       }                       \
-                               }                               \
-                               check(Z,X,27)                   \
-                               left(Z,X,26) {                  \
-                                       right(Z,X,26) {         \
-                                               Z = 26;         \
-                                       }                       \
-                                       check(Z,X,25)           \
-                                       left(Z,X,24) {          \
-                                               Z = 24;         \
-                                       }                       \
-                               }                               \
-                       }                                       \
-                       check(Z,X,23)                           \
-                       left(Z,X,22) {                          \
-                               right(Z,X,20){                  \
-                                       right(Z,X,22) {         \
-                                               Z = 22;         \
-                                       }                       \
-                                       check(Z,X,21)           \
-                                       left(Z,X,20) {          \
-                                               Z = 20;         \
-                                       }                       \
-                               }                               \
-                               check(Z,X,19)                   \
-                               left(Z,X,18) {                  \
-                                       right(Z,X,18) {         \
-                                               Z = 18;         \
-                                       }                       \
-                                       check(Z,X,17)           \
-                                       left(Z,X,16) {          \
-                                               Z = 16;         \
-                                       }                       \
-                               }                               \
-                       }                                       \
-               }                                               \
-               check(Z,X,15)                                   \
-               left(Z,X,14) {                                  \
-                       right(Z,X,8) {                          \
-                               right(Z,X,12){                  \
-                                       right(Z,X,14) {         \
-                                               Z = 14;         \
-                                       }                       \
-                                       check(Z,X,13)           \
-                                       left(Z,X,12) {          \
-                                               Z = 12;         \
-                                       }                       \
-                               }                               \
-                               check(Z,X,11)                   \
-                               left(Z,X,10) {                  \
-                                       right(Z,X,10) {         \
-                                               Z = 10;         \
-                                       }                       \
-                                       check(Z,X,9)            \
-                                       left(Z,X,8) {           \
-                                               Z = 8;          \
-                                       }                       \
-                               }                               \
-                       }                                       \
-                       check(Z,X,7)                            \
-                       left(Z,X,6) {                           \
-                               right(Z,X,4){                   \
-                                       right(Z,X,6) {          \
-                                               Z = 6;          \
-                                       }                       \
-                                       check(Z,X,5)            \
-                                       left(Z,X,4) {           \
-                                               Z = 4;          \
-                                       }                       \
-                               }                               \
-                               check(Z,X,3)                    \
-                               left(Z,X,2) {                   \
-                                       right(Z,X,2) {          \
-                                               Z = 2;          \
-                                       }                       \
-                                       check(Z,X,1)            \
-                                       left(Z,X,0) {           \
-                                               Z = 0;          \
-                                       }                       \
-                               }                               \
-                       }                                       \
-               }                                               \
-       }
+/*
+ * bin-finding using "carefully controlled predication"
+ * reduces overall imprints creation time by up to 50%
+ * (i.e., 2x) compared to the original "binary search"
+ */
 
-#define GETBIN32(Z,X)                                  \
-       right(Z,X,16) {                                 \
-               right(Z,X,24) {                         \
-                       right(Z,X,28){                  \
-                               right(Z,X,30) {         \
-                                       Z = 30;         \
-                                       right(Z,X,31) { \
-                                               Z = 31; \
-                                       }               \
-                               }                       \
-                               check(Z,X,29)           \
-                               left(Z,X,28) {          \
-                                       Z = 28;         \
-                               }                       \
-                       }                               \
-                       check(Z,X,27)                   \
-                       left(Z,X,26) {                  \
-                               right(Z,X,26) {         \
-                                       Z = 26;         \
-                               }                       \
-                               check(Z,X,25)           \
-                               left(Z,X,24) {          \
-                                       Z = 24;         \
-                               }                       \
-                       }                               \
-               }                                       \
-               check(Z,X,23)                           \
-               left(Z,X,22) {                          \
-                       right(Z,X,20){                  \
-                               right(Z,X,22) {         \
-                                       Z = 22;         \
-                               }                       \
-                               check(Z,X,21)           \
-                               left(Z,X,20) {          \
-                                       Z = 20;         \
-                               }                       \
-                       }                               \
-                       check(Z,X,19)                   \
-                       left(Z,X,18) {                  \
-                               right(Z,X,18) {         \
-                                       Z = 18;         \
-                               }                       \
-                               check(Z,X,17)           \
-                               left(Z,X,16) {          \
-                                       Z = 16;         \
-                               }                       \
-                       }                               \
-               }                                       \
-       }                                               \
-       check(Z,X,15)                                   \
-       left(Z,X,14) {                                  \
-               right(Z,X,8) {                          \
-                       right(Z,X,12){                  \
-                               right(Z,X,14) {         \
-                                       Z = 14;         \
-                               }                       \
-                               check(Z,X,13)           \
-                               left(Z,X,12) {          \
-                                       Z = 12;         \
-                               }                       \
-                       }                               \
-                       check(Z,X,11)                   \
-                       left(Z,X,10) {                  \
-                               right(Z,X,10) {         \
-                                       Z = 10;         \
-                               }                       \
-                               check(Z,X,9)            \
-                               left(Z,X,8) {           \
-                                       Z = 8;          \
_______________________________________________
checkin-list mailing list
checkin-list@monetdb.org
https://www.monetdb.org/mailman/listinfo/checkin-list

Reply via email to