First commit

Author: pap0018

.gitignore

@@ -0,0 +1,45 @@
+lib
+*~
+*.o
+*.swp
+*#
+Object files
+*.o
+*.ko
+*.obj
+*.elf
+
+# Precompiled Headers
+*.gch
+*.pch
+
+# Libraries
+*.lib
+*.a
+*.la
+*.lo
+
+# Shared objects (inc. Windows DLLs)
+*.dll
+*.so
+*.so.*
+*.dylib
+
+# Executables
+*.exe
+*.out
+*.app
+*.i*86
+*.x86_64
+*.hex
+*-omp
+*-gomp
+*-asm
+*-domp
+*-dgomp
+*.prv
+*.pcf
+*.row
+*.mpits
+set-0
+*.sym

src/Makefile

@@ -0,0 +1,13 @@
+CC = gcc
+
+CFLAGS   = -Wall -O -std=c99 -march=native -I. -D_GNU_SOURCE
+CFLAGS_SO = -fPIC --shared
+
+TARGETS  = libminiomp.so
+all: $(TARGETS) 
+
+libminiomp.so: libminiomp.h libminiomp.c env.c intrinsic.c parallel.c synchronization.c single.c loop.c task.c taskloop.c
+	$(CC) $(CFLAGS_SO) $(CFLAGS) $+ -o $(MINIOMP)/lib/$@ -lpthread 
+
+clean:
+	rm -rf $(MINIOMP)/lib/$(TARGETS)

src/env.c

@@ -0,0 +1,20 @@
+#include <unistd.h>
+#include "libminiomp.h"
+
+// Global variable storing the ICV (internal control variables) supported in our implementation
+miniomp_icv_t miniomp_icv;
+
+// Function to parse OpenMP environment variables, currently just OMP_NUM_THREADS
+void parse_env(void) {
+    char * env = getenv ("OMP_NUM_THREADS");
+    if (env == NULL) {
+      printf("Environment variable OMP_NUM_THREADS not defined, setting nthreads_var ICV to number of cores\n");
+      int procs = (int)sysconf( _SC_NPROCESSORS_ONLN ); // returns the number of cores in system
+      if (procs < 0) 
+          miniomp_icv.nthreads_var = 1; 
+      else miniomp_icv.nthreads_var = procs;
+    } else {
+      miniomp_icv.nthreads_var = atoi(env);
+    }
+    printf("Setting nthreads_var ICV to %d\n", miniomp_icv.nthreads_var);
+}

src/env.h

@@ -0,0 +1,11 @@
+// Type declaration for Internal Control Variables (ICV) structure
+typedef struct {
+  int nthreads_var;
+  // Add other ICVs if needed
+} miniomp_icv_t;
+
+// Global variable storing the ICV (internal control variables) supported in our implementation
+extern miniomp_icv_t miniomp_icv;
+
+// Functions implemented in this module
+void parse_env(void);

src/intrinsic.c

@@ -0,0 +1,23 @@
+#include "libminiomp.h"
+
+void omp_set_num_threads (int n) {
+  miniomp_icv.nthreads_var = (n > 0 ? n : 1);
+}
+
+int omp_get_num_threads (void) {
+  return(miniomp_icv.nthreads_var);
+}
+
+int omp_get_thread_num (void) {
+  //printf("TBI: omp_get_thread_num still doesn't know who I am ... let's say I am 0\n");
+  int thread_id = ((miniomp_parallel_t*) (pthread_getspecific(miniomp_specifickey)))->id;
+  return(thread_id);
+}
+
+// No need to implement this function, it is just involked by Extrae at some point
+// and returns the current nesting for parallel regions
+int omp_get_level (void) {
+    printf("TBI: omp_get_level ... let say current nesting level is 1\n");
+    return(1);
+}
+

src/intrinsic.h

@@ -0,0 +1,14 @@
+// OpenMP intrinsics
+
+// Sets the number of threads to be used in the following parallel regions
+void omp_set_num_threads (int n);
+
+// Returns the number of threads in the current parallel region
+int omp_get_num_threads (void);
+
+// Returns the identifier of the invoking thread within the team
+int omp_get_thread_num (void);
+
+// This function returns the nesting level for the parallel region, 
+// which enclose the calling call 
+int omp_get_level (void);

src/libminiomp.c

@@ -0,0 +1,28 @@
+#include "libminiomp.h"
+//#include "intrinsic.h"
+
+// Library constructor and desctructor
+void init_miniomp(void) __attribute__((constructor));
+void fini_miniomp(void) __attribute__((destructor));
+
+// Function to parse OMP_NUM_THREADS environment variable
+void parse_env(void);
+
+void
+init_miniomp(void) {
+  printf ("mini-omp is being initialized\n");
+  // Parse OMP_NUM_THREADS environment variable to initialize nthreads_var internal control variable
+  parse_env();
+  // Initialize Pthread data structures 
+  // Initialize Pthread thread-specific data, useful for example to store the OpenMP thread identifier
+  pthread_key_create(&miniomp_specifickey, NULL);
+  // Initialize OpenMP default lock and default barrier
+  // Initialize OpenMP workdescriptors for for and single 
+  // Initialize OpenMP task queue for task and taskloop
+}
+
+void
+fini_miniomp(void) {
+  // free structures allocated during library initialization
+  printf ("mini-omp is finalized\n");
+}

src/libminiomp.h

@@ -0,0 +1,25 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <ctype.h>
+#include <stdbool.h>
+#include <string.h>
+#include <stdint.h>
+#include <pthread.h>
+
+// Maximum number of threads to be supported by our implementation
+// To be used whenever you need to dimension thread-related structures
+#define MAX_THREADS 32
+
+extern pthread_key_t miniomp_specifickey;
+
+// To implement memory barrier (flush)
+//void __atomic_thread_fence(int);
+#define mb() __atomic_thread_fence(3)
+
+#include "intrinsic.h"
+#include "env.h"
+#include "parallel.h"
+#include "synchronization.h"
+#include "loop.h"
+#include "single.h"
+#include "task.h"

src/loop.c

@@ -0,0 +1,79 @@
+#include "libminiomp.h"
+
+// Declaratiuon of global variable for loop work descriptor
+miniomp_loop_t miniomp_loop;
+
+/* The *_next routines are called when the thread completes processing of 
+   the iteration block currently assigned to it.  If the work-share 
+   construct is bound directly to a parallel construct, then the iteration
+   bounds may have been set up before the parallel.  In which case, this
+   may be the first iteration for the thread.
+
+   Returns true if there is work remaining to be performed; *ISTART and
+   *IEND are filled with a new iteration block.  Returns false if all work
+   has been assigned.  */
+
+bool
+GOMP_loop_dynamic_next (long *istart, long *iend) {
+  printf("TBI: Asking for more iterations? I gave you all at the beginning, no more left ...\n");
+  return(false);
+}
+
+/* The *_start routines are called when first encountering a loop construct
+   that is not bound directly to a parallel construct.  The first thread 
+   that arrives will create the work-share construct; subsequent threads
+   will see the construct exists and allocate work from it.
+
+   START, END, INCR are the bounds of the loop; CHUNK_SIZE is the
+   scheduling parameter. 
+
+   Returns true if there's any work for this thread to perform.  If so,
+   *ISTART and *IEND are filled with the bounds of the iteration block
+   allocated to this thread.  Returns false if all work was assigned to
+   other threads prior to this thread's arrival.  */
+
+bool
+GOMP_loop_dynamic_start (long start, long end, long incr, long chunk_size,
+                         long *istart, long *iend)
+{
+  printf("TBI: What a mess! Starting a non-static for worksharing construct and dont know what to do, I'll take it all\n");
+  *istart = start;
+  *iend = end;
+  return(true);
+}
+
+/* The GOMP_loop_end* routines are called after the thread is told that
+   all loop iterations are complete.  The first version synchronize
+   all threads; the nowait version does not. */
+
+void
+GOMP_loop_end (void) {
+  printf("TBI: Finishing a for worksharing construct with non static schedule\n");
+}
+
+void
+GOMP_loop_end_nowait (void) {
+  printf("TBI: Finishing a for worksharing construct with non static schedule, with nowait clause\n");
+}
+
+#if 0
+// Only implement this if really needed, i.e. you find a case in which it is invoked
+
+/* The GOMP_parallel_loop_* routines pre-initialize a work-share construct
+   to avoid one synchronization once we get into the loop. The compiler 
+   does not invoke the *_start routine for the work-share. And of course, 
+   the compiler does not invoke GOMP_loop_end. These routines should create 
+   the team of threads to execute the work-share in parallel */
+
+void
+GOMP_parallel_loop_dynamic (void (*fn) (void *), void *data,
+                            unsigned num_threads, long start, long end,
+                            long incr, long chunk_size, unsigned flags)
+{
+  printf("TBI: What another mess! Directly starting a parallel and a non-static for worksharing construct! I am lost!\n");
+  // Here you should pre-initialize the work-sharing structures as done in 
+  // GOMP_loop_dynamic_start; only the master thread is doing this, the other
+  // threads in the team do not reach this point 
+  GOMP_parallel (fn, data, num_threads, flags);
+}
+#endif

src/loop.h

@@ -0,0 +1,19 @@
+// Type declaration for loop worksharing descriptor
+typedef struct {
+  long start;           // loop bounds and increment 
+  long end;
+  long incr;
+
+  int schedule;         // schedule kind for loop
+  long chunk_size;
+  // complete the definition of worksharing descriptor
+} miniomp_loop_t;
+
+#define ws_STATIC 	0
+#define ws_STATICCHUNK 	1
+#define ws_DYNAMIC 	2
+#define ws_GUIDED 	3
+#define ws_RUNTIME 	4
+#define ws_AUTO 	5
+
+extern miniomp_loop_t miniomp_loop;