benchmarking

I want to compare different implementations of Java programs in terms of their memory usage efficiency. There are different usage scenarios formulated as JUnit test cases. Actually, all the code is open source at: https://github.com/headissue/cache2k-benchmark The general wisdom to get to the used memory of a Java program is this: Runtime.getRuntime().totalMemory() - Runtime.getRuntime().freeMemory() , of course it is also possible to use the JMX interface to get these values. However, the determined values of used memory is not reliable. Possible reasons: There may be uncollected garbage

i tried to code to calculate time that a function costs list <- buildlist 10000 10000 starttime <- getClockTime let sortedlist = quicksort list endtime <- getClockTime let difftime = diffClockTimes endtime starttime function buildlist: buildlist :: Int -> Int -> IO [Int] buildlist n m = do seed <- getStdGen let l = randomRs (0, m) seed let list = take n l return list function quicksort: quicksort [] = [] quicksort (x:xs) = let head = [a|a<-xs,a<=x] tail = [a|a<-xs,a>x] in quicksort head ++ [x] ++ quicksort tail first question: when i output the difftime, it is always zero no matter how long

I just found this answer from @tony-d with a bench code to test virtual function call overhead. I checked is benchmark using g++ : $ g++ -O2 -o vdt vdt.cpp -lrt $ ./vdt virtual dispatch: 150000000 0.128562 switched: 150000000 0.0803207 overheads: 150000000 0.0543323 ... I got better performance that his (ratio is about 2), but then I checked with clang : $ clang++-3.7 -O2 -o vdt vdt.cpp -lrt $ ./vdt virtual dispatch: 150000000 0.462368 switched: 150000000 0.0569544 overheads: 150000000 0.0509332 ... Now the ratio goes up to about 70! I then noticed the -lrt command line argument, and after a

I'm looking to do some very basic micro benchmarking of small code paths, such as tight loops, that I've written in C++. I'm running on Linux and OSX, and using GCC. What facilities are there for sub millisecond accuracy? I am thinking a simple test of running the code path many times (several tens of millions?) will give me enough consistency to get a good reading. If anyone knows of preferable methods, please feel free to suggest them. osgx You can use "rdtsc" processor instruction on x86/x86_64. For multicore systems check the "constant_tsc" capability in CPUID (/proc/cpuinfo in linux) - it

The JavaDoc of annotation @OperationsPerInvocation in the Java Microbenchmarking Harness (JMH) states: value public abstract int value Returns: Number of operations per single Benchmark call. Default: 1 Being new to JMH I am wondering what type of operation (byte code operation, assembly code operation, Java operation etc) is meant here. This question naturally refers to all places in JMH (documentation, output, comments etc) where the term 'operation' is used (e.g. " operation/time " unit or "time unit/operation "). In JMH, "operation" is an abstract unit of work. See e.g. the sample result:

I'm looking to benchmark how something performs while contending with a high amount of ongoing garbage collection. I've previously benchmarked how it behaves in a stable, single-threaded run, and I'd now like to do the same tests in a more stressed JVM; essentially I'd like to have background threads creating and destroying objects at a reasonably consistent pace. I'm looking for suggestions on how to implement a stable yet GC-intensive operation. It needs to accomplish several goals: Spend a decent amount (say, 20-50%) of time in GC Do an approximately consistent amount of work over time, and