Changes between Version 3 and Version 4 of kernel_locks

Timestamp:

Dec 2, 2014, 7:11:01 PM (10 years ago)

Author:

alain

Comment:

--

kernel_locks

@@ -3 +3 @@
 [[PageOutline]]
 
-The [source:soft/giet_vm/giet_common/utils.c utils.c] and [source:soft/giet_vm/giet_common/utils.h util.h] files define the functions used to take & release a kernel lock. 
+The [source:soft/giet_vm/giet_common/locks.c locks.c] and [source:soft/giet_vm/giet_common/locks.h locks.h] files define the functions used to take & release the kernel locks. These locks are implemented as spin-locks with a waiting queue (based on a ticket allocator scheme) to enforce fairness and avoid live-lock situations. The GIET_LOCK_MAX_TICKET define the wrapping value for the ticket allocator.
 
-They are prefixed by "_" to remind that they can only be executed by a processor in kernel mode.
+The lock access functions are prefixed by "_" to remind that they can only be executed by a processor in kernel mode.
 
-The ''giet_lock_t'' structure is defined in the ''utils.h'' file to have one single lock in a 64 bytes cache line. It should be aligned on a cache line boundary.
+The ''spin_lock_t'' structure is defined to have one single lock in a 64 bytes cache line, and should be aligned on a cache line boundary.
 
- === void _get_lock( giet_lock_t lock ) ===
-Takes a lock with a blocking ll/sc atomic access. 
- * If the cache coherence is granted by the hardware, the first read is a standard (cacheable) lw, as the local copy can be polled when the lock is already taken by another task, reducing trafic on the interconnect. When the lock is released by the owner task, the local copy is updated or invalidated by the coherence protocol. 
- * If there is no hardware cache coherence a pseudo random delay is introduced between two successive retry.
 
- === void _release_lock( giet_lock_t lock ) ===
-Releases (or initializes) a lock.
+ === unsigned int '''_atomic_increment'''( unsigned int * shared , unsigned int increment ) ===
+This blocking function use a LL/SC to atomically increment a shared variable.
+ * '''shared''' : pointer on the shared variable
+ * '''increment''' : increment value
+
+ === void '''_lock_init( spin_lock_t * lock ) ===
+This function initializes the spin lock ticket allocator.
+
+ === void '''_lock_acquire'''( spin_lock_t * lock ) ===
+This blocking function uses the atomic_increment() function, and returns only when the lock as been granted.
+
+ === void '''_lock_release'''( giet_lock_t * lock ) ===
+Releases the spin-lock. This must always be called after a successful _lock_acquire().