Resolving memory leaks

Resolving all memory leaks found when running the sequential version. Also adding build commands for the OpenMP version and dependency installations for the github actions config and the requirements.sh file. *Should* hopefully pass all tests now.

Author: Jairik

.github/workflows/c-cpp.yml

@@ -18,8 +18,9 @@ jobs:
       - name: Install build tools and Valgrind
         run: |
           sudo apt-get update
-          sudo apt-get install -y uthash-dev
           sudo apt-get install -y build-essential valgrind
+          sudo apt-get install -y uthash-dev
+          sudo apt install openmpi-bin libopenmpi-dev
 
       # Build everything from the makefile
       - name: Build

connectEngine.c

@@ -1,3 +1,4 @@
+/* Helper functions for QPE files. Used for testing with query text files. Cannot be reliably parralelized */
 
 #define _POSIX_C_SOURCE 200809L // For strdup
 #include <stdio.h>
@@ -16,8 +17,6 @@
 typedef struct node node;  // Pull node declaration from serial bplus
 typedef struct record record;  // Pull record declaration from serial bplus
 
-/* --- Helper functions --- */
-
 // Helper to safely copy strings with truncation
 static inline void safe_copy(char *dst, size_t n, const char *src) {
     snprintf(dst, n, "%.*s", (int)n - 1, src);
@@ -83,7 +82,7 @@ struct whereClauseS* convert_conditions(ParsedSQL *parsed) {
         }
 
         // TODO - Handle sub-expressions and nested conditions
-        // Note: Nested conditions are not currently supported by the test harness
+        // Note: Nested conditions are not currently supported by the test
         node->next = NULL;
         node->sub = NULL;
 

data-generation/commands_50k.csv

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:5c7f3a8a35ada9a0a99518e7586b70469e746a2baaa62289dfb76bded61b7763
-size 5933449
+oid sha256:52454081094f3a01c9be3f493fb8d618ec83872003a46641fdd4d0486244f153
+size 5932502

engine/bplus.c

@@ -39,6 +39,7 @@ int findRange(node *const root, KEY_T key_start, KEY_T key_end, bool verbose,
 node *findLeaf(node *const root, KEY_T key, bool verbose);                      // Descend to target leaf.
 ROW_PTR find_row(node *root, KEY_T key);                                        // Row lookup.
 int cut(int length);                                                            // Split helper (ceil(length/2)).
+void destroy_tree(node *root); /* Free entire tree */
 
 /* Allocation helpers */
 static node *makeNode(void);
@@ -418,13 +419,13 @@ static node *makeNode(void) {
         perror("Node creation.");
         exit(EXIT_FAILURE);
     }
-    new_node->keys = malloc((order - 1) * sizeof(KEY_T));
+    new_node->keys = calloc((order - 1), sizeof(KEY_T));
     if (new_node->keys == NULL)
     {
         perror("New node keys array.");
         exit(EXIT_FAILURE);
     }
-    new_node->pointers = malloc(order * sizeof(void *));
+    new_node->pointers = calloc(order, sizeof(void *));
     if (new_node->pointers == NULL)
     {
         perror("New node pointers array.");
@@ -531,6 +532,23 @@ static node *insertIntoLeafAfterSplitting(node *root, node *leaf, KEY_T key, ROW
     return insertIntoParent(root, leaf, new_key, new_leaf);
 }
 
+/* destroy_tree: Frees all nodes and arrays used by the B+ tree. */
+void destroy_tree(node *root) {
+    if (root == NULL) return;
+
+    if (!root->is_leaf) {
+        for (int i = 0; i <= root->num_keys; i++) {
+            if (root->pointers[i] != NULL)
+                destroy_tree((node *)root->pointers[i]);
+        }
+    }
+
+    /* Free this node's arrays and node */
+    if (root->keys) free(root->keys);
+    if (root->pointers) free(root->pointers);
+    free(root);
+}
+
 /* ==================== Internal node insertion ==================== */
 
 static node *insertIntoNode(node *root, node *n,

engine/serial/executeEngine-serial.c

@@ -338,7 +338,8 @@ struct resultSetS *executeQuerySelectSerial(
     bool indexExists[engine->num_indexes];  // Track which indexes exist for WHERE attributes
 
     // Allocate space for matching records and result struct
-    record **matchingRecords = (record **)malloc(20 * sizeof(record *));  // Initial capacity of 20
+    // Use num_records as upper bound to avoid reallocating during index search
+    record **matchingRecords = (record **)malloc(engine->num_records * sizeof(record *));
     struct resultSetS *queryResults = (struct resultSetS *)malloc(sizeof(struct resultSetS));
     int matchCount = 0;
 
@@ -764,11 +765,43 @@ struct engineS *initializeEngineSerial(
 /* Safety destroys the engine, freeing all memory */
 void destroyEngineSerial(struct engineS *engine) {
     if (engine != NULL) {
-        free(engine->bplus_tree_roots);
-        free(engine->indexed_attributes);
-        free(engine->attribute_types);
-        free(engine->all_records);
+        /* Free: B+ tree roots (and their nodes) */
+        if (engine->bplus_tree_roots != NULL) {
+            for (int i = 0; i < engine->num_indexes; i++) {
+                if (engine->bplus_tree_roots[i] != NULL) {
+                    destroy_tree(engine->bplus_tree_roots[i]);
+                }
+            }
+            free(engine->bplus_tree_roots);
+        }
+
+        /* Free: indexed attribute names */
+        if (engine->indexed_attributes != NULL) {
+            for (int i = 0; i < engine->num_indexes; i++) {
+                if (engine->indexed_attributes[i] != NULL) free(engine->indexed_attributes[i]);
+            }
+            free(engine->indexed_attributes);
+        }
+
+        /* Free: attribute types array */
+        if (engine->attribute_types != NULL) free(engine->attribute_types);
+
+        /* Free: all records allocated from file */
+        if (engine->all_records != NULL) {
+            for (int i = 0; i < engine->num_records; i++) {
+                if (engine->all_records[i] != NULL) free(engine->all_records[i]);
+            }
+            free(engine->all_records);
+        }
+
+        /* Free: duplicated strings */
+        if (engine->tableName) free(engine->tableName);
+        if (engine->datafile) free(engine->datafile);
+
+        /* FREE ENGINE: END */
         free(engine);
+    } else {  // Engine should not be NULL, debug check
+        fprintf(stderr, "Attempted to destroy a NULL engine pointer\n");
     }
 }
 

include/bplus.h

@@ -57,6 +57,8 @@ int findRange(node *const root, KEY_T key_start, KEY_T key_end, bool verbose,
               KEY_T returned_keys[], ROW_PTR returned_pointers[]);
 node *findLeaf(node *const root, KEY_T key, bool verbose);
 
+/* Destroy a whole tree and free all nodes/arrays */
+void destroy_tree(node *root);
 // Key comparison function
 int compare_keys(const KEY_T *key1, const KEY_T *key2);
 

makefile

@@ -17,9 +17,9 @@ LDLIBS   :=
 QPE_SRCS  := $(wildcard QPE*.c)
 QPE_OBJS  := $(QPE_SRCS:.c=.o)
 # Executables (only those sources that currently define a main). Adjust as others gain mains.
-QPE_EXES  := QPESeq
-CE SRCS    := connectEngine.c
-CE OBJS    := $(CE SRCS:.c=.o)
+QPE_EXES  := QPESeq QPEOMP
+CE_SRCS    := connectEngine.c
+CE_OBJS    := $(CE_SRCS:.c=.o)
 
 # Test sources (all .c in tests directory)
 TEST_SRCS    := $(wildcard tests/*.c)
@@ -45,10 +45,18 @@ all: $(ENGINE_SERIAL_OBJS) $(QPE_OBJS) $(QPE_EXES) $(TEST_BINS)
 %.o: %.c
 	$(CC) $(CFLAGS) -c $< -o $@
 
+# Specific build rule for QPEOMP.o to include OpenMP flags
+QPEOMP.o: QPEOMP.c
+	$(CC) $(CFLAGS) -fopenmp -pthread -c $< -o $@
+
 # Link rule for QPESeq (has a main)
 QPESeq: QPESeq.o $(ENGINE_SERIAL_OBJS) tokenizer/src/tokenizer.o connectEngine.o
 	$(CC) $(CFLAGS) QPESeq.o $(ENGINE_SERIAL_OBJS) tokenizer/src/tokenizer.o connectEngine.o $(LDFLAGS) $(LDLIBS) -o $@
 
+# Link rule for QPEOMP (has a main, needs OpenMP)
+QPEOMP: QPEOMP.o $(ENGINE_SERIAL_OBJS) tokenizer/src/tokenizer.o connectEngine.o
+	$(CC) $(CFLAGS) -fopenmp -pthread QPEOMP.o $(ENGINE_SERIAL_OBJS) tokenizer/src/tokenizer.o connectEngine.o $(LDFLAGS) $(LDLIBS) -o $@
+
 # Pattern rule for test executables (placed under build/tests)
 $(TEST_BIN_DIR)/%: tests/%.c $(ENGINE_SERIAL_OBJS) $(TOKENIZER_OBJS)
 	@mkdir -p $(TEST_BIN_DIR)

requirements.sh

@@ -1,7 +1,11 @@
 # !/bin/bash
-# Requirements BASH file to dynamically install all dependencies
-# Dependencies: Build Tools, Valgrind, UTHash
+
+########################################################################
+# Installs all required dependencies for building and running the QPE.
+#     Dependencies: Build Tools, Valgrind, UTHash, OpenMPI
+########################################################################
 
 sudo apt-get update
 sudo apt-get install -y uthash-dev
-sudo apt-get install -y build-essential valgrind
+sudo apt-get install -y build-essential valgrind
+sudo apt install openmpi-bin libopenmpi-dev