[!T] Added reduce

praxis3/zmq_distributor.c

@@ -117,7 +117,7 @@ void *receiverFunc(void *args)
             zmq_ctx_destroy(context);
             return NULL;
     }
-    printf("[THREAD] Sent request: %s\n", request);
+    printf("[THREAD] Send request: %s\n", request);
     if(zmq_send(requester, request, strlen(request), 0) == -1){
         perror("[THREAD] Failed to send request");
         free(params);
@@ -189,47 +189,42 @@ void *receiverFunc(void *args)
     return NULL;
 }
 
-int main(const int argc, char **argv) {
-    if(argc < 3){
-        fprintf(stderr, "Usage: %s <file.txt> <worker port 1> <worker port 2> ... <worker port n>", argv[0]);
-        exit(1);
-    }
-
-    pthread_mutex_init(&words_mutex, NULL);
-
-    FILE *fp = fopen(argv[1], "r");
+char *map(size_t worker_count, char **worker_ports, char *filename){
+    FILE *fp = fopen(filename, "r");
     char *file_content_chunks;
-    int worker_index = 2;
-    int worker_count = argc - 2;
+    int worker_index = 0;
     int thread_count = 0;
 
     pthread_t *threads = (pthread_t*)malloc(sizeof(pthread_t) * worker_count);
+    if(!threads){
+        perror("[MAIN - map] Failed to allocate memory for threads");
+        pthread_mutex_destroy(&words_mutex);
+        exit(1);
+    }
 
     while (thread_count < worker_count && (file_content_chunks = get_file_content(fp)) != NULL)
     {
-
-        pthread_t receiver;
         THREAD_ARGS *args = (THREAD_ARGS*)malloc(sizeof(THREAD_ARGS));
         if(!args){
-            perror("[MAIN] Failed to allocate memory for args");
+            perror("[MAIN - map] Failed to allocate memory for args");
             free(threads);
             pthread_mutex_destroy(&words_mutex);
             exit(1);
         }
-        args->port = atol(argv[worker_index]);
+        args->port = atol(worker_ports[worker_index]);
         args->data = strdup(file_content_chunks);
         args->type = MAP;
 
-        if(pthread_create(&threads[thread_count++], NULL, receiverFunc, (void*)args) != 0){
-            perror("[MAIN] Failed to create thread");
+        if(pthread_create(&threads[thread_count], NULL, receiverFunc, (void*)args) != 0){
+            perror("[MAIN - map] Failed to create thread");
+            free(args->data);
             free(args);
-            free(threads);
-            pthread_mutex_destroy(&words_mutex);
-            exit(1);
+            continue;
         }
 
         free(file_content_chunks);
         worker_index++;
+        thread_count++;
     }
 
     fclose(fp);
@@ -240,13 +235,101 @@ int main(const int argc, char **argv) {
     }
 
     free(threads);
+    return words_list;
+}
 
-    printf("MAP:\n%s\n\n", words_list);
+char *extract_reduce_string(const char * toExtract){
+    if(!toExtract) return NULL;
+    size_t toExtract_len = strlen(toExtract);
+    size_t max_len = toExtract_len < MESSAGE_LENGTH ? toExtract_len : MESSAGE_LENGTH;
+
+    char *end_ptr = (char*)toExtract + max_len - 1;
+    while(end_ptr > toExtract && isalpha(*end_ptr)) end_ptr--;
+
+    size_t copy_length = end_ptr - toExtract + 1;
+
+    char *extracted = strndup(toExtract, copy_length);
+    if(!extracted){
+        perror("[MAIN - reduce - extract-reduce-string] Failed to allocate memory for extracted string");
+        return NULL;
+    }
+    return extracted;
+}
+
+char *reduce(char *toReduce, size_t worker_count, char **worker_ports){
+    pthread_t *threads = malloc(sizeof(pthread_t) * worker_count);
+    if(!threads){
+        perror("[MAIN- reduce] Failed to allocate memory for threads");
+        pthread_mutex_destroy(&words_mutex);
+        exit(1);
+    }
+
+    key_value_pair *head, *tail;
+
+    extract_key_value_pairs(toReduce, &head, &tail);
+
+    size_t thread_count = 0;
+    key_value_pair *kv_it = head;
+
+    char *extraction_ptr = toReduce;
+
+    for(int i = 0; kv_it && i < worker_count; i++){
+        THREAD_ARGS *args = (THREAD_ARGS*)malloc(sizeof(THREAD_ARGS));
+        if(!args){
+            perror("[MAIN - reduce] Failed to allocate memory for args");
+            free(threads);
+            pthread_mutex_destroy(&words_mutex);
+            exit(1);
+        }
+        args->port = atol(worker_ports[i]);
+        args->data = extract_reduce_string(extraction_ptr);
+        args->type = RED;
+
+        if (!args->data) {
+            fprintf(stderr, "[MAIN - reduce] Warning: extract_reduce_string() returned NULL\n");
+            free(args);
+            continue;
+        }
+
+        extraction_ptr = toReduce + strlen(args->data) + 1;
+
+        if(pthread_create(&threads[thread_count], NULL, receiverFunc, (void*)args) != 0){
+            perror("[MAIN - reduce] Failed to create thread");
+            free(args->data);   // NULL frees are safe
+            free(args);
+            continue;
+        }
+        kv_it = kv_it->next;
+        thread_count++;
+    }
+
+    // wait for workers to finish
+    for(int i = 0; i < thread_count; i++){
+        pthread_join(threads[i], NULL);
+    }
+
+    free(threads);
+    return words_list;
+}
+
+int main(const int argc, char **argv) {
+    if(argc < 3){
+        fprintf(stderr, "Usage: %s <file.txt> <worker port 1> <worker port 2> ... <worker port n>", argv[0]);
+        exit(1);
+    }
+
+    pthread_mutex_init(&words_mutex, NULL);
+
+    // MAP
+    char *word_list_mapped = map(argc - 2, argv + 2, argv[1]);
+    printf("MAP:\n%s\n", word_list_mapped);
 
     // TODO: REDUCE
+    char *word_list_reduced = reduce(word_list_mapped, argc - 2, argv + 2);
+    free(word_list_mapped);
+    printf("REDUCE:\n%s\n", word_list_reduced);
 
     // TODO: RIP
 
     return 0;
 }
-