Changeset: 5310f283ed32 for MonetDB
URL: https://dev.monetdb.org/hg/MonetDB?cmd=changeset;node=5310f283ed32
Modified Files:
        gdk/gdk_hash.c
        gdk/gdk_imprints.c
        gdk/gdk_orderidx.c
        gdk/gdk_tracer.h
        monetdb5/modules/mal/wlc.c
        monetdb5/optimizer/opt_wlc.c
        sql/backends/monet5/wlr.c
Branch: gdk_tracer
Log Message:

attempt to fix windows build


diffs (truncated from 348 to 300 lines):

diff --git a/gdk/gdk_hash.c b/gdk/gdk_hash.c
--- a/gdk/gdk_hash.c
+++ b/gdk/gdk_hash.c
@@ -127,7 +127,7 @@ HASHnew(Hash *h, int tpe, BUN size, BUN 
        ((size_t *) h->heap.base)[3] = width;
        ((size_t *) h->heap.base)[4] = count;
        ((size_t *) h->heap.base)[5] = 0; /* # filled slots (chain heads) */
-       TRC_DEBUG(ACCEL, "Create hash(size " BUNFMT ", mask " BUNFMT ", width 
%d, total " BUNFMT " bytes);\n", size, mask, width, (size + mask) * width);
+       TRC_DEBUG(ACCELERATOR, "Create hash(size " BUNFMT ", mask " BUNFMT ", 
width %d, total " BUNFMT " bytes);\n", size, mask, width, (size + mask) * 
width);
        return GDK_SUCCEED;
 }
 
@@ -172,13 +172,9 @@ BATcheckhash(BAT *b)
        /* we don't need the lock just to read the value b->thash */
        if (b->thash == (Hash *) 1) {
                /* but when we want to change it, we need the lock */
-               /* CHECK */
-               // This is in ACCELDEBUG
-               TRC_DEBUG_IF(ACCEL) t = GDKusec();
+               TRC_DEBUG_IF(ACCELERATOR) t = GDKusec();
                MT_lock_set(&b->batIdxLock);
-               /* CHECK */
-               // This is in ACCELDEBUG
-               TRC_DEBUG_IF(ACCEL) t = GDKusec() - t;
+               TRC_DEBUG_IF(ACCELERATOR) t = GDKusec() - t;
                /* if still 1 now that we have the lock, we can update */
                if (b->thash == (Hash *) 1) {
                        Hash *h;
@@ -238,7 +234,7 @@ BATcheckhash(BAT *b)
                                                        TYPE_oid,
                                                        &(oid){h->mask + 1});
                                                b->thash = h;
-                                               TRC_DEBUG(ACCEL, "Reusing 
persisted hash %s\n", BATgetId(b));
+                                               TRC_DEBUG(ACCELERATOR, "Reusing 
persisted hash %s\n", BATgetId(b));
                                                MT_lock_unset(&b->batIdxLock);
                                                return true;
                                        }
@@ -253,7 +249,7 @@ BATcheckhash(BAT *b)
                MT_lock_unset(&b->batIdxLock);
        }
        ret = b->thash != NULL;
-       TRC_DEBUG_IF(ACCEL) if (ret) TRC_DEBUG_ENDIF(ACCEL, "Already has hash 
%s, waited " LLFMT " usec\n", BATgetId(b), t);
+       TRC_DEBUG_IF(ACCELERATOR) if (ret) TRC_DEBUG_ENDIF(ACCELERATOR, 
"Already has hash %s, waited " LLFMT " usec\n", BATgetId(b), t);
        return ret;
 }
 
@@ -266,9 +262,7 @@ BAThashsync(void *arg)
        lng t0 = 0;
        const char *failed = " failed";
 
-       /* CHECK */
-       // This is in ACCELDEBUG
-       TRC_DEBUG_IF(ACCEL) t0 = GDKusec();
+       TRC_DEBUG_IF(ACCELERATOR) t0 = GDKusec();
 
        /* we could check whether b->thash == NULL before getting the
         * lock, and only lock if it isn't; however, it's very
@@ -311,7 +305,7 @@ BAThashsync(void *arg)
                                        failed = ""; /* not failed */
                                }
                        }
-                       TRC_DEBUG(ACCEL, "Persisting hash %s (" LLFMT " 
usec)%s\n", hp->filename, GDKusec() - t0, failed);
+                       TRC_DEBUG(ACCELERATOR, "Persisting hash %s (" LLFMT " 
usec)%s\n", hp->filename, GDKusec() - t0, failed);
                }
        }
        MT_lock_unset(&b->batIdxLock);
@@ -371,16 +365,16 @@ BAThash_impl(BAT *b, BAT *s, const char 
        BATiter bi = bat_iterator(b);
        PROPrec *prop;
 
-       TRC_DEBUG_IF(ACCEL) t0 = GDKusec();
-       TRC_DEBUG_IF(ACCEL) TRC_DEBUG_ENDIF(ACCEL, "Create hash(" ALGOBATFMT 
");\n", ALGOBATPAR(b));
+       TRC_DEBUG_IF(ACCELERATOR) t0 = GDKusec();
+       TRC_DEBUG_IF(ACCELERATOR) TRC_DEBUG_ENDIF(ACCELERATOR, "Create hash(" 
ALGOBATFMT ");\n", ALGOBATPAR(b));
 
        if (b->ttype == TYPE_void) {
                if (is_oid_nil(b->tseqbase)) {
-                       TRC_DEBUG(ACCEL, "Cannot create hash-table on void-NIL 
column.\n");
+                       TRC_DEBUG(ACCELERATOR, "Cannot create hash-table on 
void-NIL column.\n");
                        GDKerror("BAThash: no hash on void/nil column\n");
                        return NULL;
                }
-               TRC_DEBUG(ACCEL, "Creating hash-table on void column..\n");
+               TRC_DEBUG(ACCELERATOR, "Creating hash-table on void 
column..\n");
 
                tpe = TYPE_void;
        }
@@ -487,8 +481,8 @@ BAThash_impl(BAT *b, BAT *s, const char 
                        }
                        break;
                }
-               TRC_DEBUG_IF(ACCEL) if (p < cnt1)
-                       TRC_DEBUG_ENDIF(ACCEL, "BAThash(%s): Abort starthash 
with mask " BUNFMT 
+               TRC_DEBUG_IF(ACCELERATOR) if (p < cnt1)
+                       TRC_DEBUG_ENDIF(ACCELERATOR, "BAThash(%s): Abort 
starthash with mask " BUNFMT 
                                                        " at " BUNFMT "\n", 
BATgetId(b), mask, p);
                if (p == cnt1 || mask == maxmask)
                        break;
@@ -552,8 +546,8 @@ BAThash_impl(BAT *b, BAT *s, const char 
                b->tkey = true;
                b->batDirtydesc = true;
        }
-       TRC_DEBUG_IF(ACCEL) {
-               TRC_DEBUG_ENDIF(ACCEL, "Hash construction " LLFMT " usec\n", 
GDKusec() - t0);
+       TRC_DEBUG_IF(ACCELERATOR) {
+               TRC_DEBUG_ENDIF(ACCELERATOR, "Hash construction " LLFMT " 
usec\n", GDKusec() - t0);
                HASHcollisions(b, h);
        }
        return h;
@@ -587,7 +581,7 @@ BAThash(BAT *b)
                        }
                        return GDK_SUCCEED;
                } else
-                       TRC_DEBUG(ACCEL, "NOT persisting hash %d\n", 
b->batCacheid);
+                       TRC_DEBUG(ACCELERATOR, "NOT persisting hash %d\n", 
b->batCacheid);
 #endif
        }
        MT_lock_unset(&b->batIdxLock);
@@ -658,8 +652,8 @@ HASHdestroy(BAT *b)
                                hp = BBP_cache(p);
 
                        if (!hp || hs != hp->thash) {
-                               TRC_DEBUG_IF(ACCEL) if (*(size_t *) 
hs->heap.base & (1 << 24))
-                                       TRC_DEBUG_ENDIF(ACCEL, "Removing 
persisted hash %d\n", b->batCacheid);
+                               TRC_DEBUG_IF(ACCELERATOR) if (*(size_t *) 
hs->heap.base & (1 << 24))
+                                       TRC_DEBUG_ENDIF(ACCELERATOR, "Removing 
persisted hash %d\n", b->batCacheid);
                                HEAPfree(&hs->heap, true);
                                GDKfree(hs);
                        }
diff --git a/gdk/gdk_imprints.c b/gdk/gdk_imprints.c
--- a/gdk/gdk_imprints.c
+++ b/gdk/gdk_imprints.c
@@ -251,7 +251,7 @@ BATcheckimprints(BAT *b)
                                                close(fd);
                                                imprints->imprints.parentid = 
b->batCacheid;
                                                b->timprints = imprints;
-                                               TRC_DEBUG(ACCEL, 
"BATcheckimprints(" ALGOBATFMT "): reusing persisted imprints\n", 
ALGOBATPAR(b));
+                                               TRC_DEBUG(ACCELERATOR, 
"BATcheckimprints(" ALGOBATFMT "): reusing persisted imprints\n", 
ALGOBATPAR(b));
                                                MT_lock_unset(&b->batIdxLock);
 
                                                return true;
@@ -267,7 +267,7 @@ BATcheckimprints(BAT *b)
                MT_lock_unset(&b->batIdxLock);
        }
        ret = b->timprints != NULL;
-       TRC_DEBUG_IF(ACCEL) if (ret) TRC_DEBUG_ENDIF(ACCEL, "BATcheckimprints(" 
ALGOBATFMT "): already has imprints\n", ALGOBATPAR(b));
+       TRC_DEBUG_IF(ACCELERATOR) if (ret) TRC_DEBUG_ENDIF(ACCELERATOR, 
"BATcheckimprints(" ALGOBATFMT "): already has imprints\n", ALGOBATPAR(b));
        return ret;
 }
 
@@ -280,9 +280,7 @@ BATimpsync(void *arg)
        lng t0 = 0;
        const char *failed = " failed";
 
-       /* CHECK */
-       // This is defined in ACCELDEBUG
-       TRC_DEBUG_IF(ACCEL) t0 = GDKusec();
+       TRC_DEBUG_IF(ACCELERATOR) t0 = GDKusec();
 
        MT_lock_set(&b->batIdxLock);
        if ((imprints = b->timprints) != NULL) {
@@ -326,7 +324,7 @@ BATimpsync(void *arg)
                                        failed = ""; /* not failed */
                                }
                        }
-                       TRC_DEBUG(ACCEL, "BATimpsync(" ALGOBATFMT "): "
+                       TRC_DEBUG(ACCELERATOR, "BATimpsync(" ALGOBATFMT "): "
                                                "imprints persisted "
                                                "(" LLFMT " usec)%s\n", 
ALGOBATPAR(b),
                                                GDKusec() - t0, failed);
@@ -379,7 +377,7 @@ BATimprints(BAT *b)
 
        /* CHECK */
        // This is defined in ACCELDEBUG
-       TRC_DEBUG_IF(ACCEL) t0 = GDKusec();
+       TRC_DEBUG_IF(ACCELERATOR) t0 = GDKusec();
 
        if (b->timprints == NULL) {
                BUN cnt;
@@ -388,14 +386,14 @@ BATimprints(BAT *b)
 
                MT_lock_unset(&b->batIdxLock);
 
-               TRC_DEBUG_IF(ACCEL) {
+               TRC_DEBUG_IF(ACCELERATOR) {
                        if (s2)
-                               TRC_DEBUG_ENDIF(ACCEL, "BATimprints(b=" 
ALGOBATFMT
+                               TRC_DEBUG_ENDIF(ACCELERATOR, "BATimprints(b=" 
ALGOBATFMT
                                                "): creating imprints on parent 
"
                                                ALGOBATFMT "\n",
                                                ALGOBATPAR(s2), ALGOBATPAR(b));
                        else
-                               TRC_DEBUG_ENDIF(ACCEL, "BATimprints(b=" 
ALGOBATFMT
+                               TRC_DEBUG_ENDIF(ACCELERATOR, "BATimprints(b=" 
ALGOBATFMT
                                                "): creating imprints\n",
                                                ALGOBATPAR(b));
                }
@@ -555,7 +553,7 @@ BATimprints(BAT *b)
                }
        }
 
-       TRC_DEBUG(ACCEL, "BATimprints(%s): imprints construction " LLFMT " 
usec\n", BATgetId(b), GDKusec() - t0);
+       TRC_DEBUG(ACCELERATOR, "BATimprints(%s): imprints construction " LLFMT 
" usec\n", BATgetId(b), GDKusec() - t0);
        MT_lock_unset(&b->batIdxLock);
 
        /* BBPUnfix tries to get the imprints lock which might lead to
diff --git a/gdk/gdk_orderidx.c b/gdk/gdk_orderidx.c
--- a/gdk/gdk_orderidx.c
+++ b/gdk/gdk_orderidx.c
@@ -22,9 +22,7 @@ BATidxsync(void *arg)
        lng t0 = 0;
        const char *failed = " failed";
 
-       /* CHECK */
-       // This is in ACCEL DEBUG
-       TRC_DEBUG_IF(ACCEL) t0 = GDKusec();
+       TRC_DEBUG_IF(ACCELERATOR) t0 = GDKusec();
 
        MT_lock_set(&b->batIdxLock);
        if ((hp = b->torderidx) != NULL) {
@@ -59,7 +57,7 @@ BATidxsync(void *arg)
                                        failed = ""; /* not failed */
                                }
                        }
-                       TRC_DEBUG(ACCEL, "BATidxsync(%s): orderidx persisted"
+                       TRC_DEBUG(ACCELERATOR, "BATidxsync(%s): orderidx 
persisted"
                                                " (" LLFMT " usec)%s\n",
                                                BATgetId(b), GDKusec() - t0, 
failed);
                }
@@ -79,9 +77,7 @@ BATcheckorderidx(BAT *b)
 
        if (b == NULL)
                return false;
-       /* CHECK */
-       // This is in DEBUG ACCEL
-       TRC_DEBUG_IF(ACCEL) t = GDKusec();
+       TRC_DEBUG_IF(ACCELERATOR) t = GDKusec();
        assert(b->batCacheid > 0);
        /* we don't need the lock just to read the value b->torderidx */
        if (b->torderidx == (Heap *) 1) {
@@ -118,7 +114,7 @@ BATcheckorderidx(BAT *b)
                                            HEAPload(hp, nme, "torderidx", 
false) == GDK_SUCCEED) {
                                                close(fd);
                                                b->torderidx = hp;
-                                               TRC_DEBUG(ACCEL, 
"BATcheckorderidx(" ALGOBATFMT "): reusing persisted orderidx\n", 
ALGOBATPAR(b));
+                                               TRC_DEBUG(ACCELERATOR, 
"BATcheckorderidx(" ALGOBATFMT "): reusing persisted orderidx\n", 
ALGOBATPAR(b));
                                                MT_lock_unset(&b->batIdxLock);
                                                return true;
                                        }
@@ -133,9 +129,7 @@ BATcheckorderidx(BAT *b)
                MT_lock_unset(&b->batIdxLock);
        }
        ret = b->torderidx != NULL;
-       /* CHECK */
-       // The if statement in in ACCEL DEBUG
-       TRC_DEBUG_IF(ACCEL) if (ret) TRC_DEBUG_ENDIF(ACCEL, "BATcheckorderidx(" 
ALGOBATFMT "): already has orderidx, waited " LLFMT " usec\n", ALGOBATPAR(b), 
GDKusec() - t);
+       TRC_DEBUG_IF(ACCELERATOR) if (ret) TRC_DEBUG_ENDIF(ACCELERATOR, 
"BATcheckorderidx(" ALGOBATFMT "): already has orderidx, waited " LLFMT " 
usec\n", ALGOBATPAR(b), GDKusec() - t);
        return ret;
 }
 
@@ -182,7 +176,7 @@ persistOIDX(BAT *b)
                                     MT_THR_DETACHED, name) < 0)
                        BBPunfix(b->batCacheid);
        } else
-               TRC_DEBUG(ACCEL, "persistOIDX(" ALGOBATFMT "): NOT persisting 
order index\n", ALGOBATPAR(b));
+               TRC_DEBUG(ACCELERATOR, "persistOIDX(" ALGOBATFMT "): NOT 
persisting order index\n", ALGOBATPAR(b));
 #else
        (void) b;
 #endif
@@ -195,7 +189,7 @@ BATorderidx(BAT *b, bool stable)
                return GDK_SUCCEED;
        if (!BATtdense(b)) {
                BAT *on;
-               TRC_DEBUG(ACCEL, "BATorderidx(" ALGOBATFMT ",%d) create 
index\n", ALGOBATPAR(b), stable);
+               TRC_DEBUG(ACCELERATOR, "BATorderidx(" ALGOBATFMT ",%d) create 
index\n", ALGOBATPAR(b), stable);
                if (BATsort(NULL, &on, NULL, b, NULL, NULL, false, false, 
stable) != GDK_SUCCEED)
                        return GDK_FAIL;
                assert(BATcount(b) == BATcount(on));
@@ -365,7 +359,7 @@ GDKmergeidx(BAT *b, BAT**a, int n_ar)
                         ATOMname(b->ttype));
                return GDK_FAIL;
        }
-       TRC_DEBUG(ACCEL, "GDKmergeidx(" ALGOBATFMT ") create index\n", 
ALGOBATPAR(b));
+       TRC_DEBUG(ACCELERATOR, "GDKmergeidx(" ALGOBATFMT ") create index\n", 
ALGOBATPAR(b));
        MT_lock_set(&b->batIdxLock);
        if (b->torderidx) {
                MT_lock_unset(&b->batIdxLock);
@@ -493,7 +487,7 @@ GDKmergeidx(BAT *b, BAT**a, int n_ar)
                                     MT_THR_DETACHED, name) < 0)
                        BBPunfix(b->batCacheid);
        } else
-               TRC_DEBUG(ACCEL, "GDKmergeidx(%s): NOT persisting index\n", 
BATgetId(b));
+               TRC_DEBUG(ACCELERATOR, "GDKmergeidx(%s): NOT persisting 
index\n", BATgetId(b));
 #endif
 
        b->batDirtydesc = true;
diff --git a/gdk/gdk_tracer.h b/gdk/gdk_tracer.h
--- a/gdk/gdk_tracer.h
+++ b/gdk/gdk_tracer.h
@@ -119,7 +119,7 @@ typedef enum {
_______________________________________________
checkin-list mailing list
[email protected]
https://www.monetdb.org/mailman/listinfo/checkin-list

Reply via email to