Concurrent vs. Exclusive Reading in Parallel Decoding of LZ-Compressed Files

Agostino, Sergio De; Carpentieri, Bruno; Pizzolante, Raffaele

doi:10.3390/a10010021

开放式访问第条

LZ压缩文件并行解码中的并发读取与独占读取^†

通过

塞尔吉奥·德·阿戈斯蒂诺

^1,*

,

布鲁诺·卡彭蒂埃里

²和

拉斐尔·皮佐兰特

²

¹

意大利罗马萨皮恩扎大学计算机科学系，罗马00185

²

意大利费西亚诺萨勒诺大学信息学院（邮编：84084）

^*

信件应寄给的作者。

^†

本文是我们在2016年国际数据压缩、通信处理和安全会议上发表的论文的扩展版本。

算法 2017,10(1), 21;https://doi.org/10.3390/a10010021

收到的提交文件：2016年11月25日/修订日期：2016年12月24日/接受日期：2017年1月23日/发布日期：2017年1月28日

（本文属于特刊2016年数据压缩、通信处理和安全)

下载版本注释

摘要

:

将消息从网络中的一个处理器广播到多个处理器相当于在随机访问共享内存并行机上并发读取。计算森林的树、树中每个节点的级别以及两个节点之间的路径是可以通过在树的最大高度上以时间对数并发读取来轻松解决的问题。使用独占读取解决此类问题需要节点数的时间对数，这意味着在分布式系统上不相交的处理器对之间传递消息。如果在具有特定约束的浅树上遇到这些问题，那么在分布式计算的并行算法设计中允许并发读取在实践中可能是有利的。我们展示了LZC（Lempel-Ziv-Compress）压缩文件解码的一个应用程序，其并行化利用这些树上的计算来处理实际数据。另一方面，压缩文件没有这个优势，因为它们是通过Lempel–Ziv滑动窗口技术压缩的。

关键词：

LZ压缩;解码;婴儿车;地图缩小

1.简介

并行随机存取机器（PRAM）现在已经过时了，但从并行算法设计的角度来看，仍然可以对这种模型进行道歉。事实上，所谓的PRAM模型为第一种方法提供了最自然的计算工具，用于并行计算问题的算法解决方案，第二种方法是可以在网络上从它派生出分布式内存实现。并行和分布式算法设计中涉及的计算技术与并行或分布式系统所基于的计算模型密切相关。当应用于不同的系统时，为特定模型设计的技术的效率可能会持续下降。当为共享内存并行随机访问机设计的技术在分布式系统上实现时，这一点尤其明显。事实上，当系统规模扩大时，通信成本是线性加速的瓶颈。因此，为了获得一个实用的算法，我们需要限制处理器之间的通信，要么涉及更多的局部计算，要么限制全局计算步骤的数量。当需要可伸缩性属性时，本地计算可能会导致健壮性不足。另一方面，如果可以为特定问题限定全局计算步骤的数量，则通常可以保证可伸缩性和健壮性。

在本文中，我们在设计基于消息传递的分布式计算的并行算法时面临并发读取与排他读取的问题，并将其应用于Lempel–Ziv数据压缩[1,2,三]. 将消息从网络中的一个处理器广播到多个处理器相当于在随机访问共享内存并行机上并发读取，而独占读取意味着在分布式系统上不相交的处理器对之间传递消息。并行算法设计的基本子程序是计算森林的树、树中每个节点的级别以及两个节点之间的路径。这些问题可以很容易地通过指针跳跃技术在树的最大高度的时间对数中同时读取来解决。著名的欧拉巡演技术于[4]通过林的线性化避免并发读取，将这些问题减少到列出排名和并行前缀。使用独占读取解决此类问题需要节点数的时间对数。除了避免并发读取之外，Euler巡更技术还可以并行计算多个树函数，如前序、后序，以及使用线性处理器数计算对数时间内每个节点的后代数。如果没有这样的线性化，即使允许并发读取，也无法以这样的并行复杂度计算这些函数。另一方面，如果在具有特定约束的浅树上遇到此类问题，那么允许并发读取来计算森林的树、树中每个节点的级别以及两个节点之间的路径，在实际分布式计算的并行算法设计中可能是有利的。事实上，并发读取是由两个或多个子节点同时访问存储在父节点中的信息引起的，每一步都会随着子节点的增加而增加。因此，如果限制为恒定数量的节点，那么这种并发性的降低就不那么重要了。我们证明了树必须具有的属性才能获得这样的限制，并观察到在浅树的情况下，应用欧拉巡游技术不仅没有必要，甚至对运行时间不利。

我们展示了LZC压缩文件解码的应用程序[5,6]，它的并行化利用这些树上的计算来获得真实的数据。由于编码器是不可并行的，因此对压缩器/解压缩器在全局并行计算方面呈现出不对称性[7,8]，而解码器具有非常高效的并行化[8,9,10]. 在实际数据上，当在并行随机存取共享存储机上表示时，解码算法的迭代次数远远少于十个单位[10]，在MapReduce并行编程范例中表示时约为10个单位[11]，正如我们将在本文中显示的。这使得它在很少执行压缩的情况下（在实践中最常见）具有吸引力，而频繁读取原始数据需要快速解压缩。另一方面，压缩文件没有这样的优势，因为它们是通过Lempel–Ziv滑动窗口技术压缩的[2,12,13]. 在这种情况下，编码和解码都可以以对称的方式并行，实际上至少需要对数时间[8,14].

在第2节，我们描述了并行算法设计中涉及的计算技术，并讨论了并发与排他读取问题。第3节显示了并行解压缩的应用程序。MapReduce实现如所述第4节结论和未来工作见第5节.

2.并发阅读与独占阅读

如果我们使用父数组作为表示林的数据结构，计算树、树中每个节点的级别以及两个节点之间的路径都是可以通过并行运行指针跳转操作在CREW（并发读取、独占写入）PRAM上轻松解决的问题起源[我] =起源[起源[我]]. 该过程在节点数上采用线性处理器，在树的最大高度上采用时间对数。一般来说，如果我们使用标准广播技术解决读取冲突，那么实现这样的过程会导致节点数的对数变慢。因此，在最坏的情况下，总运行时间增加到平方算术，因为树的最大高度可以达到节点数的数量级。为了保持时间对数，我们需要假设森林中每棵树的结构有一些约束。的确，一定有一个常数

c（c） > 0

这样，对于森林中的每棵树，具有多个子节点的节点数远远大于c（c）根的距离小于c（c），并且没有节点比c（c）从根开始有超过c（c）儿童。不难看出，这是通过标准广播解决读取冲突的一个必要和充分条件，并且从并行复杂性的渐近行为来看，总运行时间不会减慢。如果不存在这样的常数，著名的欧拉巡演技术在[4]避免孩子们同时阅读。

Euler tour技术将问题减少到在EREW（排他读，排他写）PRAM上列出排名，其中处理器的数量和时间分别是节点数量的线性和对数。让F类是一个有根树的森林，每个节点都有一个父指针和一个双重链接的子节点列表。首先，我们替换每个节点v（v）属于F类按数组

V（V） [1 \dots d日 (v（v）) + 1]

的副本v（v），其中

d日 (v（v）)

是的子级数v（v）.让

{w个}_{1} \dots {w个}_{d日 (v（v）)}

成为…的孩子v（v）和

{W公司}_{1} [1 \dots d日 ({w个}_{1}) + 1], \dots {W公司}_{d日 (v（v）)} [1 \dots d日 ({w个}_{d日 (v（v）)} + 1)]

相应的数组。我们链接

{W公司}_{我} [1]

到

V（V） [我]

和

V（V） [我 + 1]

到

{W公司}_{我} [d日 ({w个}_{我}) + 1]

，并为每棵树获取T型属于F类从开始的链接列表

R（右） [1]

结束于

R（右） [d日 (第页) + 1]

，其中第页是的根T型和R（右）相应的数组。然后，很明显，我们通过应用列表排名找到了森林中的树。此外，对于与树相关联的每个列表，我们将权重+1分配给每个数组中的第一个条目，并将权重-1分配给所有其他条目。然后，通过计算列表中这些值的部分和，通过前缀计算获得其树中每个节点的级别。与关联的数组组件位置相对应的部分和v（v）在列表中等于v（v）在它的树上。由于我们假设子级与父级具有双重链接，因此列表的实现需要线性处理器数的恒定时间或O的对数时间(n个/日志n个)处理器。列表排名和前缀计算需要O的对数时间(n个/日志n个)处理器。如果子级与父级之间没有双重链接，那么将父级与子级之间的链接相加通常需要对数时间，因为线性数量的处理器采用并行排序过程。然而，在某些情况下，子数的界限是已知的并且是恒定的。

在结束这一节时，我们希望指出，即使有一个常量将节点与更多的子节点绑定在一起，并且节点的子节点距离根太远，当树不够浅时，Euler巡游技术可能仍然是有利的。然而，我们在本文中介绍的LZC压缩文件解码应用程序并非如此。

3.并行解码LZC-压缩文件

最流行的文本压缩器基于Lempel–Ziv字符串复杂性[1]. 拉链压缩器采用Lempel–Ziv滑动窗方法[2,12,13]，而其他应用使用LZW（Lempel、Ziv和Welch）压缩机[三,5]，也称为LZC[6]当在Unix和Linux平台上实现命令行“compress”时。LZC压缩效率较低，但比压缩应用程序更快。Zip压缩器基于字符串因式分解过程，其中每个因子都独立于其他因子，因为它通过一个字符扩展最长的匹配，并且在输入字符串中的左侧有一个子字符串。另一方面，LZC压缩器是基于因式分解的，其中每个因子是与先前因子之一的最长匹配的一个字符的扩展。这种计算差异意味着，虽然压缩应用程序具有理论上的并行性，但LZC压缩很难并行化。另一方面，两种方法都可以并行解压缩。

并行压缩和解压缩文件需要对数的全局计算步骤，即使允许并发读取。另一方面，LZC编码器/解码器对呈现出不对称性，因为解码器具有非常有效的并行化，在CREW PRAM上需要的迭代次数远远少于十次。如上所述，这使得LZC在这些情况下比Zip更有吸引力（这在实践中是最常见的）其中很少执行压缩，而频繁读取原始数据需要快速解压缩。最后，我们表明，如果在EREW PRAM上实现LZC解码器，则会失去这一优势。

3.1. LZC压缩

Lempel–Ziv压缩是一种基于字典的技术。实际上，字符串的因子被替换为指针复制，存储在词典，称为目标在实际实现中，字典具有固定大小

d日 + α

，其中α是字母表的基数。有了LZC，

d日 + α = 2^{16}

，字典最初等于字母表。字符串的LZC因子分解S公司通过分解前缀来填充字典P（P）属于S公司.因子分解

P（P） = {（f）}_{1} {（f）}_{2} \dots {（f）}_{我} \dots {（f）}_{d日}

是这样的

{（f）}_{我}

是与前一个因子串联的最长匹配项

{（f）}_{j个}

如果没有匹配项，则为下一个字符或当前字母字符（即，与下一个字母相连的每个因子都是字典元素）。填满的字典被“冻结”，因子分解以“静态”方式继续一段时间；也就是说，对于

d日 < 我 \leq t吨

，因素

{（f）}_{我}

是与前一个因子串联的最长匹配项

{（f）}_{j个}

，使用

j个 \leq d日

，如果不匹配，则显示下一个字符或当前字母字符。价值观t吨通过监测压缩比确定。当这个比率恶化时，字典被重置为等于字母表。LZC压缩是Unix和Linux“压缩”应用程序所采用的压缩方式，在Windows和Dos平台上使用Stuffit实现了类似的应用程序。

3.2. CREW PRAM算法

当字典被清除时，LZC编码的指针序列中会出现一个特殊标记，因此解码器不必监视压缩比。特殊标记的位置由并行前缀检测。每个子序列

{q个}_{1} \dots {q个}_{米}

两个连续标记之间的指针可以并行解码。并行算法基于指针的目标

{q个}_{我}

在子序列中是指针目标在位置上的串联

{q个}_{我} - α

指针目标的第一个字符位于适当位置

{q个}_{我} - α + 1

，并使用并发读取[9].

让

问_{1} \dots 问_{N个}

是字符串的LZC编码S公司，画在字母表上A类基数α，使用

问_{小时}

两个连续重置操作之间的指针序列，用于

1 \leq 小时 \leq N个

.每个

问_{小时}

可以独立解码。让

{q个}_{1} . . . {q个}_{米}

是指针的序列

问_{小时}

对子字符串进行编码

{S公司}^{'}

属于S公司.的解码

问_{小时}

需要团队PRAM O

((我 哦 克 (L（左）))

带O的时间

(| {S公司}^{'} |)

处理器，其中L（左）指针目标的最大长度。字典大小是L（左）这对于一元字符串来说很紧。该算法计算

米 \times d日

前缀指针矩阵 M（M），初始为null

d日 = 2^{16}

，如下所示：

输入：指针序列q个₁...q个_米;输出：矩阵M（M）前缀指针；1k:= 1;2并行用于1 ≤我≤米 做三。M（M）[我,j个] :=q个_我;4最后的[我] := 1;5.价值[我] :=M（M）[我,j个] −d日;6虽然 价值[我] > 0做7并行用于1 ≤j个≤k 做8如果 j个≤最后的[价值[我]]然后9M（M）[最后的[我] +j.i公司] =M（M）[j个,价值[我];10最后的[我] :=最后的[我] +最后的[价值[我]];11价值[我] :=价值[价值[我]];13k:= 2k;

在每个步骤中，

我 一 秒 t吨 [我]

是上的最后一个非null组件

我^{t吨 小时}

考虑的列（第4行初始化后的第10行）。的非空组件

v（v） 一 我 u个 e（电子） {(我)}^{t吨 小时}

列复制到

我^{t吨 小时}

列在后面的位置

我 一 秒 t吨 [我]

（第7-9行）。请注意

v（v） 一 我 u个 e（电子） (我)

严格小于我.然后，

v（v） 一 我 u个 e（电子） (我)

通过设置更新

v（v） 一 我 u个 e（电子） (我) : = v（v） 一 我 u个 e（电子） (v（v） 一 我 u个 e（电子） (我))

（第11行）。循环在列上停止我什么时候

v（v） 一 我 u个 e（电子） (我)

小于或等于零。此过程需要O

(| {S公司}^{'} |)

处理器和O

(我 哦 克 (L（左）))

CREW PRAM上的时间，因为每一步列上非空组件的数量都会加倍。指针的目标

{q个}_{我}

是指针目标在位置上的串联

{q个}_{我} - α

指针目标的第一个字符位于适当位置

{q个}_{我} - α + 1

，因为字典最初包含字母字符。在程序结束时，

M（M） [我 一 秒 t吨 [我], 我]

是表示目标的第一个字符的指针

{q个}_{我}

和

我 一 秒 t吨 [我]

是目标长度。然后，我们得出结论

M（M） [我 一 秒 t吨 [M（M） [j个, 我] - d日 + 1], M（M） [j个, 我] - d日 + 1]

，用于

1 \leq j个 \leq 我 一 秒 t吨 [我] - 1

，是表示

{(我 一 秒 t吨 [我] - j个 + 1)}^{t吨 小时}

目标的特征

{q个}_{我}

也就是说，我们必须查看写入列的指针值我并考虑这些值所给位置中列的最后非空分量减少了

α - 1

。这些组件必须按照列上各个值的自下而上顺序连接我通过将每个组件映射到相应的字母字符，我们获得目标的第一个字符后面的后缀

{q个}_{我}

，指针因此被解码（请参见[9]进一步澄清）。

指针序列可视为林的父指针表示，其中每个指针q个值大于α表示来自与关联的节点的链接q个指向与其位置上的指针关联的父节点

q个 - α

。矩阵的生成在每一列上计算与指向其树根的相应指针相关联的节点的路径。这样的根总是与字母字符相关联。树的最大高度是一个因子的最大长度。因子长度的理论上限是字典大小，在一元字符串的情况下字典大小很紧。然而，根据实际数据，我们可以假设最大因子长度L（左）是这样的

10 < L（左） < 20

。这种假设的动机是，实际上，一个因子的最大长度远小于字典的大小。例如，当使用16位指针压缩英文文本时，平均匹配长度将只有大约5个单位（有关经验结果，请参阅[13]). 因此，如果在实践中执行PRAM CREW算法，迭代次数（全局计算步骤）将大大少于十次。在某些例外情况下，最大因子长度将达到100个单位；也就是说，迭代次数将等于七个单元。此外，每个节点的子节点数理论上受字母基数的限制，但实际上，这种限制只适用于根。经过几个级别后，假设节点只有一个子节点是现实的。因此，对于实际数据，有一个小常数

c（c） > 0

这样，对于森林中的每棵树，具有多个子节点的节点数远远大于c（c）根的距离小于c（c），并且没有节点的距离超过c（c）从根开始有超过c（c）儿童。因此，并发读取是通过标准广播技术解决的，没有相关的减速。

3.3. EREW PRAM算法

子序列

{q个}_{1} \dots {q个}_{米}

上一小节中我们在CREW PRAM上解码的两个连续重置操作之间的指针分两个阶段在EREW PRAM上解码。在第一阶段，由于指针不包含有关其目标长度的信息，因此必须计算这些长度。指针的目标

{q个}_{我}

在子序列中是指针目标在位置上的串联

{q个}_{我} - α

指针目标的第一个字符位于适当位置

{q个}_{我} - α + 1

，其中α是字母基数。然后，对每个我，链接指针

{q个}_{我}

指向指针的位置

{q个}_{我} - α

如果

{q个}_{我} > α

再次，我们得到了一个森林，其中每棵树都以一个表示字母字符的指针为根，并且树的长度

我_{我}

指针目标的

{q个}_{我}

等于树中指针的级别加1。据了解[1]其串联形成给定长度字符串的最大数量的不同因子ℓ是O

(ℓ / 日志 ℓ)

。由于字符串的LZW因式分解的一个因子出现了多次，最多等于字母基数，因此如下所示米是O

(ℓ / 日志 ℓ)

如果ℓ是子序列编码的子字符串的长度

{q个}_{1} \dots {q个}_{米}

那么，建造这样的森林需要O

(我 哦 克 (| {S公司}^{'} |))

带O的时间

(| {S公司}^{'} |)

共享内存并行机上的处理器没有写入和读取冲突。在相同的并行复杂度下，我们可以通过Euler tour技术计算这种森林的树以及每个节点在其自己的树中的级别。因此，我们可以计算长度

我_{1}, . . ., 我_{米}

的目标。如果

秒_{1}, . . ., 秒_{米}

是部分和，是

{q个}_{我}

是位置上的子字符串

秒_{我 - 1} + 1 \dots 秒_{我}

输出字符串的。对于每个

{q个}_{我}

它与字母字符不对应，定义

（f） 我 第页 秒 t吨 (我) = 秒_{{q个}_{我} - α - 1} + 1

和

我 一 秒 t吨 (我) = 秒_{{q个}_{我} - α} + 1

.由于指针的目标

{q个}_{我}

是指针的目标在位置上的串联

{q个}_{我} - α

指针目标的第一个字符位于适当位置

{q个}_{我} - α + 1

，链接位置

秒_{我 - 1} + 1 \dots 秒_{我}

到位置

秒_{（f） 我 第页 秒 t吨 (我)} \dots 秒_{我 一 秒 t吨 (我)}

分别是。与滑动字典的情况一样，如果

{q个}_{我}

是一个字母字符，输出字符串中的相应位置是林中树的根，树中的所有节点都对应于解码字符串中该字符为根的位置。因为每个节点的子节点数最多为α，单位为O

(我 哦 克 (| {S公司}^{'} |))

带O的时间

(| {S公司}^{'} |)

处理器，我们可以将森林存储在双链接结构中，并通过EREW PRAM上的欧拉巡游技术进行解码[14]. 与CREW PRAM算法不同，运行时间明显为O

(我 哦 克 (| {S公司}^{'} |))

，不考虑系数最大长度。

4.CREW算法的MapReduce实现

我们展示了如何在MapReduce中实现上一节的CREW PRAM算法，并讨论了复杂性问题。首先，我们提出了MapReduce计算模型。

4.1. MapReduce计算模型

MapReduce模型允许在分布式系统的理论公式中进行全局计算。因此，限制计算步骤的数量是设计实用算法的要求。

MapReduce编程范例是一个序列

P（P） = μ_{1} ρ_{1} \dots μ_{R（右）} ρ_{R（右）}

，其中

μ_{我}

是映射器，并且

ρ_{我}

是一个减速器

1 \leq 我 \leq R（右）

首先，我们描述了这个范例，然后讨论如何在分布式系统上实现它。由于输入/输出相位是任何并行算法固有的，并且具有标准解决方案，因此序列P（P）不包括I/O阶段

μ_{1}

是多集

{U型}_{0}

其中每个元素都是

(k e（电子） 年, v（v） 一 我 u个 e（电子）)

一对。每个映射器的输入

μ_{我}

是多集

{U型}_{我 - 1}

减速器输出

ρ_{我 - 1}

，用于

1 < 我 \leq R（右）

.映射器

μ_{我}

在每对上运行

(k, v（v）)

在里面

{U型}_{我 - 1}

，映射

(k, v（v）)

到一套新的

(k e（电子） 年, v（v） 一 我 u个 e（电子）)

对。减速机输入

ρ_{我}

是

{U型}_{我}^{'}

，集合的并集输出

μ_{我}

.对于每个键k,

ρ_{我}

减少对的子集

{U型}_{我}^{'}

关键组件等于k到一组新的对，其关键组件仍然等于k.

{U型}_{我}

就是这些新集合的结合。

在分布式系统实现中，密钥与处理器相关联。具有给定密钥的所有对都由同一节点处理，但可以将更多密钥关联到该节点，以降低所涉及的系统的规模。映射器负责数据分发，因为它们可以生成新的键值。另一方面，归约器只处理存储在分布式存储器中的数据，因为它们为一组具有给定密钥的对输出另一组具有相同给定密钥的对。

以下复杂性要求是出于对以下内容的实际兴趣所必需的[11]:

R（右）输入大小为多对数n个;
所涉及的处理器（或Web中的节点）数量为O( ${n个}^{1 - ϵ}$ )带有 $0 < ϵ < 1$ ;
每个节点的内存量为O( ${n个}^{1 - ϵ}$ );
映射器和约简器占用多项式时间n个.

在[11]，还显示了

t吨 (n个)

使用次二次工作空间和次二次处理器数的时间CREW PRAM算法可以通过MapReduce实现，并且仿真满足上述要求，如果

t吨 (n个)

是多对数的。的确，参数R（右）模拟值为O(

t吨 (n个)

)而次二次工作空间被划分为占用多项式计算时间的次线性处理器数。

这些要求是必要的，但不足以保证计算速度的加快。显然，mapper和reducer的总运行时间不能高于sequential运行时间，这在[11]. 非平凡的瓶颈是计算阶段的通信成本。这需要通过实验进行检查，因为R（右）在输入大小中可以是多对数。一般来说，如果R（右）大约是10个单位或更少。如果这是从CREW PRAM算法的模拟中获得的，那么它可能比具有更高迭代次数的EREW PRAM算法的模拟更好。

4.2. 在MapReduce中解码LZC压缩文件

解码器解压缩指针序列的MapReduce实现

{q个}_{1} . . . {q个}_{米}

上一节的

P（P） = μ_{0} ρ_{0} μ_{1} ρ_{1} \dots μ_{2 R（右）} ρ_{2 R（右）} μ_{2 R（右） + 1} ρ_{2 R（右） + 1}

，使用

R（右） = ⌈ 我 哦 克 L（左） ⌉

。迭代次数为

2 R（右） + 2

因为，一般来说，CREW PRAM算法步骤的模拟是通过两个映射器和两个约简器实现的，其中，减速机计算内存请求和必须提供给处理器的相应信息，而映射器将内存请求和信息路由到负责特定处理器的减速机[11]. 在这种特殊情况下，键对应于矩阵条目，减速机通过查看与对应于矩阵条目的键相关联的值来计算内存请求，并将最后一个非空组件存储在列上。就其他减速机而言，必须提供给处理器的信息已经计算好了，因为该过程只是将值从列复制到列。因此，这样的缩减器只标识用于路由信息的映射器的处理器（或密钥）。

输入到

μ_{0}

是多集

{U型}_{- 1}

基数米，其中每个元素都是

(k e（电子） 年, v（v） 一 我 u个 e（电子）)

与配对

k e（电子） 年 = (1, 我)

和

v（v） 一 我 u个 e（电子） = {q个}_{我}

对于

1 \leq 我 \leq 米

.的输出

μ_{0}

是

{U型}_{0}^{'} = {U型}_{- 1} \cup {O（运行）}_{0}^{'}

，其中每个元素

{O（运行）}_{0}^{'}

是一个

(k e（电子） 年, v（v） 一 我 u个 e（电子）)

与配对

k e（电子） 年 = (1, 我)

和

v（v） 一 我 u个 e（电子） = 我^{'}

这样的话

我 < 我^{'} \leq 米

和

{q个}_{我^{'}} - α = 我

然后，减速器

ρ_{0}

输出集合

{U型}_{0} = {U型}_{- 1} \cup {O（运行）}_{0}

，其中

{O（运行）}_{0}

是从以下位置获得的

{O（运行）}_{0}^{'}

通过减少每个元素

((1, 我), 我^{'})

到元素

((1, 我), (2, 我^{'}))

换句话说，

μ_{0}

（与具有偶数索引的序列的每个其他映射器一样）为每个处理器路由内存请求。自

μ_{0}

是第一个映射器，它还负责计算内存请求（即，将字母基数减去指针值）。总之，这项工作是由每个减速器为下一个映射器使用奇数索引完成的。减速器

ρ_{0}

（与其他具有偶数索引的reducer一样）计算下一个映射器用于路由信息的键。

由计算的键

ρ_{0}

由映射器使用

μ_{1}

.的输出

μ_{1}

是

{U型}_{1}^{'} = {U型}_{- 1} \cup {O（运行）}_{1}^{'}

，其中每个元素

{O（运行）}_{1}^{'}

是一个

(k e（电子） 年, v（v） 一 我 u个 e（电子）)

与配对

k e（电子） 年 = (2, 我^{'})

和

v（v） 一 我 u个 e（电子） = q个 > 0

这样的话

((1, 我), (2, 我^{'})) \in {O（运行）}_{0}

和

{q个}_{我} = q个

然后，减速器

ρ_{1}

输出集合

{U型}_{1} = {U型}_{1}^{'} \cup {O（运行）}_{1}

，其中

{O（运行）}_{1}

是具有键的元素集

(2, 我)

和价值

q个 - α

这样的话

((2, 我), q个) \in {U型}_{1}^{'}

和

q个 - α > 0

所以，减速机

ρ_{1}

做这份工作

μ_{0}

自行完成。因此，映射器

μ_{2}

操作方式与

μ_{0}

就像其他具有偶数索引的映射器一样。

映射器

μ_{2}

输出

{U型}_{2}^{'} = {U型}_{1}^{'} \cup {O（运行）}_{2}^{'}

，其中每个元素

{O（运行）}_{2}^{'}

是一个

(k e（电子） 年, v（v） 一 我 u个 e（电子）)

与配对

k e（电子） 年 = (1, 我)

或

k e（电子） 年 = (2, 我)

和

v（v） 一 我 u个 e（电子） = 我^{'}

这样的话

我 < 我^{'} \leq 米

和

{q个}_{我^{'}} - α = 我

也就是说，

((2, 我^{'}), 我) \in {O（运行）}_{1}

然后，减速器

ρ_{2}

输出集合

{U型}_{2} = {U型}_{1}^{'} \cup {O（运行）}_{2}

，其中

{O（运行）}_{2}

是从以下位置获得的

{O（运行）}_{2}^{'}

通过减少每个元素

((1, 我), 我^{'})

或

((2, 我), 我^{'})

在里面

{O（运行）}_{2}^{'}

到元素

((1, 我), (三, 我^{'}))

或

((2, 我), (4, 我^{'}))

为了完成前两个CREW PRAM算法步骤，我们描述了mapper

μ_{三}

和减速器

ρ_{三}

.

映射器

μ_{三}

输出

{U型}_{三}^{'} = {U型}_{1}^{'} \cup {O（运行）}_{三}^{'}

中的每个元素

{O（运行）}_{三}^{'}

是一个

(k e（电子） 年, v（v） 一 我 u个 e（电子）)

与配对

k e（电子） 年 = (三, 我^{'})

或

k e（电子） 年 = (4, 我^{'})

和

v（v） 一 我 u个 e（电子） = q个 > 0

这样的话

((1, 我), (三, 我^{'})) \in {O（运行）}_{2}

或

((2, 我), (4, 我^{'})) \in {O（运行）}_{2}

和

{q个}_{我} = q个

然后，减速器

ρ_{三}

输出集合

{U型}_{三} = {U型}_{三}^{'} \cup {O（运行）}_{三}

，其中

{O（运行）}_{三}

是具有键的元素集

(4, 我)

和价值

q个 - α

这样的话

((4, 我), q个) \in {U型}_{三}^{'}

和

q个 - α > 0

，类似于

ρ_{1}

现在，我们可以提供通用步骤的MapReduce实现。

在k-第步，用于

4 \leq k \leq 2 R（右） - 1

，如果k甚至是地图绘制者

μ_{k}

输出

{U型}_{k}^{'} = {U型}_{k - 1}^{'} \cup {O（运行）}_{k}^{'}

中的每个元素

{O（运行）}_{k}^{'}

是一个

(k e（电子） 年, v（v） 一 我 u个 e（电子）)

与密钥配对

(χ, 我)

，用于

1 \leq χ \leq t吨

和

t吨 \leq 2^{k / 2 - 1}

、和值

我^{'}

这样的话

我 < 我^{'} \leq 米

和

{q个}_{我^{'}} - α = 我

; 也就是说，

((2^{k / 2 - 1}, 我^{'}), 我) \in {O（运行）}_{k - 1}

然后，减速器

ρ_{k}

输出集合

{U型}_{k} = {U型}_{k - 1}^{'} \cup {O（运行）}_{k}

，其中

{O（运行）}_{k}

是从以下位置获得的

{O（运行）}_{k}^{'}

通过减少每个元素

((χ, 我), 我^{'}) \in {O（运行）}_{2}^{'}

到元素

((χ, 我), (2^{k / 2 - 1} + χ, 我^{'}))

.

如果k很奇怪，mapper

μ_{k}

输出

{U型}_{k}^{'} = {U型}_{k - 2}^{'} \cup {O（运行）}_{k}^{'}

中的每个元素

{O（运行）}_{k}^{'}

是一个

(k e（电子） 年, v（v） 一 我 u个 e（电子）)

与配对

k e（电子） 年 = (j个, 我^{'})

和

v（v） 一 我 u个 e（电子） = q个 > 0

这样的话

(j个 - χ, 我), (j个, 我^{'})) \in {O（运行）}_{k - 1}

和

{q个}_{我} = q个

对一些人来说χ具有

1 \leq χ \leq t吨

和

t吨 \leq 2^{k / 2 - 1}

然后，如果

k < 2 R（右） - 1

，减速器

ρ_{k}

输出集合

{U型}_{k} = {U型}_{k}^{'} \cup {O（运行）}_{k}

，其中

{O（运行）}_{k}

是具有键的元素集

(2^{⌈ k / 2 ⌉}, 我)

和价值

q个 - α

这样的话

((2^{⌈ k / 2 ⌉}, 我), q个) \in {U型}_{k}^{'}

和

q个 - α > 0

.

减速器

ρ_{2 R（右） - 1}

输出集合

{U型}_{2 R（右） - 1} = {U型}_{2 R（右） - 1}^{'} \cup {O（运行）}_{2 R（右） - 1}

，其中每个

((j个, 我), q个) \in {U型}_{2 R（右） - 1}^{'}

减少到

((j个, 我), q个 - α + 1) \in {O（运行）}_{2 R（右） - 1}

.映射器

μ_{2 R（右）}

输出

{U型}_{2 R（右）}^{'} = {U型}_{2 R（右） - 1}^{'} \cup {O（运行）}_{2 R（右）}^{'}

中的每个元素

{O（运行）}_{2 R（右）}^{'}

等于

((1, 我), q个)

，其中

((ℓ_{我}, 我), q个) \in {U型}_{2 R（右） - 1}^{'}

和

ℓ_{我}

是由编码的因子的长度

{q个}_{我}

或发送到

(k e（电子） 年, v（v） 一 我 u个 e（电子）)

密钥等于的配对

(1, 我)

和价值

({j个}^{'}, 我^{'})

这样的话

(({j个}^{'}, 我^{'}), 我) \in {O（运行）}_{2 R（右） - 1}

然后，减速器

ρ_{2 R（右）}

输出

{U型}_{2 R（右）}

，其中每个元素

((1, 我), (q个, ({j个}^{'}, 我^{'}))) \in {U型}_{2 R（右）}

从两个元素中获得

((1, 我), q个)

和

((1, 我), ({j个}^{'}, 我^{'}))

在里面

{U型}_{2 R（右）}^{'}

.

最后，

μ_{2 R（右） + 1}

输出

{U型}_{2 R（右） + 1}^{'}

通过映射元素

((1, 我), (q个, ({j个}^{'}, 我^{'})))

到元素

((1, 我^{'}), ({j个}^{'}, 一)) \in {U型}_{2 R（右） + 1}^{'}

，其中一是的字母字符目标q个。然后，减速器

ρ_{2 R（右） + 1}

输出

{U型}_{2 R（右） + 1}

通过减少元素集{

((1, 我^{'}), (一, {j个}^{'})) \in {U型}_{2 R（右） + 1}^{'} : 1 \leq {j个}^{'} \leq ℓ_{我^{'}}

}到元素

((1, 我^{'}), {（f）}_{我^{'}})

，其中

{（f）}_{我^{'}}

是的目标

{q个}_{我^{'}}

通过连接每个字母字符获得一对于

ℓ_{我^{'}} \geq {j个}^{'} \geq 1

.

4.3. 复杂性问题

如果

问^{1} \dots 问^{N个}

是输入字符串的编码S公司，使用

问^{小时} = {q个}_{1}^{小时} . . . {q个}_{米^{小时}}^{小时}

的两个连续重置操作之间的指针序列

1 \leq 小时 \leq N个

，MapReduce解码序列

P（P） = μ_{0} ρ_{0} μ_{1} ρ_{1} \dots μ_{2 R（右）} ρ_{2 R（右）} μ_{2 R（右） + 1} ρ_{2 R（右） + 1}

属于

问^{小时}

是这样的

2 R（右） + 2

实际上大约有十个单位。很容易扩展MapReduce序列P（P）到MapReduce序列

Π = {M（M）}_{0} {P（P）}_{0} {M（M）}_{1} {P（P）}_{1} \dots {M（M）}_{2 R（右）} {P（P）}_{2 R（右）} {M（M）}_{2 R（右） + 1} {P（P）}_{2 R（右） + 1}

，其中输入到

{M（M）}_{0}

是multiset

\cup_{小时 = 1}^{N个} {V（V）}^{小时}

和中的每个元素

{V（V）}^{小时}

是一个

(k e（电子） 年, v（v） 一 我 u个 e（电子）)

与配对

k e（电子） 年 = (1, 我)

和

v（v） 一 我 u个 e（电子） = {q个}_{我}^{小时}

，用于

1 \leq 我 \leq 米^{小时}

和

1 \leq 小时 \leq N个

。对于

1 \leq 小时 \leq N个

，序列∏的映射器和减速机按照上一小节中对对应于小时.让

H（H） =

最大值

{米^{小时} : 1 \leq 小时 \leq N个}

中规定的亚线性要求[11]如果我们在集群上实现∏H（H）处理器，自N个和

米^{小时}

，用于

1 \leq 小时 \leq N个

，在实践中通常是次线性的。此外，MapReduce操作的时间乘以处理器数量是O

(T型)

，具有T连续时间，自

2 R（右） + 2

约为10个单位（优化要求）。这使得这个MapReduce实现具有实际意义，因为它有少量的迭代。最后，由于MapReduce序列实现了上一节的CREW PRAM算法，因此，并发读取通过标准广播技术解决，没有相关的减速。

5.结论

在本文中，我们讨论了当设计并发读、排他写并行算法时，它可能比相应的排他读版本更有实用价值。我们展示了一个使用MapReduce实现解码LZC压缩文件的实际示例。作为未来的工作，我们希望在当今的大规模集群上实现LZC解码器的MapReduce实现。

作者贡献

Bruno Carpentieri和Raffaele Pizzolante设想了如何在实践中实现Sergio De Agostino设计的并行解码算法；Sergio De Agostino编写了MapReduce实现和论文。

利益冲突

作者声明没有利益冲突。

工具书类

Lempel，A。；Ziv，J.论有限序列的复杂性。IEEE传输。Inf.理论 1976,22, 75–81. [谷歌学者] [交叉参考]
Lempel，A。；Ziv，J.序列数据压缩的通用算法。IEEE传输。Inf.理论 1977,23, 337–443. [谷歌学者]
Ziv，J。；Lempel，A.通过可变速率编码压缩单个序列。IEEE传输。Inf.理论 1978,24, 530–536. [谷歌学者] [交叉参考]
R.E.塔尔詹。；Vishkin，U。一种高效的并行双连通性算法。SIAM J.计算。 1985,14, 862–874. [谷歌学者] [交叉参考]
高性能数据压缩技术。IEEE计算。 1984,17, 8–19. [谷歌学者] [交叉参考]
贝尔，T.C。；克利里，J.G。；I.H.威滕。文本压缩; 普伦蒂斯·霍尔：上马鞍河，新泽西州，美国，1990年。[谷歌学者]
De Agostino，S.《数据压缩中的完整问题》。理论。计算。科学。 1994,127, 181–186. [谷歌学者] [交叉参考]
De Agostino，S.Lempel-Ziv《并行和分布式系统上的数据压缩》。算法 2011,4, 183–199. [谷歌学者] [交叉参考]
De Agostino，S.一种用于LZ2数据压缩的并行解码算法。并行计算。 1995,21, 1957–1961. [谷歌学者] [交叉参考]
De Agostino，S.分布式通信系统上的解压缩应用程序。2015年5月24日至29日在意大利罗马举行的第十一届网络与服务国际会议记录；第55-60页。
H.J.卡洛夫。；苏里，S。；Vassilvitskii，S.MapReduce的计算模型。SIAM-ACM离散算法研讨会论文集，美国德克萨斯州奥斯汀，2010年1月17日至19日；第938-948页。
斯托尔，J.A。；Szymansky，T.G.通过文本替换进行数据压缩。J.ACM公司 1982,24, 928–951. [谷歌学者] [交叉参考]
J.A.斯托尔。数据压缩：方法和理论; 计算机科学出版社：美国马里兰州罗克维尔，1988年。[谷歌学者]
De Agostino，S.《LZ压缩文本的PRAM EREW解码器几乎奏效》。并行过程。莱特。 2004,14, 351–359. [谷歌学者] [交叉参考]

分享和引用

MDPI和ACS样式

Agostino，S.D.公司。；Carpentieri，B。；R·皮佐兰特。LZ压缩文件并行解码中的并发读取与独占读取。算法 2017,10, 21.https://doi.org/10.3390/a10010021

AMA风格

Agostino SD、Carpentieri B、火山灰R。LZ压缩文件并行解码中的并发读取与独占读取。算法. 2017; 10(1):21.https://doi.org/10.3390/a10010021

芝加哥/图拉宾风格

阿戈斯蒂诺、塞尔吉奥·德、布鲁诺·卡彭蒂埃里和拉斐尔·皮佐兰特。2017.“LZ压缩文件并行解码中的并发读取与独占读取”算法第10页，第1页：第21页。https://doi.org/10.3390/a10010021

请注意，从2016年第一期开始，该杂志使用文章编号而不是页码。请参阅更多详细信息在这里.

文章菜单

LZ压缩文件并行解码中的并发读取与独占读取^†

摘要

1.简介

2.并发阅读与独占阅读

3.并行解码LZC-压缩文件

3.1. LZC压缩

3.2. CREW PRAM算法

3.3. EREW PRAM算法

4.CREW算法的MapReduce实现

4.1. MapReduce计算模型

4.2. 在MapReduce中解码LZC压缩文件

4.3. 复杂性问题

5.结论

作者贡献

利益冲突

工具书类

分享和引用

文章指标

文章访问统计

更多信息

指导方针

MDPI计划

遵循MDPI

文章菜单

LZ压缩文件并行解码中的并发读取与独占读取 †

摘要

1.简介

2.并发阅读与独占阅读

3.并行解码LZC-压缩文件

3.1. LZC压缩

3.2. CREW PRAM算法

3.3. EREW PRAM算法

4.CREW算法的MapReduce实现

4.1. MapReduce计算模型

4.2. 在MapReduce中解码LZC压缩文件

4.3. 复杂性问题

5.结论

作者贡献

利益冲突

工具书类

分享和引用

文章指标

文章访问统计

更多信息

指导方针

MDPI计划

遵循MDPI

LZ压缩文件并行解码中的并发读取与独占读取^†