k_spinlock.h

Go to the documentation of this file.

 
#ifndef K_SPINLOCK_H
#define K_SPINLOCK_H
 
#include <minix/sys_config.h> /* For potential CONFIG_SMP or other system configs */
 
/* Include arch-specific definitions, e.g., for arch_pause() */
#if defined(__i386__) || defined(__x86_64__)
#include "arch/i386/include/arch_cpu.h"  // Provides arch_pause for x86
#else
static inline void arch_pause(void) { /* No-op */ }
#endif
 
#define MAX_SPIN_THRESHOLD 100000
 
#ifndef KERNEL_YIELD_DEFINED
#define KERNEL_YIELD_DEFINED
static inline void kernel_yield(void) {
  /* Placeholder for actual yield. On x86, 'rep nop' is sometimes used
   * as a more potent pause than single 'pause', or actual scheduler yield.
   * For now, this can be a kprintf_stub for debugging or just a comment.
   * A true yield would involve scheduler interaction.
   */
  // kprintf_stub("kernel_yield() called (stub)\n"); // Uncomment for debugging
  // yield calls
  arch_pause();  // At least do an arch_pause if yielding fully is complex.
}
#endif
 
typedef struct {
  volatile int locked;
  unsigned long acquisitions;
  unsigned long contentions;
  /* Future: unsigned long total_spin_cycles; // Could be added with more
   * advanced cycle counting */
} simple_spinlock_t;
 
static inline void simple_spin_init(simple_spinlock_t *lock) {
  // Initialize the lock state to 0 (unlocked).
  lock->locked = 0;
  // Initialize statistics.
  lock->acquisitions = 0;
  lock->contentions = 0;
}
 
static inline void simple_spin_lock(simple_spinlock_t *lock) {
  // Attempt to acquire the lock immediately using atomic test-and-set.
  // If __sync_lock_test_and_set returns 0, the lock was acquired successfully
  // (it was 0 and is now 1).
  if (__sync_lock_test_and_set(&lock->locked, 1) == 0) {
    lock->acquisitions++;  // Successfully acquired on the first try.
    return;                // Lock acquired, no contention.
  }
 
  // If the first attempt failed, the lock was already held. This is a
  // contention.
  lock->contentions++;
  int spin_count = 0;  // Initialize spin counter for this contention episode.
 
  // Loop indefinitely, spinning and re-attempting to acquire the lock.
  while (1) {
    // Inner busy-wait loop: Spin while the lock is held by someone else.
    // This inner read loop (checking lock->locked directly) can be slightly
    // more efficient on some architectures than repeatedly executing the atomic
    // __sync_lock_test_and_set, as it might reduce bus contention.
    while (lock->locked != 0) {
      /* arch_pause() provides a hint to the CPU that this is a spin-wait loop.
       * On x86, this is the "pause" instruction, which can improve performance
       * and reduce power consumption during the spin, especially on
       * hyper-threaded processors by yielding execution resources.
       */
      arch_pause();
 
      spin_count++;  // Increment spin counter.
      if (spin_count > MAX_SPIN_THRESHOLD) {
        /* If we've spun too many times, call kernel_yield().
         * This is to prevent CPU monopolization on highly contended locks
         * by allowing other threads/processes to run.
         * The actual behavior of kernel_yield() depends on its implementation
         * (e.g., true scheduler yield or just a more potent pause).
         */
        kernel_yield();
        spin_count = 0;  // Reset counter after yielding.
      }
    }
 
    // After observing lock->locked == 0 in the inner loop,
    // attempt to acquire the lock again using atomic test-and-set.
    if (__sync_lock_test_and_set(&lock->locked, 1) == 0) {
      lock->acquisitions++;  // Lock acquired after spinning.
      return;                // Exit the function, lock is now held.
    }
    // If __sync_lock_test_and_set still returned non-zero, it means another
    // CPU/thread acquired the lock between our read of lock->locked and our TAS
    // attempt (a race). In this case, the outer while(1) loop continues, and we
    // re-enter the inner spin.
  }
}
 
static inline void simple_spin_unlock(simple_spinlock_t *lock) {
  /* Atomically set lock->locked to 0 (unlocked).
   * __sync_lock_release provides a release memory barrier. This ensures that
   * all memory writes made by this thread within the critical section (before
   * this unlock) are visible to other CPUs before the lock is actually
   * released.
   */
  __sync_lock_release(&lock->locked);
}
 
#endif /* K_SPINLOCK_H */