xv6---spinlock自旋锁

 Spinlock

目录

 Spinlock

自旋锁的结构体

自旋锁的方法

initlock-----设置锁的参数，名字

acquire----循环，直到可以拿到锁。

release---释放锁

holding---检查当前的cpu是否拿到了锁

死锁问题：

中断问题：

---

参考：xv6 Kernel-4 Spinlocks_哔哩哔哩_bilibili

• 自旋锁的结构体

// Mutual exclusion lock.
struct spinlock {
  uint locked;       // Is the lock held?
 
  // For debugging:
  char *name;        // Name of lock.
  struct cpu *cpu;   // The cpu holding the lock.
};

• 自旋锁的方法

• initlock-----设置锁的参数，名字

void
initlock(struct spinlock *lk, char *name)
{
  lk->name = name;
  lk->locked = 0;
  lk->cpu = 0;
}

• acquire----循环，直到可以拿到锁。

伪代码如下

func:
    if (*lock == 0)  // spinlock空闲
    {
        *lock = 1;
    } else {   //spinlock不空闲，循环等待
       goto func; 
    }

• 上述的代码必须保证原子性，否则当同一个cpu的两个线程同时满足 *lock == 0，那么两个线程都会拿到spinlock,这肯定是不行的。
• 在xv6中，原子操作指令就是ampswap指令，对应到c语言就是__sync_lock_test_and_set函数来保证原子性。

• __sync_synchronize();   避免编译优化改变代码执行顺序。

// Acquire the lock.
// Loops (spins) until the lock is acquired.
void
acquire(struct spinlock *lk)
{
  push_off(); // disable interrupts to avoid deadlock.
  if(holding(lk))
    panic("acquire");
{  //执行原子操作，避免出现并发问题
          // On RISC-V, sync_lock_test_and_set turns into an atomic swap:
          //   a5 = 1
          //   s1 = &lk->locked
          //   amoswap.w.aq a5, a5, (s1)
          while(__sync_lock_test_and_set(&lk->locked, 1) != 0)
            ;
}
          // Tell the C compiler and the processor to not move loads or stores
          // past this point, to ensure that the critical section's memory
          // references happen strictly after the lock is acquired.
          // On RISC-V, this emits a fence instruction.
          __sync_synchronize();
 
  // Record info about lock acquisition for holding() and debugging.
  lk->cpu = mycpu();
}

• release---释放锁

释放锁：等价于操作lk->locked = 0 ，用__sync_lock_release(&lk->locked);实现。也是原子操作

// Release the lock.
void
release(struct spinlock *lk)
{
  if(!holding(lk)) // 正常是当前cpu有spinlock, 所以才不会有panic("release");
    panic("release");
 
  lk->cpu = 0; //因为随后会释放锁，所以不妨设为空，表示当前没有cpu拿到锁
 
          // Tell the C compiler and the CPU to not move loads or stores
          // past this point, to ensure that all the stores in the critical
          // section are visible to other CPUs before the lock is released,
          // and that loads in the critical section occur strictly before
          // the lock is released.
          // On RISC-V, this emits a fence instruction.
          __sync_synchronize();
{ // amoswap 原子操作
          // Release the lock, equivalent to lk->locked = 0.
          // This code doesn't use a C assignment, since the C standard
          // implies that an assignment might be implemented with
          // multiple store instructions.
          // On RISC-V, sync_lock_release turns into an atomic swap:
          //   s1 = &lk->locked
          //   amoswap.w zero, zero, (s1)
          __sync_lock_release(&lk->locked);
}
  pop_off();
}

• holding---检查当前的cpu是否拿到了锁

// Check whether this cpu is holding the lock.
// Interrupts must be off.
int
holding(struct spinlock *lk)
{
  int r;
  r = (lk->locked && lk->cpu == mycpu()); //获取当前cpu是否拿到了锁
  return r;
}

• 死锁问题：

进程A：键盘打字---产生中断---acquired 等待spinlock----写入数据

进程B：某个调用拿到了spinlock,  等待键盘打字--写入的数据。   

------>产生死锁

解决方法：acquire()的时候disable interupt   ,  release的时候，enable interupt

额外的好处：可以让拿到spinlock的线程不会太久。

所以代码的push_off()和pop_off()中分别会打开/关闭中断来避免死锁

void
push_off(void)
{
...
  intr_off();     // 关闭中断
...
}
 
void
pop_off(void)
{
...
    intr_on();   //打开中断
...
}

• 中断问题：

如果此时有三个调用去执行acquire()，其中一个调用拿到了spinlock, diable中断在执行结束后，会在release的时候去enable中断。查看spinlock的acquire实现（如下面的代码）

可知：如果在release的时候打开了中断，那么其他cpu会立刻拿到spinlock, 且这个时候已经关闭过了中断，然后中断又被打开了，这肯定不行！！！

void
acquire(struct spinlock *lk)
{
  push_off(); // disable interrupts to avoid deadlock.
  if(holding(lk))
    panic("acquire");
 
// 原子操作---等待直到拿到spinlock
  while(__sync_lock_test_and_set(&lk->locked, 1) != 0)
    ;
............
}

解决方案：加上计数器，实现如下：acquire一次,中断计数就增加(noff变量)

release一次就减1，直到为0才恢复中断（不一定会打开，需要根据，int old = intr_get()的值判断，old == 1代表acquires spinlock之前中断是打开的，反之用完了锁不打开）。

void
push_off(void)
{
  int old = intr_get();  // 调用push_off之前 打开了中断 if old != 0
 
  intr_off();
  if(mycpu()->noff == 0)  // 第一次调用acquire
    mycpu()->intena = old; //intena保存锁之前的中断状态
  mycpu()->noff += 1;
}
 
void
pop_off(void)
{
  struct cpu *c = mycpu();
  if(intr_get())
    panic("pop_off - interruptible");
  if(c->noff < 1)
    panic("pop_off");
  c->noff -= 1;
  if(c->noff == 0 && c->intena) //直到aqcuire对应的release次数为0 && 调用push_off之前打开了中断
    intr_on();  //打开中断
}