Changes in libcfa/src/concurrency/kernel.cfa [24e321c:445f984]

File:

• libcfa/src/concurrency/kernel.cfa (modified) (10 diffs)

libcfa/src/concurrency/kernel.cfa

@@ -341 +341 @@
                                 }
 
-                                __STATS( if(this->print_halts) __cfaabi_bits_print_safe( STDOUT_FILENO, "PH:%d - %lld 0\n", this->unique_id, rdtscl()); )
+                                        __STATS( if(this->print_halts) __cfaabi_bits_print_safe( STDOUT_FILENO, "PH:%d - %lld 0\n", this->unique_id, rdtscl()); )
                                 __cfadbg_print_safe(runtime_core, "Kernel : core %p waiting on eventfd %d\n", this, this->idle);
 
-                                {
-                                        eventfd_t val;
-                                        ssize_t ret = read( this->idle, &val, sizeof(val) );
-                                        if(ret < 0) {
-                                                switch((int)errno) {
-                                                case EAGAIN:
-                                                #if EAGAIN != EWOULDBLOCK
-                                                        case EWOULDBLOCK:
-                                                #endif
-                                                case EINTR:
-                                                        // No need to do anything special here, just assume it's a legitimate wake-up
-                                                        break;
-                                                default:
-                                                        abort( "KERNEL : internal error, read failure on idle eventfd, error(%d) %s.", (int)errno, strerror( (int)errno ) );
-                                                }
-                                        }
-                                }
+                                // __disable_interrupts_hard();
+                                eventfd_t val;
+                                eventfd_read( this->idle, &val );
+                                // __enable_interrupts_hard();
 
                                         __STATS( if(this->print_halts) __cfaabi_bits_print_safe( STDOUT_FILENO, "PH:%d - %lld 1\n", this->unique_id, rdtscl()); )
@@ -422 +409 @@
         /* paranoid */ verifyf( thrd_dst->link.next == 0p, "Expected null got %p", thrd_dst->link.next );
         __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);
@@ -476 +473 @@
                 if(unlikely(thrd_dst->preempted != __NO_PREEMPTION)) {
                         // The thread was preempted, reschedule it and reset the flag
-                        schedule_thread$( thrd_dst, UNPARK_LOCAL );
+                        schedule_thread$( thrd_dst );
                         break RUNNING;
                 }
@@ -560 +557 @@
 // Scheduler routines
 // KERNEL ONLY
-static void __schedule_thread( thread$ * thrd, unpark_hint hint ) {
+static void __schedule_thread( thread$ * thrd ) {
         /* paranoid */ verify( ! __preemption_enabled() );
         /* paranoid */ verify( ready_schedule_islocked());
@@ -580 +577 @@
         // Dereference the thread now because once we push it, there is not guaranteed it's still valid.
         struct cluster * cl = thrd->curr_cluster;
-        __STATS(bool outside = hint == UNPARK_LOCAL && thrd->last_proc && thrd->last_proc != kernelTLS().this_processor; )
+        __STATS(bool outside = thrd->last_proc && thrd->last_proc != kernelTLS().this_processor; )
 
         // push the thread to the cluster ready-queue
-        push( cl, thrd, hint );
+        push( cl, thrd, local );
 
         // variable thrd is no longer safe to use
@@ -608 +605 @@
 }
 
-void schedule_thread$( thread$ * thrd, unpark_hint hint ) {
+void schedule_thread$( thread$ * thrd ) {
         ready_schedule_lock();
-                __schedule_thread( thrd, hint );
+                __schedule_thread( thrd );
         ready_schedule_unlock();
 }
@@ -661 +658 @@
 }
 
-void __kernel_unpark( thread$ * thrd, unpark_hint hint ) {
+void __kernel_unpark( thread$ * thrd ) {
         /* paranoid */ verify( ! __preemption_enabled() );
         /* paranoid */ verify( ready_schedule_islocked());
@@ -669 +666 @@
         if(__must_unpark(thrd)) {
                 // Wake lost the race,
-                __schedule_thread( thrd, hint );
+                __schedule_thread( thrd );
         }
 
@@ -676 +673 @@
 }
 
-void unpark( thread$ * thrd, unpark_hint hint ) {
+void unpark( thread$ * thrd ) {
         if( !thrd ) return;
 
@@ -682 +679 @@
                 disable_interrupts();
                         // Wake lost the race,
-                        schedule_thread$( thrd, hint );
+                        schedule_thread$( thrd );
                 enable_interrupts(false);
         }