[dev.power64] code review 152570049: all: merge default into dev.power64

src/net/rpc/client.go

 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
 package rpc
 
 import (
         "bufio"
         "encoding/gob"
         "errors"
@@ skipping 23 matching lines @@
         Done          chan *Call  // Strobes when call is complete.
 }
 
 // Client represents an RPC Client.
 // There may be multiple outstanding Calls associated
 // with a single Client, and a Client may be used by
 // multiple goroutines simultaneously.
 type Client struct {
         codec ClientCodec
 
-        sending sync.Mutex
+        reqMutex sync.Mutex // protects following
+        request  Request
 
         mutex    sync.Mutex // protects following
-        request  Request
         seq      uint64
         pending  map[uint64]*Call
         closing  bool // user has called Close
         shutdown bool // server has told us to stop
 }
 
 // A ClientCodec implements writing of RPC requests and
 // reading of RPC responses for the client side of an RPC session.
 // The client calls WriteRequest to write a request to the connection
 // and calls ReadResponseHeader and ReadResponseBody in pairs
 // to read responses.  The client calls Close when finished with the
 // connection. ReadResponseBody may be called with a nil
 // argument to force the body of the response to be read and then
 // discarded.
 type ClientCodec interface {
         // WriteRequest must be safe for concurrent use by multiple goroutines.
         WriteRequest(*Request, interface{}) error
         ReadResponseHeader(*Response) error
         ReadResponseBody(interface{}) error
 
         Close() error
 }
 
 func (client *Client) send(call *Call) {
-        client.sending.Lock()
-        defer client.sending.Unlock()
+        client.reqMutex.Lock()
+        defer client.reqMutex.Unlock()
 
         // Register this call.
         client.mutex.Lock()
         if client.shutdown || client.closing {
                 call.Error = ErrShutdown
                 client.mutex.Unlock()
                 call.done()
                 return
         }
         seq := client.seq
@@ skipping 55 matching lines @@
                         call.done()
                 default:
                         err = client.codec.ReadResponseBody(call.Reply)
                         if err != nil {
                                 call.Error = errors.New("reading body " + err.Error())
                         }
                         call.done()
                 }
         }
         // Terminate pending calls.
-        client.sending.Lock()
+        client.reqMutex.Lock()
         client.mutex.Lock()
         client.shutdown = true
         closing := client.closing
         if err == io.EOF {
                 if closing {
                         err = ErrShutdown
                 } else {
                         err = io.ErrUnexpectedEOF
                 }
         }
         for _, call := range client.pending {
                 call.Error = err
                 call.done()
         }
         client.mutex.Unlock()
-        client.sending.Unlock()
+        client.reqMutex.Unlock()
         if debugLog && err != io.EOF && !closing {
                 log.Println("rpc: client protocol error:", err)
         }
 }
 
 func (call *Call) done() {
         select {
         case call.Done <- call:
                 // ok
         default:
@@ skipping 132 matching lines @@
         call.Done = done
         client.send(call)
         return call
 }
 
 // Call invokes the named function, waits for it to complete, and returns its error status.
 func (client *Client) Call(serviceMethod string, args interface{}, reply interface{}) error {
         call := <-client.Go(serviceMethod, args, reply, make(chan *Call, 1)).Done
         return call.Error
 }