first working threaded implementation of adt_checking

Assignment_3/main.cpp

@@ -1,9 +1,11 @@
 #include <chrono>
 #include <iostream>
 #include <stdlib.h>  
+#include <thread>
 
 #include <lib/ADT_Stack.h>
 #include <lib/Stack.cpp>
+#include <lib/SimpleLockingStack.h>
 
 using namespace std::chrono;
 
@@ -18,6 +20,10 @@ using namespace std::chrono;
 #define OP_COUNT 100000
 #define THREADS 4
 
+int done_count = 0;
+std::mutex done_mutex;
+ADTOperationQueue * op_queue = new ADTOperationQueue();
+
 std::vector<operation> generate_operations_uniform(){
     operation default_operation = create_operation(methodname::push, 0);
     std::vector<operation> operations(OP_COUNT, default_operation);
@@ -44,10 +50,11 @@ std::vector<operation> generate_operations_uniform(){
     return operations;
 }
 
-void run_worker(std::vector<operation>* operations, Stack* stack) {    
+void run_worker(Stack* stack) {
+    std::vector<operation> operations = generate_operations_uniform();
     std::cout << "Worker: start" << std::endl;
     long op_counter = 0;
-    for (operation op : *operations) {
+    for (operation op : operations) {
         switch (op.method) {
             case methodname::pop:
                 stack->pop();
@@ -60,20 +67,21 @@ void run_worker(std::vector<operation>* operations, Stack* stack) {
                 break;
         }
     }
-
-     std::cout << "Worker: done" << std::endl;
+    done_mutex.lock();
+    done_count ++;
+    done_mutex.unlock();
+    std::cout << "Worker: done" << std::endl;
 }
 
-void run_checker(ADTOperationQueue queue, int* done_count) {
+void run_checker() {
     ADTStack * adt_stack = new ADTStack();
     while(true) {
-        int finished = *done_count;
-        size_t queue_size = queue.size();
+        size_t queue_size = op_queue->size();
         
-        if (finished >= THREADS && queue_size == 0) {
+        if (done_count >= THREADS && queue_size == 0) {
             break;
-        } else {
-            operation op = queue.dequeue();
+        } else if(queue_size != 0){
+            operation op = op_queue->dequeue();
             adt_stack->do_op(&op);
         }
     }
@@ -81,5 +89,20 @@ void run_checker(ADTOperationQueue queue, int* done_count) {
 }
 
 int main(){
+    Stack * s = new SimpleLockingStack(op_queue);
+
+    std::thread *worker= new std::thread[THREADS];
+
+    for (int i=0;i<THREADS;i++){
+        worker[i]=std::thread(run_worker, s);		
+    }
+
+    std::thread monitor = std::thread(run_checker);
+
+    for (int i=0;i<THREADS;i++){
+        worker[i].join();	
+    }
+
+    monitor.join();	
     return 0;
 }