巨大字符串上的 Ruby 字符串操作

Question

我有一个大小约为 10 GB 的字符串(使用大量 RAM 的 c..)。问题是，我需要执行 gsub 之类的字符串操作并对其进行拆分。我注意到 Ruby 会在某个时候“停止工作”(尽管不会产生任何错误)。

例子:

str = HUGE_STRING_10_GB

# I will try to split the string using .split:
str.split("\r\n")
# but Ruby will instead just return an array with 
# the full unsplitted string itself...

# let's break this down:
# each of those attempts doesn't cause problems and 
# returns arrays with thousands or even millions of items (lines)
str[0..999].split("\r\n")
str[0..999_999].split("\r\n")
str[0..999_999_999].split("\r\n")

# starting from here, problems will occur
str[0..1_999_999_999].split("\r\n")

我正在使用 Ruby MRI 1.8.7，这里有什么问题？为什么 Ruby 不能对超大字符串进行字符串操作？这里的解决方案是什么？

我想出的唯一解决方案是使用 [0..9]、[10..19]...“循环”字符串并逐个执行字符串操作。然而，这似乎不可靠，例如，如果我的分隔符很长并且落在两个“部分”之间怎么办。

另一个实际有效的解决方案是像 str.each_line {..} 一样迭代字符串。然而，这只是替换了换行符。

编辑:感谢所有这些答案。就我而言，“巨大的 10 GB 字符串”实际上是从互联网上下载的。它包含由特定序列分隔的数据(在大多数情况下是一个简单的换行符)。在我的场景中，我将 10 GB 文件的每个元素与脚本中已有的另一个(较小的)数据集进行了比较。我感谢所有建议。

Answer 1

这是针对真实日志文件的基准测试。在用于读取文件的方法中，只有使用 foreach 的方法是可扩展的，因为它避免了对文件的吞吐。

使用 lazy 会增加开销，导致比单独使用 map 更慢。

请注意，就处理速度而言，foreach 就在那里，并产生可扩展的解决方案。 Ruby 不会关心文件是无数行还是无数 TB，它仍然一次只能看到一行。有关读取文件的一些相关信息，请参见“Why is "slurping" a file not a good practice?”。

人们通常倾向于使用一次性提取整个文件，然后将其拆分成多个部分的工具。这忽略了 Ruby 然后必须使用 split 或类似的东西根据行结束重建数组的工作。加起来，这就是我认为 foreach 领先的原因。

另请注意，两次基准测试运行的结果略有不同。这可能是由于作业正在运行时我的 Mac Pro 上正在运行系统任务。重要的是显示差异是一次清洗，向我确认使用 foreach 是处理大文件的正确方法，因为如果输入文件超过可用内存，它不会杀死机器。

require 'benchmark'

REGEX = /\bfoo\z/
LOG = 'debug.log'
N = 1

# each_line: "Splits str using the supplied parameter as the record separator
# ($/ by default), passing each substring in turn to the supplied block."
#
# Because the file is read into a string, then split into lines, this isn't
# scalable. It will work if Ruby has enough memory to hold the string plus all
# other variables and its overhead.
def lazy_map(filename)
  File.open("lazy_map.out", 'w') do |fo|
    fo.puts File.readlines(filename).lazy.map { |li|
      li.gsub(REGEX, 'bar')
    }.force
  end
end

# each_line: "Splits str using the supplied parameter as the record separator
# ($/ by default), passing each substring in turn to the supplied block."
#
# Because the file is read into a string, then split into lines, this isn't
# scalable. It will work if Ruby has enough memory to hold the string plus all
# other variables and its overhead.
def map(filename)
  File.open("map.out", 'w') do |fo|
    fo.puts File.readlines(filename).map { |li|
      li.gsub(REGEX, 'bar')
    }
  end
end

# "Reads the entire file specified by name as individual lines, and returns
# those lines in an array."
# 
# As a result of returning all the lines in an array this isn't scalable. It
# will work if Ruby has enough memory to hold the array plus all other
# variables and its overhead.
def readlines(filename)
  File.open("readlines.out", 'w') do |fo|
    File.readlines(filename).each do |li|
      fo.puts li.gsub(REGEX, 'bar')
    end
  end
end

# This is completely scalable because no file slurping is involved.
# "Executes the block for every line in the named I/O port..."
#
# It's slower, but it works reliably.
def foreach(filename)
  File.open("foreach.out", 'w') do |fo|
    File.foreach(filename) do |li|
      fo.puts li.gsub(REGEX, 'bar')
    end
  end
end

puts "Ruby version: #{ RUBY_VERSION }"
puts "log bytes: #{ File.size(LOG) }"
puts "log lines: #{ `wc -l #{ LOG }`.to_i }"

2.times do
  Benchmark.bm(13) do |b|
    b.report('lazy_map')  { lazy_map(LOG)  }
    b.report('map')       { map(LOG)       }
    b.report('readlines') { readlines(LOG) }
    b.report('foreach')   { foreach(LOG)   }
  end
end

%w[lazy_map map readlines foreach].each do |s|
  puts `wc #{ s }.out`
end

结果是:

Ruby version: 2.0.0
log bytes: 733978797
log lines: 5540058
                    user     system      total        real
lazy_map       35.010000   4.120000  39.130000 ( 43.688429)
map            29.510000   7.440000  36.950000 ( 43.544893)
readlines      28.750000   9.860000  38.610000 ( 43.578684)
foreach        25.380000   4.120000  29.500000 ( 35.414149)
                    user     system      total        real
lazy_map       32.350000   9.000000  41.350000 ( 51.567903)
map            24.740000   3.410000  28.150000 ( 32.540841)
readlines      24.490000   7.330000  31.820000 ( 37.873325)
foreach        26.460000   2.540000  29.000000 ( 33.599926)
5540058 83892946 733978797 lazy_map.out
5540058 83892946 733978797 map.out
5540058 83892946 733978797 readlines.out
5540058 83892946 733978797 foreach.out

gsub 的使用是无害的，因为每个方法都使用它，但它不是必需的，添加它是为了一些无聊的电阻加载。