Java Code Examples for java.util.concurrent.TimeUnit#MICROSECONDS

private TimeUnit findMaxUnitToDisplay(ExpectMaxExecutionTime annotation) {
    if(annotation.hours() != 0) {
        return TimeUnit.HOURS;
    }
    if(annotation.minutes() != 0) {
        return TimeUnit.MINUTES;
    }
    if(annotation.seconds() != 0) {
        return TimeUnit.SECONDS;
    }
    if(annotation.milliSeconds() != 0) {
        return TimeUnit.MILLISECONDS;
    }
    if(annotation.microSeconds() != 0) {
        return TimeUnit.MICROSECONDS;
    }
    if(annotation.nanoSeconds() != 0) {
        return TimeUnit.NANOSECONDS;
    }
    return TimeUnit.HOURS;
}
 

@Test
public void shouldOmitNaNsEtcWhenSerializingUsingLineProtocolForDouble() {
    Map<String, Object> fields = new LinkedHashMap<String, Object>();
    fields.put("field1Key", "field1Value");
    fields.put("field2Key", Double.NaN);
    fields.put("field3Key", Double.POSITIVE_INFINITY);
    fields.put("field4Key", Double.NEGATIVE_INFINITY);
    fields.put("field5Key", 0.432);
    InfluxDbWriteObject influxDbWriteObject = new InfluxDbWriteObject("test-db", TimeUnit.MICROSECONDS);
    influxDbWriteObject.getPoints().add(new InfluxDbPoint("measurement1", 456l, fields));

    InfluxDbWriteObjectSerializer influxDbWriteObjectSerializer = new InfluxDbWriteObjectSerializer("");
    String lineString = influxDbWriteObjectSerializer.getLineProtocolString(influxDbWriteObject);

    assertThat(lineString).isEqualTo("measurement1 field1Key=\"field1Value\",field5Key=0.432 456000\n");
}
 

@Benchmark
@BenchmarkMode({ Mode.Throughput })
@OutputTimeUnit(TimeUnit.MICROSECONDS)
public long loopReadLongDirectByteBuffer() {
	long value = 0;

	directByteBuffe.position(0);
	while (directByteBuffe.hasRemaining()) {
		value = directByteBuffe.getLong();
	}

	return value;
}
 

@Benchmark
@BenchmarkMode({ Mode.Throughput })
@OutputTimeUnit(TimeUnit.MICROSECONDS)
public int sumByAtomicMuiltInteger1() {
	atomicMuiltInteger1.set(1, 1);
	return atomicMuiltInteger1.sum();
}
 

@Warmup(iterations = 5)
@Measurement(iterations = 10)
@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.MICROSECONDS)
@Fork(value = 1)
@Threads(8)
@Benchmark
public void get(Blackhole blackhole,BenchmarkState state,ThreadState threadState) {
    String key = state.keys.get(threadState.i++ % state.numRows);
    String val = state.oakMap.get(key);
    blackhole.consume(val);
}
 

@Test
public void shouldEscapeMeasurement() {
    Map<String, String> tags = new HashMap<String, String>();
    Map<String, Object> fields = new HashMap<String, Object>();
    fields.put("field1 Key", "field1Value");
    InfluxDbWriteObject influxDbWriteObject = new InfluxDbWriteObject("test-db", TimeUnit.MICROSECONDS);
    influxDbWriteObject.getPoints().add(new InfluxDbPoint("my measurement,1=1", tags, 456l, fields));

    InfluxDbWriteObjectSerializer influxDbWriteObjectSerializer = new InfluxDbWriteObjectSerializer("");
    String lineString = influxDbWriteObjectSerializer.getLineProtocolString(influxDbWriteObject);

    assertThat(lineString)
        .isEqualTo("my\\ measurement\\,1=1 field1\\ Key=\"field1Value\" 456000\n");
}
 

private BaseWindowedSink getWindowSinkInstance() {
  BaseWindowedSink baseWindowedSink = new IterativeStreamingWindowedCompute(
      new ProcessWindowFunctionImpl(),
      OperationMode.STREAMING,
      this.svmJobParameters,
      this.binaryBatchModel,
      "online-training-graph");
  WindowArguments windowArguments = this.svmJobParameters.getWindowArguments();
  TimeUnit timeUnit = TimeUnit.MICROSECONDS;
  if (windowArguments != null) {
    WindowType windowType = windowArguments.getWindowType();
    if (windowArguments.isDuration()) {
      if (windowType.equals(WindowType.TUMBLING)) {
        baseWindowedSink
            .withTumblingDurationWindow(windowArguments.getWindowLength(), timeUnit);
      }
      if (windowType.equals(WindowType.SLIDING)) {
        baseWindowedSink
            .withSlidingDurationWindow(windowArguments.getWindowLength(), timeUnit,
                windowArguments.getSlidingLength(), timeUnit);
      }
    } else {
      if (windowType.equals(WindowType.TUMBLING)) {
        baseWindowedSink
            .withTumblingCountWindow(windowArguments.getWindowLength());
      }
      if (windowType.equals(WindowType.SLIDING)) {
        baseWindowedSink
            .withSlidingCountWindow(windowArguments.getWindowLength(),
                windowArguments.getSlidingLength());
      }
    }
  }
  return baseWindowedSink;
}
 

@Benchmark
@BenchmarkMode({ Mode.Throughput })
@OutputTimeUnit(TimeUnit.MICROSECONDS)
public Integer nonBlockingHashMapLong() {
	int random = ThreadLocalRandom.current().nextInt(1024 * 256);
	nonBlockingHashMapLong.remove(random);
	nonBlockingHashMapLong.put(random, random);
	return nonBlockingHashMapLong.get(random);
}
 

@Benchmark
@BenchmarkMode({ Mode.Throughput })
@OutputTimeUnit(TimeUnit.MICROSECONDS)
public void writeByteToUnsafe() {
	for (int i = 0; i < 1024; i++) {
		UnsafeUtils.unsafe().putByte(OFFSET + i, (byte) 1);
	}
}
 

/** Verify that tryResume(TransctionId, long, TimeUnit) waits the full time and returns the expected
 *  value. 
 * 
 * @param txId The transaction ID to attempt to resume. 
 * @param timeValue A tryResume argument.
 * @param unit A tryResume argument.
 * @param expectedResult The expected result from tryResume.
 */
private void verifyTryResumeWaits(TransactionId txId, long timeValue, TimeUnit unit, boolean expectedResult) {
  Object[] tmp = tryResume(txId, timeValue, unit);
  boolean result = (Boolean)tmp[0];
  long duration = (Long)tmp[1];

  // verify the wait
  long expectedWaitMs = timeValue;
  if (unit == TimeUnit.SECONDS) {
    expectedWaitMs = timeValue * 1000;
  } else if (unit == TimeUnit.MICROSECONDS) {
    expectedWaitMs = timeValue / 1000;
  } else if (unit == TimeUnit.NANOSECONDS) {
    expectedWaitMs = timeValue / 1000000;
  } else if (unit == TimeUnit.MILLISECONDS){
    // already set
  } else {
    throw new TestException("Unknown TimeUnit " + unit);
  }
  if (duration < expectedWaitMs) {
    throw new TestException("Expected tryResume(" + txId + ", " + timeValue + ", " + unit + ") to wait for " +
        expectedWaitMs + "ms but it took " + duration + "ms");
  }
  if (result != expectedResult) {
    throw new TestException("Expected tryResume(" + txId + ", " + timeValue + ", " + unit + ") to return " +
        expectedResult + ", but it returned " + result);
  }
}
 

@Benchmark
@BenchmarkMode({ Mode.Throughput })
@OutputTimeUnit(TimeUnit.MICROSECONDS)
public int sumByAtomicMuiltInteger2() {
	atomicMuiltInteger2.set(1, 1);
	return atomicMuiltInteger2.sum();
}
 

@Benchmark
@BenchmarkMode(Mode.SampleTime)
@OutputTimeUnit(TimeUnit.MICROSECONDS)
@Fork(1)
@Warmup(iterations = 2, time = 3)
@Measurement(iterations = 3, time = 7)
public void test(){
    buffer.add(n1);
    buffer.remove();
}
 

@BenchmarkMode(Mode.SampleTime)
@OutputTimeUnit(TimeUnit.MICROSECONDS)
@Benchmark
public void testResponseTimeHSQLDBMessage(final Blackhole bh) {
    loggerHSQLDB.info("Test message");
}
 

@Benchmark
@BenchmarkMode({ Mode.Throughput })
@OutputTimeUnit(TimeUnit.MICROSECONDS)
public Object newObject() throws Exception {
	return new Object();
}
 

@Benchmark
@BenchmarkMode({ Mode.Throughput })
@OutputTimeUnit(TimeUnit.MICROSECONDS)
public String decodeByJavaURLEncoder() throws Exception {
	return URLDecoder.decode(encoded, "UTF-8");
}
 

@Benchmark
@BenchmarkMode({ Mode.Throughput })
@OutputTimeUnit(TimeUnit.MICROSECONDS)
public Object newObject() {
	return new Object();
}
 

@Benchmark
@BenchmarkMode({ Mode.Throughput })
@OutputTimeUnit(TimeUnit.MICROSECONDS)
public RandomId128 newRandomId128() throws Exception {
	return RandomId128.next();
}
 

@Benchmark
@BenchmarkMode({ Mode.Throughput })
@OutputTimeUnit(TimeUnit.MICROSECONDS)
public Boolean getByCopyOnWriteArrayList() {
	return copyOnWriteArrayList.get(512);
}
 

@Benchmark
@BenchmarkMode({ Mode.Throughput })
@OutputTimeUnit(TimeUnit.MICROSECONDS)
public byte[] StringUtils2_getLatin1Bytes() throws Exception {
	return UnsafeStringUtils.getLatin1Bytes(str);
}
 

@Benchmark
@BenchmarkMode({ Mode.Throughput })
@OutputTimeUnit(TimeUnit.MICROSECONDS)
public String instanceByNew() {
	return new String();
}