Changeset: 9435e293444b for MonetDB
URL: http://dev.monetdb.org/hg/MonetDB?cmd=changeset;node=9435e293444b
Added Files:
        gdk/gdk_imprints.c
        gdk/gdk_imprints.h
Branch: default
Log Message:

missing files for imprints.


diffs (truncated from 880 to 300 lines):

diff --git a/gdk/gdk_imprints.c b/gdk/gdk_imprints.c
new file mode 100644
--- /dev/null
+++ b/gdk/gdk_imprints.c
@@ -0,0 +1,822 @@
+/*
+ * The contents of this file are subject to the MonetDB Public License
+ * Version 1.1 (the "License"); you may not use this file except in
+ * compliance with the License. You may obtain a copy of the License at
+ * http://www.monetdb.org/Legal/MonetDBLicense
+ *
+ * Software distributed under the License is distributed on an "AS IS"
+ * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See the
+ * License for the specific language governing rights and limitations
+ * under the License.
+ *
+ * The Original Code is the MonetDB Database System.
+ *
+ * The Initial Developer of the Original Code is CWI.
+ * Portions created by CWI are Copyright (C) 1997-July 2008 CWI.
+ * Copyright August 2008-2012 MonetDB B.V.
+ * All Rights Reserved.
+ */
+
+/*
+ * Implementation for the column imprints index.
+ * See paper:
+ * Column Imprints: A Secondary Index Structure,
+ * L.Sidirourgos and M.Kersten.
+ */
+
+#include "monetdb_config.h"
+#include "gdk.h"
+#include "gdk_private.h"
+#include "gdk_imprints.h"
+
+#define BINSIZE(B, FUNC, T) do {                 \
+       switch (B) {                             \
+               case 8: FUNC(T,8); break;        \
+               case 16: FUNC(T,16); break;      \
+               case 32: FUNC(T,32); break;      \
+               case 64: FUNC(T,64); break;      \
+               default: assert(0); break;       \
+       }                                        \
+} 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; \
+                                       }\
+                               }\
+                       }\
+               }\
+       }
+
+#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)\
_______________________________________________
checkin-list mailing list
checkin-list@monetdb.org
http://mail.monetdb.org/mailman/listinfo/checkin-list

Reply via email to