In terms of readability and exposing responsibility of method immediately, my personal preference is to return immediately from a method once task is done. Based on my experience with dealing complex, long methods with limited documentation, multiple returns in a method helped me to understand code easier in past.
But readability is not always the only factor when I write code in my current job. Performance (low latency) beats readability. So, I decided to benchmark these two methods:
Multiple return points
public Number multipleReturnPoints(Number num) { if (num instanceof Integer) { return Integer.valueOf(num.intValue()); } if (num instanceof Float) { return Float.valueOf(num.floatValue()); } if (num instanceof Double) { return Double.valueOf(num.doubleValue()); } return null; }
Single returns in the end
public Number singleReturnPoint(Number num) { Number val = null; if (num instanceof Integer) { val = Integer.valueOf(num.intValue()); } if (num instanceof Float) { val = Float.valueOf(num.floatValue()); } if (num instanceof Double) { val = Double.valueOf(num.doubleValue()); } return val; }
I used following setup for testing:
- Both method is called 5 million times, after 500K warm up
- In order to asses JIT compile's affect, two different schemes is used for methods parameter selection:
- Clustered (Batch): Same type parameter called in batch sequentially. In other words first Double, then Integer and finally Float type is chosen.
- Random : Type parameter is chosen from a uniform distribution. This is more realistic case would happen in a system.
- Following JRE are tested:
- Oracle JRE 1.6.0_20
- Oracle JRE 1.7.0_15
- Oracle JRE 1.8.0_11
- Azur Zing 1.7.0-5.9.5.0
- Garbage collection is prevented by allocating large amount of heap size
- Tests are run on Redhat Linux (64 bit,2.93GHz).
Results
Above benchmark test is done 7 times and in below charts, average latency (mSec) is illustrated .
Oracle JDK, although single
returns perform marginally better , there is not much difference between
multiple or single returns for both clustered random parameter selection. Whereas for Zing JVM, there is not a definitive conclusion. But given that random parameter selection is more realistic, single return is the winner, I think.
In conclusion, I could not find a definitive answer which
method exit case performs better in terms of low latency.
package com.denizstij; public interface Simulation { Number run(Number num); String getName(); } //////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////// package com.denizstij; import java.util.Arrays; import java.util.Random; public class SingleOrMultipleExitPoints { public static class MultipleReturns implements Simulation { public Number run(Number num) { if (num instanceof Integer) { return Integer.valueOf(num.intValue()); } if (num instanceof Float) { return Float.valueOf(num.floatValue()); } if (num instanceof Double) { return Double.valueOf(num.doubleValue()); } return null; } @Override public String getName() { return "Multiple Returns"; } } public static class SingleReturn implements Simulation { public Number run(Number num) { Number val = null; if (num instanceof Integer) { val = Integer.valueOf(num.intValue()); } if (num instanceof Float) { val = Float.valueOf(num.floatValue()); } if (num instanceof Double) { val = Double.valueOf(num.doubleValue()); } return val; } @Override public String getName() { return "Single Return"; } } public static void main(String[] args) { Random random = new Random(0); int warmUpLoopSize = 50000; int loopSize = warmUpLoopSize * 10; if (args.length==2){ warmUpLoopSize=Integer.parseInt(args[0]); loopSize=Integer.parseInt(args[1]); System.out.println("Number of warmUpLoopSize:"+warmUpLoopSize); System.out.println("Number of loopSize :"+loopSize); } // Arrays for warming up JVM Integer warmUpIntArr[] = new Integer[warmUpLoopSize]; Float warmUpFloatArr[] = new Float[warmUpLoopSize]; Double warmUpDoubleArr[] = new Double[warmUpLoopSize]; // Simulation arrays Integer intArr[] = new Integer[loopSize]; Float floatArr[] = new Float[loopSize]; Double doubleArr[] = new Double[loopSize]; // Creatring random numbers createRandomNumbers(random, warmUpIntArr, warmUpFloatArr, warmUpDoubleArr,warmUpLoopSize); createRandomNumbers(random, intArr, floatArr, doubleArr, loopSize); // Creating test cases MultipleReturns multipleReturns = new MultipleReturns(); SingleReturn singleReturn= new SingleReturn(); int[] warmUpRandomCallSeq = generateRandomCallSequence(warmUpLoopSize,3,random); int[] warmUpClusteredCallSeq = generateClusteredCallSequence(warmUpLoopSize,3,random); int[] randomCallSeq = generateRandomCallSequence(loopSize,3,random); int[] clusteredCallSeq = generateClusteredCallSequence(loopSize,3,random); //System.out.println(Arrays.toString(warmUpRandomCallSeq)); //System.out.println(Arrays.toString(warmUpClusteredCallSeq)); String simName="Clustered Warmup"; callSimulation(warmUpIntArr, warmUpFloatArr, warmUpDoubleArr,simName, multipleReturns,warmUpClusteredCallSeq); callSimulation(warmUpIntArr, warmUpFloatArr, warmUpDoubleArr,simName, singleReturn,warmUpClusteredCallSeq); simName="Clustered Calls"; callSimulation(intArr, floatArr, doubleArr,simName, multipleReturns,clusteredCallSeq); callSimulation(intArr, floatArr, doubleArr,simName, singleReturn,clusteredCallSeq); System.out.println("=============================="); simName="Random Warmup"; callSimulation(warmUpIntArr, warmUpFloatArr, warmUpDoubleArr,simName, multipleReturns,warmUpRandomCallSeq); callSimulation(warmUpIntArr, warmUpFloatArr, warmUpDoubleArr,simName, singleReturn,warmUpRandomCallSeq); simName="Random Calls"; callSimulation(intArr, floatArr, doubleArr,simName, multipleReturns,randomCallSeq); callSimulation(intArr, floatArr, doubleArr,simName, singleReturn,randomCallSeq); System.out.println("=============================="); } private static void callSimulation(Integer[] intArr, Float[] floatArr, Double[] doubleArr, String msg, Simulation sim, int[] callSeq) { long now = System.currentTimeMillis(); int clusterIndexes[]= new int[3]; int index=0; for (int i = 0; i < callSeq.length; i++) { int callerIndex = callSeq[i]; index=clusterIndexes[callerIndex]++; if (index>=intArr.length){ continue; } switch (callerIndex){ case 0: doubleArr[index] = (Double) sim.run(doubleArr[index]); break; case 1: intArr[index] = (Integer) sim.run(intArr[index]); break; case 2: floatArr[index] = (Float) sim.run(floatArr[index]); break; default: System.out.println("Unknown cluster :("+callerIndex); } } long finish = System.currentTimeMillis(); long elapsedTime = finish - now; System.out.println(elapsedTime + ": " +msg+" :"+ sim.getName()); System.out.println(Arrays.toString(clusterIndexes)); System.out.flush(); } static void createRandomNumbers(Random random, Integer intArr[], Float floatArr[], Double doubleArr[], int size) { for (int i = 0; i < size; i++) { intArr[i] = Integer.valueOf(random.nextInt(size)); floatArr[i] = Float.valueOf(random.nextFloat() * size); doubleArr[i] = Double.valueOf(random.nextDouble() * size); } } static int[] generateClusteredCallSequence(int simSize,int numOfCluster,Random random){ int totalSize=numOfCluster*simSize; int callSeq[]= new int[totalSize]; int index=0; for (int j=0;j < numOfCluster;j++){ for (int i=0;i < simSize;i++){ callSeq[index++]=j; } } return callSeq; } static int[] generateRandomCallSequence(int simSize,int numOfCluster,Random random){ int totalSize=numOfCluster*simSize; int callSeq[]= new int[totalSize]; for (int i=0;i < totalSize;i++){ callSeq[i]=random.nextInt(numOfCluster); } return callSeq; } }
No comments:
Post a Comment