主从处理机内核

1.

   1:  void lock(volatile lock_t *lock)

   2:  {

   3:       do

   4:       {

   5:             while(load_linked(lock) == 1);

   6:       }while(store_conditional(lock, 1) == 0);

   7:  }

   8:   

   9:   

  10:  void unlock(volatile lock_t *lock)

  11:  {

  12:                *lock = 0;

  13:  }

2.

   1:  void lock(volatile lock_t *lock)

   2:  {

   3:       while(swap_atomic(lock, 1) == 1);

   4:  }

   5:   

   6:  void unlock(volatile lock_t *lock)

   7:  {

   8:         *lock = 0;

   9:  }

3.

   1:  struct element

   2:  {

   3:      struct element *next;

   4:      int tag;

   5:      int data;

   6:  };

   7:   

   8:  struct rwlock

   9:  {

  10:      spint_t reader_lock;

  11:      int reader_cnt;

  12:      spint_t writer_lock;

  13:  };

  14:   

  15:  typedef struct rwlock rwlock_t;

  16:   

  17:  typedef struct element elem_t;

  18:   

  19:   

  20:  struct list

  21:  {

  22:      elem_t *head;

  23:      rwlock_t lock;

  24:  };

  25:   

  26:  void initlock(rwlock_t *lock);

  27:  void reader_lock(rwlock_t *lock);

  28:  void reader_unlock(rwlock_t *lock);

  29:  void writer_lock(rwlock_t *lock);

  30:  void writer_unlock(rwlockt_t *lock);

  31:   

  32:  void initlock(rwlock_t *lock)

  33:  {

  34:      spin_init(&lock->reader_lock);

  35:      spin_init(&lock->writer_lock);

  36:      lock->reader_cnt = 0;

  37:  }

  38:   

  39:  void reader_lock(rwlock_t *lock)

  40:  {

  41:      spin_lock(&lock->writer_lock);

  42:      spin_lock(&lock->reader_lock);

  43:      lock->reader_cnt++;

  44:      spin_unlock(&lock->reader_lock);

  45:      spin_unlock(&lock->writer_lock);

  46:  }

  47:   

  48:  void reader_unlock(rwlock_t *lock)

  49:  {

  50:      spin_lock(&lock->reader_lock);

  51:      lock->read_cnt--;

  52:      spin_unlock(&lock->reader_lock);

  53:  }

  54:   

  55:  void writer_lock(rwlock_t *lock)

  56:  {

  57:      spin_lock(&lock->writer_lock);

  58:      while(lock->read_cnt);

  59:  }

  60:   

  61:  void writer_lock(rwlock_t *lock)

  62:  {

  63:      spin_unlock(&lock->writer_lock);

  64:  }

  65:   

  66:  void initlist(list_t *list);

  67:  int search(list_t *list, int tag);

  68:  void add(list_t *list, elem_t *element);

  69:  elem_t *remove(list_t *list, int tag);

  70:   

  71:   

  72:  void initlist(list_t *list)

  73:  {

  74:      list->head = NULL;

  75:      initlock(&list->lock);

  76:  }

  77:   

  78:  int search(list_t *list, int tag)

  79:  {

  80:      reader_lock(&list->lock);

  81:      elem_t *next;

  82:      int result = 0;

  83:      next = list->head;

  84:      while(next != NULL)

  85:      {

  86:          if(next->tag == tag)

  87:          {

  88:              result = next->data;

  89:              break;

  90:          }

  91:          next = next->next;

  92:      }

  93:      reader_unlock(&list->lock);

  94:      return result;

  95:  }

4.

不一样，处理的方式也不一样

5.

不会发生死锁

6.

会， 每个函数占第一个锁而准备获取第二个锁，就会发生死锁

7.

不能，多个进程向一个进程发送信号，自己的可以处理。

8.

能

9.

直接发送信号就可以，时钟中断时可以检查当前运行进程的信号状态。