simulate_failures.py

from hashlib import sha256
import random

def duplicates_for_shortid(txidsize, mempoolsize_mb=32, mempoolsize_kb=None):
    if mempoolsize_kb:
        n = int(mempoolsize_kb * 1024.0 / 266)
    else:
        n = int(mempoolsize_mb * 1024.0 * 1024.0 / 266)

    txids = set()
    for i in xrange(n):
        txid = sha256(str(random.random())).hexdigest()
        txids.add(txid[:txidsize])
    dup_count = n - len(txids)
    return dup_count

def simulate_decode_failures(txidsize, iterations=100, mempoolsize_mb=32, mempoolsize_kb=None):
    failures = 0
    for i in xrange(iterations):
        if duplicates_for_shortid(txidsize, mempoolsize_mb, mempoolsize_kb):
            failures += 1

    return "%d failures out of %d blocks (%.3f%%)" % (
        failures, iterations, 100.0 * failures / iterations
    )

"""
In [2]: simulate_decode_failures(8, mempoolsize_mb=8)
Out[2]: '9 failures out of 100 blocks (9.000%)'

In [3]: simulate_decode_failures(8, mempoolsize_mb=32)
Out[3]: '87 failures out of 100 blocks (87.000%)'

In [4]: simulate_decode_failures(2, mempoolsize_mb=32)
Out[4]: '100 failures out of 100 blocks (100.000%)'

In [5]: simulate_decode_failures(2, mempoolsize_mb=1)
Out[5]: '100 failures out of 100 blocks (100.000%)'

In [6]: simulate_decode_failures(2, mempoolsize_kb=500)
Out[6]: '100 failures out of 100 blocks (100.000%)'

In [7]: simulate_decode_failures(2, mempoolsize_kb=100)
Out[7]: '100 failures out of 100 blocks (100.000%)'

In [8]: simulate_decode_failures(2, mempoolsize_kb=50)
Out[8]: '100 failures out of 100 blocks (100.000%)'

In [9]: simulate_decode_failures(2, mempoolsize_kb=10)
Out[9]: '92 failures out of 100 blocks (92.000%)'

In [10]: simulate_decode_failures(2, mempoolsize_kb=5)
Out[10]: '47 failures out of 100 blocks (47.000%)'

In [11]: simulate_decode_failures(2, mempoolsize_kb=1)
Out[11]: '1 failures out of 100 blocks (1.000%)'
"""