KONC

dn2/Makefile

@@ -1,5 +1,6 @@
 CC=gcc
 CFLAGS=-g -Wall -lpthread -fopenmp
+DESTINATION=/ceph/grid/home/gs0104/dn/dn2
 
 all: server
 
@@ -9,4 +10,9 @@ server: server.c
 clean: 
 	rm server
 
+push:
+	 rsync -a --progress . nsc:$(DESTINATION)
 
+run_remote:
+	 ssh nsc 'cd $(DESTINATION); make clean; make server;'	
+	 ssh nsc 'srun --reservation=fri --ntasks=1 --cpus-per-task=16 --nodes=1 $(DESTINATION)/server'

dn2/server_b.c

@@ -0,0 +1,108 @@
+#include<stdio.h>
+#include <pthread.h> 
+#include <omp.h>
+#include <stdlib.h>
+#include <unistd.h>
+
+#define N_THREADS 16
+#define N_STEPS 100
+#define N_NUMBERS_CALCULATED 10000
+
+pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
+pthread_spinlock_t alive_threads_lock;
+pthread_spinlock_t produced_numbers_lock;
+
+int amicable_numbers[N_NUMBERS_CALCULATED];
+long produced = 0;
+int threads_alive = 0;
+
+int calculate_amicable_number(int number) {
+    for(int i=1; i< number; i++){
+        if(number % i == 0){
+            number = number + i;
+        }
+    }
+    return number;
+}
+
+void *calculate_amicable_number_invterval(void * arg) {
+  int start = *((int *)arg);
+  int calculated = 0;
+  int h = 0;
+
+  for(int i = 0; i < N_STEPS; i++){ 
+    calculated = calculate_amicable_number(start + i);
+    h++;
+    if (start + i < N_NUMBERS_CALCULATED) {
+      amicable_numbers[start +i] = calculated;
+    } else {
+	    pthread_spin_lock(&alive_threads_lock);
+      threads_alive--;
+	    pthread_spin_unlock(&alive_threads_lock);
+      free(arg);
+      return NULL;
+    }
+  }
+
+	pthread_spin_lock(&alive_threads_lock);
+  threads_alive--;
+	pthread_spin_unlock(&alive_threads_lock);
+  free(arg);
+  return NULL;
+}
+
+int not_all_numbers_calculated() {
+  int ret = 0;
+  pthread_spin_lock(&produced_numbers_lock);
+  if(produced < N_NUMBERS_CALCULATED)
+    ret = 1;
+  pthread_spin_unlock(&produced_numbers_lock); 
+  return ret;
+}
+
+int is_there_space_for_new_thread() {
+  int ret = 0;
+  pthread_spin_lock(&alive_threads_lock);
+  if (threads_alive < N_THREADS)
+    ret = 1;
+  pthread_spin_unlock(&alive_threads_lock);
+  return ret;
+}
+
+int main() {
+	pthread_spin_init(&alive_threads_lock, PTHREAD_PROCESS_PRIVATE);
+	pthread_spin_init(&produced_numbers_lock, PTHREAD_PROCESS_PRIVATE);
+	pthread_t t[N_THREADS];
+
+	double dt = omp_get_wtime();
+  
+  while(not_all_numbers_calculated()){
+
+  
+    for (int i = 0; i<N_THREADS; i++) {
+      int *arg = malloc(sizeof(*arg));
+      pthread_spin_lock(&produced_numbers_lock);
+      *arg = produced;
+      pthread_spin_unlock(&produced_numbers_lock);
+      pthread_create(&t[i], NULL, calculate_amicable_number_invterval,(void *) arg);
+      pthread_spin_lock(&produced_numbers_lock);
+      produced += N_STEPS;
+      pthread_spin_unlock(&produced_numbers_lock);
+    }
+
+    for (int i = 0; i<N_THREADS; i++)
+      pthread_join(t[i], NULL);
+  }
+	dt = omp_get_wtime() - dt;
+  
+	printf("\nExecution time: %lf\n",  dt);
+  return 0;
+
+  /// 10 000 korakov
+  /// 1 THREAD:  14.294979
+  /// 2 THREADS: 11.441722
+  /// 4 THREADS:  9.474156
+  /// 8 THREADS:  7.467914
+  /// 16 THREADS: 3.413084
+
+}