时间戳

首页 > 解决方案 > 减少程序生成随机数据的运行时间

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

问题描述

我需要生成 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()

标签： pythonperformance

解决方案

首先，如果您正在生成纯 ASCII，并且您需要它尽可能快，那么它的生成速度可能会bytes比str. 如果需要，您可以随时调用decode('ascii')它们，但更简单的是，只需将它们直接写入sys.stdout.bufferor 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 倍。事实证明，这在这里无关紧要（我们正在做大约一个randint几百choices），但仍然不妨修复它。

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

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.buffersys.stdout.buffer.write

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

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

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

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

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)，对吧？

memoryview（将返回的 bydata切片而不是切片数组并调用它有点 hacky 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/nullor NUL），以及您选择的参数。

使用默认值low=4, high=10, 和total_bytes=1000（我使用1010NumPy 失败），在我的笔记本电脑上运行（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
  • NumPycumsum版本：41µs

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

推荐阅读