Added comments in Client.java.

Added doesWrites() to MultiDeleteRequest.
Updated SimpleRateLimiter to delay properly with
usePercent != 100.0 and units == 0.

Author: connelly38

driver/src/main/java/oracle/nosql/driver/http/Client.java

@@ -15,7 +15,6 @@
 import static oracle.nosql.driver.util.LogUtil.logFine;
 import static oracle.nosql.driver.util.LogUtil.logInfo;
 import static oracle.nosql.driver.util.LogUtil.logTrace;
-import static oracle.nosql.driver.util.BinaryProtocol.READ_KB_LIMIT;
 import static oracle.nosql.driver.util.HttpConstants.ACCEPT;
 import static oracle.nosql.driver.util.HttpConstants.CONNECTION;
 import static oracle.nosql.driver.util.HttpConstants.CONTENT_LENGTH;
@@ -729,6 +728,25 @@ private int consumeLimiterUnits(RateLimiter rl, long units,
             return 0;
         }
 
+        /*
+         * The logic consumes units (and potentially delays) _after_ a
+         * successful operation for a few reasons:
+         * 1) We don't know the actual number of units an op uses unitl
+         *    after the operation successfully finishes
+         * 2) Delaying after the op keeps the application from immediately
+         *    trying the next op and ending up waiting along with other
+         *    client threads until the rate goes below the limit, at which
+         *    time all client threads would continue at once. By waiting
+         *    after a successful op, client threads will get staggered
+         *    better to avoid spikes in throughput and oscillation that
+         *    can result from it.
+         * 3) For operations that use less than 100% of the limits (i.e.
+         *    they set a usePercent to less than 100), this is the only place
+         *    where the delay time may be longer, because the pre-operation
+         *    "wait for below the limit" limiter checks do not take usePercent
+         *    into account.
+         */
+
         double usePercent = request.getRateLimiterPercentage();
         if (usePercent == 0.0) {
             usePercent = config.getDefaultRateLimitingPercentage();

driver/src/main/java/oracle/nosql/driver/ops/MultiDeleteRequest.java

@@ -235,4 +235,12 @@ public void validate() {
     public boolean doesReads() {
         return true;
     }
+
+    /**
+     * @hidden
+     */
+    @Override
+    public boolean doesWrites() {
+        return true;
+    }
 }

driver/src/main/java/oracle/nosql/driver/util/SimpleRateLimiter.java

@@ -375,10 +375,9 @@ private synchronized int consumeInternalPercent(long units, int timeoutMs,
          * the logic will only consume the given amount, but will
          * return a sleep time proportional to the usePercent
          */
-        long nanosAdded = 0;
         long infunits = (long)((double)units / usePercent);
         long inflatedNanos = infunits * nanosPerUnit;
-        nanosAdded = inflatedNanos - nanosNeeded;
+        long nanosAdded = inflatedNanos - nanosNeeded;
 
         /*
          * if the new last nano is less than now, the consume
@@ -411,6 +410,15 @@ private synchronized int consumeInternalPercent(long units, int timeoutMs,
             sleepMs = 1;
         }
 
+        /*
+         * if this was called to get the time before the limiter is below its
+         * limit, adjust the time based on usePercentage (this is easier to
+         * adjust for here instead of trying to factor it into the math above).
+         */
+        if (units == 0) {
+            sleepMs = (int)((double)sleepMs / usePercent);
+        }
+
         if (alwaysConsume) {
             /*
              * if we're told to always consume the units no matter what,
@@ -514,4 +522,25 @@ private void uninterruptibleSleep(int sleepMs) {
         }
     }
 
+
+    /**
+     * @hidden
+     * Consumes units and returns the time to sleep.
+     *
+     * Note this method returns immediately in all cases. It returns
+     * the number of milliseconds to sleep.
+     *
+     * @param units number of units to attempt to consume
+     * @return number of milliseconds to sleep.
+     *         If the return value is zero, the consume succeeded under the
+     *         limit and no sleep is necessary.
+     */
+    public int consumeExternally(long units) {
+        /* If disabled, just return success */
+        if (nanosPerUnit <= 0) {
+            return 0;
+        }
+        return consumeInternalFull(units, 0, true, System.nanoTime());
+    }
+
 }