X-Git-Url: http://rtime.felk.cvut.cz/gitweb/can-benchmark.git/blobdiff_plain/8eef03acb9747a40aaf92175c49e43397b872404..ddc40c70cfce8c93b228bc28a3144da45acd6708:/rtems/gw/libs/load.c

diff --git a/rtems/gw/libs/load.c b/rtems/gw/libs/load.c
index 6afb7a9..d895491 100644
--- a/rtems/gw/libs/load.c
+++ b/rtems/gw/libs/load.c
@@ -1,123 +1,123 @@
-#include <stdio.h>
-
-#include <pthread.h>
-#include <semaphore.h>
-
-#include "load.h"
-
-/* Load function for threads. */
-static void* produce(void* arg);
-static void* consume(void* arg);
-
-/* semaphores for consumer/producer pair */
-static sem_t produced, consumed;
-/* pthread handles for the loader */
-static pthread_t consumer, producer;
-static int n = 0;
-static char running = 0;
-
-static void* produce(void* arg){
-    while (1) {
-            sem_wait(&consumed);
-            n++; 
-            sem_post(&produced);
-            pthread_testcancel();
-    }
-    return NULL;
-}       
-
-static void* consume(void* arg){
-    while (1) {
-            sem_wait(&produced);
-            n--;
-            sem_post(&consumed);
-            pthread_testcancel();
-    }
-    return NULL;
-}
-
-/*
-* This function starts threads loading the CPU and creates associated semaphores. 
-* 
-* Has a guard to prevent starting again, before it was stopped.
-*
-* No error handling currently, only tries to report errors.
-*/
-int start_thread_load(){
-    if (running == 0){
-        printf("Attempting to start load.\n");
-        int res;
-        running = 1;
-        res = sem_init(&consumed, 0, 0);
-        if (res < 0){
-            printf("Couldn't initialize consumed semaphore.\n");
-            return 1;
-        }
-        res = sem_init(&produced, 0, 1);
-        if (res < 0){
-            printf("Couldn't initialize produced semaphore.\n");
-            return 1;
-        }
-        
-        res = pthread_create(&producer, NULL, produce, NULL);
-        if (res < 0){
-            printf("Couldn't create producer thread.\n");
-            return 1;
-        }
-        
-        res = pthread_create(&consumer, NULL, consume, NULL);
-        if (res < 0){
-            printf("Couldn't create consumer thread.\n");
-            return 1;
-        }
-    
-        pthread_detach(producer);
-        pthread_detach(consumer);
-        printf("Load started succesfully.\n");
-        return 0;
-    } else {
-        printf("Load is already running.\n");
-        return 0;
-    }
-}
-
-/*
-* This function stops threads loading the CPU and destroys associated semaphores. 
-*
-* Has a guard against attempting to stop the threads if they are not running.
-* 
-* No error handling currently, only tries to report errors.
-*/
-int end_thread_load(){
-    if (running == 1){
-        int res;
-        printf("Attempting to cancel producer thread.\n");
-        res = pthread_cancel(producer);
-        if (res != 0){
-            /* This means that sending cancel signal has failed... Just returning an error should be enough. */
-            /* If we killed the thread, destroying the semaphore would lead to UB. */
-            printf("Failed.\n");
-            return 1;
-        }
-
-        printf("Attempting to cancel consumer thread.\n");
-        res = pthread_cancel(consumer);
-        if (res != 0){
-            /* Same here. */
-            printf("Failed.\n");
-            return 1;
-        }
-
-        printf("Preparing to destroy semaphores.\n");
-        /* Wait a bit so that the threads can get to a cancellation point. */
-        sleep(1);
-        sem_destroy(&produced);
-        sem_destroy(&consumed);
-        running = 0;
-        printf("Finished.\n");
-        return 0;
-    } else {
-        printf("Load is not running.\n");
-        return 0;
-    }
+#include <stdio.h>
+
+#include <pthread.h>
+#include <semaphore.h>
+
+#include "load.h"
+
+/* Load function for threads. */
+static void* produce(void* arg);
+static void* consume(void* arg);
+
+/* semaphores for consumer/producer pair */
+static sem_t produced, consumed;
+/* pthread handles for the loader */
+static pthread_t consumer, producer;
+static int n = 0;
+static char running = 0;
+
+static void* produce(void* arg){
+    while (1) {
+            sem_wait(&consumed);
+            n++; 
+            sem_post(&produced);
+            pthread_testcancel();
+    }
+    return NULL;
+}       
+
+static void* consume(void* arg){
+    while (1) {
+            sem_wait(&produced);
+            n--;
+            sem_post(&consumed);
+            pthread_testcancel();
+    }
+    return NULL;
+}
+
+/*
+* This function starts threads loading the CPU and creates associated semaphores. 
+* 
+* Has a guard to prevent starting again, before it was stopped.
+*
+* No error handling currently, only tries to report errors.
+*/
+int start_thread_load(){
+    if (running == 0){
+        printf("Attempting to start load.\n");
+        int res;
+        running = 1;
+        res = sem_init(&consumed, 0, 0);
+        if (res < 0){
+            printf("Couldn't initialize consumed semaphore.\n");
+            return 1;
+        }
+        res = sem_init(&produced, 0, 1);
+        if (res < 0){
+            printf("Couldn't initialize produced semaphore.\n");
+            return 1;
+        }
+        
+        res = pthread_create(&producer, NULL, produce, NULL);
+        if (res < 0){
+            printf("Couldn't create producer thread.\n");
+            return 1;
+        }
+        
+        res = pthread_create(&consumer, NULL, consume, NULL);
+        if (res < 0){
+            printf("Couldn't create consumer thread.\n");
+            return 1;
+        }
+    
+        pthread_detach(producer);
+        pthread_detach(consumer);
+        printf("Load started succesfully.\n");
+        return 0;
+    } else {
+        printf("Load is already running.\n");
+        return 0;
+    }
+}
+
+/*
+* This function stops threads loading the CPU and destroys associated semaphores. 
+*
+* Has a guard against attempting to stop the threads if they are not running.
+* 
+* No error handling currently, only tries to report errors.
+*/
+int end_thread_load(){
+    if (running == 1){
+        int res;
+        printf("Attempting to cancel producer thread.\n");
+        res = pthread_cancel(producer);
+        if (res != 0){
+            /* This means that sending cancel signal has failed... Just returning an error should be enough. */
+            /* If we killed the thread, destroying the semaphore would lead to UB. */
+            printf("Failed.\n");
+            return 1;
+        }
+
+        printf("Attempting to cancel consumer thread.\n");
+        res = pthread_cancel(consumer);
+        if (res != 0){
+            /* Same here. */
+            printf("Failed.\n");
+            return 1;
+        }
+
+        printf("Preparing to destroy semaphores.\n");
+        /* Wait a bit so that the threads can get to a cancellation point. */
+        sleep(1);
+        sem_destroy(&produced);
+        sem_destroy(&consumed);
+        running = 0;
+        printf("Finished.\n");
+        return 0;
+    } else {
+        printf("Load is not running.\n");
+        return 0;
+    }
 }
\ No newline at end of file