/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.kafka.test;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Random;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.locks.ReentrantLock;
import org.apache.kafka.common.utils.CopyOnWriteMap;
import org.apache.kafka.common.utils.Time;
public class Microbenchmarks {
public static void main(String[] args) throws Exception {
final int iters = Integer.parseInt(args[0]);
double x = 0.0;
long start = System.nanoTime();
for (int i = 0; i < iters; i++)
x += Math.sqrt(x);
System.out.println(x);
System.out.println("sqrt: " + (System.nanoTime() - start) / (double) iters);
// test clocks
systemMillis(iters);
systemNanos(iters);
long total = 0;
start = System.nanoTime();
total += systemMillis(iters);
System.out.println("System.currentTimeMillis(): " + (System.nanoTime() - start) / iters);
start = System.nanoTime();
total += systemNanos(iters);
System.out.println("System.nanoTime(): " + (System.nanoTime() - start) / iters);
System.out.println(total);
// test random
int n = 0;
Random random = new Random();
start = System.nanoTime();
for (int i = 0; i < iters; i++) {
n += random.nextInt();
}
System.out.println(n);
System.out.println("random: " + (System.nanoTime() - start) / iters);
float[] floats = new float[1024];
for (int i = 0; i < floats.length; i++)
floats[i] = random.nextFloat();
Arrays.sort(floats);
int loc = 0;
start = System.nanoTime();
for (int i = 0; i < iters; i++)
loc += Arrays.binarySearch(floats, floats[i % floats.length]);
System.out.println(loc);
System.out.println("binary search: " + (System.nanoTime() - start) / iters);
final Time time = Time.SYSTEM;
final AtomicBoolean done = new AtomicBoolean(false);
final Object lock = new Object();
Thread t1 = new Thread() {
public void run() {
time.sleep(1);
int counter = 0;
long start = time.nanoseconds();
for (int i = 0; i < iters; i++) {
synchronized (lock) {
counter++;
}
}
System.out.println("synchronized: " + ((time.nanoseconds() - start) / iters));
System.out.println(counter);
done.set(true);
}
};
Thread t2 = new Thread() {
public void run() {
int counter = 0;
while (!done.get()) {
time.sleep(1);
synchronized (lock) {
counter += 1;
}
}
System.out.println("Counter: " + counter);
}
};
t1.start();
t2.start();
t1.join();
t2.join();
System.out.println("Testing locks");
done.set(false);
final ReentrantLock lock2 = new ReentrantLock();
Thread t3 = new Thread() {
public void run() {
time.sleep(1);
int counter = 0;
long start = time.nanoseconds();
for (int i = 0; i < iters; i++) {
lock2.lock();
counter++;
lock2.unlock();
}
System.out.println("lock: " + ((time.nanoseconds() - start) / iters));
System.out.println(counter);
done.set(true);
}
};
Thread t4 = new Thread() {
public void run() {
int counter = 0;
while (!done.get()) {
time.sleep(1);
lock2.lock();
counter++;
lock2.unlock();
}
System.out.println("Counter: " + counter);
}
};
t3.start();
t4.start();
t3.join();
t4.join();
Map<String, Integer> values = new HashMap<String, Integer>();
for (int i = 0; i < 100; i++)
values.put(Integer.toString(i), i);
System.out.println("HashMap:");
benchMap(2, 1000000, values);
System.out.println("ConcurentHashMap:");
benchMap(2, 1000000, new ConcurrentHashMap<String, Integer>(values));
System.out.println("CopyOnWriteMap:");
benchMap(2, 1000000, new CopyOnWriteMap<String, Integer>(values));
}
private static void benchMap(int numThreads, final int iters, final Map<String, Integer> map) throws Exception {
final List<String> keys = new ArrayList<String>(map.keySet());
final List<Thread> threads = new ArrayList<Thread>();
for (int i = 0; i < numThreads; i++) {
threads.add(new Thread() {
public void run() {
long start = System.nanoTime();
for (int j = 0; j < iters; j++)
map.get(keys.get(j % threads.size()));
System.out.println("Map access time: " + ((System.nanoTime() - start) / (double) iters));
}
});
}
for (Thread thread : threads)
thread.start();
for (Thread thread : threads)
thread.join();
}
private static long systemMillis(int iters) {
long total = 0;
for (int i = 0; i < iters; i++)
total += System.currentTimeMillis();
return total;
}
private static long systemNanos(int iters) {
long total = 0;
for (int i = 0; i < iters; i++)
total += System.currentTimeMillis();
return total;
}
}