Openwall GNU/*/Linux - a small security-enhanced Linux distro for servers
[<prev] [next>] [day] [month] [year] [list]
Date: Tue, 26 Jul 2011 17:41:37 +0200
From: magnum <rawsmooth@...dband.net>
To: john-dev@...ts.openwall.com
Subject: Performance fluctuations

I'm trying to measure the performance boost from the "0010" patch but I 
can't see any. In fact, it seems to drop by less than 1% (it definitely 
should not). This brings up the old issue of fluctuations in performance 
between runs of the exact same binary.

This quote is from an old private thread I had with Jim about --test 
fluctuations:

On 2011-07-05 21:01, JFoug wrote:
 > -test=10 hides 'some' of the variation. -test=4 if the system is more
 > stable. I usually run on Winblos with a ton of other shit running
 > Windows does not task switch 'too' smoothly, and the timing resolution
 > is only 55ms. Thus, for a second or a couple seconds, the timing is
 > flaky. I use 10s. You may be able to get by with less, but I think
 > default john is 2 or 3s, and I have seen that simply not be enough.
 > However, the code does look a little faster, and almost never slower.

I believe on Linux, the timing resolution is a couple of magnitudes 
better than 55ms and I get the same amount of fluctuations whether I run 
--test=1 or --test=20. Also, I have an idling dual core system and only 
run john on one core. But it fluctuates wildly. I believe the code (many 
formats) actually runs this much faster/slower between runs. This is an 
interesting issue. It must have to do with how things end up in memory, 
caches, alignment and so on. For a while when I made mskrb5 I used 
__align__ heavily, not because it was needed but becuase I thought it 
would stabilize things (always ending up aligned so a tad faster for 
various operations) but in the end I dropped them because it did not 
really help.

Another interesting thing is that more of the formats are rock stable 
when compiled with icc. During development of the latest mscash2 (dcc2) 
we had a version that would vary between 459-472 c/s when built with 
gcc, but *always* 496 c/s when built with icc. I wonder what makes that 
difference.

This is not just when running --test. I remember a set of test hashes I 
used with a specific dictionary (much like the test suite we have now) 
which would take anything between 30s and 1:30 to complete. I believe 
the performance does not vary *within* a run, only *between* runs.

To sum it up, I would like to find ways to "help" the compiler produce 
binaries with less fluctuating performance. Anyone have a clue? I tried 
googling it to no avail.

magnum

Powered by blists - more mailing lists

Your e-mail address:

Powered by Openwall GNU/*/Linux - Powered by OpenVZ