#include <stdlib.h>// Number to guess: How many iterations of
// this loop can we go through in a second?int main (int argc, char **argv) {int NUMBER, i, s;NUMBER = atoi (argv[1]);for (s = i = 0; i < NUMBER; ++i) {s += 1;}return 0;
}

#!/usr/bin/env python# Number to guess: How many iterations of an
# empty loop can we go through in a second?def f (NUMBER):for _ in xrange (NUMBER):passimport sys
f (int(sys.argv[1]))

#!/usr/bin/env python# Number to guess: How many entries can
# we add to a dictionary in a second?# Note: we take `i % 1000` to control
# the size of the dictionarydef f (NUMBER):d = {}for i in xrange (NUMBER):d[i % 1000] = iimport sys
f (int(sys.argv[1]))

#!/usr/bin/env python# Number to guess: How many HTTP requests
# can we parse in a second?from BaseHTTPServer import BaseHTTPRequestHandler
from StringIO import StringIOclass HTTPRequest (BaseHTTPRequestHandler):def __init__(self, request_text):self.rfile = StringIO (request_text)self.raw_requestline = self.rfile.readline ()self.error_code = self.error_message = Noneself.parse_request ()def send_error (self, code, message):self.error_code = codeself.error_message = messagerequest_text = """GET / HTTP/1.1
Host: localhost:8001
Connection: keep-alive
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8
Upgrade-Insecure-Requests: 1
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_10_5) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/45.0.2454.85 Safari/537.36
Accept-Encoding: gzip, deflate, sdch
Accept-Language: en-GB,en-US;q=0.8,en;q=0.6
"""def f (NUMBER):for _ in range (NUMBER):HTTPRequest (request_text)import sys
f (int(sys.argv[1]))

#!/usr/bin/env python# Number to guess: How many times can we
# download google.com in a second?from urllib2 import urlopendef f (NUMBER):for _ in xrange (NUMBER):r = urlopen ("http://google.com")r.read ()import sys
f (int(sys.argv[1]))

#!/bin/bash# Number to guess: How many times can we start
# the Python interpreter in a second?NUMBER=$1for i in $(seq $NUMBER); dopython -c '';
done

#!/usr/bin/env python# Number to guess: How many bytes can we write
# to an output file in a second?
# Note: we make sure everything is sync'd to disk
# before exiting
import tempfile
import osCHUNK_SIZE = 1000000
s = "a" * CHUNK_SIZEdef cleanup (f, name):f.flush ()os.fsync (f.fileno ())f.close ()try:os.remove (name)except:passdef f (NUMBER):name = './out'f = open (name, 'w')bytes_written = 0while bytes_written < NUMBER:f.write (s)bytes_written += CHUNK_SIZEcleanup (f, name)import sys
f (int(sys.argv[1]))

#!/usr/bin/env python# Number to guess: How many bytes can we write
# to a string in memory in a second?import cStringIOCHUNK_SIZE = 1000000
s = "a" * CHUNK_SIZEdef f (NUMBER):output = cStringIO.StringIO ()bytes_written = 0while bytes_written < NUMBER:output.write (s)bytes_written += CHUNK_SIZEimport sys
f (int(sys.argv[1]))

#!/bin/bash # Number to guess: How many bytes can `grep`
# search, unsuccessfully, in a second?
# Note: the bytes are in memoryNUMBER=$1cat /dev/zero | head -c $NUMBER | grep blah
exit 0

#!/bin/bash# Number to guess: How many files can `find` list in a second?
# Note: the files will be in the filesystem cache.find / -name '*' 2> /dev/null | head -n $1 > /dev/null

#!/usr/bin/env python# Number to guess: How many times can we parse
# 64K of JSON in a second?import jsonwith open ('./setup/protobuf/message.json') as f:message = f.read ()def f (NUMBER):for _ in xrange (NUMBER):json.loads (message)import sys
f (int(sys.argv[1]))

#!/usr/bin/env python# Number to guess: How many times can we parse
# 46K of msgpack data in a second?import msgpackwith open ('./setup/protobuf/message.msgpack') as f:message = f.read ()def f (NUMBER):for _ in xrange (NUMBER):msgpack.unpackb (message)import sys
f (int(sys.argv[1]))

#!/usr/bin/env python# Number to guess: How many times can we
# select a row from an **indexed** table with
# 10,000,000 rows?import sqlite3conn = sqlite3.connect ('./indexed_db.sqlite')
c = conn.cursor ()
def f (NUMBER):query = "select * from my_table where key = %d" % 5for i in xrange (NUMBER):c.execute (query)c.fetchall ()import sys
f (int(sys.argv[1]))

#!/usr/bin/env python# Number to guess: How many times can we
# select a row from an **unindexed** table with
# 10,000,000 rows?import sqlite3conn = sqlite3.connect ('./unindexed_db.sqlite')
c = conn.cursor ()
def f (NUMBER):query = "select * from my_table where key = %d" % 5for i in xrange (NUMBER):c.execute (query)c.fetchall ()import sys
f (int(sys.argv[1]))

#!/usr/bin/env python# Number to guess: How many bytes can we md5sum in a second?import hashlibCHUNK_SIZE = 10000
s = 'a' * CHUNK_SIZEdef f (NUMBER):bytes_hashed = 0h = hashlib.md5()while bytes_hashed < NUMBER:h.update (s)bytes_hashed += CHUNK_SIZEh.digest ()
import sys
f (int(sys.argv[1]))

#!/usr/bin/env python# Number to guess: How many passwords
# can we bcrypt in a second?import bcryptpassword = 'a' * 100def f (NUMBER):for _ in xrange (NUMBER):bcrypt.hashpw (password, bcrypt.gensalt ())import sys
f (int(sys.argv[1]))

#include <stdlib.h>
#include <stdio.h>// Number to guess: How big of an array (in bytes)
// can we allocate and fill in a second?// this is intentionally more complicated than it needs to be
// so that it matches the out-of-order versionint main (int argc, char **argv) {int NUMBER, i;NUMBER = atoi (argv[1]);char* array = malloc (NUMBER);int j = 1;for (i = 0; i < NUMBER; ++i) {j = j * 2;if (j > NUMBER) {j = j - NUMBER;}array[i] = j;}printf ("%d", array[NUMBER / 7]);// so that -O2 doesn't optimize out the loopreturn 0;
}

#include <stdlib.h>
#include <stdio.h>// Number to guess: How big of an array (in bytes)
// can we allocate and fill with 5s in a second?
// The catch: We do it out of order instead of in order.
int main (int argc, char **argv) {int NUMBER, i;NUMBER = atoi (argv[1]);char* array = malloc (NUMBER);int j = 1;for (i = 0; i < NUMBER; ++i) {j = j * 2;if (j > NUMBER) {j = j - NUMBER;}array[j] = j;}printf ("%d", array[NUMBER / 7]);// so that -O2 doesn't optimize out the loopreturn 0;
}