  1#include "thread.h"
  2#include "thread-sync.h"
  3
  4struct cpu {
  5  int ncli;
  6};
  7
  8struct spinlock {
  9  const char *name;
 10  int locked;
 11  struct cpu *cpu;
 12};
 13
 14__thread struct cpu lcpu;
 15
 16struct cpu *mycpu() {
 17  return &lcpu;
 18}
 19
 20#define panic(...) \
 21  do { \
 22    fprintf(stderr, "Panic %s:%d ", __FILE__, __LINE__); \
 23    fprintf(stderr, __VA_ARGS__); \
 24    fprintf(stderr, "\n"); \
 25    abort(); \
 26  } while (0) \
 27
 28void
 29initlock(struct spinlock *lk, char *name)
 30{
 31  lk->name = name;
 32  lk->locked = 0;
 33  lk->cpu = 0;
 34}
 35
 36// Pushcli/popcli are like cli/sti except that they are matched:
 37// it takes two popcli to undo two pushcli.  Also, if interrupts
 38// are off, then pushcli, popcli leaves them off.
 39
 40void
 41pushcli(void)
 42{
 43  // removes CPU-dependent code
 44  // eflags = readeflags();
 45  // cli();
 46  // if(mycpu()->ncli == 0)
 47  //   mycpu()->intena = eflags & FL_IF;
 48  mycpu()->ncli += 1;
 49}
 50
 51void
 52popcli(void)
 53{
 54  // removes CPU-dependent code
 55  //if(readeflags()&FL_IF)
 56  //  panic("popcli - interruptible");
 57  if(--mycpu()->ncli < 0)
 58    panic("popcli");
 59  //if(mycpu()->ncli == 0 && mycpu()->intena)
 60  //  sti();
 61}
 62
 63// Check whether this cpu is holding the lock.
 64int
 65holding(struct spinlock *lock)
 66{
 67  int r;
 68  pushcli();
 69  r = lock->locked && lock->cpu == mycpu();
 70  popcli();
 71  return r;
 72}
 73
 74// Acquire the lock.
 75// Loops (spins) until the lock is acquired.
 76// Holding a lock for a long time may cause
 77// other CPUs to waste time spinning to acquire it.
 78void
 79acquire(struct spinlock *lk)
 80{
 81  pushcli(); // disable interrupts to avoid deadlock.
 82  if(holding(lk))
 83    panic("acquire");
 84
 85  // The xchg is atomic.
 86  while(atomic_xchg(&lk->locked, 1) != 0)
 87    ;
 88
 89  // Tell the C compiler and the processor to not move loads or stores
 90  // past this point, to ensure that the critical section's memory
 91  // references happen after the lock is acquired.
 92  __sync_synchronize();
 93
 94  // Record info about lock acquisition for debugging.
 95  lk->cpu = mycpu();
 96}
 97
 98// Release the lock.
 99void
100release(struct spinlock *lk)
101{
102  if(!holding(lk))
103    panic("release");
104
105  lk->cpu = 0;
106
107  // Tell the C compiler and the processor to not move loads or stores
108  // past this point, to ensure that all the stores in the critical
109  // section are visible to other cores before the lock is released.
110  // Both the C compiler and the hardware may re-order loads and
111  // stores; __sync_synchronize() tells them both not to.
112  __sync_synchronize();
113
114  // Release the lock, equivalent to lk->locked = 0.
115  // This code can't use a C assignment, since it might
116  // not be atomic. A real OS would use C atomics here.
117  asm volatile("movl $0, %0" : "+m" (lk->locked) : );
118
119  popcli();
120}
121
122struct spinlock lk;
123
124#define N 10000000
125
126long sum = 0;
127
128void Tworker(int tid) {
129  lcpu = (struct cpu) { .ncli = 0 };
130  for (int i = 0; i < N; i++) {
131    acquire(&lk);
132    sum++;
133    release(&lk);
134  }
135}
136
137int main() {
138  initlock(&lk, "spinlock");
139  for (int i = 0; i < 2; i++) {
140    create(Tworker);
141  }
142  join();
143  printf("sum = %ld\n", sum);
144}
13. 并发 Bug 的应对¶

Take-away Messages¶

课后习题/编程作业¶

1. 阅读材料¶

2. 编程实践¶
