你知道你的電腦 1 秒鐘能做多少事情嗎？

作者：小峰 2015-11-02 09:50:48

開發(fā) 前端

讓我們來看看你有多么了解電腦！所有這些程序的數(shù)值都是可變的。你的任務是：在程序花費1秒運行之前猜測它的大概值。

你并不需要猜出一個精確值：選擇范圍在1和10億之間。你只要能猜出正確的數(shù)量級，就算正確！下面是一些注意事項：

如果答案是38,000，那么你選擇10,000或100,000，我們就認為都是正確答案。誤差只要在10倍范圍內就ok:)
我們知道不同的計算機有不同的磁盤、網(wǎng)絡和CPU速度！我們會告訴運行10次/秒和10萬次/秒的代碼之間的差別。更新的電腦不會讓你的代碼運行速度快1000倍:)
也就是說，所有這一切都是運行在一臺新的擁有一個快速的SSD和一個湊合的網(wǎng)絡連接的筆記本電腦上的。 C代碼用gcc -O2編譯。

祝你好運！

[[154392]]

歡迎來到第一個程序！這一個只是讓你練練手的：1秒能完成多少循環(huán)？（結果可能比你想象得更多！）

猜猜下面的程序每秒執(zhí)行多少次循環(huán)：

#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; 
}

準確答案：550,000,000

猜猜下面的程序每秒執(zhí)行多少次循環(huán)：

#!/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]))

當我看著代碼的時候，我想的是1毫秒完成多少次——我以為是微不足道的，但事實是，即使是Python，你也可以在1毫秒的時間內執(zhí)行68,000次空循環(huán)迭代。

下面讓我們來探討一個更接近現(xiàn)實的用例。在Python中字典幾乎是無處不在的，那么在1秒時間內我們可以用Python添加多少元素呢？
然后再來看一個更復雜的操作——使用Python的內置HTTP請求解析器來解析請求。

猜猜下面的程序每秒執(zhí)行多少次循環(huán)：

#!/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])) 
 
準確答案：11,000,000

猜猜下面的程序每秒處理多少次HTTP請求：

#!/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 
 
request_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])) 
 
準確答案：25,000

我們每秒可以解析25,000個小的HTTP請求！有一件事我要在這里指出的是，這里請求解析的代碼是用純Python編寫的，而不是C。

接下來，我們要試試下載網(wǎng)頁與運行Python腳本！提示：少于1億:)

猜猜下面的程序每秒可以完成多少次HTTP請求：

#!/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]))

準確答案：4

猜猜下面的程序每秒可以執(zhí)行多少次循環(huán)：

#!/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

準確答案：77

啟動程序實際上昂貴在其本身，而不是啟動Python。如果我們只是運行/bin/true，那么1秒能做500次，所以看起來運行任何程序只需要大約1毫秒時間。當然，下載網(wǎng)頁的快慢很大程度上取決于網(wǎng)頁大小，網(wǎng)絡連接速度，以及服務器間的距離，不過今天我們不談網(wǎng)絡性能。我的一個朋友說，高性能的網(wǎng)絡完成網(wǎng)絡往返甚至可能只要250納秒（！！！），但這是在計算機位置更相鄰，硬件更好的情況下。

1秒時間能夠在磁盤中寫入多少字節(jié)？我們都知道寫到內存中時速度會更快，但是究竟會快多少呢？對了，下面的代碼運行在帶有SSD的計算機上。

猜猜下面的程序每秒可以寫入多少字節(jié)數(shù)據(jù)：

#!/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]))

準確答案：342,000,000

猜猜下面的程序每秒可以寫入多少字節(jié)數(shù)據(jù)：

#!/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]))

準確答案：2,000,000,000

下面輪到文件了！有時候，運行一個大型的grep之后，它可以永恒跑下去。在1秒時間內，grep可以搜索多少字節(jié)？
請注意，在這么做的時候，grep正在讀取的字節(jié)已經(jīng)在內存中。
文件列表同樣需要時間！1秒能列出多少文件？

猜猜下面的程序每秒可以搜索多少字節(jié)的數(shù)據(jù)：

#!/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 
 
準確答案：2,000,000,000 
 
猜猜下面的程序每秒可以列出多少文件： 
 
#!/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

準確答案：325,000

序列化是一個普遍要花費大量時間的地方，讓人很蛋疼，特別是如果你反復結束序列化/反序列化相同數(shù)據(jù)的時候。這里有幾個基準：轉換64K大小的JSON格式數(shù)據(jù)，與同樣大小的msgpack格式數(shù)據(jù)。

猜猜下面的程序每秒可以執(zhí)行多少次循環(huán)：

#!/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]))

準確答案：449

猜猜下面的程序每秒可以執(zhí)行多少次循環(huán)：

#!/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]))

準確答案：4,000

數(shù)據(jù)庫。沒有任何類似于PostgreSQL花里胡哨的東西，我們做了2份有1000萬行數(shù)據(jù)的SQLite表，一個是有索引的，另一個是未建索引的。

猜猜下面的程序每秒可以執(zhí)行多少次查詢：

#!/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]))

準確答案：53,000

猜猜下面的程序每秒執(zhí)行多少次查詢：

#!/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]))

準確答案：2

下面要說Hash算法！在這里，我們將比較MD5和bcrypt。用MD5你在1秒時間內可以哈希到相當多的東西，而用bcrypt則不能。

猜猜下面的程序每秒可以哈希多少字節(jié)的數(shù)據(jù)：

#!/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]))

準確答案：455,000,000

猜猜下面的程序每秒可以哈希多少字節(jié)的密碼：

#!/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]))

準確答案：3

接下來，我們要說一說內存訪問。現(xiàn)在的CPU有L1和L2緩存，這比主內存訪問速度更快。這意味著，循序訪問內存通常比不按順序訪問內存能提供更快的代碼。

猜猜下面的程序每秒可以向內存寫入多少字節(jié)數(shù)據(jù)：

#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; 
}

準確答案：376,000,000

猜猜下面的程序每秒可以向內存寫入多少字節(jié)數(shù)據(jù)：

#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; 
}

準確答案：68,000,000

歡迎大家去試一試，給我們留下寶貴的意見。

譯文鏈接：http://www.codeceo.com/article/1-second-your-computer-do.html
英文原文：DO YOU KNOW HOW MUCH YOUR COMPUTER CAN DO IN A SECOND?

責任編輯：王雪燕來源：碼農網(wǎng)

電腦 1秒鐘事情