Changes in / [b0b89a8:9373b6a]

Files:

• benchmark/readyQ/cycle.cfa (modified) (1 diff)
• benchmark/readyQ/locality.cfa (modified) (2 diffs)
• benchmark/readyQ/yield.cpp (modified) (3 diffs)
• libcfa/prelude/bootloader.cf (modified) (2 diffs)
• libcfa/src/concurrency/invoke.h (modified) (1 diff)
• libcfa/src/concurrency/kernel.cfa (modified) (4 diffs)
• libcfa/src/concurrency/kernel.hfa (modified) (1 diff)
• libcfa/src/concurrency/kernel/startup.cfa (modified) (1 diff)
• libcfa/src/concurrency/ready_queue.cfa (modified) (1 diff)
• libcfa/src/concurrency/thread.cfa (modified) (1 diff)

benchmark/readyQ/cycle.cfa

@@ -85 +85 @@
                 }
 
-                printf("Duration (ms)        : %'ld\n", (end - start)`dms);
+                printf("Duration (ms)        : %'lf\n", (end - start)`dms);
                 printf("Number of processors : %'d\n", nprocs);
                 printf("Number of threads    : %'d\n", tthreads);

benchmark/readyQ/locality.cfa

@@ -126 +126 @@
 // ==================================================
 // Do some work by accessing 'cnt' cells in the array
-__attribute__((noinline)) void work(MyData & data, size_t cnt, uint64_t & state) {
-        for (cnt) {
+__attribute__((noinline)) void work(MyData & data, size_t cnt_, uint64_t & state) {
+        for (cnt_) {
                 access(data, __xorshift64(state));
         }
@@ -200 +200 @@
 
         if( nspots == 0 ) { nspots = nthreads - nprocs; }
+        if( nspots == 0 ) {
+                fprintf(stderr, "--nspots must be set or --nthreads set to something bigger than --nprocs\n");
+                exit(EXIT_FAILURE);
+        }
 
         Time start, end;

benchmark/readyQ/yield.cpp

@@ -29 +29 @@
 #include "libfibre/fibre.h"
 
-FibreBarrier * barrier;
+FredBarrier * barrier;
 struct __attribute__((aligned(128))) counter_t {
         int value = 0;
@@ -66 +66 @@
 
                 const char * arg = optarg ? optarg : "";
-                size_t len = 0;
                 char * end;
                 switch(opt) {
@@ -111 +110 @@
 
                 FibreInit();
-                barrier = new FibreBarrier(nthreads + 1);
+                barrier = new FredBarrier(nthreads + 1);
                 {
                         Context::CurrCluster().addWorkers(nprocs);

libcfa/prelude/bootloader.cf

@@ -3 +3 @@
 char ** cfa_args_argv;
 char ** cfa_args_envp;
+int cfa_main_returned = 0;
 
 int main(int argc, char* argv[], char* envp[]) {
@@ -8 +9 @@
         cfa_args_argv = argv;
         cfa_args_envp = envp;
-        return invoke_main(argc, argv, envp);
+        int ret = invoke_main(argc, argv, envp);
+        cfa_main_returned = 1;
+        return ret;
 }

libcfa/src/concurrency/invoke.h

@@ -170 +170 @@
                 bool corctx_flag;
 
+                int last_cpu;
+
                 //SKULLDUGGERY errno is not save in the thread data structure because returnToKernel appears to be the only function to require saving and restoring it
 

libcfa/src/concurrency/kernel.cfa

@@ -394 +394 @@
         __builtin_prefetch( thrd_dst->context.SP );
 
+        int curr = __kernel_getcpu();
+        if(thrd_dst->last_cpu != curr) {
+                int64_t l = thrd_dst->last_cpu;
+                int64_t c = curr;
+                int64_t v = (l << 32) | c;
+                __push_stat( __tls_stats(), v, false, "Processor", this );
+        }
+
+        thrd_dst->last_cpu = curr;
+
         __cfadbg_print_safe(runtime_core, "Kernel : core %p running thread %p (%s)\n", this, thrd_dst, thrd_dst->self_cor.name);
 
@@ -470 +480 @@
                                 #if !defined(__CFA_NO_STATISTICS__)
                                         __tls_stats()->ready.threads.threads++;
-                                        __push_stat( __tls_stats(), __tls_stats()->ready.threads.threads, false, "Processor", this );
                                 #endif
                                 // This is case 2, the racy case, someone tried to run this thread before it finished blocking
@@ -488 +497 @@
         #if !defined(__CFA_NO_STATISTICS__)
                 __tls_stats()->ready.threads.threads--;
-                __push_stat( __tls_stats(), __tls_stats()->ready.threads.threads, false, "Processor", this );
         #endif
 
@@ -570 +578 @@
                                 __tls_stats()->ready.threads.extunpark++;
                         }
-                        __push_stat( __tls_stats(), __tls_stats()->ready.threads.threads, false, "Processor", kernelTLS().this_processor );
                 }
                 else {
                         __atomic_fetch_add(&cl->stats->ready.threads.threads, 1, __ATOMIC_RELAXED);
                         __atomic_fetch_add(&cl->stats->ready.threads.extunpark, 1, __ATOMIC_RELAXED);
-                        __push_stat( cl->stats, cl->stats->ready.threads.threads, true, "Cluster", cl );
                 }
         #endif

libcfa/src/concurrency/kernel.hfa

@@ -67 +67 @@
                 unsigned target;
                 unsigned last;
+                unsigned cnt;
                 unsigned long long int cutoff;
         } rdq;

libcfa/src/concurrency/kernel/startup.cfa

@@ -478 +478 @@
         state = Start;
         self_cor{ info };
+        last_cpu = __kernel_getcpu();
         curr_cor = &self_cor;
         curr_cluster = mainCluster;

libcfa/src/concurrency/ready_queue.cfa

@@ -345 +345 @@
                         /* paranoid */ verify(lanes.count < 65536); // The following code assumes max 65536 cores.
                         /* paranoid */ verify(map.count < 65536); // The following code assumes max 65536 cores.
-                        uint64_t chaos = __tls_rand();
-                        uint64_t high_chaos = (chaos >> 32);
-                        uint64_t  mid_chaos = (chaos >> 16) & 0xffff;
-                        uint64_t  low_chaos = chaos & 0xffff;
-
-                        unsigned me = map.self;
-                        unsigned cpu_chaos = map.start + (mid_chaos % map.count);
-                        bool global = cpu_chaos == me;
-
-                        if(global) {
-                                proc->rdq.target = high_chaos % lanes.count;
+
+                        if(0 == (__tls_rand() % 10_000)) {
+                                proc->rdq.target = __tls_rand() % lanes.count;
                         } else {
-                                proc->rdq.target = (cpu_chaos * READYQ_SHARD_FACTOR) + (low_chaos % READYQ_SHARD_FACTOR);
+                                unsigned cpu_chaos = map.start + (__tls_rand() % map.count);
+                                proc->rdq.target = (cpu_chaos * READYQ_SHARD_FACTOR) + (__tls_rand() % READYQ_SHARD_FACTOR);
                                 /* paranoid */ verify(proc->rdq.target >= (map.start * READYQ_SHARD_FACTOR));
                                 /* paranoid */ verify(proc->rdq.target <  ((map.start + map.count) * READYQ_SHARD_FACTOR));

libcfa/src/concurrency/thread.cfa

@@ -34 +34 @@
         preempted = __NO_PREEMPTION;
         corctx_flag = false;
+        last_cpu = __kernel_getcpu();
         curr_cor = &self_cor;
         self_mon.owner = &this;