减少程序生成随机数据的运行时间

Question

我需要生成 10GB 的随机数据。

我编写了以下 python 脚本，通过将包含随机长度的可打印 ASCII 字符的字符串写入文件的每一行来生成所需的字节数

它需要 3 个命令行参数。 1) 尺寸 2）字符串的最小长度（可选参数，默认为4） 3) 字符串的最大长度（可选参数，默认为10）

这个程序既不使用内存也不做大量的 IO。我可以使用什么策略来增加单位时间内写入的字节数。

import random
import sys

K_SIZE = 1000

class Generator:
    def __init__(self,low=4,high=10):
        self.table = {i:chr(i) for i in range(33,127)}
        self.low = low
        self.high = high


    def create_n_bytes(self,total_bytes):
        bytes_created = 0
        """Hack at the moment, this condition will fail only after more than n bytes are 
        written """
        while bytes_created < total_bytes:
            bytes_to_create = random.randint(self.low,self.high)
            bytes_created = bytes_created+bytes_to_create+1
            word=[""]*bytes_to_create
            for i in range(bytes_to_create):
                word[i] = self.table[random.randint(33,126)]
            text = "".join(word)
            #print(str(hash(text))+"\t"+text)
            print(text)

def get_file_size_from_command_line():
    size = sys.argv[1]
    return size

def get_min_word_len_from_command_line():
    if len(sys.argv) > 2:
        low = sys.argv[2]
        return int(low)

def get_max_word_len_from_command_line():
    if len(sys.argv) > 3:
        high = sys.argv[3]
        return int(high)

def get_file_size_in_bytes(size):
    multiplier = 1
    size_unit = size[-1]

    if size_unit == 'M' or size_unit == 'm':
        multiplier = K_SIZE*K_SIZE
    elif size_unit == 'K' or size_unit == 'k':
        multiplier = K_SIZE
    elif size_unit == 'G' or size_unit == 'g':
        multiplier = K_SIZE*K_SIZE*K_SIZE
    elif size_unit in ('0','1','2','3','4','5','6','7','8','9'):
        multiplier = 1
    else:
        print("invalid size")
        exit()

    total_bytes = 0
    if multiplier == 1:
        total_bytes = int(size)
    else:
        total_bytes = multiplier*int(size[:len(size)-1])

    return total_bytes


def main():
    if len(sys.argv) == 2:
        gen = Generator()
    elif len(sys.argv) == 3:
        gen = Generator(get_min_word_len_from_command_line())
    elif len(sys.argv) == 4:
        gen = Generator(get_min_word_len_from_command_line(),get_max_word_len_from_command_line())
    file_size = get_file_size_in_bytes(get_file_size_from_command_line())
    gen.create_n_bytes(file_size)

if __name__== "__main__":
    main()

Answer 1

首先，如果您正在生成纯 ASCII，并且您需要它尽可能快，那么生成 bytes 可能会比生成 str 更快。如果需要，您可以随时致电decode('ascii')，但更简单的是，直接将它们写到sys.stdout.buffer 或sys.stdout.buffer.raw。

这意味着您可以摆脱将数字映射到chr 值的表，只需从您的整数中构造一个bytes 或bytearray。 （只要所有值都在range(0, 128) 中，就可以保证得到相同的结果，但只需一个函数调用，其中包含一个 C 循环，而不是 Python 循环中的函数调用。）

另外，您可以调用random.choices(range(33, 127), k=N)，然后将结果传递给bytes 构造函数，而不是构造一个包含N 个空字符串的列表然后逐个替换它们。

正如 Dillon Davis 指出的那样，randint 非常缓慢；通过手动执行相同的逻辑，您可以将速度提高 3-5 倍。事实证明，这在这里并不重要（我们正在为几百个 choices 做一个 randint），但还是可以修复它。

所以，把所有这些放在一起：

def create_n_bytes(self,total_bytes):
    bytes_created = 0
    """Hack at the moment, this condition will fail only after more than n bytes are 
    written """
    chars = range(33, 127)
    while bytes_created < total_bytes:
        bytes_to_create = int(random.random() * (high-low+1) + low)
        word = bytes(random.choices(chars, k=bytes_to_create))
        bytes_created = bytes_created+bytes_to_create+1
        sys.stdout.buffer.write(word + b'\n')
    # necessary if you're doing any prints between calls
    sys.stdout.flush() 

---

另外，尝试在 PyPy 而不是 CPython 中运行相同的代码。它可能快 5%，也可能快 20 倍。

---

如果您需要提高性能，所有常见的微优化技巧都可能适用于此处，例如存储 randint 和 choices 和 sys.stdout.buffer（或者可能是 sys.stdout.buffer.write - 都尝试一下方式）在局部变量中。

---

如果仍然不够快，您需要进行更改以一次生成更多字节。

这意味着传递一个更大的total_bytes 值，但也可能意味着拖入 NumPy：

buf = np.random.randint(33, 127, size=total_bytes, dtype=np.uint8)

现在，您如何将其分解为 low 到 high 字节的单词？我想不出任何真正聪明的东西，但是一个愚蠢的循环应该仍然比上面所有的代码都快：

i = 0
while i < len(buf) - self.high:
    i += random.randint(self.low, self.high)
    buf[i] = 10 # newline
sys.stdout.buffer.write(buf.data[:i])

这个结束太快了，而不是走得太远。但无论你做什么，你显然都必须处理这个问题——无论你如何做事，你准确命中 total_bytes 的几率都是 1/(high-low)，对吧？

（将data 返回的memoryview 切片而不是切片数组并在其上调用to_bytes() 有点麻烦，但是考虑到我们创建数组的方式，它可以保证做同样的事情，而且可能会节省几微秒，因此可能值得添加评论。）

---

如果我们不介意浪费内存，我们可以构建一个随机偏移数组，保证足够大（但可能会太大），然后将其用作索引数组：

sizes = np.random.randint(self.low, self.high, total_bytes//self.low, dtype=np.int32)
offsets = np.cumsum(sizes)
last = np.searchsorted(offsets, 1000)
offsets = offsets[:last]
buf[offsets] = 10

这里的加速比对于 1MB 的数组来说应该比对于像 1000 字节这样的小数组大得多（而且对于绝对巨大的数组也可能不好，因为有额外的分配），但它当然值得测试。

---

性能比较很大程度上取决于您的平台（包括您正在写入的终端，如果您没有重定向到/dev/null 或NUL），以及您选择的参数。

使用您的默认值low=4、high=10 和total_bytes=1000（我使用1010 导致 NumPy 失败），在我的笔记本电脑上运行（macOS、iTerm 内的 IPython，不重定向标准输出、CPython 3.7 .0 和 PyPy 3.5.2/5.10)，这是我的结果：

• 原码：2.7ms
• PyPy 中的原始代码：938µs
• 我的版本randint：911µs
• 我使用random的版本：909µs
• 我在 PyPy 中的版本（没有 random.choices）：799µs
• NumPy 循环版本：584µs
• 仅写入一个预先存在的 1000 字节缓冲区：504µs

如果你减去最后一个以获得不同算法的真实时间：

• 原码：2.2ms
• PyPy 中的原始代码：434µs
• 我的版本randint：407µs
• 我使用random的版本：405µs
• 我在 PyPy 中的版本（没有random.choices）：295µs
• NumPy 循环版本：80µs

我在另一台笔记本电脑上使用 NumPy randint/cumsum 版本，但针对原始 NumPy 版本进行测试，标准输出重定向到 /dev/null：

• NumPy 循环版本：122µs
• NumPy cumsum 版本：41µs

所以，这比已经是 27 倍的加速提高了 3 倍，所以我们说的是 80 倍左右的某个地方。但是写入终端会使事情变慢，以至于挂钟加速只有大约 5 倍。 （如果您使用的是 Windows，可能会更糟。）不过，还不错。