Changes between Version 15 and Version 16 of kernel_locks

Timestamp:

Jul 17, 2015, 11:43:10 AM (9 years ago)

Author:

alain

Comment:

--

kernel_locks

@@ -19 +19 @@
 == Atomic access function ==
 
- === unsigned int '''_atomic_increment'''( unsigned int * shared , unsigned int increment ) ===
-This blocking function use a LL/SC to atomically increment a shared variable. 
+ === __unsigned int '''_atomic_increment'''( unsigned int * shared , unsigned int increment )__ ===
+This blocking function uses  LL/SC to atomically increment a shared variable. 
  * '''shared''' : pointer on the shared variable
  * '''increment''' : increment value
 It returns the value of the shared variable before increment.
 
+ === __void '''_atomic_or'''( unsigned int *shared , unsigned int mask )__ ===
+This blocking function uses LL/SC to atomically set a bit field in a shared variable.
+ * '''shared''' : pointer on the shared variable.
+ * '''mask''' : *ptr <= *ptr | mask
+
+ === __void '''_atomic_and'''( unsigned int *shared , unsigned int mask )__ ===
+This blocking function uses LL/SC to atomically reset a bit field in a shared variable.
+ * '''shared''' : pointer on the shared variable.
+ * '''mask''' : *ptr <= *ptr & mask
+
 == Simple lock access functions ==
 
- === void '''_simple_lock_acquire'''( simple_lock_t * lock ) ===
+ === __void '''_simple_lock_acquire'''( simple_lock_t * lock )__ ===
 This blocking function does not implement any ordered allocation, and is not distributed. 
 It returns only when the lock as been granted.
 
- === void '''_simple_lock_release'''( simple_lock_t * lock ) ===
+ === __void '''_simple_lock_release'''( simple_lock_t * lock )__ ===
 This function releases the lock, and can be used for lock initialisation. 
 It must always be called after a successful _simple_lock_acquire().
@@ -37 +47 @@
 == Queuing Lock Access functions == 
 
- === void '''_spin_lock_init'''( spin_lock_t * lock ) ===
+ === __void '''_spin_lock_init'''( spin_lock_t * lock )__ ===
 This function initializes the spin_lock ticket allocator.
 
- === void '''_spin_lock_acquire'''( spin_lock_t * lock ) ===
+ === __void '''_spin_lock_acquire'''( spin_lock_t * lock )__ ===
 This blocking function uses the atomic_increment() function, to implement a ticket allocator and provide ordered access to the lock. It returns only when the lock as been granted.
 
- === void '''_spin_lock_release'''( spin_lock_t * lock ) ===
+ === __void '''_spin_lock_release'''( spin_lock_t * lock )__ ===
 This function releases the lock, but cannot be used for lock initialisation. It must always be called after a successful _lock_acquire().
 
 == Distributed Lock Access functions ==
 
- === void '''_sbt_lock_init'''( sbt_lock_t*   lock ) === 
+ === __void '''_sqt_lock_init'''( sqt_lock_t*   lock )__ === 
 This function allocates and initialises the SQT nodes, distributed on all clusters. It computes the smallest SQT covering all processors defined in the mapping. This function use the _remote_malloc() function, and the distributed kernel heap segments.
 
- === void '''_sbt_lock_acquire'''( sbt_lock_t*  lock ) ===
-This function tries to acquire the SBT lock: It tries to get each "partial" lock on the path from bottom to top, using an atomic LL/SC, and starting from bottom. It is blocking : it polls each "partial" lock until it can be taken, and returns only  when all "partial" locks, at all levels have been obtained.
+ === __void '''_sqt_lock_acquire'''( sqt_lock_t*  lock )__ ===
+This function tries to acquire the SQT lock: It tries to get each "partial" lock on the path from bottom to top, using an atomic LL/SC, and starting from bottom. It is blocking : it polls each "partial" lock until it can be taken, and returns only  when all "partial" locks, at all levels have been obtained.
 
- === void '''_sbt_lock_release'''( sbt_lock_t*  lock ) ===
-This function releases the SBT lock: It reset all "partial" locks on the path from bottom to top, using a normal write, and starting from bottom.
+ === __void '''_sqt_lock_release'''( sqt_lock_t*  lock )__ ===
+This function releases the SQT lock: It reset all "partial" locks on the path from bottom to top, using a normal write, and starting from bottom.
 
-