Changeset: 953a36261dbd for MonetDB
URL: https://dev.monetdb.org/hg/MonetDB/rev/953a36261dbd
Modified Files:
        gdk/gdk_atoms.c
        gdk/gdk_calc_convert.c
        gdk/gdk_time.c
        monetdb5/mal/mal_profiler.c
        monetdb5/mal/mal_stack.c
        monetdb5/modules/atoms/inet.c
        monetdb5/modules/atoms/json.c
        monetdb5/modules/mal/manifold.c
        monetdb5/modules/mal/tablet.c
        monetdb5/modules/mal/txtsim.c
        sql/backends/monet5/sql_result.c
Branch: resource_management
Log Message:

WIP fix memory leaks


diffs (truncated from 691 to 300 lines):

diff --git a/gdk/gdk_atoms.c b/gdk/gdk_atoms.c
--- a/gdk/gdk_atoms.c
+++ b/gdk/gdk_atoms.c
@@ -402,9 +402,9 @@ ATOMdup(int t, const void *p)
 #define atommem(size)                                  \
        do {                                            \
                if (*dst == NULL || *len < (size)) {    \
-                       GDKfree(*dst);                  \
+                       /*GDKfree(*dst);*/                      \
                        *len = (size);                  \
-                       *dst = GDKmalloc(*len);         \
+                       *dst = ma_alloc(ma, *len);              \
                        if (*dst == NULL) {             \
                                *len = 0;               \
                                return -1;              \
@@ -418,6 +418,8 @@ ATOMdup(int t, const void *p)
 ssize_t                                                                        
\
 TYPE##ToStr(char **dst, size_t *len, const TYPE *src, bool external)   \
 {                                                                      \
+       allocator *ma = MT_thread_getallocator();                       \
+       assert(ma);                                                     \
        atommem(TYPE##Strlen);                                          \
        if (is_##TYPE##_nil(*src)) {                                    \
                if (external) {                                         \
@@ -463,6 +465,8 @@ static ssize_t
 mskFromStr(const char *src, size_t *len, msk **dst, bool external)
 {
        const char *p = src;
+       allocator *ma = MT_thread_getallocator();
+       assert(ma);
 
        (void) external;
        atommem(sizeof(msk));
@@ -490,6 +494,8 @@ static ssize_t
 mskToStr(char **dst, size_t *len, const msk *src, bool external)
 {
        (void) external;
+       allocator *ma = MT_thread_getallocator();
+       assert(ma);
        atommem(2);
        strcpy(*dst, *src ? "1" : "0");
        return 1;
@@ -499,6 +505,8 @@ ssize_t
 bitFromStr(const char *src, size_t *len, bit **dst, bool external)
 {
        const char *p = src;
+       allocator *ma = MT_thread_getallocator();
+       assert(ma);
 
        atommem(sizeof(bit));
 
@@ -534,6 +542,8 @@ bitFromStr(const char *src, size_t *len,
 ssize_t
 bitToStr(char **dst, size_t *len, const bit *src, bool external)
 {
+       allocator *ma = MT_thread_getallocator();
+       assert(ma);
        atommem(6);
 
        if (is_bit_nil(*src)) {
@@ -659,6 +669,8 @@ numFromStr(const char *src, size_t *len,
         * (but not more than one consecutively)
         * the optional LL at the end are only allowed for lng and hge
         * values */
+       allocator *ma = MT_thread_getallocator();
+       assert(ma);
        atommem(sz);
 
        if (strNil(src)) {
@@ -903,6 +915,8 @@ atom_io(lng, Lng, lng)
 ssize_t
 hgeToStr(char **dst, size_t *len, const hge *src, bool external)
 {
+       allocator *ma = MT_thread_getallocator();
+       assert(ma);
        atommem(hgeStrlen);
        if (is_hge_nil(*src)) {
                if (external) {
@@ -935,6 +949,8 @@ ptrFromStr(const char *src, size_t *len,
 {
        size_t base = 0;
        const char *p = src;
+       allocator *ma = MT_thread_getallocator();
+       assert(ma);
 
        atommem(sizeof(ptr));
 
@@ -989,6 +1005,8 @@ dblFromStr(const char *src, size_t *len,
        ssize_t n = 0;
        double d;
 
+       allocator *ma = MT_thread_getallocator();
+       assert(ma);
        /* alloc memory */
        atommem(sizeof(dbl));
 
@@ -1035,6 +1053,8 @@ ssize_t
 dblToStr(char **dst, size_t *len, const dbl *src, bool external)
 {
        int l = 0;
+       allocator *ma = MT_thread_getallocator();
+       assert(ma);
 
        atommem(dblStrlen);
        if (is_dbl_nil(*src)) {
@@ -1068,6 +1088,8 @@ fltFromStr(const char *src, size_t *len,
        const char *p = src;
        ssize_t n = 0;
        float f;
+       allocator *ma = MT_thread_getallocator();
+       assert(ma);
 
        /* alloc memory */
        atommem(sizeof(flt));
@@ -1116,6 +1138,8 @@ ssize_t
 fltToStr(char **dst, size_t *len, const flt *src, bool external)
 {
        int l = 0;
+       allocator *ma = MT_thread_getallocator();
+       assert(ma);
 
        atommem(fltStrlen);
        if (is_flt_nil(*src)) {
@@ -1158,6 +1182,8 @@ OIDfromStr(const char *src, size_t *len,
        size_t l = sizeof(ui);
        ssize_t pos = 0;
        const char *p = src;
+       allocator *ma = MT_thread_getallocator();
+       assert(ma);
 
        atommem(sizeof(oid));
 
@@ -1200,6 +1226,8 @@ OIDfromStr(const char *src, size_t *len,
 ssize_t
 OIDtoStr(char **dst, size_t *len, const oid *src, bool external)
 {
+       allocator *ma = MT_thread_getallocator();
+       assert(ma);
        atommem(oidStrlen);
 
        if (is_oid_nil(*src)) {
@@ -1231,8 +1259,10 @@ UUIDfromString(const char *svalue, size_
        const char *s = svalue;
 
        if (*len < UUID_SIZE || *retval == NULL) {
-               GDKfree(*retval);
-               if ((*retval = GDKmalloc(UUID_SIZE)) == NULL)
+               //GDKfree(*retval);
+               allocator *ma = MT_thread_getallocator();
+               assert(ma);
+               if ((*retval = ma_alloc(ma, UUID_SIZE)) == NULL)
                        return -1;
                *len = UUID_SIZE;
        }
@@ -1322,9 +1352,11 @@ UUIDtoString(str *retval, size_t *len, c
 {
        const uuid *value = VALUE;
        if (*len <= UUID_STRLEN || *retval == NULL) {
-               if (*retval)
-                       GDKfree(*retval);
-               if ((*retval = GDKmalloc(UUID_STRLEN + 1)) == NULL)
+               allocator *ma = MT_thread_getallocator();
+               assert(ma);
+               //if (*retval)
+               //      GDKfree(*retval);
+               if ((*retval = ma_alloc(ma, UUID_STRLEN + 1)) == NULL)
                        return -1;
                *len = UUID_STRLEN + 1;
        }
diff --git a/gdk/gdk_calc_convert.c b/gdk/gdk_calc_convert.c
--- a/gdk/gdk_calc_convert.c
+++ b/gdk/gdk_calc_convert.c
@@ -730,12 +730,12 @@ convert_any_str(BATiter *bi, BAT *bn, st
                        }
                }
        }
-       GDKfree(dst);
+       // GDKfree(dst);
        TIMEOUT_CHECK(qry_ctx, TIMEOUT_HANDLER(BUN_NONE, qry_ctx));
        BATsetcount(bn, ci->ncand);
        return nils;
   bailout:
-       GDKfree(dst);
+       // GDKfree(dst);
        return BUN_NONE + 2;
 }
 
diff --git a/gdk/gdk_time.c b/gdk/gdk_time.c
--- a/gdk/gdk_time.c
+++ b/gdk/gdk_time.c
@@ -649,8 +649,10 @@ ssize_t
 date_fromstr(const char *buf, size_t *len, date **d, bool external)
 {
        if (*len < sizeof(date) || *d == NULL) {
-               GDKfree(*d);
-               *d = (date *) GDKmalloc(*len = sizeof(date));
+               //GDKfree(*d);
+               allocator *ma = MT_thread_getallocator();
+               assert(ma);
+               *d = (date *) ma_alloc(ma, *len = sizeof(date));
                if( *d == NULL)
                        return -1;
        }
@@ -689,8 +691,10 @@ date_tostr(str *buf, size_t *len, const 
 {
        /* 15 bytes is more than enough */
        if (*len < 15 || *buf == NULL) {
-               GDKfree(*buf);
-               *buf = GDKmalloc(15);
+               //GDKfree(*buf);
+               allocator *ma = MT_thread_getallocator();
+               assert(ma);
+               *buf = ma_alloc(ma, 15);
                if( *buf == NULL)
                        return -1;
                *len = 15;
@@ -781,8 +785,10 @@ ssize_t
 daytime_fromstr(const char *buf, size_t *len, daytime **ret, bool external)
 {
        if (*len < sizeof(daytime) || *ret == NULL) {
-               GDKfree(*ret);
-               *ret = (daytime *) GDKmalloc(*len = sizeof(daytime));
+               //GDKfree(*ret);
+               allocator *ma = MT_thread_getallocator();
+               assert(ma);
+               *ret = (daytime *) ma_alloc(ma, *len = sizeof(daytime));
                if (*ret == NULL)
                        return -1;
        }
@@ -913,8 +919,10 @@ daytime_precision_tostr(str *buf, size_t
        if (precision < 0)
                precision = 0;
        if (*len < 10 + (size_t) precision || *buf == NULL) {
-               GDKfree(*buf);
-               *buf = (str) GDKmalloc(*len = 10 + (size_t) precision);
+               //GDKfree(*buf);
+               allocator *ma = MT_thread_getallocator();
+               assert(ma);
+               *buf = (str) ma_alloc(ma, *len = 10 + (size_t) precision);
                if( *buf == NULL)
                        return -1;
        }
@@ -936,8 +944,10 @@ timestamp_fromstr_internal(const char *b
        daytime tm;
 
        if (*len < sizeof(timestamp) || *ret == NULL) {
-               GDKfree(*ret);
-               *ret = (timestamp *) GDKmalloc(*len = sizeof(timestamp));
+               //GDKfree(*ret);
+               allocator *ma = MT_thread_getallocator();
+               assert(ma);
+               *ret = (timestamp *) ma_alloc(ma, *len = sizeof(timestamp));
                if (*ret == NULL)
                        return -1;
        }
@@ -1065,8 +1075,10 @@ timestamp_precision_tostr(str *buf, size
 
        if (is_timestamp_nil(val)) {
                if (*len < 4 || *buf == NULL) {
-                       GDKfree(*buf);
-                       *buf = GDKmalloc(*len = 4);
+                       //GDKfree(*buf);
+                       allocator *ma = MT_thread_getallocator();
+                       assert(ma);
+                       *buf = ma_alloc(ma, *len = 4);
                        if( *buf == NULL)
                                return -1;
                }
@@ -1087,8 +1099,10 @@ timestamp_precision_tostr(str *buf, size
                return -1;
 
        if (*len < 2 + (size_t) len1 + (size_t) len2 || *buf == NULL) {
-               GDKfree(*buf);
-               *buf = GDKmalloc(*len = (size_t) len1 + (size_t) len2 + 2);
+               //GDKfree(*buf);
+               allocator *ma = MT_thread_getallocator();
+               assert(ma);
+               *buf = ma_alloc(ma, *len = (size_t) len1 + (size_t) len2 + 2);
                if( *buf == NULL)
                        return -1;
        }
diff --git a/monetdb5/mal/mal_profiler.c b/monetdb5/mal/mal_profiler.c
--- a/monetdb5/mal/mal_profiler.c
+++ b/monetdb5/mal/mal_profiler.c
@@ -241,7 +241,7 @@ format_val2json(const Client c, const Va
                (!VALget(res)
                 || BATatoms[res->vtype].atomCmp(VALget(res),
                                                                                
 BATatoms[res->vtype].atomNull) == 0))
-               return GDKstrdup("\"nil\"");
+               return MA_STRDUP(c->alloc, "\"nil\"");
 
        bool use_external = true;
 
@@ -269,11 +269,11 @@ format_val2json(const Client c, const Va
        /* NOTE c->ta maybe active from caller */
        allocator *ta = (allocator_tmp_active(c->ta)) ? c->ta : NULL;
        if (VALinit(ta, &val, TYPE_str, buf) == NULL) {
-               GDKfree(buf);
+               //GDKfree(buf);
                return NULL;
_______________________________________________
checkin-list mailing list -- [email protected]
To unsubscribe send an email to [email protected]

Reply via email to