你知道你的电脑1秒钟能做多少事情吗？

#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):
        pass
import 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 dictionary
def f (NUMBER):
    d = {}
    for i in xrange (NUMBER):
        d[i % 1000] = i
import 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 StringIO
class HTTPRequest (BaseHTTPRequestHandler):
    def __init__(self, request_text):
        self.rfile = StringIO (request_text)
        self.raw_requestline = self.rfile.readline ()
        self.error_code = self.error_message = None
        self.parse_request ()
    def send_error (self, code, message):
        self.error_code = code
        self.error_message = message

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 urlopen
def 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=$1
for i in $(seq $NUMBER); do
    python -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 os
CHUNK_SIZE = 1000000
s = "a" * CHUNK_SIZE
def cleanup (f, name):
    f.flush ()
    os.fsync (f.fileno ())
    f.close ()
    try:
        os.remove (name)
    except:
        pass
def f (NUMBER):
    name = './out'
    f = open (name, 'w')
    bytes_written = 0
    while bytes_written < NUMBER:
        f.write (s)
        bytes_written += CHUNK_SIZE
    cleanup (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 cStringIO
CHUNK_SIZE = 1000000
s = "a" * CHUNK_SIZE
def f (NUMBER):
    output = cStringIO.StringIO ()
    bytes_written = 0
    while bytes_written < NUMBER:
        output.write (s)
        bytes_written += CHUNK_SIZE
import 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 memory
NUMBER=$1
cat /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 ***.
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 json
with 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 msgpack
with 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 sqlite3
conn = sqlite3.connect ('./indexed_db.sqlite')
c = conn.cursor ()
def f (NUMBER):
    query = "select * from my_table where key = %d" % 5
    for 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 sqlite3
conn = sqlite3.connect ('./unindexed_db.sqlite')
c = conn.cursor ()
def f (NUMBER):
    query = "select * from my_table where key = %d" % 5
    for 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 hashlib
CHUNK_SIZE = 10000
s = 'a' * CHUNK_SIZE
def f (NUMBER):
    bytes_hashed = 0
    h = hashlib.md5()
    while bytes_hashed < NUMBER:
        h.update (s)
        bytes_hashed += CHUNK_SIZE
    h.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 bcrypt
password = 'a' * 100
def 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 version
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[i] = j;
    }
    printf ("%d", array[NUMBER / 7]);
    // so that -O2 doesn't optimize out the loop
    return 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 loop
    return 0;
}