benchmarking

So I am aware of this question, and others on SO that deal with issue, but most of those deal with the complexities of the data structures (just to copy here, linked this theoretically has O( I understand the complexities would seem to indicate that a list would be better, but I am more concerned with the real world performance. Note: This question was inspired by slides 45 and 46 of Bjarne Stroustrup's presentation at Going Native 2012 where he talks about how processor caching and locality of reference really help with vectors, but not at all (or enough) with lists. Question: Is there a good

I wanted to try out the new feature of JMH by running it as Java Application in eclipse. I imported and built jmh-samples project. Compiled classes ended in /jmh-samples/target/generated-sources/annotations, there are several JARs in /target/ and running microbenchmarks.jar from command line works as usual. However when I execute main I always get No matching benchmarks. Miss-spelled regexp? Any ideas? I am using version 0.3 jmh-dev@ is a better way to communicate this with the developers. Few things to try: Hijacking Main is probably not a good idea. Use Java API instead, like this sample .

While trying to tackle a more complex problem, I came to compare access speed to local variable vs member variables. Here a test program: #!/usr/bin/env python MAX=40000000 class StressTestMember(object): def __init__(self): self.m = 0 def do_work(self): self.m += 1 self.m *= 2 class StressTestLocal(object): def __init__(self): pass def do_work(self): m = 0 m += 1 m *= 2 # LOCAL access test for i in range(MAX): StressTestLocal().do_work() # MEMBER access test for i in range(MAX): StressTestMember().do_work() I know it might look like a bad idea to instantiate StressTestMember and

I'm looking into measuring benchmark performance using the time-stamp register (TSR) found in x86 CPUs. It's a useful register, since it measures in a monotonic unit of time which is immune to the clock speed changing. Very cool. Here is an Intel document showing asm snippets for reliably benchmarking using the TSR, including using cpuid for pipeline synchronisation. See page 16: http://www.intel.com/content/www/us/en/embedded/training/ia-32-ia-64-benchmark-code-execution-paper.html To read the start time, it says (I annotated a bit): __asm volatile ( "cpuid\n\t" // writes e[abcd]x "rdtsc\n\t"

So I did some testing and got odd results. Code: import numpy as np import timeit setup = """ import numpy as np A = np.ones((1000,1000,3), dtype=datatype) """ datatypes = "np.uint8", "np.uint16", "np.uint32", "np.uint64", "np.float16", "np.float32", "np.float64" stmt1 = """ A = A * 255 A = A / 255 A = A - 1 A = A + 1 """ #~ np.uint8 : 1.04969205993 #~ np.uint16 : 1.19391073202 #~ np.uint32 : 1.37279821351 #~ np.uint64 : 2.99286961148 #~ np.float16 : 9.62375889588 #~ np.float32 : 0.884994368045 #~ np.float64 : 0.920502625252 stmt2 = """ A *= 255 A /= 255 A -= 1 A += 1 """ #~ np.uint8 : 0

I have been looking into benchmarking lately, I have always been interested in logging program data etc. I was interested in knowing if we can implement our own memory usage code and implement our own time consumption code efficently inside our program. I know how to check long it takes for a code to run: public static void main(String[]args){ long start = System.currentTimeMillis(); // code System.out.println(System.currentTimeMillis() - start); } I also looked into Robust Java benchmarking, Part 1: Issues , this tutorial is very comprehensive. Displays the negative effects of System

I need to do some performance benchmarks on .NET programs (C#) in Windows, but I haven't done benchmarking much in the Windows world. I've looked into using the Windows 2000/XP Performance monitor with custom counters for this, but I don't think this is quite what I want. Are there any good system facilities for this in Windows XP, or do I need to just use System.Diagnostics.Stopwatch [edit] and write text logs for manual interpretation, or is there something else? Edit: is there anything beyond System.Diagnostics.Stopwatch ? For micro-benchmarking I really like MeasureIt (can be downloaded