refrator; tests

Makefile

 CFLAGS = -Wall -Wextra -Werror -pedantic -std=c99 -fopenmp
 LDLIBS = -lrt
 CC = gcc
-SOURCES_COMMON = common.c mergeseq.c mergepar.c
-SOURCES_SEQ = $(SOURCES_COMMON) d2s.c
-OUT_SEQ = omp-merge-sort-seq
-OBJS_SEQ = $(SOURCES_SEQ:.c=.o)
-SOURCES_PAR = $(SOURCES_COMMON) d2p.c
-OUT_PAR = omp-merge-sort-par
-OBJS_PAR = $(SOURCES_PAR:.c=.o)
+SOURCES = common.c d2s.c d2p.c main.c
+OUT = omp-merge-sort
+OBJS = $(SOURCES:.c=.o)
 
 all: release
 
 debug: CFLAGS += -g3 -ggdb3
-debug: $(OUT_SEQ) $(OUT_PAR)
+debug: $(OUT)
 
 release: CFLAGS += -o3
-release: $(OUT_SEQ) $(OUT_PAR)
+release: $(OUT)
 
-$(OUT_SEQ): $(OBJS_SEQ)
-	  $(LINK.c) $(OUTPUT_OPTION) $(OBJS_SEQ) $(LDLIBS)
-
-$(OUT_PAR): $(OBJS_PAR)
-	  $(LINK.c) $(OUTPUT_OPTION) $(OBJS_PAR) $(LDLIBS)
+$(OUT): $(OBJS)
+	  $(LINK.c) $(OUTPUT_OPTION) $(OBJS) $(LDLIBS)
 
 clean:
 	  rm -f *.o
 
 distclean: clean
-	  rm -f *.a $(OUT_SEQ) $(OUT_PAR)
+	  rm -f *.a $(OUT)

benchmark.sh

+#! /usr/bin/env sh
+
+cat tests/*.in | ./omp-merge-sort --no-array

common.c

 #include <stdlib.h>
 #include <unistd.h>
 
+unsigned get_cpu_count(void)
+{
+    return (unsigned)sysconf(_SC_NPROCESSORS_ONLN);
+}
+
 struct timespec get_time(void)
 {
     struct timespec start_time;
 {
   int* array = (int*)malloc(n * sizeof(unsigned));
   for (unsigned i = 0; i < n; ++i) {
-    scanf("%i", &array[i]);
+    if (scanf("%i", &array[i]) == EOF) {
+      return 0;
+    }
   }
   return array;
 }
   if (isatty(0)) {
     printf("Enter n: ");
   }
-  scanf("%u", n);
+  if (scanf("%u", n) == EOF) {
+    *array = 0;
+    *n = 0;
+    return;
+  }
   if (isatty(0)) {
     printf("Enter %u integers: ", 2 * *n);
   }
   *array = read_int_array(2 * *n);
+  if (!*array) {
+    *n = 0;
+  }
 }
 
 void print_array(int* array, unsigned n)

common.h

 #define _POSIX_C_SOURCE 199309L
 #include <time.h>
 
+unsigned get_cpu_count(void);
 struct timespec get_time(void);
 struct timespec time_diff(struct timespec* ts1, struct timespec* ts2);
 struct timespec get_duration(struct timespec* ts);

d2p.c

+#include "d2p.h"
 #include "common.h"
-#include "mergepar.h"
+#include "d2s.h"
 
-int main(void)
+void merge_sort_sub_par(int* array, unsigned l, unsigned h, unsigned threads)
 {
-  int* array;
-  unsigned n;
-  read_input(&array, &n);
-  merge_sort_par(array, 2 * n);
-  print_array(array, 2 * n);
-  return 0;
+  if (l < h) {
+    unsigned m = (l + h) / 2;
+    if (threads > 1) {
+      unsigned n = threads / 2;
+      #pragma omp parallel sections
+      {
+        #pragma omp section
+        merge_sort_sub_par(array, l, m, threads);
+        #pragma omp section
+        merge_sort_sub_par(array, m + 1, h, threads - n);
+      }
+    }
+    else {
+      merge_sort_sub_seq(array, l, m);
+      merge_sort_sub_seq(array, m + 1, h);
+    }
+    merge_sort_merge_seq(array, l, m, h);
+  }
+}
+
+void merge_sort_par(int* array, unsigned s, unsigned threads)
+{
+  merge_sort_sub_par(array, 0, s - 1, threads);
 }

d2p.h

+#ifndef D2P_H
+#define D2P_H
+
+void merge_sort_sub_par(int* array, unsigned l, unsigned h, unsigned threads);
+void merge_sort_par(int* array, unsigned s, unsigned threads);
+
+#endif

d2s.c

+#include "d2s.h"
 #include "common.h"
-#include "mergeseq.h"
 
-int main(void)
+void merge_sort_merge_seq(int* array, unsigned l, unsigned m, unsigned h)
 {
-  int* array;
-  unsigned n;
-  read_input(&array, &n);
-  merge_sort_seq(array, 2 * n);
-  print_array(array, 2 * n);
-  return 0;
+  unsigned i = l, j = m + 1, k = 0;
+  int tmp[h - l + 1];
+  while (i <= m && j <= h) {
+    if (array[i] <= array[j]) {
+      tmp[k++] = array[i++];
+    }
+    else {
+      tmp[k++] = array[j++];
+    }
+  }
+
+  while (i <= m) {
+    tmp[k++] = array[i++];
+  }
+  while (j <= h) {
+    tmp[k++] = array[j++];
+  }
+
+  for (--k; k != (unsigned)-1; --k) {
+    array[l + k] = tmp[k];
+  }
+}
+
+void merge_sort_sub_seq(int* array, unsigned l, unsigned h)
+{
+  if (l < h) {
+    unsigned m = (l + h) / 2;
+    merge_sort_sub_seq(array, l, m);
+    merge_sort_sub_seq(array, m + 1, h);
+    merge_sort_merge_seq(array, l, m, h);
+  }
+}
+
+void merge_sort_seq(int* array, unsigned s)
+{
+  merge_sort_sub_seq(array, 0, s - 1);
 }

d2s.h

+#ifndef D2S_H
+#define D2S_H
+
+void merge_sort_merge_seq(int* array, unsigned l, unsigned m, unsigned h);
+void merge_sort_sub_seq(int* array, unsigned l, unsigned h);
+void merge_sort_seq(int* array, unsigned s);
+
+#endif

main.c

+#define _POSIX_C_SOURCE 199309L
+#include <stdio.h>
+#include <string.h>
+#include <time.h>
+#include "common.h"
+#include "d2s.h"
+#include "d2p.h"
+
+int main(int argc, char** argv)
+{
+  int oprint_stats = 1;
+  int oprint_array = 1;
+  int otest = 0;
+
+  for (int i = 1; i < argc; ++i) {
+    if (!strcmp("--no-stats", argv[i])) {
+      oprint_stats = 0;
+    }
+    else if (!strcmp("--no-array", argv[i])) {
+      oprint_array = 0;
+    }
+    else if (!strcmp("--test", argv[i])) {
+      otest = 1;
+    }
+  }
+  if (otest) {
+    oprint_stats = 0;
+    oprint_array = 1;
+  }
+
+  int* array;
+  unsigned n;
+  unsigned threads[3] = {0, 12, 24};
+  unsigned threads_count = (otest ? 1 : sizeof(threads) / sizeof(*threads));
+
+  do {
+    read_input(&array, &n);
+    if (array && n) {
+      for (unsigned t = 0; t < threads_count; ++t) {
+        unsigned thread_count = threads[t];
+        struct timespec start = get_time();
+        if (thread_count == 0) {
+          merge_sort_seq(array, 2 * n);
+        }
+        else {
+          merge_sort_par(array, 2 * n, thread_count);
+        }
+        struct timespec ts = get_duration(&start);
+        if (oprint_array) {
+          print_array(array, 2 * n);
+        }
+        if (oprint_stats) {
+          printf("%3dcpu %3dthreads %6d ", get_cpu_count(), thread_count, n);
+          print_time(&ts);
+          printf("\n");
+        }
+      }
+    }
+  } while (array && n);
+
+  return 0;
+}

mergepar.c

-#include "common.h"
-
-void merge_sort_merge_par(int* array, unsigned l, unsigned m, unsigned h)
-{
-  unsigned i = l, j = m + 1, k = 0;
-  int tmp[h - l + 1];
-  while (i <= m && j <= h) {
-    if (array[i] <= array[j]) {
-      tmp[k++] = array[i++];
-    }
-    else {
-      tmp[k++] = array[j++];
-    }
-  }
-
-  while (i <= m) {
-    tmp[k++] = array[i++];
-  }
-  while (j <= h) {
-    tmp[k++] = array[j++];
-  }
-
-  for (--k; k != (unsigned)-1; --k) {
-    array[l + k] = tmp[k];
-  }
-}
-
-void merge_sort_sub_par(int* array, unsigned l, unsigned h)
-{
-  if (l < h) {
-    unsigned m = (l + h) / 2;
-    merge_sort_sub_par(array, l, m);
-    merge_sort_sub_par(array, m + 1, h);
-    merge_sort_merge_par(array, l, m, h);
-  }
-}
-
-void merge_sort_par(int* array, unsigned s)
-{
-  merge_sort_sub_par(array, 0, s - 1);
-}

mergepar.h

-#ifndef MERGEPAR_H
-#define MERGEPAR_H
-
-void merge_sort_par(int* array, unsigned s);
-
-#endif

mergeseq.c

-#include "common.h"
-
-void merge_sort_merge_seq(int* array, unsigned l, unsigned m, unsigned h)
-{
-  unsigned i = l, j = m + 1, k = 0;
-  int tmp[h - l + 1];
-  while (i <= m && j <= h) {
-    if (array[i] <= array[j]) {
-      tmp[k++] = array[i++];
-    }
-    else {
-      tmp[k++] = array[j++];
-    }
-  }
-
-  while (i <= m) {
-    tmp[k++] = array[i++];
-  }
-  while (j <= h) {
-    tmp[k++] = array[j++];
-  }
-
-  for (--k; k != (unsigned)-1; --k) {
-    array[l + k] = tmp[k];
-  }
-}
-
-void merge_sort_sub_seq(int* array, unsigned l, unsigned h)
-{
-  if (l < h) {
-    unsigned m = (l + h) / 2;
-    merge_sort_sub_seq(array, l, m);
-    merge_sort_sub_seq(array, m + 1, h);
-    merge_sort_merge_seq(array, l, m, h);
-  }
-}
-
-void merge_sort_seq(int* array, unsigned s)
-{
-  merge_sort_sub_seq(array, 0, s - 1);
-}

mergeseq.h

-#ifndef MERGESEQ_H
-#define MERGESEQ_H
-
-void merge_sort_seq(int* array, unsigned s);
-
-#endif

test.sh

 #! /usr/bin/env sh
 
-for exe in omp-merge-sort-seq omp-merge-sort-par
-do
-
-echo "Running ${exe}"
-
 for tIn in tests/*.in
 do
   tOut=$(echo "${tIn}" | sed -re 's/(.+).in/\1/')".out"
   tmpfile=$(mktemp)
-  cat "${tIn}" | "./${exe}" > "${tmpfile}"
+  cat "${tIn}" | ./omp-merge-sort --test > "${tmpfile}"
   cmp "${tmpfile}" "${tOut}"
   res=$?
   if [ ${res} -ne 0 ]
     rm "${tmpfile}"
   fi
 done
-
-done