Changeset 581 for trunk/kernel/libk/remote_barrier.c

Timestamp:

Oct 10, 2018, 3:11:53 PM (6 years ago)

Author:

alain

Message:

1) Improve the busylock debug infrastructure.
2) introduce a non-distributed, but portable implementation for the pthread_barrier.

File:

• trunk/kernel/libk/remote_barrier.c (modified) (6 diffs)

trunk/kernel/libk/remote_barrier.c

@@ -83 +83 @@
 
     // get pointer on local process descriptor
-    process_t * process = CURRENT_THREAD->process;
+    thread_t  * this    = CURRENT_THREAD;
+    process_t * process = this->process;
+
+#if DEBUG_BARRIER
+uint32_t cycle = (uint32_t)hal_get_cycles();
+if( cycle > DEBUG_BARRIER )
+printk("\n[DBG] %s : thread %x in process %x enter / count %d / cycle %d\n",
+__FUNCTION__, this->trdid, process->pid, count, cycle );
+#endif
 
     // get extended pointer on reference process
@@ -110 +118 @@
 
     // initialise barrier
-    hal_remote_s32 ( XPTR( ref_cxy , &barrier_ptr->nb_threads ) , count );
-    hal_remote_s32 ( XPTR( ref_cxy , &barrier_ptr->current    ) , 0 );
-    hal_remote_s32 ( XPTR( ref_cxy , &barrier_ptr->sense      ) , 0 );
+    hal_remote_s32( XPTR( ref_cxy , &barrier_ptr->nb_threads ) , count );
+    hal_remote_s32( XPTR( ref_cxy , &barrier_ptr->current    ) , 0 );
+    hal_remote_s32( XPTR( ref_cxy , &barrier_ptr->sense      ) , 0 );
     hal_remote_spt( XPTR( ref_cxy , &barrier_ptr->ident      ) , (void*)ident );
 
-    xlist_entry_init( XPTR( ref_cxy , &barrier_ptr->list ) );
+    xlist_root_init( XPTR( ref_cxy , &barrier_ptr->root ) );
 
     // register  barrier in reference process xlist
@@ -125 +133 @@
     remote_busylock_release( XPTR( ref_cxy , &ref_ptr->sync_lock ) );
 
+#if DEBUG_BARRIER
+cycle = (uint32_t)hal_get_cycles();
+if( cycle > DEBUG_BARRIER )
+printk("\n[DBG] %s : thread %x in process %x exit / barrier %x in cluster %x / cycle %d\n",
+__FUNCTION__, this->trdid, process->pid, barrier_ptr, ref_cxy, cycle );
+#endif
+
     return 0;
-}
+
+}  // end remote_barrier_create()
 
 ////////////////////////////////////////////////
@@ -162 +178 @@
         rpc_kcm_free_client( barrier_cxy , barrier_ptr , KMEM_BARRIER );
     }
-}
+}  // end remote_barrier_destroy()
 
 /////////////////////////////////////////////
@@ -168 +184 @@
 {
     uint32_t  expected;
+    uint32_t  sense;
     uint32_t  current;
-    uint32_t  count;
-    uint32_t  sense;
-    reg_t     irq_state;
+    uint32_t  nb_threads;
     xptr_t    root_xp;
-
-    // get cluster and local pointer on calling thread
-    cxy_t              thread_cxy = local_cxy;
-    thread_t         * thread_ptr = CURRENT_THREAD;
-
-// check calling thread can yield
-assert( (thread_ptr->busylocks == 0),
-"cannot yield : busylocks = %d\n", thread_ptr->busylocks );
+    xptr_t    lock_xp;
+    xptr_t    current_xp;
+    xptr_t    sense_xp;
+    xptr_t    nb_threads_xp;
+
+    // get pointer on calling thread
+    thread_t * this = CURRENT_THREAD;
+
+    // check calling thread can yield
+    thread_assert_can_yield( this , __FUNCTION__ );
 
     // get cluster and local pointer on remote barrier
-    remote_barrier_t * barrier_ptr = (remote_barrier_t *)GET_PTR( barrier_xp );
+    remote_barrier_t * barrier_ptr = GET_PTR( barrier_xp );
     cxy_t              barrier_cxy = GET_CXY( barrier_xp );
 
-    // get count and root fields from barrier descriptor
-    count   = hal_remote_l32 ( XPTR( barrier_cxy , &barrier_ptr->nb_threads ) );
-    root_xp = hal_remote_l64( XPTR( barrier_cxy , &barrier_ptr->root ) );
-
-    // get barrier sense value
-    sense = hal_remote_l32( XPTR( barrier_cxy , &barrier_ptr->sense ) );
+#if DEBUG_BARRIER
+uint32_t cycle = (uint32_t)hal_get_cycles();
+if( cycle > DEBUG_BARRIER )
+printk("\n[DBG] %s : thread %x in process %x enter / barrier %x in cluster %x / cycle %d\n",
+__FUNCTION__, this->trdid, this->process->pid, barrier_ptr, barrier_cxy, cycle );
+#endif
+
+    // compute extended pointers on various barrier fields
+    lock_xp       = XPTR( barrier_cxy , &barrier_ptr->lock );
+    root_xp       = XPTR( barrier_cxy , &barrier_ptr->root );
+    current_xp    = XPTR( barrier_cxy , &barrier_ptr->current );
+    sense_xp      = XPTR( barrier_cxy , &barrier_ptr->sense );
+    nb_threads_xp = XPTR( barrier_cxy , &barrier_ptr->nb_threads );
+
+    // take busylock protecting the remote_barrier
+    remote_busylock_acquire( lock_xp );
+
+#if (DEBUG_BARRIER & 1)
+cycle = (uint32_t)hal_get_cycles();
+if( cycle > DEBUG_BARRIER )
+printk("\n[DBG] %s : thread %x in process %x get lock / cycle %d\n",
+__FUNCTION__, this->trdid, this->process->pid, cycle );
+#endif
+
+    // get sense and nb_threads values from barrier descriptor
+    sense      = hal_remote_l32( sense_xp );
+    nb_threads = hal_remote_l32( nb_threads_xp );
 
     // compute expected value
@@ -197 +235 @@
     else              expected = 0;
 
-    // atomically increment current
-    current = hal_remote_atomic_add( XPTR( barrier_cxy , &barrier_ptr->current ) , 1 );
+#if (DEBUG_BARRIER & 1)
+cycle = (uint32_t)hal_get_cycles();
+if( cycle > DEBUG_BARRIER )
+printk("\n[DBG] %s : thread %x in process %x / count %d / sense %d / cycle %d\n",
+__FUNCTION__, this->trdid, this->process->pid, nb_threads, sense, cycle );
+#endif
+
+    // atomically increment current, and get value before increment
+    current = hal_remote_atomic_add( current_xp , 1 );
 
     // last thread reset current, toggle sense, and activate all waiting threads
     // other threads block, register in queue, and deschedule
 
-    if( current == (count-1) )                       // last thread
-    {
-        hal_remote_s32( XPTR( barrier_cxy , &barrier_ptr->current) , 0 );
-        hal_remote_s32( XPTR( barrier_cxy , &barrier_ptr->sense  ) , expected );
-
-        // activate waiting threads if required
-        if( xlist_is_empty( root_xp ) == false )
+    if( current == (nb_threads-1) )                       // last thread
+    {
+        hal_remote_s32( current_xp , 0 );
+        hal_remote_s32( sense_xp , expected );
+
+        // unblock all waiting threads
+        while( xlist_is_empty( root_xp ) == false )
         {
-            // disable interrupts
-            hal_disable_irq( &irq_state );
-
-            xptr_t  iter_xp;
-            xptr_t  thread_xp;
-            XLIST_FOREACH( root_xp , iter_xp )
-            {
-                // get extended pointer on waiting thread
-                thread_xp = XLIST_ELEMENT( iter_xp , thread_t , wait_list );
-
-                // remove waiting thread from queue
-                remote_busylock_acquire( XPTR( barrier_cxy , &barrier_ptr->lock ) );
-                xlist_unlink( XPTR( barrier_cxy , &barrier_ptr->list ) );
-                remote_busylock_release( XPTR( barrier_cxy , &barrier_ptr->lock ) );
-
-                // unblock waiting thread
-                thread_unblock( thread_xp , THREAD_BLOCKED_USERSYNC );
-            }
-
-            // restore interrupts
-            hal_restore_irq( irq_state );
+            // get pointers on first waiting thread
+            xptr_t     thread_xp  = XLIST_FIRST( root_xp , thread_t , wait_list );
+            cxy_t      thread_cxy = GET_CXY( thread_xp );
+            thread_t * thread_ptr = GET_PTR( thread_xp );
+
+#if (DEBUG_BARRIER & 1)
+cycle = (uint32_t)hal_get_cycles();
+if( cycle > DEBUG_BARRIER )
+printk("\n[DBG] %s : thread %x in process %x / unblock thread %x / cycle %d\n",
+__FUNCTION__, this->trdid, this->process->pid, thread_ptr, cycle );
+#endif
+
+            // remove waiting thread from queue
+            xlist_unlink( XPTR( thread_cxy , &thread_ptr->wait_list ) );
+
+            // unblock waiting thread
+            thread_unblock( thread_xp , THREAD_BLOCKED_USERSYNC );
         }
+
+        // release busylock protecting the remote_barrier
+        remote_busylock_release( lock_xp );
     }
     else                                             // not the last thread
     {
-        // disable interrupts
-        hal_disable_irq( &irq_state );
+
+#if (DEBUG_BARRIER & 1)
+cycle = (uint32_t)hal_get_cycles();
+if( cycle > DEBUG_BARRIER )
+printk("\n[DBG] %s : thread %x in process %x / blocked / cycle %d\n",
+__FUNCTION__, this->trdid, this->process->pid, cycle );
+#endif
 
         // register calling thread in barrier waiting queue
-        xptr_t entry_xp = XPTR( thread_cxy , &thread_ptr->wait_list );
-
-        remote_busylock_acquire( XPTR( barrier_cxy , &barrier_ptr->lock ) );
-        xlist_add_last( root_xp , entry_xp );
-        remote_busylock_release( XPTR( barrier_cxy , &barrier_ptr->lock ) );
-
-        // block & deschedule the calling thread
-        thread_block( XPTR( local_cxy , thread_ptr ) , THREAD_BLOCKED_USERSYNC );
+        xlist_add_last( root_xp , XPTR( local_cxy , &this->wait_list ) );
+
+        // block calling thread
+        thread_block( XPTR( local_cxy , this ) , THREAD_BLOCKED_USERSYNC );
+
+        // release busylock protecting the remote_barrier
+        remote_busylock_release( lock_xp );
+
+        // deschedule
         sched_yield("blocked on barrier");
-
-        // restore interrupts
-        hal_restore_irq( irq_state );
-    }
-}
+    }
+
+#if DEBUG_BARRIER
+cycle = (uint32_t)hal_get_cycles();
+if( cycle > DEBUG_BARRIER )
+printk("\n[DBG] %s : thread %x in process %x exit / barrier %x in cluster %x / cycle %d\n",
+__FUNCTION__, this->trdid, this->process->pid, barrier_ptr, barrier_cxy, cycle );
+#endif
+
+}  // end remote_barrier_wait()