Algorithm on Tech Explorer

倒排索引求交算法相关资料调研

Sun, 14 Jun 2020 00:00:00 +0000

1. IR-book 经典教材中的思路
#

Faster postings list intersection via skip pointers 通过跳指针，实现更快的 posting list 求交 https://nlp.stanford.edu/IR-book/html/htmledition/faster-postings-list-intersection-via-skip-pointers-1.html

首先有个最 trival 的算法，两个 posting list，各一个指针，谁不匹配，就把谁右移一个，

跳表方法，思路类似 skip list，是要在建索引的时候，额外构建 skip list，这样就不是右移一个，而是按照跳表来右移。

2. lemire 教授的 SIMDCompressionAndIntersection 库中有多种算法
#

https://github.com/lemire/SIMDCompressionAndIntersection/blob/master/src/intersection.cpp

可以看到实现了这些求交算法，并且还有个 benchmark 程序 benchintersection 可以做对比

“simd”
“galloping”
“scalar”
“v1”
“v3”
“simdgalloping”
“simd_avx2”
“v1_avx2”
“v3_avx2”
“simdgalloping_avx2”
“highlyscalable_intersect_SIMD”
“lemire_highlyscalable_intersect_SIMD”

其中根据输入数据的规模，会选用不同的算法，并且还有 avx2 指令集的优化算法。

其中提到的 sse 优化的 fast-intersection-sorted-lists-sse https://highlyscalable.wordpress.com/2012/06/05/fast-intersection-sorted-lists-sse/

3. “The magic of Algorithms! " 中的算法
#

Chap. 6, Algorithm 6.1 Intersection based on Mutual Partitioning

http://didawiki.di.unipi.it/doku.php/magistraleinformaticanetworking/ae/ae2019/start#books_notes_etc

pdf 是 https://www.dropbox.com/s/dqttqigvuf4ydkd/main.pdf?dl=0

思路很简单，就是嵌套的 binary search，实测效果不错，而且实现简单，可以直接递归实现。

我实测效果还不错，提了个 issue https://github.com/lemire/SIMDCompressionAndIntersection/pull/29

4. List Intersection for Web Search: Algorithms, Cost Models, and Optimizations
#

http://www.vldb.org/pvldb/vol12/p1-kim.pdf 微软的文章，搞了个 cost model，来评估各种 list 求交集算法的性能，但是不开源。

本文提出一种基于代价的模型，来估算各种算法组合的代价，并使用代价模型来搜索代价最低的算法，得到的计划通常是 2-way 算法的一个组合，并且比传统的 2-way 和 k-way 算法性能都好。

并列举了常见的 List Intersection 算法： 2-way:

2-Gallop
2-Merge
2-SIMD

k-way:

k-Gallop
k-Merge

2-way vs. k-way 本文断言，对 k-list 求交，通过 k-1 次重复 2-way 求交算法，比通过单次 k-way 求交算法，更快。

结论，通过本文 cost model optimizer 规划出来的 2-way 求交计算，通常比 k-way 求交更快。

https://arxiv.org/pdf/1401.6399.pdf

We demonstrated that combining unpacking and differential coding resulted in faster decompression speeds, which were approximately 30 % better than the best speeds reported previously [3]. To match the performance of these fast compression schemes, we additionally vectorized and optimized the intersection of posting lists. To this end, we introduced a family of algorithms exploiting commonly available SIMD instructions (V1, V3 and SIMD GALLOPING). They are often twice as fast as the best non-SIMD algorithms. Then, we used our fast SIMD routines for decompression and posting

Efficient set intersection for inverted indexing

http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.415.2636&rep=rep1&type=pdf

Intersection in integer inverted indices https://pdfs.semanticscholar.org/db30/9935b512ef4d0c8941c96e987ad70400ebde.pdf

lookup 算法最快，非常简单，两层存储，按位分成两层。首层直接定位，二层直接遍历。二层可以压缩。

【翻译/介绍】jump consistent hash 零内存消耗，均匀，快速，简洁，来自Google的一致性哈希算法

Fri, 13 Mar 2015 00:00:00 +0000

一，简介
#

jump consistent hash是一种一致性哈希算法, 此算法零内存消耗，均匀分配，快速，并且只有5行代码。

此算法适合使用在分shard的分布式存储系统中。

此算法的作者是 Google 的 John Lamping 和 Eric Veach，论文原文在 http://arxiv.org/ftp/arxiv/papers/1406/1406.2294.pdf

完整代码：

 
 int32_t JumpConsistentHash(uint64_t key, int32_t num_buckets) {
 int64_t b = -1, j = 0;
 while (j < num_buckets) {
 b = j;
 key = key * 2862933555777941757ULL + 1;
 j = (b + 1) * (double(1LL << 31) / double((key >> 33) + 1));
 }
 return b;
 }

输入是一个64位的key，和桶的数量（一般对应服务器的数量），输出是一个桶的编号。

二，原理解释：
#

下面byron根据论文的推导过程，做个翻译：

jump consistent hash的设计目标是：

平衡性，把对象均匀地分布在所有桶中。
单调性，当桶的数量变化时，只需要把一些对象从旧桶移动到新桶，不需要做其它移动。

jump consistent hash的设计思路是：计算当bucket数量变化时，有哪些输出需要变化。

让我们循序渐进地思考：

记 ch(key,num_buckets) 为num_buckets时的hash函数。
当num_buckets=1时，由于只有1个桶，显而易见，对任意k，有ch(k,1)==0。
当num_buckets=2时，为了使hash的结果保持均匀，ch(k,2)的结果应该有占比1/2的结果保持为0，有1/2跳变为1。
由此，一般规律是：num_buckets从n变化到n+1后，ch(k,n+1) 的结果中，应该有占比 n/(n+1) 的结果保持不变，而有 1/(n+1) 跳变为 n+1。

因此，我们可以用一个随机数生成器，来决定每次要不要跳变，并且让这个随机数生成器的状态仅仅依赖于key。就得到下面这个初步代码：

 int ch(int key, int num_buckets) {
 random.seed(key) ;
 int b = 0; // This will track ch(key, j +1) .
 for (int j = 1; j < num_buckets; j ++) {
 if (random.next() < 1.0/(j+1) ) b = j ;
 } 
 return b;
 } 

显而易见，这个算法是O(n)的。同时我们可以发现，大多数情况下b=j 是不会执行的，而且随着 j 越来越大，这个概率越来越低。那么有没有办法根据一个随机数，直接得出下一个跳变的 j ，降低时间复杂度呢？

ok,请把你的大脑切换到概率论模式。

我们可以把 ch(key,bum_buckets) 看做一个随机变量，

上述算法，追踪了桶编号的的跳变过程，我们记上一个跳变结果是b，假设下一个结果以一定概率是 j ，那么从b+1到j-1，这中间的多次增加桶都不能跳变。对于在区间 (b, j) 内的任意整数 i ，j是下一个结果的概率可以记为:

$$P(j>=i) = P(ch(k,i)=ch(k,b+1))$$

其中 $ch(k,i)=ch(k,b+1)$ 意即从 $b+1$ 到 $i$ 的过程中，连续多次增加桶的时候都没有跳变，这个概率也就是连续多次不跳变事件概率的乘积，因此：

$$ P(j>=i) = P(ch(k,b+1)=ch(k,b+2)) * $$

$$ P(ch(k,b+2)=ch(k,b+3)) * $$

$$ P(ch(k,b+3)=ch(k,b+4)) * $$

$$ ...... * $$

$$ P(ch(k,i-1)=ch(k,i)) $$

由于单次不跳变的概率：

$$P( ch(k,i)=ch(k,i+1) ) = i/(i+1)$$

所以连续多次不跳变的概率

$$P(j>=i) = (b+1)/(b+2) * (b+2)/(b+3) * ... * (i-1)/i$$

前后项分子分母相互抵消，得到：

$$P(j>=i) = (b+1)/i$$

意即：$j>=i$ 的概率为 $(b+1)/i$

此时，我们取一个在 [0,1] 区间均匀分布的随机数 $r$，规定 $r<(b+1)/i$，就有 $j>=i$，所以有 $i<(b+1)/r$，这样就得到了i的上界是 $(b+1)/r$，由于对任意的i都要有$j>=i$，所以 $j=floor( (b+1)/r )$，这样我们用一个随机数 $r$ 得到了 $j$ 。

因此，代码可以改进为：

 int ch(int key, int num_buckets) {
 random. seed(key) ;
 int b = -1; // bucket number before the previous jump
 int j = 0; // bucket number before the current jump
 while(j<num_buckets){
 b=j;
 double r=random.next(); // 0<r<1.0
 j = floor( (b+1) /r);
 }
 return b;
 }

这个算法的时间复杂度，可以假设每次r都取0.5，则可以认为每次 $j=2*j$，因此时间复杂度为 $O(log(n))$ 。

此处需要一个均匀的伪随机数生成器，论文中使用了一个64位的线性同余随机数生成器。

需要指出的是：不像割环法，jump consistent hash不需要对 key 做 hash ，这是由于 jump consistent hash 使用内置的伪随机数生成器，来对每一次 key 做再 hash，（byron的理解：所以结果分布的均匀性与输入key的分布无关，由伪随机数生成器的均匀性保证）。

三，各项指标对比分析
#

consistent hash的概念出自David Karger的论文，经典并且应用广泛的割环法即出自这篇论文：http://www.ra.ethz.ch/cdstore/www8/data/2181/pdf/pd1.pdf

Karger提出2种实现:

“version A”，用 std::map<uint64_t, int32_t>表示key的hash 到桶id的映射。
“version B”，用 vector<pair<uint64_t, int32_t> >存储，vector事先排好序，用二分查找。

这两种实现的查找时间复杂度也都是O(log(n))

jump consistent hash的论文中，用jump consistent hash和Karger的割环算法做了对比，结果如下：

1. key分布的均匀性
#

直接从论文中摘录如下表格：

从标准差(Standard Error)这一列可见，jump consistent hash的均匀性要胜过割环法。

并且显而易见，jump consistent hash，当扩/缩容时，跳变key数量已经是理论最少值 1/n。

2. 执行耗时
#

下面是论文中的执行耗时对比图，其中k=1000。

3. 内存占用对比
#

显而易见，请自行脑补

4. 初始化耗时对比
#

显而易见，请自行脑补

四，相关链接
#

jump consistent hash 适合节点数只增加的业务场景，比如存储系统分 shard。

如果节点数会随机减少，比如 web caching 场景下服务器节点随机故障。

假设节点 i ( 0 <= i < num_buckets ) 故障，此时如果简单地把 num_buckets 减 1，就会导致编号在 i 之后的节点上的数据全部错位到前一个节点。因此 jump consistent hash 不适合节点随机故障的场景。

在 Hacker News上面的讨论：https://news.ycombinator.com/item?id=8136408

这个算法最早在Google的guava库里面开源：https://github.com/google/guava/blob/master/guava/src/com/google/common/hash/Hashing.java#L392

递增子序列数目计算的算法

Mon, 17 Oct 2011 00:00:00 +0000

这是前几天笔试时，考场上想出来的算法，但是算了两次都不一样，最后只好蒙了一个选项，悲催！

问题如下：

给定一个整数序列，例如 4,2,6,3,7,1 ，该序列有多少个递增子序列？

我的算法如下：

记第i个元素为arr[i] ，记以第i个元素结尾的递增子序列有N[i]个，

则，考虑以第i+1个元素结尾的所有递增子序列，

首先置N[i+1]=1;//表示只有第i+1个元素一个元素的子序列。

对j=1...i

 如果arr[j]<arr[i+1]

 N[i+1]+=N[j]

最后结果等于N数组里所有元素之和。

Algorithm on Tech Explorer

倒排索引求交算法相关资料调研

1. IR-book 经典教材中的思路 #

2. lemire 教授的 SIMDCompressionAndIntersection 库中有多种算法 #

3. “The magic of Algorithms! " 中的算法 #

4. List Intersection for Web Search: Algorithms, Cost Models, and Optimizations #

【翻译/介绍】jump consistent hash 零内存消耗，均匀，快速，简洁，来自Google的一致性哈希算法

一，简介 #

二，原理解释： #

三，各项指标对比分析 #

1. key分布的均匀性 #

2. 执行耗时 #

3. 内存占用对比 #

4. 初始化耗时对比 #

四，相关链接 #