示例#1
0
  /**
   * Assign a predefined ordinal to a serialized representation.
   *
   * <p>WARNING: THIS OPERATION IS NOT THREAD-SAFE.
   *
   * <p>This is intended for use in the client-side heap-safe double snapshot load.
   */
  public void put(ByteDataBuffer serializedRepresentation, int ordinal) {
    if (size > sizeBeforeGrow) growKeyArray();

    int hash = SegmentedByteArrayHasher.hashCode(serializedRepresentation);

    int modBitmask = pointersAndOrdinals.length() - 1;
    int bucket = hash & modBitmask;
    long key = pointersAndOrdinals.get(bucket);

    while (key != EMPTY_BUCKET_VALUE) {
      if (compare(serializedRepresentation, key)) return;

      bucket = (bucket + 1) & modBitmask;
      key = pointersAndOrdinals.get(bucket);
    }

    int pointer = byteData.length();

    VarInt.writeVInt(byteData, serializedRepresentation.length());
    serializedRepresentation.copyTo(byteData);

    key = ((long) ordinal << 32) | pointer;

    size++;

    pointersAndOrdinals.set(bucket, key);
  }
示例#2
0
  /**
   * Create an array mapping the ordinals to pointers, so that they can be easily looked up when
   * writing to blob streams.
   *
   * @return the maximum length, in bytes, of any byte sequence in this map.
   */
  public int prepareForWrite() {
    int maxOrdinal = 0;
    int maxLength = 0;

    for (int i = 0; i < pointersAndOrdinals.length(); i++) {
      long key = pointersAndOrdinals.get(i);
      if (key != EMPTY_BUCKET_VALUE) {
        int ordinal = (int) (key >> 32);
        if (ordinal > maxOrdinal) maxOrdinal = ordinal;
      }
    }

    pointersByOrdinal = new int[maxOrdinal + 1];
    Arrays.fill(pointersByOrdinal, -1);

    for (int i = 0; i < pointersAndOrdinals.length(); i++) {
      long key = pointersAndOrdinals.get(i);
      if (key != EMPTY_BUCKET_VALUE) {
        int ordinal = (int) (key >> 32);
        pointersByOrdinal[ordinal] = (int) key;

        int dataLength = VarInt.readVInt(byteData.getUnderlyingArray(), pointersByOrdinal[ordinal]);
        if (dataLength > maxLength) maxLength = dataLength;
      }
    }

    return maxLength;
  }
示例#3
0
  /**
   * @return the largest value that could have been added to this histogram. If the histogram
   *     overflowed, returns Long.MAX_VALUE.
   */
  public long max() {
    int lastBucket = buckets.length() - 1;
    if (buckets.get(lastBucket) > 0) return Long.MAX_VALUE;

    for (int i = lastBucket - 1; i >= 0; i--) {
      if (buckets.get(i) > 0) return bucketOffsets[i];
    }
    return 0;
  }
示例#4
0
  /**
   * @param percentile
   * @return estimated value at given percentile
   */
  public long percentile(double percentile) {
    assert percentile >= 0 && percentile <= 1.0;
    int lastBucket = buckets.length() - 1;
    if (buckets.get(lastBucket) > 0)
      throw new IllegalStateException("Unable to compute when histogram overflowed");

    long pcount = (long) Math.floor(count() * percentile);
    if (pcount == 0) return 0;

    long elements = 0;
    for (int i = 0; i < lastBucket; i++) {
      elements += buckets.get(i);
      if (elements >= pcount) return bucketOffsets[i];
    }
    return 0;
  }
示例#5
0
  /**
   * This is used to store the server's SerializationState, so that it may resume the delta chain
   * after a new server is brought back up.
   *
   * @param os
   * @throws IOException
   */
  public void serializeTo(OutputStream os) throws IOException {
    /// write the hashed key array size
    VarInt.writeVInt(os, pointersAndOrdinals.length());

    /// write the keys in sorted ordinal order to the stream
    long keys[] = new long[size];

    int counter = 0;

    for (int i = 0; i < pointersAndOrdinals.length(); i++) {
      long key = pointersAndOrdinals.get(i);
      if (key != EMPTY_BUCKET_VALUE) {
        keys[counter++] = key;
      }
    }

    Arrays.sort(keys);

    VarInt.writeVInt(os, keys.length);

    for (int i = 0; i < keys.length; i++) {
      VarInt.writeVInt(os, (int) (keys[i] >> 32));
      VarInt.writeVInt(os, (int) (keys[i]));
    }

    /// write the byte data to the stream
    VarInt.writeVInt(os, byteData.length());

    for (int i = 0; i < byteData.length(); i++) {
      os.write(byteData.get(i) & 0xFF);
    }

    /// write the freeOrdinalTracker to the stream
    freeOrdinalTracker.serializeTo(os);
  }
示例#6
0
  /**
   * Grow the key array. All of the values in the current array must be re-hashed and added to the
   * new array.
   */
  private void growKeyArray() {
    AtomicLongArray newKeys = emptyKeyArray(pointersAndOrdinals.length() * 2);

    long valuesToAdd[] = new long[size];

    int counter = 0;

    /// do not iterate over these values in the same order in which they appear in the hashed array.
    /// if we do so, we cause large clusters of collisions to appear (because we resolve collisions
    // with linear probing).
    for (int i = 0; i < pointersAndOrdinals.length(); i++) {
      long key = pointersAndOrdinals.get(i);
      if (key != EMPTY_BUCKET_VALUE) {
        valuesToAdd[counter++] = key;
      }
    }

    Arrays.sort(valuesToAdd);

    populateNewHashArray(newKeys, valuesToAdd);

    /// 70% load factor
    sizeBeforeGrow = (newKeys.length() * 7) / 10;
    pointersAndOrdinals = newKeys;
  }
示例#7
0
  /**
   * @return the mean histogram value (average of bucket offsets, weighted by count)
   * @throws IllegalStateException if any values were greater than the largest bucket threshold
   */
  public long mean() {
    int lastBucket = buckets.length() - 1;
    if (buckets.get(lastBucket) > 0)
      throw new IllegalStateException(
          "Unable to compute ceiling for max when histogram overflowed");

    long elements = 0;
    long sum = 0;
    for (int i = 0; i < lastBucket; i++) {
      long bCount = buckets.get(i);
      elements += bCount;
      sum += bCount * bucketOffsets[i];
    }

    return (long) Math.ceil((double) sum / elements);
  }
示例#8
0
  /**
   * @param reset zero out buckets afterwards if true
   * @return a long[] containing the current histogram buckets
   */
  public long[] getBuckets(boolean reset) {
    final int len = buckets.length();
    long[] rv = new long[len];

    if (reset) for (int i = 0; i < len; i++) rv[i] = buckets.getAndSet(i, 0L);
    else for (int i = 0; i < len; i++) rv[i] = buckets.get(i);

    return rv;
  }
示例#9
0
  /**
   * Add a sequence of bytes to this map. If the sequence of bytes has already been added to this
   * map, return the originally assigned ordinal. If the sequence of bytes has not been added to
   * this map, assign and return a new ordinal. This operation is thread-safe.
   */
  public int getOrAssignOrdinal(ByteDataBuffer serializedRepresentation) {
    int hash = SegmentedByteArrayHasher.hashCode(serializedRepresentation);

    int modBitmask = pointersAndOrdinals.length() - 1;
    int bucket = hash & modBitmask;
    long key = pointersAndOrdinals.get(bucket);

    /// linear probing to resolve collisions.
    while (key != EMPTY_BUCKET_VALUE) {
      if (compare(serializedRepresentation, key)) {
        return (int) (key >> 32);
      }

      bucket = (bucket + 1) & modBitmask;
      key = pointersAndOrdinals.get(bucket);
    }

    return assignOrdinal(serializedRepresentation, hash);
  }
示例#10
0
  /// acquire the lock before writing.
  private synchronized int assignOrdinal(ByteDataBuffer serializedRepresentation, int hash) {
    if (size > sizeBeforeGrow) growKeyArray();

    /// check to make sure that after acquiring the lock, the element still does not exist.
    /// this operation is akin to double-checked locking which is 'fixed' with the JSR 133 memory
    // model in JVM >= 1.5.
    int modBitmask = pointersAndOrdinals.length() - 1;
    int bucket = hash & modBitmask;
    long key = pointersAndOrdinals.get(bucket);

    while (key != EMPTY_BUCKET_VALUE) {
      if (compare(serializedRepresentation, key)) {
        return (int) (key >> 32);
      }

      bucket = (bucket + 1) & modBitmask;
      key = pointersAndOrdinals.get(bucket);
    }

    /// the ordinal for this object still does not exist in the list, even after the lock has been
    // acquired.
    /// it is up to this thread to add it at the current bucket position.
    int ordinal = freeOrdinalTracker.getFreeOrdinal();
    int pointer = byteData.length();

    VarInt.writeVInt(byteData, serializedRepresentation.length());
    serializedRepresentation.copyTo(byteData);

    key = ((long) ordinal << 32) | pointer;

    size++;

    /// this set on the AtomicLongArray has volatile semantics (i.e. behaves like a monitor
    // release).
    /// Any other thread reading this element in the AtomicLongArray will have visibility to all
    // memory writes this thread has made up to this point.
    /// This means the entire byte sequence is guaranteed to be visible to any thread which reads
    // the pointer to that data.
    pointersAndOrdinals.set(bucket, key);

    return ordinal;
  }
示例#11
0
  private int getNextIndex(Object caller) {
    long now = System.currentTimeMillis();

    if (this.policy == LoadBalancerPolicy.ROUND_ROBIN) {
      // Try all endpoints if some are suspended
      int count = endpointCount;
      int[] tried = new int[endpointCount];
      while (count > 0) {
        // Increment index and convert negative values to positive if need be
        int index = indexGenerator.getAndIncrement() % endpointCount;
        if (index < 0) {
          index += endpointCount;
        }

        // Don't retry same index
        if (tried[index] == 0) {
          // Return index if endpoint is not suspended
          if (suspensionTimes.get(index) < now) {
            return index;
          }

          tried[index] = 1;
          count--;
        }
      }

    } else if (this.policy == LoadBalancerPolicy.LATENCY_LAST) {
      int index = -1;
      for (int i = 0; i < latencyTimes.length(); i++) {
        long current = latencyTimes.get(i);
        long smallest = Long.MAX_VALUE;
        if (current < smallest && suspensionTimes.get(i) < now) {
          smallest = current;
          index = i;
        }
      }
      return index;
    }

    return -1;
  }
示例#12
0
  /**
   * Hash all of the existing values specified by the keys in the supplied long array into the
   * supplied AtomicLongArray.
   */
  private void populateNewHashArray(AtomicLongArray newKeys, long[] valuesToAdd) {
    int modBitmask = newKeys.length() - 1;

    for (int i = 0; i < valuesToAdd.length; i++) {
      if (valuesToAdd[i] != EMPTY_BUCKET_VALUE) {
        int hash = rehashPreviouslyAddedData(valuesToAdd[i]);
        int bucket = hash & modBitmask;
        while (newKeys.get(bucket) != EMPTY_BUCKET_VALUE) bucket = (bucket + 1) & modBitmask;
        newKeys.set(bucket, valuesToAdd[i]);
      }
    }
  }
示例#13
0
  /**
   * log.debug() every record in the histogram
   *
   * @param log
   */
  public void log(Logger log) {
    // only print overflow if there is any
    int nameCount;
    if (buckets.get(buckets.length() - 1) == 0) nameCount = buckets.length() - 1;
    else nameCount = buckets.length();
    String[] names = new String[nameCount];

    int maxNameLength = 0;
    for (int i = 0; i < nameCount; i++) {
      names[i] = nameOfRange(bucketOffsets, i);
      maxNameLength = Math.max(maxNameLength, names[i].length());
    }

    // emit log records
    String formatstr = "%" + maxNameLength + "s: %d";
    for (int i = 0; i < nameCount; i++) {
      long count = buckets.get(i);
      // sort-of-hack to not print empty ranges at the start that are only used to demarcate the
      // first populated range. for code clarity we don't omit this record from the maxNameLength
      // calculation, and accept the unnecessary whitespace prefixes that will occasionally occur
      if (i == 0 && count == 0) continue;
      log.debug(String.format(formatstr, names[i], count));
    }
  }
示例#14
0
  /**
   * Reclaim space in the byte array used in the previous cycle, but not referenced in this cycle.
   *
   * <p>This is achieved by shifting all used byte sequences down in the byte array, then updating
   * the key array to reflect the new pointers and exclude the removed entries. This is also where
   * ordinals which are unused are returned to the pool.
   *
   * <p>
   *
   * @param usedOrdinals a bit set representing the ordinals which are currently referenced by any
   *     image.
   */
  public void compact(ThreadSafeBitSet usedOrdinals) {
    long populatedReverseKeys[] = new long[size];

    int counter = 0;

    for (int i = 0; i < pointersAndOrdinals.length(); i++) {
      long key = pointersAndOrdinals.get(i);
      if (key != EMPTY_BUCKET_VALUE) {
        populatedReverseKeys[counter++] = key << 32 | key >>> 32;
      }
    }

    Arrays.sort(populatedReverseKeys);

    SegmentedByteArray arr = byteData.getUnderlyingArray();
    int currentCopyPointer = 0;

    for (int i = 0; i < populatedReverseKeys.length; i++) {
      int ordinal = (int) populatedReverseKeys[i];

      if (usedOrdinals.get(ordinal)) {
        int pointer = (int) (populatedReverseKeys[i] >> 32);
        int length = VarInt.readVInt(arr, pointer);
        length += VarInt.sizeOfVInt(length);

        if (currentCopyPointer != pointer) arr.copy(arr, pointer, currentCopyPointer, length);

        populatedReverseKeys[i] = populatedReverseKeys[i] << 32 | currentCopyPointer;

        currentCopyPointer += length;
      } else {
        freeOrdinalTracker.returnOrdinalToPool(ordinal);
        populatedReverseKeys[i] = EMPTY_BUCKET_VALUE;
      }
    }

    byteData.setPosition(currentCopyPointer);

    for (int i = 0; i < pointersAndOrdinals.length(); i++) {
      pointersAndOrdinals.set(i, EMPTY_BUCKET_VALUE);
    }

    populateNewHashArray(pointersAndOrdinals, populatedReverseKeys);
    size = usedOrdinals.cardinality();

    pointersByOrdinal = null;
  }
示例#15
0
 Consumer<S> check(long maxTime, PooledFatPipe parent) {
   if (parent != null && parent.group == null) return null;
   AtomicLongArray outUse = this.outUse;
   Consumer<S>[] consumers = this.consumers;
   long now = System.nanoTime();
   if (consumers.length > outUse.length()) {
     logger.warn("skipping check " + outUse.length() + "/" + consumers.length);
     return null;
   }
   try {
     for (int i = 0; i < consumers.length; i++) {
       long time = outUse.get(i);
       if (time == 0) continue;
       if (time == -1) continue;
       if (now < time + maxTime * 1_000_000) continue;
       if (parent != null) parent.group.list();
       return consumers[i];
     }
   } catch (Exception e) {
     logger.error("check", e);
   }
   return null;
 }
示例#16
0
  /**
   * Combine a portion of this matrix reduction variable with a portion of the given matrix using
   * the given operation. For each row index <TT>r</TT> from 0 to <TT>rowlen-1</TT> inclusive, and
   * for each column index <TT>c</TT> from 0 to <TT>collen-1</TT> inclusive, (this matrix
   * <TT>[dstrow+r,dstcol+c]</TT>) is set to (this matrix <TT>[dstrow+r,dstcol+c]</TT>) <I>op</I>
   * (<TT>src[srcrow+r,srccol+c]</TT>).
   *
   * <p>The <TT>reduce()</TT> method is multiple thread safe <I>on a per-element basis.</I> Each
   * individual matrix element is updated atomically, but the matrix as a whole is not updated
   * atomically.
   *
   * @param dstrow Row index of first element to update in this matrix.
   * @param dstcol Column index of first element to update in this matrix.
   * @param src Source matrix.
   * @param srcrow Row index of first element to update from in the source matrix.
   * @param srccol Column index of first element to update from in the source matrix.
   * @param rowlen Number of rows to update.
   * @param collen Number of columns to update.
   * @param op Binary operation.
   * @exception NullPointerException (unchecked exception) Thrown if <TT>src</TT> is null. Thrown if
   *     <TT>op</TT> is null.
   * @exception IndexOutOfBoundsException (unchecked exception) Thrown if <TT>rowlen</TT> &lt; 0.
   *     Thrown if <TT>collen</TT> &lt; 0. Thrown if any matrix index would be out of bounds.
   */
  public void reduce(
      int dstrow,
      int dstcol,
      long[][] src,
      int srcrow,
      int srccol,
      int rowlen,
      int collen,
      LongOp op) {
    if (rowlen < 0
        || collen < 0
        || dstrow < 0
        || dstrow + rowlen > rows()
        || dstcol < 0
        || dstcol + collen > cols()
        || srcrow < 0
        || srcrow + rowlen > src.length
        || srccol < 0
        || srccol + collen > src[0].length) {
      throw new IndexOutOfBoundsException();
    }

    for (int r = 0; r < rowlen; ++r) {
      AtomicLongArray myMatrix_r = myMatrix[dstrow + r];
      long[] src_r = src[srcrow + r];
      for (int c = 0; c < collen; ++c) {
        int dstcol_c = dstcol + c;
        long src_r_c = src_r[srccol + c];
        updateLoop:
        for (; ; ) {
          long oldvalue = myMatrix_r.get(dstcol_c);
          long newvalue = op.op(oldvalue, src_r_c);
          if (myMatrix_r.compareAndSet(dstcol_c, oldvalue, newvalue)) break updateLoop;
        }
      }
    }
  }
示例#17
0
 private boolean setConsumers(List<Consumer<S>> list) throws InterruptedException {
   AtomicLongArray oldOutUse = outUse;
   long[] oldConsumerSeqs = consumerSeqs;
   long[] useArray = new long[list.size()];
   for (int i = 0; i < useArray.length; i++) useArray[i] = -1;
   long[] seq = new long[list.size()];
   for (int i = 0; i < seq.length; i++) seq[i] = Long.MAX_VALUE;
   Consumer<S>[] oldConsumers = consumers;
   consumers = list.toArray(new Consumer[0]);
   outUse = new AtomicLongArray(useArray);
   consumerSeqs = seq;
   for (int i = 0; i < consumers.length; i++) {
     boolean found = false;
     for (int j = 0; j < oldConsumers.length; j++) {
       if (consumers[i] != oldConsumers[j]) continue;
       found = true;
       long entered = oldOutUse.get(j);
       setSequence(i, entered, oldConsumerSeqs[j]);
       break;
     }
     if (!found) setSequence(i, 0, 0); // not in use
   }
   return true;
 }
示例#18
0
 @Managed
 public long getCompletedTasksLevel4() {
   return completedTasksPerLevel.get(4);
 }
示例#19
0
  // Application entry point
  public static void main(String[] args) {
    try {

      // ---------------------------------------------------------------------------------------------------------------------------------------------------

      // Use the AppHelper utility class to retrieve command line application parameters

      // Define parameters and pull from command line
      AppHelper apph =
          new AppHelper(AsyncBenchmark.class.getCanonicalName())
              .add(
                  "displayinterval",
                  "display_interval_in_seconds",
                  "Interval for performance feedback, in seconds.",
                  10)
              .add("duration", "run_duration_in_seconds", "Benchmark duration, in seconds.", 120)
              .add(
                  "servers",
                  "comma_separated_server_list",
                  "List of VoltDB servers to connect to.",
                  "localhost")
              .add("port", "port_number", "Client port to connect to on cluster nodes.", 21212)
              .add(
                  "poolsize",
                  "pool_size",
                  "Size of the record pool to operate on - larger sizes will cause a higher insert/update-delete rate.",
                  100000)
              .add(
                  "procedure",
                  "procedure_name",
                  "Procedure to call.",
                  "JiggleExportSinglePartition")
              .add(
                  "ratelimit",
                  "rate_limit",
                  "Rate limit to start from (number of transactions per second).",
                  100000)
              .add(
                  "autotune",
                  "auto_tune",
                  "Flag indicating whether the benchmark should self-tune the transaction rate for a target execution latency (true|false).",
                  "true")
              .add(
                  "latencytarget",
                  "latency_target",
                  "Execution latency to target to tune transaction rate (in milliseconds).",
                  10)
              .add("catalogswap", "Swap catalogs from the client", "true")
              .setArguments(args);

      config = new ConnectionConfig(apph);

      // Retrieve parameters
      final boolean catalogSwap = apph.booleanValue("catalogswap");
      final String csv = apph.stringValue("statsfile");

      TxnIdWriter writer = new TxnIdWriter("dude", "clientlog");

      // Validate parameters
      apph.validate("duration", (config.duration > 0))
          .validate("poolsize", (config.poolSize > 0))
          .validate("ratelimit", (config.rateLimit > 0))
          .validate("latencytarget", (config.latencyTarget > 0));

      // Display actual parameters, for reference
      apph.printActualUsage();

      // ---------------------------------------------------------------------------------------------------------------------------------------------------

      // Get a client connection - we retry for a while in case the server hasn't started yet
      createClient();
      connect();

      // ---------------------------------------------------------------------------------------------------------------------------------------------------

      // Create a Timer task to display performance data on the procedure
      Timer timer = new Timer(true);
      timer.scheduleAtFixedRate(
          new TimerTask() {
            @Override
            public void run() {
              printStatistics(periodicStatsContext, true);
            }
          },
          config.displayInterval * 1000l,
          config.displayInterval * 1000l);

      // ---------------------------------------------------------------------------------------------------------------------------------------------------

      benchmarkStartTS = System.currentTimeMillis();
      AtomicLong rowId = new AtomicLong(0);

      // Run the benchmark loop for the requested duration
      final long endTime = benchmarkStartTS + (1000l * config.duration);
      int swap_count = 0;
      boolean first_cat = false;
      while (endTime > System.currentTimeMillis()) {
        long currentRowId = rowId.incrementAndGet();
        // Post the request, asynchronously
        try {
          clientRef
              .get()
              .callProcedure(
                  new AsyncCallback(writer, currentRowId), config.procedure, currentRowId, 0);
        } catch (Exception e) {
          e.printStackTrace();
          System.exit(-1);
        }

        swap_count++;
        if (((swap_count % CATALOG_SWAP_INTERVAL) == 0) && catalogSwap) {
          System.out.println("Changing catalogs...");
          clientRef.get().updateApplicationCatalog(catalogs[first_cat ? 0 : 1], deployment);
          first_cat = !first_cat;
        }
      }
      shutdown.compareAndSet(false, true);

      // ---------------------------------------------------------------------------------------------------------------------------------------------------

      // We're done - stop the performance statistics display task
      timer.cancel();

      // ---------------------------------------------------------------------------------------------------------------------------------------------------
      clientRef.get().drain();

      Thread.sleep(10000);
      waitForStreamedAllocatedMemoryZero(clientRef.get());
      System.out.println("Writing export count as: " + TrackingResults.get(0));
      // Write to export table to get count to be expected on other side.
      clientRef.get().callProcedure("JiggleExportDoneTable", TrackingResults.get(0));
      writer.close(true);

      // Now print application results:

      // 1. Tracking statistics
      System.out.printf(
          "-------------------------------------------------------------------------------------\n"
              + " Benchmark Results\n"
              + "-------------------------------------------------------------------------------------\n\n"
              + "A total of %d calls was received...\n"
              + " - %,9d Succeeded\n"
              + " - %,9d Failed (Transaction Error)\n"
              + "\n\n"
              + "-------------------------------------------------------------------------------------\n",
          TrackingResults.get(0) + TrackingResults.get(1),
          TrackingResults.get(0),
          TrackingResults.get(1));

      // 3. Performance statistics (we only care about the procedure that we're benchmarking)
      System.out.println(
          "\n\n-------------------------------------------------------------------------------------\n"
              + " System Statistics\n"
              + "-------------------------------------------------------------------------------------\n\n");
      printStatistics(fullStatsContext, false);

      // Dump statistics to a CSV file
      clientRef.get().writeSummaryCSV(fullStatsContext.getStatsByProc().get(config.procedure), csv);

      clientRef.get().close();

      // ---------------------------------------------------------------------------------------------------------------------------------------------------

    } catch (Exception x) {
      System.out.println("Exception: " + x);
      x.printStackTrace();
    }
  }
示例#20
0
 long[] getSequence(int index) {
   long entered = outUse.get(index);
   long sequence = consumerSeqs[index];
   return new long[] {entered, sequence};
 }
示例#21
0
 /** @return the count in the given bucket */
 long get(int bucket) {
   return buckets.get(bucket);
 }
示例#22
0
 /**
  * @return true if this histogram has overflowed -- that is, a value larger than our largest
  *     bucket could bound was added
  */
 public boolean isOverflowed() {
   return buckets.get(buckets.length() - 1) > 0;
 }
示例#23
0
 /** @return the smallest value that could have been added to this histogram */
 public long min() {
   for (int i = 0; i < buckets.length(); i++) {
     if (buckets.get(i) > 0) return i == 0 ? 0 : 1 + bucketOffsets[i - 1];
   }
   return 0;
 }
示例#24
0
 /** @return the total number of non-zero values */
 public long count() {
   long sum = 0L;
   for (int i = 0; i < buckets.length(); i++) sum += buckets.get(i);
   return sum;
 }
示例#25
-1
 /**
  * Combine this matrix reduction variable at the given row and column with the given value using
  * the given operation. (This matrix <TT>[r,c]</TT>) is set to (this matrix <TT>[r,c]</TT>)
  * <I>op</I> (<TT>value</TT>), then (this matrix <TT>[r,c]</TT>) is returned.
  *
  * @param r Row index.
  * @param c Column index.
  * @param value Value.
  * @param op Binary operation.
  * @return (This matrix <TT>[r,c]</TT>) <I>op</I> (<TT>value</TT>).
  */
 public long reduce(int r, int c, long value, LongOp op) {
   AtomicLongArray myMatrix_r = myMatrix[r];
   for (; ; ) {
     long oldvalue = myMatrix_r.get(c);
     long newvalue = op.op(oldvalue, value);
     if (myMatrix_r.compareAndSet(c, oldvalue, newvalue)) {
       return newvalue;
     }
   }
 }