Changeset: 23dc57b5baaf for MonetDB
URL: https://dev.monetdb.org/hg/MonetDB/rev/23dc57b5baaf
Modified Files:
        clients/Tests/exports.stable.out
Branch: txtsim
Log Message:

merged with default


diffs (truncated from 1782 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
@@ -946,7 +946,6 @@ int getBitConstant(MalBlkPtr mb, bit val
 int getBlockBegin(MalBlkPtr mb, int pc);
 int getBlockExit(MalBlkPtr mb, int pc);
 int getBteConstant(MalBlkPtr mb, bte val);
-Client getClientContext(void);
 int getDblConstant(MalBlkPtr mb, dbl val);
 str getExceptionMessage(const char *);
 str getExceptionMessageAndState(const char *);
diff --git a/clients/examples/C/testcondvar.c b/clients/examples/C/testcondvar.c
--- a/clients/examples/C/testcondvar.c
+++ b/clients/examples/C/testcondvar.c
@@ -12,8 +12,6 @@
 #include "gdk.h"
 #include "gdk_system.h"
 
-#include <assert.h>
-
 #define NN (3)
 
 volatile int timeout = 100; // set this to 0 during interactive debugging
diff --git a/clients/odbc/driver/SQLExecute.c b/clients/odbc/driver/SQLExecute.c
--- a/clients/odbc/driver/SQLExecute.c
+++ b/clients/odbc/driver/SQLExecute.c
@@ -424,9 +424,6 @@ MNDBExecute(ODBCStmt *stmt)
                return SQL_ERROR;
        }
 
-       /* internal state correctness checks */
-       assert(stmt->State == PREPARED0 || stmt->State == EXECUTED0 || 
stmt->ImplRowDescr->descRec != NULL);
-
        assert(stmt->Dbc);
        assert(stmt->Dbc->mid);
        hdl = stmt->hdl;
diff --git a/gdk/gdk_analytic_bounds.c b/gdk/gdk_analytic_bounds.c
--- a/gdk/gdk_analytic_bounds.c
+++ b/gdk/gdk_analytic_bounds.c
@@ -1161,7 +1161,7 @@ GDKanalyticalrangebounds(BAT *r, BAT *b,
                                break;
                        }
                        default:
-                               assert(0);
+                               MT_UNREACHABLE();
                        }
                        if (is_lng_nil(limit) || limit < 0 || 
is_int_nil(int_limit) || int_limit < 0) {
                                goto invalid_bound;
@@ -1446,7 +1446,7 @@ GDKanalyticalwindowbounds(BAT *r, BAT *b
        case 2:
                return GDKanalyticalgroupsbounds(r, b, p, l, bound, tp2, 
preceding);
        default:
-               assert(0);
+               MT_UNREACHABLE();
        }
        GDKerror("42000!unit type %d not supported (this is a bug).\n", unit);
        return GDK_FAIL;
diff --git a/gdk/gdk_bat.c b/gdk/gdk_bat.c
--- a/gdk/gdk_bat.c
+++ b/gdk/gdk_bat.c
@@ -100,55 +100,51 @@ BATcreatedesc(oid hseq, int tt, bool hea
                .batTransient = true,
                .batRestricted = BAT_WRITE,
        };
-       if (heapnames && (bn->theap = GDKmalloc(sizeof(Heap))) == NULL) {
-               GDKfree(bn);
-               return NULL;
-       }
 
-       /*
-        * add to BBP
-        */
-       if (BBPinsert(bn) == 0) {
-               GDKfree(bn->theap);
-               GDKfree(bn);
-               return NULL;
-       }
-       /*
-        * fill in heap names, so HEAPallocs can resort to disk for
-        * very large writes.
-        */
        if (heapnames) {
-               assert(bn->theap != NULL);
+               if ((bn->theap = GDKmalloc(sizeof(Heap))) == NULL) {
+                       GDKfree(bn);
+                       return NULL;
+               }
                *bn->theap = (Heap) {
-                       .parentid = bn->batCacheid,
                        .farmid = BBPselectfarm(role, bn->ttype, offheap),
                        .dirty = true,
                };
 
-               const char *nme = BBP_physical(bn->batCacheid);
-               settailname(bn->theap, nme, tt, width);
-
                if (ATOMneedheap(tt)) {
                        if ((bn->tvheap = GDKmalloc(sizeof(Heap))) == NULL) {
-                               BBPclear(bn->batCacheid);
-                               HEAPfree(bn->theap, true);
                                GDKfree(bn->theap);
                                GDKfree(bn);
                                return NULL;
                        }
                        *bn->tvheap = (Heap) {
-                               .parentid = bn->batCacheid,
                                .farmid = BBPselectfarm(role, bn->ttype, 
varheap),
                                .dirty = true,
                        };
+               }
+       }
+       /*
+        * add to BBP
+        */
+       if (BBPinsert(bn) == 0) {
+               GDKfree(bn->tvheap);
+               GDKfree(bn->theap);
+               GDKfree(bn);
+               return NULL;
+       }
+       if (bn->theap) {
+               bn->theap->parentid = bn->batCacheid;
+               ATOMIC_INIT(&bn->theap->refs, 1);
+               const char *nme = BBP_physical(bn->batCacheid);
+               settailname(bn->theap, nme, tt, width);
+
+               if (bn->tvheap) {
+                       bn->tvheap->parentid = bn->batCacheid;
                        ATOMIC_INIT(&bn->tvheap->refs, 1);
                        strconcat_len(bn->tvheap->filename,
                                      sizeof(bn->tvheap->filename),
                                      nme, ".theap", NULL);
                }
-               ATOMIC_INIT(&bn->theap->refs, 1);
-       } else {
-               assert(bn->theap == NULL);
        }
        char name[MT_NAME_LEN];
        snprintf(name, sizeof(name), "heaplock%d", bn->batCacheid); /* fits */
@@ -918,7 +914,7 @@ COLcopy(BAT *b, int tt, bool writable, r
                                bn->batCapacity = 0;
                } else if (BATatoms[tt].atomFix || tt != TYPE_void || 
ATOMextern(tt)) {
                        /* case (4): one-by-one BUN insert (really slow) */
-                       BUN p, q, r = 0;
+                       BUN p, q;
 
                        BATloop(b, p, q) {
                                const void *t = BUNtail(bi, p);
@@ -926,7 +922,6 @@ COLcopy(BAT *b, int tt, bool writable, r
                                if (bunfastapp_nocheck(bn, t) != GDK_SUCCEED) {
                                        goto bunins_failed;
                                }
-                               r++;
                        }
                        bn->theap->dirty |= bi.count > 0;
                } else if (tt != TYPE_void && bi.type == TYPE_void) {
diff --git a/gdk/gdk_hash.h b/gdk/gdk_hash.h
--- a/gdk/gdk_hash.h
+++ b/gdk/gdk_hash.h
@@ -211,7 +211,7 @@ HASHgetlink(const Hash *h, BUN i)
 #define hash_flt(H,V)  hash_int(H,V)
 #define hash_dbl(H,V)  hash_lng(H,V)
 
-static inline BUN __attribute__((__const__))
+static inline BUN __attribute__((__pure__))
 mix_uuid(const uuid *u)
 {
        ulng u1, u2;
diff --git a/gdk/gdk_imprints.c b/gdk/gdk_imprints.c
--- a/gdk/gdk_imprints.c
+++ b/gdk/gdk_imprints.c
@@ -124,15 +124,15 @@
 #define IMPRINTS_VERSION       2
 #define IMPRINTS_HEADER_SIZE   4 /* nr of size_t fields in header */
 
-#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;      \
-               }                               \
+#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: MT_UNREACHABLE(); break;       \
+               }                                       \
        } while (0)
 
 
@@ -253,7 +253,7 @@ imprints_create(BAT *b, BATiter *bi, voi
                break;
        default:
                /* should never reach here */
-               assert(0);
+               MT_UNREACHABLE();
        }
 
        *dictcnt = dcnt;
@@ -636,7 +636,7 @@ BATimprints(BAT *b)
                        break;
                default:
                        /* should never reach here */
-                       assert(0);
+                       MT_UNREACHABLE();
                }
 
                imprints_create(b, &bi,
@@ -762,9 +762,7 @@ IMPSgetbin(int tpe, bte bits, const char
                break;
        }
        default:
-               assert(0);
-               (void) inbins;
-               break;
+               MT_UNREACHABLE();
        }
        return ret;
 }
diff --git a/gdk/gdk_logger.c b/gdk/gdk_logger.c
--- a/gdk/gdk_logger.c
+++ b/gdk/gdk_logger.c
@@ -300,12 +300,12 @@ string_reader(logger *lg, BAT *b, lng nr
                if (mnstr_readLng(lg->input_log, &SZ) != 1)
                        return LOG_EOF;
                sz = (size_t)SZ;
-               char *buf = lg->buf;
-               if (lg->bufsize < sz) {
-                       if (!(buf = GDKrealloc(lg->buf, sz)))
+               char *buf = lg->rbuf;
+               if (lg->rbufsize < sz) {
+                       if (!(buf = GDKrealloc(lg->rbuf, sz)))
                                return LOG_ERR;
-                       lg->buf = buf;
-                       lg->bufsize = sz;
+                       lg->rbuf = buf;
+                       lg->rbufsize = sz;
                }
 
                if (mnstr_read(lg->input_log, buf, sz, 1) != 1)
@@ -399,8 +399,7 @@ log_read_updates(logger *lg, trans *tr, 
                                                }
                                                else
                                                        res = LOG_ERR;
-                                       }
-                                       else {
+                                       } else {
                                                assert((*cands)->ttype == 
TYPE_oid);
                                                assert(BATcount(*cands) > 0);
                                                if (BATappend(*cands, dense, 
NULL, true) != GDK_SUCCEED)
@@ -410,8 +409,8 @@ log_read_updates(logger *lg, trans *tr, 
                                }
 
                                // We have to read the value to update the read 
cursor
-                               size_t tlen = lg->bufsize;
-                               void *t = rt(lg->buf, &tlen, lg->input_log, 1);
+                               size_t tlen = lg->rbufsize;
+                               void *t = rt(lg->rbuf, &tlen, lg->input_log, 1);
                                if (t == NULL) {
                                        res = LOG_ERR;
                                }
@@ -429,13 +428,13 @@ log_read_updates(logger *lg, trans *tr, 
                }
 
                if (l->flag == LOG_UPDATE_CONST) {
-                       size_t tlen = lg->bufsize;
-                       void *t = rt(lg->buf, &tlen, lg->input_log, 1);
+                       size_t tlen = lg->rbufsize;
+                       void *t = rt(lg->rbuf, &tlen, lg->input_log, 1);
                        if (t == NULL) {
                                res = LOG_ERR;
                        } else {
-                               lg->buf = t;
-                               lg->bufsize = tlen;
+                               lg->rbuf = t;
+                               lg->rbufsize = tlen;
                                for(BUN p = 0; p<(BUN) nr; p++) {
                                        if (r && BUNappend(r, t, true) != 
GDK_SUCCEED)
                                                res = LOG_ERR;
@@ -454,32 +453,32 @@ log_read_updates(logger *lg, trans *tr, 
                                        else
                                                res = LOG_ERR;
                                } else {
-                                       size_t tlen = lg->bufsize/sizeof(int);
+                                       size_t tlen = lg->rbufsize/sizeof(int);
                                        size_t cnt = 0, snr = (size_t)nr;
                                        snr = (snr+31)/32;
                                        assert(tlen);
                                        for (; res == LOG_OK && snr > 0; 
snr-=cnt) {
                                                cnt = snr>tlen?tlen:snr;
-                                               if 
(!mnstr_readIntArray(lg->input_log, lg->buf, cnt))
+                                               if 
(!mnstr_readIntArray(lg->input_log, lg->rbuf, cnt))
                                                        res = LOG_ERR;
                                        }
_______________________________________________
checkin-list mailing list -- [email protected]
To unsubscribe send an email to [email protected]

Reply via email to