← Back to branch summary

~linaro-toolchain-dev/cortex-strings/trunk

« back to all changes in this revision

Viewing changes to src/reference/test.py

  • Committer: Michael Hope
  • Date: 2010-08-26 22:34:40 UTC
  • Revision ID: michael.hope@linaro.org-20100826223440-ddib3epkpb63yfct
Made the different routines compile.  Expanded the tests.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/reference/test.py
2
2
import timeit
3
3
import pprint
4
4
import gc
5
 
 
6
 
from pylab import *
 
5
import math
7
6
 
8
7
plain = ctypes.cdll.LoadLibrary("install/lib/libplain.so")
 
8
libc = ctypes.cdll.LoadLibrary("/lib/libc.so.6")
 
9
bionic = ctypes.cdll.LoadLibrary("install/lib/libbionic.so")
 
10
glibc = ctypes.cdll.LoadLibrary("install/lib/libglibc.so")
 
11
newlib = ctypes.cdll.LoadLibrary("install/lib/libnewlib.so")
9
12
helpers = ctypes.cdll.LoadLibrary("install/lib/libhelpers.so")
10
13
 
11
 
dest = ctypes.create_string_buffer(1024)
12
 
src = ctypes.create_string_buffer('Hi there', 1024)
 
14
dest = ctypes.create_string_buffer(1024*1024)
 
15
src = ctypes.create_string_buffer(('\x55' * 13) + '\0', 1024*1024)
 
16
 
 
17
overhead = 0
 
18
 
 
19
def round2(v):
 
20
    base = 10**(int(math.log10(v)))
 
21
    return int(v/base + 1) * base
13
22
 
14
23
def run(fun):
15
24
    timer = timeit.default_timer
23
32
    if gcold:
24
33
        gc.enable()
25
34
 
26
 
    return t1 - t0
 
35
    elapsed = t1 - t0
 
36
 
 
37
    return elapsed
27
38
 
28
39
# Calculate a good number of loops
29
40
loops = 100000
30
41
 
31
42
while True:
32
43
    elapsed = run(lambda: helpers.spawniis(plain.memcpy, loops, dest, src, 20))
33
 
    print loops, elapsed
34
44
 
35
45
    if elapsed < 0.1:
36
46
        loops *= 10
37
47
    else:
38
 
        loops *= 2/elapsed
39
 
        base = 10**(int(math.log10(loops)))
40
 
        loops = int(loops/base + 1) * base
 
48
        loops = round2(loops*2/elapsed)
41
49
        print loops
42
50
        break
43
51
 
44
 
# Calculate the call overhead
45
 
elapsed = run(lambda: helpers.spawniis(helpers.bounce, loops, dest, src, 20))
46
 
 
47
 
print elapsed
48
 
 
49
 
elapsed = run(lambda: helpers.spawniis(plain.memcpy, loops, dest, src, 20))
50
 
print elapsed
 
52
limit = 512*1024
 
53
step = 2
 
54
last = None
 
55
 
 
56
#small = range(4096, limit, 4096)
 
57
big = [int(step**x) for x in range(1, int(math.log(limit)/math.log(step)+1))]
 
58
big = []
 
59
small = range(1, 3)
 
60
steps = sorted(list(set(big) | set(small)))
 
61
 
 
62
print steps
 
63
 
 
64
for size in steps:
 
65
    if size >= 8:
 
66
        l = round2(int(loops*30/size))
 
67
    else:
 
68
        l = loops
 
69
 
 
70
    # tests = [
 
71
    #     lambda: helpers.spawniis(helpers.bounce, l, dest, src, size),
 
72
    #     lambda: helpers.spawniis(plain.memcpy, l, dest, src, size),
 
73
    #     lambda: helpers.spawniis(plain.memcpy2, l, dest, src, size),
 
74
    #     lambda: helpers.spawniis(libc.memcpy, l, dest, src, size),
 
75
    #     lambda: helpers.spawniis(glibc.memcpy, l, dest, src, size),
 
76
    #     lambda: helpers.spawniis(bionic.memcpy, l, dest, src, size),
 
77
    #     ]
 
78
    # tests = [
 
79
    #     lambda: helpers.spawniis(helpers.bounce, l, dest, src, size),
 
80
    #     lambda: helpers.spawniis(libc.strcpy, l, dest, src, size),
 
81
    #     lambda: helpers.spawniis(newlib.strcpy, l, dest, src, size)
 
82
    #     ]
 
83
    tests = [
 
84
        lambda: helpers.spawniis(helpers.bounce, l, dest, src, size),
 
85
        lambda: helpers.spawniis(libc.strlen, l, src, src, size),
 
86
        lambda: helpers.spawniis(glibc.strlen, l, src, src, size),
 
87
        lambda: helpers.spawniis(bionic.strlen, l, src, src, size),
 
88
        lambda: helpers.spawniis(newlib.strlen, l, src, src, size),
 
89
        ]
 
90
 
 
91
    results = [size, l] + [run(x) for x in tests]
 
92
    print '\t'.join('%s' % x for x in results)