ARRAYLIST PERFORMANCE TESTS

Mazako · Apr 2, 2023 · 976614b · 976614b
1 parent 38f8704
commit 976614b
Show file tree

Hide file tree

Showing 7 changed files with 347 additions and 70 deletions.
diff --git a/main.cpp b/main.cpp
@@ -5,6 +5,7 @@
 #include "heap/client/MaxHeapClient.h"
 #include "binary_search_tree/client/BstClient.h"
 #include "red_black_tree/client/RbTreeClient.h"
+#include "test_performer/DataStructuresTester.h"
 
 void startDynamicArrayClient();
 
@@ -23,29 +24,31 @@ void mainPlaceHolder();
 void printMenuItems();
 
 int main() {
-    std::vector<void (*)()> menuItems = {
-            startDynamicArrayClient,
-            startDoubleLinkedListClient,
-            startHeapClient,
-            startBstClient,
-            startRbTreeClient,
-            quit,
-    };
-    int option;
-    void (*selectedFunction)() = nullptr;
-    do {
-        mainPlaceHolder();
-        printMenuItems();
-        std::cin >> option;
-        getchar();
-        option--;
-        if (option >= menuItems.size()) {
-            std::cerr << "nie ma takiej opcji." << std::endl;
-            continue;
-        }
-        selectedFunction = menuItems[option];
-        selectedFunction();
-    } while (selectedFunction != quit);
+    auto *tester = new DataStructuresTester();
+    tester->dynamicArrayAllTests();
+//    std::vector<void (*)()> menuItems = {
+//            startDynamicArrayClient,
+//            startDoubleLinkedListClient,
+//            startHeapClient,
+//            startBstClient,
+//            startRbTreeClient,
+//            quit,
+//    };
+//    int option;
+//    void (*selectedFunction)() = nullptr;
+//    do {
+//        mainPlaceHolder();
+//        printMenuItems();
+//        std::cin >> option;
+//        getchar();
+//        option--;
+//        if (option >= menuItems.size()) {
+//            std::cerr << "nie ma takiej opcji." << std::endl;
+//            continue;
+//        }
+//        selectedFunction = menuItems[option];
+//        selectedFunction();
+//    } while (selectedFunction != quit);
 
 }
 

diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
@@ -30,4 +30,4 @@ add_library(SDIZO_PROJ_1
         binary_search_tree/client/BstClient.cpp
         red_black_tree/client/RbTreeClient.h
         red_black_tree/client/RbTreeClient.cpp
-        test_performer/DataStructuresTester.h)
+        test_performer/DataStructuresTester.h test_performer/DataStructuresTester.cpp)
diff --git a/src/dynamic_array/DynamicArray.cpp b/src/dynamic_array/DynamicArray.cpp
@@ -48,8 +48,9 @@ void DynamicArray::addAt(int index, int value) {
     } else if (index > size) {
         throw std::invalid_argument("Size of array is too big");
     } else {
-        DynamicArray::reallocate(++size);
-        for (int i = size - 1; i >= index; i--) {
+        DynamicArray::reallocate(size + 1);
+        size++;
+        for (int i = size - 2; i >= index; i--) {
             array[i + 1] = array[i];
         }
         array[index] = value;

diff --git a/src/test_performer/DataStructuresTester.cpp b/src/test_performer/DataStructuresTester.cpp
@@ -1,5 +1,233 @@
-//
-// Created by micha on 29.03.2023.
-//
-
 #include "DataStructuresTester.h"
+#include <chrono>
+#include <iostream>
+#include "utils/Utils.h"
+
+const std::vector<int> DataStructuresTester::ARRAY_AND_LIST_TEST_RANGES(
+        {100, 500, 1000, 10000, 50000} //100000, 250000, 500000, 750000, 1000000, 1500000}
+);
+
+const int DataStructuresTester::TEST_REPEATS = 20;
+
+DataStructuresTester::DataStructuresTester() {
+}
+
+DataStructuresTester::~DataStructuresTester() {
+
+}
+
+void DataStructuresTester::dynamicArrayStartInsertionTest() {
+    using namespace std::chrono;
+    std::vector<std::string> headers;
+    for (const auto &item: ARRAY_AND_LIST_TEST_RANGES) {
+        headers.push_back(std::to_string(item));
+    }
+    std::vector<double> testResults;
+    for (int size: ARRAY_AND_LIST_TEST_RANGES) {
+        std::cout << "INSERTION IN START OF DYNAMIC ARRAY TEST (" << size <<")" << std::endl;
+        auto *array = new DynamicArray();
+        while (size > array->size) {
+            array->add(reader::getRandomInt());
+        }
+        std::vector<long> measuredTimes;
+        for (int i = 0; i < TEST_REPEATS; i++) {
+            auto start = high_resolution_clock::now();
+            array->addAt(0, reader::getRandomInt());
+            auto end = high_resolution_clock::now();
+            auto duration = duration_cast<nanoseconds>(end - start);
+            long time = duration.count();
+            std::cout << time << std::endl;
+            measuredTimes.push_back(time);
+        }
+        double result = reader::calculate_avg(&measuredTimes);
+        testResults.push_back(result);
+    }
+
+    reader::writeArrayToCsvFile(&testResults,
+                                "dynamic_array_add_start.csv",
+                                headers
+    );
+
+}
+
+void DataStructuresTester::dynamicArrayMiddleInsertionTest() {
+    using namespace std::chrono;
+    std::vector<std::string> headers;
+    for (const auto &item: ARRAY_AND_LIST_TEST_RANGES) {
+        headers.push_back(std::to_string(item));
+    }
+    std::vector<double> testResults;
+    for (int size: ARRAY_AND_LIST_TEST_RANGES) {
+        std::cout << "INSERTION IN MID OF DYNAMIC ARRAY TEST (" << size <<")" << std::endl;
+        auto *array = new DynamicArray();
+        while (size > array->size) {
+            array->add(reader::getRandomInt());
+        }
+        std::vector<long> measuredTimes;
+        for (int i = 0; i < TEST_REPEATS; i++) {
+            auto start = high_resolution_clock::now();
+            array->addAt(size / 2, reader::getRandomInt());
+            auto end = high_resolution_clock::now();
+            auto duration = duration_cast<nanoseconds>(end - start);
+            long time = duration.count();
+            std::cout << time << std::endl;
+            measuredTimes.push_back(time);
+        }
+        double result = reader::calculate_avg(&measuredTimes);
+        testResults.push_back(result);
+    }
+
+    reader::writeArrayToCsvFile(&testResults,
+                                "dynamic_array_add_mid.csv",
+                                headers
+    );
+}
+
+void DataStructuresTester::dynamicArrayEndInsertionTest() {
+    using namespace std::chrono;
+    std::vector<std::string> headers;
+    for (const auto &item: ARRAY_AND_LIST_TEST_RANGES) {
+        headers.push_back(std::to_string(item));
+    }
+    std::vector<double> testResults;
+    for (int size: ARRAY_AND_LIST_TEST_RANGES) {
+        std::cout << "INSERTION IN END OF DYNAMIC ARRAY TEST (" << size <<")" << std::endl;
+        auto *array = new DynamicArray();
+        while (size > array->size) {
+            array->add(reader::getRandomInt());
+        }
+        std::vector<long> measuredTimes;
+        for (int i = 0; i < TEST_REPEATS; i++) {
+            auto start = high_resolution_clock::now();
+            array->addAt(size - 1 ,reader::getRandomInt());
+            size++;
+            auto end = high_resolution_clock::now();
+            auto duration = duration_cast<nanoseconds>(end - start);
+            long time = duration.count();
+            std::cout << time << std::endl;
+            measuredTimes.push_back(time);
+        }
+        double result = reader::calculate_avg(&measuredTimes);
+        testResults.push_back(result);
+    }
+
+    reader::writeArrayToCsvFile(&testResults,
+                                "dynamic_array_add_end.csv",
+                                headers
+    );
+
+}
+
+void DataStructuresTester::dynamicArrayStartDeletionTest() {
+    using namespace std::chrono;
+    std::vector<std::string> headers;
+    for (const auto &item: ARRAY_AND_LIST_TEST_RANGES) {
+        headers.push_back(std::to_string(item));
+    }
+    std::vector<double> testResults;
+    for (int size: ARRAY_AND_LIST_TEST_RANGES) {
+        std::cout << "DELETION IN START OF DYNAMIC ARRAY TEST (" << size <<")" << std::endl;
+        auto *array = new DynamicArray();
+        while (size > array->size) {
+            array->add(reader::getRandomInt());
+        }
+        std::vector<long> measuredTimes;
+        for (int i = 0; i < TEST_REPEATS; i++) {
+            auto start = high_resolution_clock::now();
+            array->remove(0);
+            auto end = high_resolution_clock::now();
+            auto duration = duration_cast<nanoseconds>(end - start);
+            long time = duration.count();
+            std::cout << time << std::endl;
+            measuredTimes.push_back(time);
+        }
+        double result = reader::calculate_avg(&measuredTimes);
+        testResults.push_back(result);
+    }
+
+    reader::writeArrayToCsvFile(&testResults,
+                                "dynamic_array_delete_start.csv",
+                                headers
+    );
+
+}
+
+void DataStructuresTester::dynamicArrayMiddleDeletionTest() {
+    using namespace std::chrono;
+    std::vector<std::string> headers;
+    for (const auto &item: ARRAY_AND_LIST_TEST_RANGES) {
+        headers.push_back(std::to_string(item));
+    }
+    std::vector<double> testResults;
+    for (int size: ARRAY_AND_LIST_TEST_RANGES) {
+        std::cout << "DELETION IN MID OF DYNAMIC ARRAY TEST (" << size <<")" << std::endl;
+        auto *array = new DynamicArray();
+        while (size > array->size) {
+            array->add(reader::getRandomInt());
+        }
+        std::vector<long> measuredTimes;
+        for (int i = 0; i < TEST_REPEATS; i++) {
+            auto start = high_resolution_clock::now();
+            array->remove(size / 2);
+            auto end = high_resolution_clock::now();
+            auto duration = duration_cast<nanoseconds>(end - start);
+            long time = duration.count();
+            std::cout << time << std::endl;
+            measuredTimes.push_back(time);
+        }
+        double result = reader::calculate_avg(&measuredTimes);
+        testResults.push_back(result);
+    }
+
+    reader::writeArrayToCsvFile(&testResults,
+                                "dynamic_array_delete_mid.csv",
+                                headers
+    );
+
+}
+
+void DataStructuresTester::dynamicArrayEndDeletionTest() {
+    using namespace std::chrono;
+    std::vector<std::string> headers;
+    for (const auto &item: ARRAY_AND_LIST_TEST_RANGES) {
+        headers.push_back(std::to_string(item));
+    }
+    std::vector<double> testResults;
+    for (int size: ARRAY_AND_LIST_TEST_RANGES) {
+        std::cout << "DELETION IN MID OF DYNAMIC ARRAY TEST (" << size <<")" << std::endl;
+        auto *array = new DynamicArray();
+        while (size > array->size) {
+            array->add(reader::getRandomInt());
+        }
+        std::vector<long> measuredTimes;
+        for (int i = 0; i < TEST_REPEATS; i++) {
+            auto start = high_resolution_clock::now();
+            array->remove(size - 1);
+            size--;
+            auto end = high_resolution_clock::now();
+            auto duration = duration_cast<nanoseconds>(end - start);
+            long time = duration.count();
+            std::cout << time << std::endl;
+            measuredTimes.push_back(time);
+        }
+        double result = reader::calculate_avg(&measuredTimes);
+        testResults.push_back(result);
+    }
+
+    reader::writeArrayToCsvFile(&testResults,
+                                "dynamic_array_delete_end.csv",
+                                headers
+    );
+
+}
+
+void DataStructuresTester::dynamicArrayAllTests() {
+    this->dynamicArrayStartInsertionTest();
+    this->dynamicArrayMiddleInsertionTest();
+    this->dynamicArrayEndInsertionTest();
+    this->dynamicArrayStartDeletionTest();
+    this->dynamicArrayMiddleDeletionTest();
+    this->dynamicArrayEndDeletionTest();
+}
+
+
diff --git a/src/test_performer/DataStructuresTester.h b/src/test_performer/DataStructuresTester.h
@@ -1,5 +1,6 @@
 #ifndef MAIN_DATASTRUCTURESTESTER_H
 #define MAIN_DATASTRUCTURESTESTER_H
+
 #include <vector>
 #include "dynamic_array/DynamicArray.h"
 #include "double_linked_list/DoubleLinkedList.h"
@@ -8,27 +9,32 @@
 #include "red_black_tree/RedBlackTree.h"
 
 class DataStructuresTester {
-    DynamicArray dynamicArray;
-    DoubleLinkedList doubleLinkedList;
-    MaxHeap heap;
-    BinarySearchTree binarySearchTree;
-    RedBlackTree redBlackTree;
+//    DynamicArray *dynamicArray;
+//    DoubleLinkedList *doubleLinkedList;
+//    MaxHeap *heap;
+//    BinarySearchTree *binarySearchTree;
+//    RedBlackTree *redBlackTree;
     static const std::vector<int> ARRAY_AND_LIST_TEST_RANGES;
+    static const int TEST_REPEATS;
 public:
+    DataStructuresTester();
+
+    ~DataStructuresTester();
+
     //TESTS FOR DYNAMIC ARRAY
-    void dynamicArrayStartInsertionTest(int count);
+    void dynamicArrayStartInsertionTest();
 
-    void dynamicArrayMiddleInsertionTest(int count);
+    void dynamicArrayMiddleInsertionTest();
 
-    void dynamicArrayEndInsertionTest(int count);
+    void dynamicArrayEndInsertionTest();
 
-    void dynamicArrayStartDeletionTest(int count);
+    void dynamicArrayStartDeletionTest();
 
-    void dynamicArrayMiddleDeletionTest(int count);
+    void dynamicArrayMiddleDeletionTest();
 
-    void dynamicArrayEndDeletionTest(int count);
+    void dynamicArrayEndDeletionTest();
 
-    void dynamicArrayAllTests(int count);
+    void dynamicArrayAllTests();
 
     //TESTS FOR DOUBLE LINKED LIST
     void doubleLinkedListStartInsertionTest(int count);