Test

src/RpcWrapper.h

 /* Copyright (c) 2012 Stanford University
  *
  * Permission to use, copy, modify, and distribute this software for any
  * purpose with or without fee is hereby granted, provided that the above
  * copyright notice and this permission notice appear in all copies.
  *
  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR(S) DISCLAIM ALL WARRANTIES
  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL AUTHORS BE LIABLE FOR
  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
@@ skipping 171 matching lines @@
      * \return
      *      Current state of processing for this RPC.
      */
     RpcState getState() {
         RpcState result = state;
         Fence::lfence();
         return result;
     }
 
     virtual bool handleTransportError();
-    void retry(uint64_t microseconds);
+    void retry(uint32_t minDelayMicros, uint32_t maxDelayMicros);
     virtual void send();
     void simpleWait(Dispatch* dispatch);
     const char* stateString();
     bool waitInternal(Dispatch* dispatch, uint64_t abortTime = ~0UL);
 
     /// Request and response messages.  In some cases the response buffer
     /// is provided by the wrapper (e.g., for reads); if not, response refers
     /// to defaultResponse.
     Buffer request;
     Buffer* response;
 
     /// Storage to use for response if constructor was not given an explicit
     /// response buffer.
     Tub<Buffer> defaultResponse;
 
     /// Current state of processing this RPC. This variable may be accessed
     /// concurrently by wrapper methods running in one thread and transport
     /// code running in the dispatch thread (transports can only invoke the
     /// completed and failed methods).
     Atomic<RpcState> state;
 
     /// Session on which RPC has been sent, or NULL if none.
     Transport::SessionRef session;
 
     /// Retry the RPC when Cycles::rdtsc reaches this value.
     uint64_t retryTime;
 
-    /// Microseconds to wait before retrying an RPC after it receives
-    /// STATUS_RETRY from a server. Defaults to 100 us, but RPCs
-    /// may override it.
-    uint64_t usBetweenRetry;
-
     /// Expected size of the response header, in bytes.
     uint32_t responseHeaderLength;
 
     /// Response header; filled in by isReady, so that wrapper functions
     /// don't have to recompute it.  Guaranteed to actually refer to at
     /// least responseHeaderLength bytes.
     const WireFormat::ResponseCommon* responseHeader;
 
     DISALLOW_COPY_AND_ASSIGN(RpcWrapper);
 };
 
 } // end RAMCloud
 
 #endif  // RAMCLOUD_RPCWRAPPER_H