Changes between Version 7 and Version 8 of kernel_locks

Timestamp:

Dec 5, 2014, 2:49:56 PM (10 years ago)

Author:

alain

Comment:

--

kernel_locks

@@ -3 +3 @@
 [[PageOutline]]
 
-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 by the kernel to take & release  locks protecting exclusive access to a shared resource. 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.
+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 by the kernel to take & release  locks protecting exclusive access to a shared resource. 
+
+The GIET_VM kernel define two types of spin-lock:
+ * The '''spin_lock_t''' implements a spin-lock 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.
+ * The '''simple_lock_t''' implements a spin-lock without waiting queue. It is only used by the TTY0 access functions, to get exclusive access to the TTY0 kernel terminal 
 
 The lock access functions are prefixed by "_" to remind that they can only be executed by a processor in kernel mode.
 
-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.
+Both the '''spin_lock_t''' and '''simple_lock_t''' structures are implemented to have one single lock in a 64 bytes cache line, and should be aligned on a cache line boundary.
 
 
  === unsigned int '''_atomic_increment'''( unsigned int * shared , unsigned int increment ) ===
-This blocking function use a LL/SC to atomically increment a shared variable.
+This blocking function use a LL/SC to atomically increment a shared variable. 
  * '''shared''' : pointer on the shared variable
  * '''increment''' : increment value
@@ -19 +23 @@
 
  === void '''_lock_acquire'''( spin_lock_t * lock ) ===
-This blocking function uses the atomic_increment() function, and returns only when the lock as been granted.
+This blocking function uses the atomic_increment() function, to implement a ticket allocator and provide ordered access to the protected resource. It returns only when the lock as been granted.
 
- === void '''_lock_release'''( giet_lock_t * lock ) ===
-This function releases the spin-lock. It must always be called after a successful _lock_acquire().
+ === void '''_lock_release'''( spin_lock_t * lock ) ===
+This function releases the lock. It must always be called after a successful _lock_acquire().
+
+ === void '''_simple_lock_acquire'''( simple_lock_t * lock ) ===
+This blocking function does not implement any ordered allocation. It returns only when the lock as been granted.
+
+ === void '''_simple_lock_release'''( simple_lock_t * lock ) ===
+This function releases the lock. It must always be called after a successful _simple_lock_acquire().