Lock Server

      下面介绍这两个函数的实现. 在lock_server.cc中acquire的实现如下:

lock_protocol::status
  lock_server::acquire(int clt, lock_protocol::lockid_t lid, int &r) 
  {
      lock_protocol::status ret = lock_protocol::OK;
      std::map<lock_protocol::lockid_t, lock* >::iterator iter;
      pthread_mutex_lock(&mutex);
      iter = lockmap.find(lid);
      if(iter != lockmap.end()) {
          while(iter->second->status != lock::FREE) {
              pthread_cond_wait(&(iter->second->lcond), &mutex);
          }
          iter->second->status = lock::LOCKED;
          pthread_mutex_unlock(&mutex);
          return ret;
      } else {
          lock *new_lock = new lock(lid, lock::LOCKED);
          lockmap.insert(std::make_pair(lid, new_lock));
          pthread_mutex_unlock(&mutex);
          return ret;
      }      
  }

      因为多线程需要互斥的访问共享的数据结构lockmap，所以访问它时首先需要获取mutex，否则可能会发生混乱，然后在lockmap中查询lid对应的锁的状态,如果是LOCKED,那么当前线程在该锁的条件变量lcond上阻塞直到锁被释放,但是线程将被唤醒,然后在while循环中检测锁的状态,直到可以获取该锁；如果锁的状态是FREE,就直接将锁的状态修改为LOCKED,表示获取该锁；如果请求的锁不存在,就创建一个新锁加入到lockmap中, 并确保新创建的锁被客户端获取。

      对应服务器中release的实现如下:

lock_protocol::status
  lock_server::release(int clt, lock_protocol::lockid_t lid, int &r) 
  {
      lock_protocol::status ret = lock_protocol::OK;
      std::map<lock_protocol::lockid_t, lock*>::iterator iter;
      pthread_mutex_lock(&mutex);
      iter = lockmap.find(lid);
      if (iter != lockmap.end()) {
          iter->second->status = lock::FREE;
          pthread_cond_signal(&(iter->second->lcond));
          pthread_mutex_unlock(&mutex);
              return ret;
      } else {
          ret = lock_protocol::IOERR;
          pthread_mutex_unlock(&mutex);
          return ret;
      }
  }

      在lockmap中查询对应的锁,如果查到了该锁，就将锁的状态置为 FREE,然后唤醒等待该锁的线程；否则由于释放一个不存在的锁，就会发生错误

      以上是acquire和release在锁服务器端的实现,下面介绍这两个操作在客户端的实现，相对于服务端来说比较简单，参照客户端stat的写法，在lock_client.cc中添加如下代码

  lock_protocol::status
lock_client::acquire(lock_protocol::lockid_t lid)
{
    int r;
    lock_protocol::status ret = cl->call(lock_protocol::acquire, cl->id(), lid, r); 
    VERIFY(ret == lock_protocol::OK);
    return r;
}

  lock_protocol::status
lock_client::release(lock_protocol::lockid_t lid)
{
    int r;
    lock_protocol::status ret = cl->call(lock_protocol::release, cl->id(), lid, ; 
    VERIFY(ret == lock_protocol::OK);
    return r;
}

      到此，任务一的需要做的工作完成，测试下:

      终端环境lab目录下：make(编译)、./lock_server 3772、./lock_client 3772

3、Step2: 消除重复RPC请求带来的错误

      任务二主要考虑如何消除重复RPC带来的错误,确保at-most-once(至多一次)执行. 一种方法是在服务器端记录所有已经接收到的RPC请求,每个RPC请求由xid和clt_nonce标示,clt_nonce用来标示是哪个客户端,xid标示该客户端发送的特定的一个请求，除了记录RPC的标示,还需要记录每个RPC的处理结果,这样当重复的RPC请求到来时,重发这个结果就行，这种方法确保"at-most-once",但是记录这些信息的内存消耗几乎是无限增长的。

      另一种方法是滑动窗口。服务器端只记录部分的RPC请求信息,而不是全部,而且要求客户端的xid必须是严格的递增,如0,1,2,3... 当服务器端接收到一个请求,该请求中包含三个信息(xid, clt_nonce, xid_rep) xid和clt_nonce前面已经介绍,用来标示一个请求,而xid_rep的意思是告诉服务器 端xid_rep之前的请求客户端都已经收到了回复，所以服务器端不需要在保存xid_rep之前的信息了,可以删除，服务器收到请求(xid,clt_nonce,xid_rep)后,将该请求 在窗口中查询:

      上面三个过程由rpc/rpc.cc中checkduplicate_and_update函数完成.这部分代码 需要我们编写. 实现如下:

rpcs::rpcstate_t
rpcs::checkduplicate_and_update(unsigned int clt_nonce, unsigned int xid,
    unsigned int xid_rep, char **b, int *sz)
    {
        ScopedLock rwl(&reply_window_m_);
        std::list<reply_t>::iterator iter;
        for (iter = reply_window_[clt_nonce].begin(); iter != reply_window_[clt_nonc end(); ) {
            if (iter->xid < xid_rep && iter->cb_present) {
                free(iter->buf);
                iter = reply_window_[clt_nonce].erase(iter);
                continue;
            }
            if (xid == iter->xid) {
                if(iter->cb_present) {
                    *b = iter->buf;
                    *sz = iter->sz;
                    return DONE;
                } else {
                     return INPROGRESS;
                }
            }
            if(reply_window_[clt_nonce].front().xid > xid)
                return FORGOTTEN;
            iter++;
        }
        reply_t reply(xid);
        for (iter = reply_window_[clt_nonce].begin(); iter != reply_window_[clt_nonce].end(); iter++) {
            if(iter->xid > xid) {
                reply_window_[clt_nonce].insert(iter, reply);
                break;
            }
        }
        if(iter == reply_window_[clt_nonce].end())
            reply_window_[clt_nonce].push_back(reply);
        return NEW;
    }

      iter->cb_present表示结果是否有效.如果有效则返回DONE，如果无效表示还在处理,返回INPROGRESS； 如果xid比clt_nonce对的窗口中最小的xid还要xiao,说明这个请求已经被删除，返回FORGOTTEN， 对于新的请求则按序插入到窗口中，第一个for循环中已经将xid_rep前面的请求删除.

      我们还需要实现另一个函数add_reply,这个函数的作用是将一个请求的结果保存在 窗口中.在rpc/rpc.cc中add_reply实现如下:

void
  rpcs::add_reply(unsigned int clt_nonce, unsigned int xid,
      char *b, int sz)
 {
      ScopedLock rwl(&reply_window_m_);
      std::map<unsigned int, std::list<reply_t> >::iterator clt;
      std::list<reply_t>::iterator iter;
      clt = reply_window_.find(clt_nonce);
      if (clt != reply_window_.end()) {
          for (iter = clt->second.begin(); iter != clt->second.end(); iter++) {
              if (iter->xid == xid) {
                  iter->buf = b;
                  iter->sz = sz;
                  iter->cb_present = true;
                  break;
              }
          }   
      }
  }

      在窗口中找到对应的请求(这个请求是在checkduplicate_and_update中加入到窗口的,但是结果还未有效,handler还在处理),然后保存将结果保存.并且置cb_preset为true.表示结果有效.

      最后测试./rpc/rpctest和lock_tester，在网络有丢失的情形下,测试成功。