microbenchmark

I'm writing some code in Java where, at some point, the flow of the program is determined by whether two int variables, "a" and "b", are non-zero (note: a and b are never negative, and never within integer overflow range). I can evaluate it with if (a != 0 && b != 0) { /* Some code */ } Or alternatively if (a*b != 0) { /* Some code */ } Because I expect that piece of code to run millions of times per run, I was wondering which one would be faster. I did the experiment by comparing them on a huge randomly generated array, and I was also curious to see how the sparsity of the array (fraction of

There are some answers on SO where timings are compared without checking the results. However, I prefer to see whether an expression is correct and fast. The microbenchmark package supports this with the check parameter. Unfortunately, the check fails on expressions which change a data.table by reference , i.e., the check does not recognize that results are different. Case 1: data.table expressions where check works as expected library(data.table) library(microbenchmark) # minimal data.table 1 col, 3 rows dt <- data.table(x = c(1, 1, 10)) # define check function as in example section of help

I have some highly perf sensitive code. A SIMD implementation using SSEn and AVX uses about 30 instructions, while a version that uses a 4096 byte lookup table uses about 8 instructions. In a microbenchmark, the lookup table is faster by 40%. If I microbenchmark, trying to invalidate the cache very 100 iterations, they appear about the same. In my real program, it appears that the non-loading version is faster, but it's really hard to get a provably good measurement, and I've had measurements go both ways. I'm just wondering if there are some good ways to think about which one would be better

Let's say I have a function that I plan to execute as part of a benchmark. I want to bring this code into the L1 instruction cache prior to executing since I don't want to measure the cost of I$ misses as part of the benchmark. The obvious way to do this is to simply execute the code at least once before the benchmark, hence "warming it up" and bringing it into the L1 instruction cache and possibly the uop cache, etc. What are my alternatives in the case I don't want to execute the code (e.g., because I want the various predictors which key off of instruction addresses to be cold)? One

The following code checks if x and y are distinct values (the variables x , y , z can only have values a , b , or c ) and if so, sets z to the third character: if x == 'a' and y == 'b' or x == 'b' and y == 'a': z = 'c' elif x == 'b' and y == 'c' or x == 'c' and y == 'b': z = 'a' elif x == 'a' and y == 'c' or x == 'c' and y == 'a': z = 'b' Is is possible to do this in a more, concise, readable and efficient way? z = (set(("a", "b", "c")) - set((x, y))).pop() I am assuming that one of the three cases in your code holds. If this is the case, the set set(("a", "b", "c")) - set((x, y)) will consist