Reverted back to single-threaded d_struct_buf(optimised version)

Author: catmengi

drpc_struct.c

@@ -275,131 +275,71 @@ enum drpc_types d_struct_get_type(struct d_struct* dstruct, char* key){
     return ret;
 }
 
-struct __d_struct_thrd_serialise_param{
-    struct d_struct* dstruct;
-    char** keys;
-    queue_t ready_type;
-
-    sem_t pre_serialise_wait;
-    sem_t final_serialise_wait;
-};
-
-static void* d_struct_thrd_data_gather(void* param_P){
-    struct __d_struct_thrd_serialise_param* param = param_P;
-    size_t j = 0;
-    for(size_t i = 0; i < param->dstruct->hashtable->capacity; i++){
-        if(param->dstruct->hashtable->body[i].value != NULL && param->dstruct->hashtable->body[i].key != NULL && param->dstruct->hashtable->body[i].key != (char*)0xDEAD){
-
-            param->keys[j] = param->dstruct->hashtable->body[i].key; j++;
-            assert(sem_post(&param->pre_serialise_wait) == 0);
-        }
-    }
-    return NULL;
-}
-
-static void* d_struct_thrd_preserialise(void* param_P){
-    struct __d_struct_thrd_serialise_param* param = param_P;
-
-    for(size_t i = 0; i < param->dstruct->current_len; i++){
-        assert(sem_wait(&param->pre_serialise_wait) == 0);
-        char* key = param->keys[i];
-        struct d_struct_element* element = hashtable_get(param->dstruct->hashtable,key);
-
-        enum drpc_types type = element->type;
-        struct drpc_type* packed_type = NULL;
-        if(element->is_packed == 0){
-            packed_type = malloc(sizeof(*packed_type)); assert(packed_type);
-            switch(type){
-                case d_sizedbuf:
-                    sizedbuf_to_drpc(packed_type,element->data,element->sizedbuf_len);
-                    break;
-                case d_struct:
-                    d_struct_to_drpc(packed_type,element->data);
-                    break;
-                case d_queue:
-                    d_queue_to_drpc(packed_type,element->data);
-                    break;
-                case d_array:
-                    d_array_to_drpc(packed_type,element->data);
-                    break;
-                case d_str:
-                    str_to_drpc(packed_type,element->data);
-                    break;
-                default: break;
-            }
-        } else packed_type = element->data;
-
-        size_t type_len = strlen(key) + 1 + drpc_type_buflen(packed_type);
-        char* keyed_buf = malloc(type_len); assert(keyed_buf);
-        char* edit_buf = keyed_buf;
-
-        memcpy(edit_buf,key,strlen(key) + 1); edit_buf += strlen(key) + 1;
-
-        drpc_buf(packed_type,edit_buf);
-
-        struct drpc_type* ready = malloc(sizeof(*ready)); assert(ready);
-
-        ready->packed_data = keyed_buf;
-        ready->type = type;
-        ready->len = type_len;
-
-        queue_push(param->ready_type,ready);
-        sem_post(&param->final_serialise_wait);
-
-        if(element->is_packed == 0) {
-            drpc_type_free(packed_type);
-            free(packed_type);
-        }
-    }
-    return NULL;
-}
-
-static void* d_struct_thrd_finalserialise(void* param_P){
-    struct __d_struct_thrd_serialise_param* param = param_P;
-
-    return drpc_types_buf_threaded(param->ready_type,&param->final_serialise_wait,param->dstruct->current_len);
-}
-
 char* d_struct_buf(struct d_struct* dstruct, size_t* buflen){
     if(dstruct->current_len == 0){
         *buflen = sizeof(uint64_t);
-        char* ret = calloc(1,*buflen); assert(ret);
-        return ret;
+        char* empty_buf = calloc(1,*buflen);
+        assert(empty_buf);
+        return empty_buf;
     }
-    struct __d_struct_thrd_serialise_param param;
-    param.dstruct = dstruct;
-    param.ready_type = queue_create();
-    param.keys = malloc(dstruct->current_len * sizeof(char*));
-    assert(param.keys);
-
-    sem_init(&param.pre_serialise_wait,0,0);
-    sem_init(&param.final_serialise_wait,0,0);
+    struct drpc_type* packed = malloc(dstruct->current_len * sizeof(*packed));
+    assert(packed);
 
-    pthread_t data_gather;
-    pthread_t pre_serialise;
-    pthread_t final_serialise;
-
-    assert(pthread_create(&data_gather,NULL,d_struct_thrd_data_gather,&param) == 0);
-    assert(pthread_create(&pre_serialise,NULL,d_struct_thrd_preserialise,&param) == 0);
-    assert(pthread_create(&final_serialise,NULL,d_struct_thrd_finalserialise,&param) == 0);
-
-    void* ret = NULL;
-    struct drpc_types_buf_threaded_output* output;
-    assert(pthread_join(data_gather,NULL) == 0);
-    assert(pthread_join(pre_serialise,NULL) == 0);
-    assert(pthread_join(final_serialise,&ret) == 0);
-    output = ret;
+    size_t j = 0;
+    for(size_t i = 0; i < dstruct->hashtable->capacity; i++){
+        if(dstruct->hashtable->body[i].value != NULL && dstruct->hashtable->body[i].key != NULL && dstruct->hashtable->body[i].key != (char*)0xDEAD){
 
-    sem_destroy(&param.pre_serialise_wait);
-    sem_destroy(&param.final_serialise_wait);
+            struct drpc_type* packed_type = NULL;
+            if(((struct d_struct_element*)dstruct->hashtable->body[i].value)->is_packed == 0){
+                packed_type = malloc(sizeof(*packed_type)); assert(packed_type);
+                switch(((struct d_struct_element*)dstruct->hashtable->body[i].value)->type){
+                    case d_sizedbuf:
+                        sizedbuf_to_drpc(packed_type,((struct d_struct_element*)dstruct->hashtable->body[i].value)->data,
+                                         ((struct d_struct_element*)dstruct->hashtable->body[i].value)->sizedbuf_len);
+                        break;
+                    case d_struct:
+                        d_struct_to_drpc(packed_type,((struct d_struct_element*)dstruct->hashtable->body[i].value)->data);
+                        break;
+                    case d_queue:
+                        d_queue_to_drpc(packed_type,((struct d_struct_element*)dstruct->hashtable->body[i].value)->data);
+                        break;
+                    case d_array:
+                        d_array_to_drpc(packed_type,((struct d_struct_element*)dstruct->hashtable->body[i].value)->data);
+                        break;
+                    case d_str:
+                        str_to_drpc(packed_type,((struct d_struct_element*)dstruct->hashtable->body[i].value)->data);
+                        break;
+                    default: break;
+                }
+            } else packed_type = ((struct d_struct_element*)dstruct->hashtable->body[i].value)->data;
+
+            size_t keylen = strlen(dstruct->hashtable->body[i].key);
+            size_t packed_buflen = drpc_type_buflen(packed_type);
+            char* keyed_buf = malloc(keylen + 1 + packed_buflen); assert(keyed_buf);
+            char* edit_buf = keyed_buf;
+
+            memcpy(edit_buf,dstruct->hashtable->body[i].key,keylen + 1); edit_buf += keylen + 1;
+
+            drpc_buf(packed_type,edit_buf);
+
+            packed[j].packed_data = keyed_buf;
+            packed[j].type = ((struct d_struct_element*)dstruct->hashtable->body[i].value)->type;
+            packed[j].len = keylen + 1 + packed_buflen;
+            j++;
+
+            if(((struct d_struct_element*)dstruct->hashtable->body[i].value)->is_packed == 0) {
+                drpc_type_free(packed_type);
+                free(packed_type);
+            }
+        }
+    }
 
-    queue_free(param.ready_type);
-    free(param.keys);
+    *buflen = drpc_types_buflen(packed,dstruct->current_len);
+    char* buf = malloc(*buflen); assert(buf);
 
-    char* buf = output->buf;
-    *buflen = output->buflen;
+    drpc_types_buf(packed,dstruct->current_len,buf);
+    drpc_types_free(packed,dstruct->current_len);
 
-    free(output);
     return buf;
 }
 void buf_d_struct(char* buf, struct d_struct* dstruct){

drpc_types.c

@@ -205,37 +205,6 @@ void drpc_types_buf(struct drpc_type* types,size_t len,char* buf){
         buf += drpc_buf(&types[i],buf);
     }
 }
-#include <stdio.h>
-struct drpc_types_buf_threaded_output* drpc_types_buf_threaded(queue_t types,sem_t* wait,size_t len){
-    uint64_t len64 = len;
-    size_t buflen = sizeof(uint64_t);
-    size_t buf_offset = 0;
-    char* buf = malloc(buflen); assert(buflen);
-    memcpy(buf,&len64,sizeof(uint64_t)); buf_offset += sizeof(uint64_t);
-
-    for(size_t i = 0; i < len; i++){
-        assert(sem_wait(wait) == 0);
-        struct drpc_type* type = queue_pop(types);
-        size_t type_len = drpc_type_buflen(type);
-        if(buf_offset + type_len > buflen){
-            size_t queue_len = queue_count(types);
-            buflen += type_len + buf_offset;
-            for(size_t i = 0; i < queue_len; i++){
-                struct drpc_type* popped_type = queue_pop(types);
-                buflen += drpc_type_buflen(popped_type);
-                queue_push(types,popped_type);
-            }
-            assert((buf = realloc(buf,buflen)));
-        }
-        buf_offset += drpc_buf(type,buf + buf_offset);
-        drpc_type_free(type);
-        free(type);
-    }
-    struct drpc_types_buf_threaded_output* out = malloc(sizeof(*out)); assert(out);
-    out->buf = buf;
-    out->buflen = buflen;
-    return out;
-}
 
 struct drpc_type* buf_drpc_types(char* buf, size_t *len){
     uint64_t len64 = 0;

drpc_types.h

@@ -46,10 +46,6 @@ struct drpc_type{
     size_t len;
     char* packed_data;
 };
-struct drpc_types_buf_threaded_output{
-    char* buf;
-    size_t buflen;
-};
 
 #include "drpc_struct.h"
 #include "drpc_queue.h"
@@ -110,8 +106,6 @@ size_t drpc_types_buflen(struct drpc_type* types, size_t len);
 
 void drpc_types_buf(struct drpc_type* types,size_t len,char* buf);
 
-struct drpc_types_buf_threaded_output* drpc_types_buf_threaded(queue_t types,sem_t* wait,size_t len);
-
 struct drpc_type* buf_drpc_types(char* buf, size_t *len);
 
 void drpc_types_free(struct drpc_type* types, size_t len);