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

英文原文：DO YOU KNOW HOW MUCH YOUR COMPUTER CAN DO IN A SECOND?

　　让我们来看看你有多么了解电脑！所有这些程序的数值都是可变的。你的任务是：在程序花费 1 秒运行之前猜测它的大概值。

　　你并不需要猜出一个精确值：选择范围在 1 和 10 亿之间。你只要能猜出正确的数量级，就算正确！下面是一些注意事项：

  • 如果答案是 38,000，那么你选择 10,000 或 100,000，我们就认为都是正确答案。误差只要在 10 倍范围内就 ok:)
  • 我们知道不同的计算机有不同的磁盘、网络和 CPU 速度！我们会告诉运行 10 次/秒和 10 万次/秒的代码之间的差别。更新的电脑不会让你的代码运行速度快 1000 倍:)
  • 也就是说，所有这一切都是运行在一台新的拥有一个快速的 SSD 和一个凑合的网络连接的笔记本电脑上的。 C 代码用 gcc -O2 编译。

　　祝你好运！

欢迎来到第一个程序！这一个只是让你练练手的：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;
}

　　准确答案：550,000,000

　　猜猜下面的程序每秒执行多少次循环：

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

　　准确答案：68,000,000

　　当我看着代码的时候，我想的是 1 毫秒完成多少次——我以为是微不足道的，但事实是，即使是 Python，你也可以在 1 毫秒的时间内执行 68,000 次空循环迭代。

下面让我们来探讨一个更接近现实的用例。在 Python 中字典几乎是无处不在的，那么在 1 秒时间内我们可以用 Python 添加多少元素呢？

然后再来看一个更复杂的操作——使用 Python 的内置 HTTP 请求解析器来解析请求。

　　猜猜下面的程序每秒执行多少次循环：

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

接下来，我们要试试下载网页与运行 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

　　猜猜下面的程序每秒可以执行多少次循环：

#!/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 毫秒时间。当然，下载网页的快慢很大程度上取决于网页大小，网络连接速度，以及服务器间的距离，不过今天我们不谈网络性能。我的一个朋友说，高性能的网络完成网络往返甚至可能只要 250 纳秒（！！！），但这是在计算机位置更相邻，硬件更好的情况下。

1 秒时间能够在磁盘中写入多少字节？我们都知道写到内存中时速度会更快，但是究竟会快多少呢？对了，下面的代码运行在带有 SSD 的计算机上。

　　猜猜下面的程序每秒可以写入多少字节数据：

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

　　猜猜下面的程序每秒可以写入多少字节数据：

#!/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 可以搜索多少字节？

请注意，在这么做的时候，grep 正在读取的字节已经在内存中。

文件列表同样需要时间！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

　　准确答案：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

序列化是一个普遍要花费大量时间的地方，让人很蛋疼，特别是如果你反复结束序列化/反序列化相同数据的时候。这里有几个基准：转换 64K 大小的 JSON 格式数据，与同样大小的 msgpack 格式数据。

　　猜猜下面的程序每秒可以执行多少次循环：

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

　　猜猜下面的程序每秒可以执行多少次循环：

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

数据库。没有任何类似于 PostgreSQL 花里胡哨的东西，我们做了 2 份有 1000 万行数据的 SQLite 表，一个是有索引的，另一个是未建索引的。

　　猜猜下面的程序每秒可以执行多少次查询：

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

　　猜猜下面的程序每秒执行多少次查询：

#!/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 则不能。

　　猜猜下面的程序每秒可以哈希多少字节的数据：

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

　　猜猜下面的程序每秒可以哈希多少字节的密码：

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

接下来，我们要说一说内存访问。 现在的 CPU 有 L1 和 L2 缓存，这比主内存访问速度更快。这意味着，循序访问内存通常比不按顺序访问内存能提供更快的代码。

　　猜猜下面的程序每秒可以向内存写入多少字节数据：

#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

　　猜猜下面的程序每秒可以向内存写入多少字节数据：

#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

 

时间： 2024-09-13 00:56:24

你知道你的电脑1秒钟能做多少事情吗？（转）的相关文章

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

让我们来看看你有多么了解电脑!所有这些程序的数值都是可变的.你的任务是:在程序花费1秒运行之前猜测它的大概值. 你并不需要猜出一个精确值:选择范围在1和10亿之间.你只要能猜出正确的数量级,就算正确!下面是一些注意事项: 如果答案是38,000,那么你选择10,000或100,000,我们就认为都是正确答案.误差只要在10倍范围内就ok:) 我们知道不同的计算机有不同的磁盘.网络和CPU速度!我们会告诉运行10次/秒和10万次/秒的代码之间的差别.更新的电脑不会让你的代码运行速度快1000倍:)

MySQL之父Michael Wideneus：有自己的电脑，我可以做任何事情

MySQL之父Michael Wideneus,在2016云栖大会上受到诸多追捧. 先是微博上,转发超过200,评论超过50条.有人评论:"可怕的不是人家很牛逼,而是人家这么牛逼还比你努力."也有人热衷八卦,想了解他用的是什么系统.哪个发行版本?甚至他的电脑型号-- 为了满足大家好奇心,笔者走访了和Michael Wideneus接触的几位阿里云专家,以拼凑出一个云栖大会期间比较完整的Michael Wideneus. 再叙述之前,先来一组照片,展示下大神风采: 图1开场前10分钟,还

计算机-用什么方法可以实现一个实验室中的电脑相互博弈，做一些博弈试验

问题描述 用什么方法可以实现一个实验室中的电脑相互博弈,做一些博弈试验 如果说用jsp网页开发,那么每台电脑就要都打开MyEclipse,再连接数据库很麻烦. 如果用java直接做一个客户端,本人技术不到家,求大神帮忙. 而且每台电脑做一道题目就会跟不同的机房电脑进行博弈,怎么解决通信问题. 解决方案 java客户端的话用socket通信就好了啊

TCL集团中剥离出来分拆上市，是TCL电脑必须要做的事情

为了解决电脑业务快速发展急需的资金来源,不愿追加投资的TCL集团(000100.SZ),已经决定将电脑业务分拆上市融资.昨日,TCL电脑一高层对<第一财经日报>表示,如果TCL集团在今年能够取得盈利,那明年就可以脱掉ST的帽子,届时就真正开始实施"电脑业务分拆上市"的方案,目前TCL集团和TCL电脑都正在为此作相应准备.目前TCL电脑正在做"股份改制"工作,并计划引入境外投资者入股,其后再进一步实施上市融资的方案.该高层还透露,之所以不愿引入境内投资者,

如何设置一台电脑两个显示器

  双显示器设置,如何设置一台电脑两个显示器:一般来说一台电脑通常只配一个显示器,在我们平时的的工作.娱乐基本上都是这样的搭配.但是这种用法,当您打开多个窗口的时候,一个显示器空间就显得很晓,尤其是做一些复杂工作,比如分析图表.调试程序时,你往往需要不断地在不同窗口之间来回切换,非常麻烦,有没有方法让这些事情变的简单一些呢? 方法是有的!答案是:Windows的双屏显示功能(或多屏显示,windows最多可以支持10个显示器同时工作) 要想给电脑同时使用两个显示器的话,在硬件上你需要对显卡进行一

Win8.1技巧高效地管理应用程序

应用程序,是用户控制电脑执行任务的核心.因此,对于程序的组织管理是用户电脑上经常要做的事情,自Win8.1操作系统发布以来,加入了更高效的程序管理模块,用户只要掌握方法,对程序的控制就比以往的系统更加自由和便捷. 设置兼容性与权限让应用程序正常运行 1.设置兼容模式 有的程序在Win8.1上无法启动,是因为不兼容新系统,用户只要右键单击该程序的快捷方式图标,在弹出的菜单上选择"属性",然后在属性对话框选择 "兼 容性"选项卡,再从"兼容模式"栏里

Twitter的17种使用方法

Twitter是一个微博平台,可以让你通过不同的媒介(比如即时通讯.手机和网页)发布不到140字的短讯.它允许用户之间交朋友和检测对方的信息或更新内容.所以,你就有了一个发布公共内容或私人信息的出版工具. 它类似于一个IRC(互联网中转聊天)频道--尽管消息显示的速度稍慢.有人说这是一个慢版本的互联网信使. Twitter会给你一些分散的意见.事件.新闻.想法和反馈,主要是因为它的构造是用来适应非语境的可用性:你可以轻松地追踪数千名用户,并且在任何时候聆听并进入到多用户的对话中,这种情况是很正常

谈谈新人站长每天必做的几件事

中介交易 http://www.aliyun.com/zixun/aggregation/6858.html">SEO诊断 淘宝客 云主机 技术大厅 作为一名普通的网虫,你可以不刷牙,不洗脸,不吃早餐,但是身为个人站长,尤其是在家里创业或者租用办公室做站的朋友们,为了能够让网站有更好的发展,我们每天几乎都会重复某些相同的工作,久而久之难免会觉的厌倦,为了减少站长对这些工作的厌倦感,因此沙予总结了一些站长每天要做的事情,至于其他那些不是必须每天需要做的的工作,站长们可以自已决定要不要每天都要

国内第一人：MariaDB基金会将阿里云数据库高级专家彭立勋列为个人成员

上周三,MariaDB在其官网宣布,正式把阿里云数据库工程师彭立勋列为Mariadb基金会个人成员(Staff). 作为Mariadb高级开发人员,彭立勋将主要从事Replication模块的优化:同时,他也致力于MariaDB在中国的普及以及技术社区工作. "跟公司沟通之后,非常爽快的答应让我参与MariaDB基金会,以便更直接地为社区贡献我们的能力." 为什么会被MariaDB基金会邀请担任个人成员,这位阿里云数据库高级专家解读称,从他个人角度来看有两个原因:一是时间和贡献积累的结