Java BeforeExperiment类代码示例

import com.google.caliper.BeforeExperiment; //导入依赖的package包/类
@BeforeExperiment void setUp() throws Exception {
  executorService = new ThreadPoolExecutor(NUM_THREADS,
      NUM_THREADS,
      Long.MAX_VALUE,
      TimeUnit.SECONDS,
      new ArrayBlockingQueue<Runnable>(1000));
  executorService.prestartAllCoreThreads();
  final AtomicInteger integer = new AtomicInteger();
  // Execute a bunch of tasks to ensure that our threads are allocated and hot
  for (int i = 0; i < NUM_THREADS * 10; i++) {
    @SuppressWarnings("unused") // go/futurereturn-lsc
    Future<?> possiblyIgnoredError =
        executorService.submit(
            new Runnable() {
              @Override
              public void run() {
                integer.getAndIncrement();
              }
            });
  }
}
 

import com.google.caliper.BeforeExperiment; //导入依赖的package包/类
@BeforeExperiment
void addOtherEntries() throws Exception {
  GetCheckedTypeValidator validator = this.validator.validator;
  Class<? extends Exception> exceptionType = this.exceptionType.exceptionType;

  for (Class<? extends Exception> exceptionClass :
        OTHER_EXCEPTION_TYPES.asList().subList(0, otherEntriesInDataStructure)) {
    getChecked(validator, immediateFuture(""), exceptionClass);
  }

  for (int i = 0; i < otherEntriesInDataStructure; i++) {
    ClassValue<Boolean> classValue =
        new ClassValue<Boolean>() {
          @Override
          protected Boolean computeValue(Class<?> type) {
            return true;
          }
        };
    classValue.get(exceptionType);
    retainedReferencesToOtherClassValues.add(classValue);
  }
}
 

import com.google.caliper.BeforeExperiment; //导入依赖的package包/类
@BeforeExperiment void setUp() {
  random = new Random(0xdeadbeef);  // fix the seed so results are comparable across runs

  int nonAlpha = size / nonAlphaRatio;
  int alpha = size - nonAlpha;

  List<Character> chars = Lists.newArrayListWithCapacity(size);
  for (int i = 0; i < alpha; i++) {
    chars.add(randomAlpha());
  }
  for (int i = 0; i < nonAlpha; i++) {
    chars.add(randomNonAlpha());
  }
  Collections.shuffle(chars, random);
  char[] array = Chars.toArray(chars);
  this.testString = new String(array);
}
 

import com.google.caliper.BeforeExperiment; //导入依赖的package包/类
@BeforeExperiment
void setUp() {
  Random random = new Random(randomSeed);
  xInts = new int[SAMPLE_SIZE];
  yInts = new int[SAMPLE_SIZE];
  xLongs = new long[SAMPLE_SIZE];
  yLongs = new long[SAMPLE_SIZE];
  constant = new int[SAMPLE_SIZE];
  for (int i = 0; i < SAMPLE_SIZE; i++) {
    xInts[i] = random.nextInt(Integer.MAX_VALUE);
    yInts[i] = random.nextInt(Integer.MAX_VALUE);
    xLongs[i] = random.nextLong() & NONNEGATIVE_LONG_MASK;
    yLongs[i] = random.nextLong() & NONNEGATIVE_LONG_MASK;
    constant[i] = random.nextInt();
  }
}
 

import com.google.caliper.BeforeExperiment; //导入依赖的package包/类
@BeforeExperiment void setUp() {
  if (emptySetProportion + singletonSetProportion > 1.01) {
    throw new SkipThisScenarioException();
  }

  Random rng = new Random();
  for (int i = 0; i < 0x1000; i++) {
    double setSize = rng.nextDouble();
    if (setSize < emptySetProportion) {
      sets[i] = ImmutableSet.of();
    } else if (setSize < emptySetProportion + singletonSetProportion) {
      sets[i] = ImmutableSet.of(PRESENT);
    } else {
      sets[i] = ImmutableSet.of(PRESENT, new Object());
    }

    if (rng.nextDouble() < hitRate) {
      queries[i] = PRESENT;
    } else {
      queries[i] = ABSENT;
    }
  }
}
 

import com.google.caliper.BeforeExperiment; //导入依赖的package包/类
@BeforeExperiment void setUp() {
  hashMultiset = HashMultiset.create(size);
  linkedHashMultiset = LinkedHashMultiset.create(size);
  treeMultiset = TreeMultiset.create();

  Random random = new Random();

  int sizeRemaining = size;

  // TODO(kevinb): generate better test contents for multisets
  for (int i = 0; sizeRemaining > 0; i++) {
    // The JVM will return interned values for small ints.
    Integer value = random.nextInt(1000) + 128;
    int count = Math.min(random.nextInt(10) + 1, sizeRemaining);
    sizeRemaining -= count;
    hashMultiset.add(value, count);
    linkedHashMultiset.add(value, count);
    treeMultiset.add(value, count);
  }

  //TODO(kevinb): convert to assert once benchmark tests enable asserts by default
  Preconditions.checkState(hashMultiset.size() == size);
}
 

import com.google.caliper.BeforeExperiment; //导入依赖的package包/类
@BeforeExperiment
void setUp() throws Exception {
  Random r = new Random();
  ba1 = new byte[length];
  r.nextBytes(ba1);
  ba2 = Arrays.copyOf(ba1, ba1.length);
  // Differ at the last element
  ba3 = Arrays.copyOf(ba1, ba1.length);
  ba4 = Arrays.copyOf(ba1, ba1.length);
  ba3[ba1.length - 1] = (byte) 43;
  ba4[ba1.length - 1] = (byte) 42;

  javaImpl = UnsignedBytes.lexicographicalComparatorJavaImpl();
  unsafeImpl =
      UnsignedBytes.LexicographicalComparatorHolder.UnsafeComparator.INSTANCE;
}
 

import com.google.caliper.BeforeExperiment; //导入依赖的package包/类
@BeforeExperiment void setUp() {
  testBytesA = new byte[size];
  random.nextBytes(testBytesA);
  testBytesB = Arrays.copyOf(testBytesA, size);
  int indexToDifferAt = -1;
  switch (whereToDiffer) {
    case ONE_PERCENT_IN:
      indexToDifferAt = (int) (size * 0.01);
      break;
    case LAST_BYTE:
      indexToDifferAt = size - 1;
      break;
    case NOT_AT_ALL:
  }
  if (indexToDifferAt != -1) {
    testBytesA[indexToDifferAt] = (byte) (testBytesB[indexToDifferAt] - 1);
  }
}
 

import com.google.caliper.BeforeExperiment; //导入依赖的package包/类
@BeforeExperiment void setUp() {
  // random integers will be generated in this range, then raised to the
  // power of (1/concentration) and floor()ed
  max = Ints.checkedCast((long) Math.pow(distinctKeys, concentration));

  cache = CacheBuilder.newBuilder()
      .concurrencyLevel(segments)
      .maximumSize(maximumSize)
      .build(
          new CacheLoader<Integer, Integer>() {
            @Override public Integer load(Integer from) {
              return (int) misses.incrementAndGet();
            }
          });

  // To start, fill up the cache.
  // Each miss both increments the counter and causes the map to grow by one,
  // so until evictions begin, the size of the map is the greatest return
  // value seen so far
  while (cache.getUnchecked(nextRandomKey()) < maximumSize) {}

  requests.set(0);
  misses.set(0);
}
 

import com.google.caliper.BeforeExperiment; //导入依赖的package包/类
@BeforeExperiment void setUp() throws Exception {
  executorService = new ThreadPoolExecutor(NUM_THREADS,
      NUM_THREADS,
      Long.MAX_VALUE,
      TimeUnit.SECONDS,
      new ArrayBlockingQueue<Runnable>(1000));
  executorService.prestartAllCoreThreads();
  final AtomicInteger integer = new AtomicInteger();
  // Execute a bunch of tasks to ensure that our threads are allocated and hot
  for (int i = 0; i < NUM_THREADS * 10; i++) {
    executorService.submit(new Runnable() {
      @Override public void run() {
        integer.getAndIncrement();
      }
    });
  }
}
 

import com.google.caliper.BeforeExperiment; //导入依赖的package包/类
@BeforeExperiment
void setUp() {
  String component = Strings.repeat("a", componentLength);
  String[] raw = new String[count];
  Arrays.fill(raw, component);
  components = Arrays.asList(raw);
}
 

import com.google.caliper.BeforeExperiment; //导入依赖的package包/类
@BeforeExperiment
@SuppressWarnings("unchecked")
void setUp() throws ClassNotFoundException {
  Preconditions.checkArgument(hitRate >= 0 && hitRate <= 1,
      "hitRate must be in the range [0,1]");

  enumType = (Class<? extends Enum>)
      Class.forName(EnumsBenchmark.class.getCanonicalName() + "$" + enumSize + "Enum");

  Enum<?>[] allConstants = enumType.getEnumConstants();
  List<String> hits = new ArrayList<String>();
  for (int i = 0; i < hitRate * 256 / 3; ++i) {
    hits.add(allConstants[0].name());
    hits.add(allConstants[allConstants.length / 2].name());
    hits.add(allConstants[allConstants.length - 1].name());
  }

  List<String> misses = new ArrayList<String>();
  for (int i = 0; i < 256 - hits.size(); ++i) {
    misses.add("INVALID");
  }

  List<String> sampleDataList = new ArrayList<String>();
  sampleDataList.addAll(hits);
  sampleDataList.addAll(misses);
  Collections.shuffle(sampleDataList);
  sampleData = sampleDataList.toArray(new String[sampleDataList.size()]);
}
 

import com.google.caliper.BeforeExperiment; //导入依赖的package包/类
@BeforeExperiment
public void doBefore() {
  recursionCount = stackDepth - new Throwable().getStackTrace().length - 1;
  if (recursionCount < 0) {
    throw new SkipThisScenarioException();
  }
}
 

import com.google.caliper.BeforeExperiment; //导入依赖的package包/类
@BeforeExperiment void setUp() {
  this.matcher = precomputed ? config.matcher.precomputed() : config.matcher;
  if (size == Size.SMALL) {
    BitSet tmp = new BitSet();
    matcher.setBits(tmp);
    int matchedCharCount = tmp.cardinality();
    this.matcher = SmallCharMatcher.from(tmp, "");
  }
  this.string = checkString(length, percent, config.matchingChars,
      new Random(), forceSlow, web);
}
 

import com.google.caliper.BeforeExperiment; //导入依赖的package包/类
@BeforeExperiment
protected void setUp() {
  BitSet bitSet = new BitSet();
  for (int i = 0; i < OLD_WHITESPACE_TABLE.length(); i++) {
    bitSet.set(OLD_WHITESPACE_TABLE.charAt(i));
  }
  bitSet.clear(0);
  bitSet.clear(1);
  matcher = useNew ? CharMatcher.whitespace() : OLD_WHITESPACE;
  teststring = newTestString(new Random(1), bitSet, percentMatching);
}