Some strange benchmark written around 2007.

timer_mul.py

import random

value_list = [random.randint(0,0xff) for x in range(0,512)]

import operator

def mul_1(value_list):
    """
    mixed
    >>> mul_1((116, 101, 115, 116, 32, 116, 101, 115, 116, 32, 116, 101, 115, 116))
    690674773
    """
    m = 0xffff # arbitrarily choosen modulus
    position = 0
    blocksize = len(value_list)
    r2 = 0
    r1 = sum(value_list) % m
    for i in value_list:
        r2 += (blocksize - position) * i # 
        position += 1
    r2 = r2 % m
    return r1 + m * r2

def mul_2(value_list):
    """
    functional
    >>> mul_2((116, 101, 115, 116, 32, 116, 101, 115, 116, 32, 116, 101, 115, 116))
    690674773
    """
    m = 0xffff # arbitrarily choosen modulus
    blocksize = len(value_list)
    r1 = sum(value_list) % m
    r2 = sum(map(operator.mul, value_list, range(blocksize, 0, -1))) % m
    return r1 + m * r2


def dig_2(value_list):
    """
    digest nach Vorbild in rsync/checksum.c
    
    >>> digest_2((116, 101, 115, 116, 32, 116, 101, 115, 116, 32, 116, 101, 115, 116))
    690674773
    """
    blocksize = len(value_list)
    #...
    i = s1 = s2 = 0
    CHAR_OFFSET = 0 # 31 for librsync
    while i < blocksize - 4:
        s2 += 4 * s1 + value_list[i]\
            + 3 * value_list[i+1]\
            + 2 * value_list[i+2]\
            + value_list[i+3]\
            + 10 * CHAR_OFFSET
        s1 += value_list[i]\
            + value_list[i+1]\
            + value_list[i+2]\
            + value_list[i+3]\
            + 4 * CHAR_OFFSET
        i += 4
    while i < blocksize:
        s1 += value_list[i] + CHAR_OFFSET
        s2 += s1
        i += 1
    return (s1 & 0xffff) + (s2 << 16)


def mul_3(value_list):
    """
    functional II
    >>> mul_2((116, 101, 115, 116, 32, 116, 101, 115, 116, 32, 116, 101, 115, 116))
    690674773
    """
    m = 0xffff # arbitrarily choosen modulus
    blocksize = len(value_list)
    r1 = sum(value_list) % m
    r2 = sum(map(lambda x,y: x*y, value_list, range(blocksize, 0, -1))) % m
    return r1 + m * r2

def mul_4(value_list):
    """
    imperative
    >>> mul_4((116, 101, 115, 116, 32, 116, 101, 115, 116, 32, 116, 101, 115, 116))
    690674773
    """
    m = 0xffff # arbitrarily choosen modulus
    r1 = 0
    r2 = 0
    position = 0
    blocksize = len(value_list)
    for i in value_list:
        r1 += i # braucht doppelte Zeit von sum()
        r2 += (blocksize - position) * i
        position += 1
    r1 = r1 % m
    r2 = r2 % m
    return r1 + m * r2

def mul_5(value_list):
    """
    imperative + lists
    >>> mul_5((116, 101, 115, 116, 32, 116, 101, 115, 116, 32, 116, 101, 115, 116))
    690674773
    """
    m = 0xffff # arbitrarily choosen modulus
    r1 = 0
    r2 = 0
    position = 0
    blocksize = len(value_list)
    list_2 = range(blocksize, 0, -1)
    for i in value_list:
        r1 += i # braucht doppelte Zeit von sum()
        r2 += (blocksize - position) * i
        position += 1
    r1 = r1 % m
    r2 = r2 % m
    return r1 + m * r2


runlist = ("mul_1", "mul_2", "mul_3", "mul_4", "mul_5", "digest_2")

if __name__ == '__main__':
    import doctest
    doctest.testmod()
    import timeit
    number_of_runs = 100000
    print "Number of loops: %s" % number_of_runs
    print "\tName\tLoops\tSingle loop"
    for i in runlist:
        time = timeit.Timer(i + '(value_list)', 'from __main__ import value_list, ' + i).timeit(number_of_runs)
        print "\t%s\t%s\t%s" % (i, round(time, 4), round(time/number_of_runs, 5))