stringbench is a set of performance tests comparing byte string

operations with unicode operations. The two string implementations

are loosely based on each other and sometimes the algorithm for one is

faster than the other.

These test set was started at the Need For Speed sprint in Reykjavik

to identify which string methods could be sped up quickly and to

identify obvious places for improvement.

Here is an example of a benchmark

@bench('"Andrew".startswith("A")', 'startswith single character', 1000)

def startswith_single(STR):

s1 = STR("Andrew")

s2 = STR("A")

s1_startswith = s1.startswith

for x in _RANGE_1000:

s1_startswith(s2)

The bench decorator takes three parameters. The first is a short

description of how the code works. In most cases this is Python code

snippet. It is not the code which is actually run because the real

code is hand-optimized to focus on the method being tested.

The second parameter is a group title. All benchmarks with the same

group title are listed together. This lets you compare different

implementations of the same algorithm, such as "t in s"

vs. "s.find(t)".

The last is a count. Each benchmark loops over the algorithm either

100 or 1000 times, depending on the algorithm performance. The output

time is the time per benchmark call so the reader needs a way to know

how to scale the performance.

These parameters become function attributes.

Here is an example of the output

========== count newlines

38.54 41.60 92.7 ...text.with.2000.newlines.count("\n") (*100)

========== early match, single character

1.14 1.18 96.8 ("A"*1000).find("A") (*1000)

0.44 0.41 105.6 "A" in "A"*1000 (*1000)

1.15 1.17 98.1 ("A"*1000).index("A") (*1000)

The first column is the run time in milliseconds for byte strings.

The second is the run time for unicode strings. The third is a

percentage; byte time / unicode time. It's the percentage by which

unicode is faster than byte strings.

The last column contains the code snippet and the repeat count for the

internal benchmark loop.

The times are computed with 'timeit.py' which repeats the test more

and more times until the total time takes over 0.2 seconds, returning

the best time for a single iteration.

The final line of the output is the cumulative time for byte and

unicode strings, and the overall performance of unicode relative to

bytes. For example

4079.83 5432.25 75.1 TOTAL

However, this has no meaning as it evenly weights every test.