CN1737799A - 一种基于分档BloomFilter结构的查询方法 - Google Patents

Abstract

一种基于分档Bloom Filter结构的查询方法，它将元素根据不同的查询代价分为不同的子集，通过考查每档子集最低查询失效率的关系，建立每档子集合最低假阳性率表示集合整体最低查询失效代价目标函数，使用类目标函数梯度遗传算法获得每档的最优哈希函数个数k_i，再完成集合到向量的映射与查找。它用于分布式计算、计算机网络资源定位、数据库的交互查询、P2P网络资源交互、传感器网络信息交换、计算机网络监测、计算机缓存系统设计等产生大量数据、需要进行交互查询的领域，可以大大减少集合查询的失效代价，实现集合的总体查询代价最小，由此降低资源消耗。

Description

一种基于分档Bloom Filter结构的查询方法

技术领域

本发明是一种支持集合查询从代价出发的基于分档Bloom Filter结构的查询方法，属于分布式计算技术领域，特别是涉及分布式系统产生大量数据、需要进行交互查询的应用。

背景技术

近年来，随着计算机的飞速发展，数据库，网络和其他应用中的数据集合规模呈几何增长。集合元素查询是数据集合中最常见的操作。当集合变得越来越大，访问和表示越来越困难，如何表示大数据集合，完成大数据集合下的查询成为国内外学术界的挑战。设计精简的数据结构表示并支持大集合的数据查询就成了迫切需要。

Bloom Filter是一种能够表示集合、支持集合查询的简洁数据结构，它能够有效的过滤掉不属于集合的元素。Bloom Filter结构的实质是将集合中的元素通过k个哈希函数映射到位向量中。Bloom Filter在达到其高效表示集合的同时，进行元素查询时却存在一定的假阳性错误，而不存在假阴性错误。这里假阳性错误是指，将不属于集合中的元素误判断属于集合中，假阴性错误是指，属于集合中的元素而误判断不属于集合中。以往的研究都已经证明Bloom Filter这种优秀的结构不存在假阴性错误。虽然Bloom Filter结构在元素查询时存在少量错误，但是由于它对存储空间的高效性，使得该数据结构由B.Bloom自1970年提出以来得到了比较广泛的应用。早期的应用主要集中在数据库操作和字典查询操作，最近，随着网络研究的发展以及新的覆盖网和P2P网络应用技术的涌现，Bloom Filter已经越来越广泛的应用于网络中，主要体现在以下几类：

1.覆盖网和P2P网节点协作交互：网络节点利用Bloom Filter存储节点的内容摘要，节点间通过互传摘要信息获得其他节点的存储内容信息，无需广播资源请求，节约节点间带宽资源，优化P2P网络的资源查询和资源互补；

2.资源路由：利用Bloom Filter记录邻接节点组的资源信息，通过一个多级的Bloom Filter结构，存储资源的路由分级信息，快速定位最短路径路由并确定到达目的节点的跳数；

3.数据帧路由标签：在IP字段中记录所通过路由器的Bloom Filter值，来判断数据帧是否重复经过路由器，从而确定是否出现环路。

4.网络测量管理：路由器中利用Bloom Filter为业务流计数，当流量超过阈值时产生告警并进行拥塞控制。

目前对Bloom Filter查询结构的研究主要有：1.标准的Bloom Filter；

2.计数器Bloom Filter；3.压缩Bloom Filter；4.Spectral Bloom Filter。

然而，当前的Bloom Filter结构因没有考虑集合的查询代价，它们认为集合元素在查询时所付出的I/O操作代价相同，而在实际中，集合中的元素由于查询失效(假阳性发生)，元素的查询失效代价由于元素在集合中的作用和地位并不相同，查询失效时额外付出的操作代价并不相同。以往的Bloom Filter结构因为没有考虑到查询代价，它们对集合中的元素都均一对待，为每个元素分配同样多的哈希映射函数，每个元素查询失效率相同，导致集合的整体查询代价比较高。缺乏查询代价考虑并且缺乏元素的区分对待是当前Bloom Filter中通用弊端，这使得在当前实际应用中往往更耗资源。

发明内容

本发明要解决的技术问题是，针对现有技术存在的缺陷，提出一种基于分档Bloom Filter结构的查询方法，它用到分布式计算、计算机网络资源定位、数据库的交互查询、P2P网络资源交互、传感器网络信息交换、计算机网络监测、计算机缓存系统设计等产生大量数据、需要进行交互查询的应用领域，可以大大减少集合查询的失效代价，降低资源消耗。

本发明的技术解决方案是，所述基于分档Bloom Filter结构的查询方法的步骤为：

(1)按照集合中元素的查询代价分为不同的档(子集合)；

   设集合S包含L档，则：

               S＝{{S₁}，{S₂}，L，{S_L}}

(2)建立由每档子集合最低假阳性率表示的集合整体最小查询代价目

   标函数：

$F_{\mathrm{baskets}}\left(L\right)=\underset{i=1}{\overset{L}{\mathrm{\Σ}}}{n}_i{c}_i{f}_i=\underset{i=1}{\overset{L}{\mathrm{\Σ}}}{n}_i{c}_i{\left(\frac{1}{2}\right)}^{\ln 2\·\left(\frac{r_{i}m}{\underset{j=1}{\overset{L}{\mathrm{\Σ}}}{n}_j{r}_j}\right)}$

上式中，每档子集合的元素个数为n_i＝|S_i|，子集合S_i中元素发生查询失效时，所需的额外I/O操作代价为c_i(1≤i≤L)，子集合S_i所需要的哈希映射函数个数为k_i(1≤i≤L)，对应的假阳性概率为f_i(1≤i≤L)，映射到长度为m的位串向量V，r_i＝ln(f_i)(1≤i≤L)；

(3)利用类目标函数梯度遗传算法求解最小查询代价目标函数，获得

   r_i(1≤i≤L)，步骤是：

步骤1：随机产生规模为n二进制编码染色体，每个染色体代表一个

r₁，r₂，L，r_L序列；

步骤2：利用类目标函数梯度适应值函数计算每个染色体的适应值；类目标函数梯度适应值函数为：

F(L)＝λf(L)+(1-λ)f(L)/inverse_number

其中inverse_number＝τ(r₁，r₂，L，r_L)为逆序数

$f\left(L\right)=\left\{\begin{array}{cc}{C}_{\max }-F_{\mathrm{basket}}\left(L\right),& \mathrm{iff}\left(L\right)<C_{\max }\\ 0& \mathrm{iff}\left(L\right)\&GreaterEqual;C_{\max }\end{array}\right.$

步骤3：检查是否已经达到最优结果，如果是转到步骤6，返回最优的染色体，否则继续；

步骤4：使用选择、交叉、变异，产生新一代n个染色体；

步骤5：利用新一带染色体代替老的染色体，转到步骤2：

步骤6：将染色体解码，获得r₁，r₂，L，r_L；

步骤7：求解获得每档映射哈希函数个数k_i(1≤i≤L)：

$k_i=\ln 2\&CenterDot;\left(\frac{r_{i}m}{\underset{j=1}{\overset{L}{\mathrm{\&Sigma;}}}{n}_j{r}_j}\right)$

(4)利用k_i(1≤i≤L)完成集合到向量的映射与查找。

以下对本发明做出进一步说明。

本发明第一次区分对待集合中待查询的元素，第一次考查Bloom Filter的查询代价，即本发明在Bloom Filter领域研究集合查询代价(重点为查询失效代价)，将集合中的元素按照查询失效代价的不同而区分为不同的档(子集合)，然后通过考查每档最低查询失效率和Bloom Filter设计的关系，建立由每档最低假阳性率表示的集合整体最低查询代价目标函数，将函数依赖转换为r_pair(r_i，r_j)(1≤i，j≤L)，求解过程使用类目标函数梯度遗传算法获得每档的最优哈希函数个数k_i(1≤i≤L)，通过这些哈希函数的个数k_i完成集合的表示和元素的查询。

关于本发明建立分档Bloom Filter集合整体最低查询失效代价目标函数的具体说明：

假设集合S包含L档，则：

         S＝{{S₁}，{S₂}，L，{S_L}}

每档子集合的元素个数为n_i＝|S_i|，子集合S_i中元素发生查询失效时，所需的额外I/O操作代价为c_i(1≤i≤L)，子集合S_i所需要的哈希映射函数个数为k_i(1≤i≤L)，对应的假阳性概率为f_i(1≤i≤L)；映射到长度为m的位串向量V；

那么定义整体查询失效代价函数为：

         F＝n₁f₁c₁+n₂f₂c₂+L+n_Lf_Lc_L    (1)

为了下面的文章中表述方便：我们将分档Bloom Filter方法(简称BBF)用{{n₁，n₂，L，n_L}，{c₁，c₂，L，c_L}，m，{k₁，k₂，L，k_L}表示，将标准Bloom Filter(简称SBF)。

通过考查每档最低假阳性率和Bloom Filter设计关系，我们得到分档Bloom Filter集合整体最低查询代价表达式为：

$F_{\mathrm{baskets}}\left(L\right)=\underset{i=1}{\overset{L}{\mathrm{\&Sigma;}}}{n}_i{c}_i{f}_i=\underset{i=1}{\overset{L}{\mathrm{\&Sigma;}}}{n}_i{c}_i{\left(\frac{1}{2}\right)}^{\ln 2\&CenterDot;\left(\frac{r_{i}m}{\underset{j=1}{\overset{L}{\mathrm{\&Sigma;}}}{n}_j{r}_j}\right)}---\left(2\right)$

其中r_i＝ln(f_i)(1≤i≤L)，而且每档元素需要映射的哈希函数个数为：

$k_i=\ln 2\&CenterDot;\left(\frac{r_{i}m}{\underset{j=1}{\overset{L}{\mathrm{\&Sigma;}}}{n}_j{r}_j}\right)---\left(3\right)$

下面是所述表达式的证明。2档Bloom Filter(L＝2)：

BBF＝{n₁，n₂}，{c₁，c₂}，m，{k₁，k₂}}，集合中所有元素插入向量V后，向量V中任一位置为0的概率为：

${(1-\frac{1}{m})}^{k_1{n}_1}{(1-\frac{1}{m})}^{k_2{n}_2}={(1-\frac{1}{m})}^{k_1{n}_1+k_2{n}_2}\&ap;e^{-\frac{k_1{n}_1+k_2{n}_2}{m}}=p---\left(4\right)$

第一档元素的假阳性率为：

f₁＝exp(k₁ ln(1-p))    (5)第二档元素的假阳性率为：

f₂＝exp(k₂ ln(1-p))    (6)令g₁＝k₁ ln(1-p)，g₂＝k₂ ln(1-p)。发现：

g₁∶g₂＝r₁∶r₂＝k₁∶k₂   (7)对g₂求k₂倒数，当g₂取最小值时

$k_{2\min }=\ln 2\left(\frac{r_{2}m}{r_1{n}_1+r_2{n}_2}\right)---\left(8\right)$

得到f₂的最小值为：

$f_{2\min }={\left(\frac{1}{2}\right)}^{k_{2\min }}={\left(\frac{1}{2}\right)}^{\ln 2\left(\frac{r_{2}m}{r_1{n}_1+r_2{n}_2}\right)}---\left(9\right)$

由k₁，k₂的比率关系(7)得k₁＝k₂r₂/r₁，所以：

$k_1=\ln 2\left(\frac{r_{1}m}{r_1{n}_1+r_2{n}_2}\right)---\left(10\right)$

同理，我们取g₁为最小值时，和前面的过程相似，可以得到：

$k_{1\min }=\ln 2\left(\frac{r_{1}m}{r_1{n}_1+r_2{n}_2}\right)---\left(11\right)$

那么f₁的最小值为：

$f_{1\min }={(1-p)}^{k_{1\min }}={\left(\frac{1}{2}\right)}^{\ln 2\&CenterDot;\left(\frac{r_{1}m}{r_1{n}_1+r_2{n}_2}\right)}---\left(12\right)$

由式(10)和式(11)我们发现k₁＝k_1min。得出结论，两档子集可以同时获得每档最小假阳性率，那么用最小假阳性率表示的最低代价为：

$F_{\mathrm{baskets}}\left(L\right)=n_1{c}_1{f}_{1\min }+n_2{c}_2{f}_{2\min }=\underset{i=1}{\overset{L}{\mathrm{\&Sigma;}}}{n}_i{c}_i{\left(\frac{1}{2}\right)}^{\ln 2\&CenterDot;\left(\frac{r_{i}m}{\underset{j=1}{\overset{L}{\mathrm{\&Sigma;}}}{n}_j{r}_j}\right)}---\left(13\right)$

满足式(2)得证，函数值依赖于r_pair(r₁，r₂)，下面就更一般的情况进行证明。多档Bloom Filter(L＞2)：

BBF＝{{n₁，n₂，L，n_L}，{c₁，c₂，L，c_L}，m，{k₁，k₂，L，k_L}}。

当L档元素都映射到V向量后，向量V中任一位为0的概率为：

${(1-\frac{1}{m})}^{k_1{n}_1}L{(1-\frac{1}{m})}^{k_L{n}_L}={(1-\frac{1}{m})}^{\underset{i=1}{\overset{L}{\mathrm{\&Sigma;}}}{k}_i{n}_i}\&ap;e^{-\frac{\underset{i=1}{\overset{L}{\mathrm{\&Sigma;}}}{k}_i{n}_i}{m}}=p---\left(14\right)$

每一档子集中的元素出现假阳性率为：

$f_1={(1-p)}^{k_1}=\exp \left(k_1\ln (1-p)\right)$

$f_2={(1-p)}^{k_2}=\exp \left(k_2\ln (1-p)\right)---\left(15\right)$

L

$f_L={(1-p)}^{k_L}=\exp \left(k_L\ln (1-p)\right)$

令g₁＝k₁ ln(1-p)，...，g_L＝k_L ln(1-p)，得：

g_i∶g_j＝k_i∶k_j＝r_i∶r_j  (1≤i，j≤L)    (16)g₁是k₁的函数，p也是k₁的函数，当g₁求倒数取最小值时：

$k_{1\min }=\ln 2\left(\frac{m}{\underset{i=1}{\overset{L}{\mathrm{\&Sigma;}}}{n}_i{r}_i/r_1}\right)---\left(17\right)$

将k_1min代入式(15)得f₁最小值：

$f_{1\min }={\left(\frac{1}{2}\right)}^{k_{1\min }}={\left(\frac{1}{2}\right)}^{\ln 2\left(\frac{r_{j}m}{\underset{i=1}{\overset{L}{\mathrm{\&Sigma;}}}{n}_i{r}_i}\right)}---\left(18\right)$

从式(17)得出k_i＝k₁r₁/r_i

$k_i=\ln 2\&CenterDot;\left(\frac{r_{i}m}{\underset{j=1}{\overset{L}{\mathrm{\&Sigma;}}}{n}_i{r}_j}\right)---\left(19\right)$

类似上面推导，这些k₁，k₂，L，k_L使得每档的f₁，f₂，L，f_L都达最小值，其他每档的最小假阳性率为：

$f_{i\min }={\left(\frac{1}{2}\right)}^{k_{i\min }}={\left(\frac{1}{2}\right)}^{\ln 2\left(\frac{r_{i}m}{\underset{i=1}{\overset{L}{\mathrm{\&Sigma;}}}{n}_j{r}_j}\right)}---\left(20\right)$

此时用最小假阳性概率表示的集合查询代价函数为：

$F_{\mathrm{baskets}}\left(L\right)=\underset{i=1}{\overset{L}{\mathrm{\&Sigma;}}}{n}_i{c}_i{f}_i=\underset{i=1}{\overset{L}{\mathrm{\&Sigma;}}}{n}_i{c}_i{\left(\frac{1}{2}\right)}^{\ln 2\&CenterDot;\left(\frac{r_{i}m}{\underset{i=1}{\overset{L}{\mathrm{\&Sigma;}}}{n}_j{r}_i}\right)}---\left(21\right)$

式(2)得证。该函数的值取决于r_pair(r_i，r_j)(1≤i，j≤L)。用类目标函数梯度遗传算法获得k_i(1≤i≤L)值：

我们得到由最低假阳性率表示的集合整体最低查询失效代价函数表达式，由于n_i，c_i都是常数，求该表达式的最小值就是确定r_pair(r_i，r_j)(1≤i，j≤L)。然后根据式(3)获得查询应用时的哈希函数个数k_i。

利用类目标函数梯度遗传算法求解每档k_i：

步骤1：随机产生规模为n二进制编码染色体，每个染色体代表一个r₁，r₂，L，r_L序列；

步骤2：利用类目标函数梯度适应值函数计算每个染色体的适应值；

类目标函数梯度适应值函数为：

F(L)＝λf(L)+(1-λ)f(L)/inverse_number

其中inverse_number＝τ(r₁，r₂，L，r_L)为逆序数

$f\left(L\right)=\left\{\begin{array}{cc}{C}_{\max }-F_{\mathrm{basket}}\left(L\right),& \mathrm{iff}\left(L\right)<C_{\max }\\ 0& \mathrm{iff}\left(L\right)\&GreaterEqual;C_{\max }\end{array}\right.$

步骤3：检查是否已经达到最优结果，如果是转到步骤6，返回最优的染色体，否则继续；

步骤4：使用选择、交叉、变异，产生新一代n个染色体；

步骤5：利用新一带染色体代替老的染色体，转到步骤2

步骤6：将染色体解码，获得最优r₁，r₂，L，r_L。

步骤7：通过式(3)计算每档的映射函数个数k_i(1≤i≤L)，此时借助k_i可以完成集合到向量的映射和集合元素查询过程，并且可以使集合整体查询代价最小。

考虑到式(2)每个子项n_ic_if_i，n_i和c_i是独立于f_i的常数，所以乘积n_ic_i越大，f_i越小，这样整体查询失效代价减小，f_i越小，就要求该子集合的映射函数越多，k_i就越大，对应得r_i就越大，所以本发明设计类目标函数梯度适应度值函数，首先将元组(n_ic_i，r_i)根据n_ic_i从小到大排列，取此时r_i的逆序数带入适应值函数。

这里的适应值函数采用类目标函数梯度适应值函数：

F(L)＝λf(L)+(1-λ)f(L)/inverse_number    (22)

其中

$f\left(L\right)=\left\{\begin{array}{cc}{C}_{\max }-F_{\mathrm{basket}}\left(L\right),& \mathrm{iff}\left(L\right)<C_{\max }\\ 0& \mathrm{iff}\left(L\right)\&GreaterEqual;C_{\max }\end{array}\right.---\left(23\right)$

inverse_number＝τ(r₁，r₂，L，r_L)取的是逆序数，如：τ(1，2，3，4，5)＝0+0+0+0+0＝0，τ(1，4，2，3，5)＝0+2+0+0+0＝2。

1.计算代价比较

对于BBF而言完成集合到向量映射需要进行哈希计算的总次数记为：

  C_basket＝n₁k₁+n₂k₂+L+n_Lk_L                                (24)对于SBF而言哈希计算总次数为：

  C_standard＝(n₁+n₂+L+n_L)·k                              (25)

将 $k_i=\ln 2\&CenterDot;\left(\frac{r_{i}m}{\underset{j=1}{\overset{L}{\mathrm{\&Sigma;}}}{n}_j{r}_i}\right)$ 带入式(24)，得：

C_basket＝(n₁k₁+n₂k₂+L+n_Lk_L)

$=\ln 2(\frac{n_1{r}_{1}m}{\underset{j=1}{\overset{L}{\mathrm{\&Sigma;}}}{n}_j{r}_j}+\frac{n_2{r}_{2}m}{\underset{j=1}{\overset{L}{\mathrm{\&Sigma;}}}{n}_j{r}_j}+L+\frac{n_L{r}_{L}m}{\underset{j=1}{\overset{L}{\mathrm{\&Sigma;}}}{n}_j{r}_j})---\left(26\right)$

$\begin{array}{c}=\ln 2\left(\frac{n_1{r}_1+n_2{r}_2+L+n_L{r}_L}{\underset{j=1}{\overset{L}{\mathrm{\&Sigma;}}}{n}_j{r}_j}\right)m\\ =\ln \left(2\right)\&CenterDot;m\end{array}$

$k=\ln \left(2\right)\left(\frac{m}{\underset{i=1}{\overset{L}{\mathrm{\&Sigma;}}}{n}_i}\right)$ 代入式(25)中， 得：

C_standard＝ln(2)m                                              (27)

这说明分档Bloom Filter和标准Bloom Filter两者计算时间相同。

2.查询代价比较：

参见图1、图2，图中横坐标表示遗传算法代数，纵坐标表示查询代价数。图1是以三档数据为例：图1(a)、图1(b)和图1(c)的向量长度分别为900bit、1050bit和1200bit，图1(a)BBF通过7代遗传得到整体代价为48.98438，比SBF的代价减少77.1％，此时三档BBF用于集合映射的实现参数是：{k₁，k₂，k₃，}={6，6，2}。图1(b)通过1代遗传达到最小查询代价36.36719，比SBF减少代价66％。图1(c)通过14代遗传达到24.49219，通过染色体解码，此时的每档映射需要的哈希函数个数为{k₁，k₂，k₃，}＝{7，7，3}。

图2以六档数据为例，对查询代价进行比较。

                                    表1

Baskets	Element number	Element cost	SBF	BBF	％
						2345678910	{31，46}{95，56，28}{91，47，23，32}{48，66，37，30，82}{40，34，26，48，94，42}{61，68，63，45，44，81，77}{64，27，36，79，33，24，34，26}{71，84，39，91，48，63，45，29，77}{34，32，42，38，23，42，27，92，36，22}	{20，2}{17，2，1}{14，6，9，1}{19，11，7，5，1}{20，15，15，4，2，2}{16，14，12，15，6，2，2}{10，17，9，3，6，7，3，1}{16，13，19，6，3，2，2，3，1}{20，20，13，10，15，8，11，3，6，3}	22.25219.375112.1875133.0625135.25492.37567.3125504.875118.1875	7.718867.234451.187572.2553.2813256.343837.6992260.37562.7734	35％31％46％54％39％52％56％52％53％

表1是2～10档数据使用标准Bloom Filter和分档Bloom Filter产生的整体查询失效代价比较表。每档元素个数和代价都是随机产生。第一列为档数；每档子集的元素个数和元素查询失效代价为第2、3列；第4、5列分别表示标准Bloom Filter和分档Bloom Filter的集合整体查询失效代价；最后一列表示分档整体失效代价占标准代价的比率。从表中我们发现这些比率都小于60％，分档Bloom Filter的代价和标准Bloom Filter相比，失效代价至少降低40％，使用分档Bloom Filter可以使集合整体失效代价显著减少，大大提高Bloom Filter性能。

由以上可知，本发明为一种基于分档Bloom Filter结构的查询方法，该方法将查询代价引入Bloom Filter研究领域，研究当集合进行查询时，查询失效时的额外I/O操作代价，进而将元素根据不同的查询代价分为不同的档(子集)，通过考查每档查询失效率的关系，建立由每档子集合最低假阳性率表示的集合整体最小查询失效代价目标函数，使用类目标函数梯度遗传算法获得每档的最优哈希函数个数ki(1≤i≤L)；本发明与Bloom Filter研究领域的其他算法结构相比，所需计算时间相同，集合总体查询失效代价降低至少40％，实现了集合的总体查询代价最小。

附图说明

图1是以三档数据为例的查询代价比较曲线，其中：BBF＝{{55，30，95}，{19，19，1}，m，{k₁，k₂，k₃}}；

图2是以六档数据为例的查询代价比较曲线，其中：BBF＝{{80，28，25，84，27，38}，{9，10，16，1，2，1}，m，{k₁，k₂，k₃，k₄，k₅，k₆}}；

图3是基于代理的文件系统结构；

图4是请求消息传输路径示意图。

具体实施方式

本实施例是BBF在一个使用文件代理的系统中的应用。

图3是利用代理的文件系统。其底层是工作站主机，中间是层层文件代理，最后是终极网络文件服务器。同级代理采用合作方式，定期的将自己存储的文件目录用BBF表示成摘要后传给其他的代理，以维护网络上文件列表的一致。在这个系统中，由于安全原因，工作站主机会不定期的更新操作系统补丁或更新防病毒软件的病毒库，同时，工作站之间可能有一些普通文件的交换。因此，我们将文件从安全的角度出发，按照其对机器的影响后果分为四类：关键系统补丁文件、病毒库更新文件、系统运行文件、普通用户文件。当网络中系统出现严重安全漏洞时如不及时打上系统补丁，就可能导致系统出现崩溃，甚至央及整个网络无法正常运行(如worm病毒针对系统漏洞的攻击会导致网络阻塞)。因此关键系统补丁文件在BBF中定义成等级最高，处理中会得到最小的查找失效率。

在系统结构中用了代理，其目的是为了减少工作站主机到服务器的直接流量和减少服务器的负载。因为工作站主机从比较近的代理上获取文件远比从远端服务器上获取文件速度快，而且当多个工作站主机从代理上获取文件时，可以有效的减少服务器到代理之间的链路拥挤程度，从而节约网络带宽，降低网络服务器的负荷。

同级代理之间的文件查找和交互过程中，在传统的采用ICP协议进行文件查找的过程中，文件请求报文以广播的形式在代理之间发出。假设有n个代理，如果时间t每个代理平均需要查找m个文件，则需要发送的报文请求量为m·n·(n-1)，这将占用大量的网络带宽，导致网络拥塞。为了减少广播请求，我们在每个代理中存储其它同级代理的文件目录，当工作站主机的文件查找请求到达某个代理时，代理不再将请求以广播的形式发送出去，而是直接在Cache中查找其他同级代理的文件目录，并将结果返回给工作站主机。

同时，在代理的设计中，为了加速查找过程，将代理中的文件目录存储到代理的高速缓存DRAM中。由于DRAM价格昂贵且容量有限，不适合存放大的存储结构，需要采用一种简洁的结构来表示其文件目录，BBF正是这么一种简洁的结构，它对每条文件目录的存储只需要几位比特，因此利用BBF在Cache系统中存储文件目录摘要很合适；更重要的是，代理和代理之间的传输信息也用BBF表示，可以减少传输的带宽。另外，我们提到在该系统中根据文件安全等级分为四类，使用BBF可以调整不同类别文件的查询失效概率，降低重要类别文件查询失效概率，从而使得整体失效代价降低，提高系统的安全性。

使用BBF的文件下载过程如下：

1.客户将文件下载请求传输到其负责的代理服务器。

2.代理首先在Cache中表示自身文件目录的BBF中查找文件，如果找到，就到自身的硬盘获取数据，如果没有，就查找在本代理保存的其他代理的文件目录BBF。

3.如果在某个其他的BBF上找到文件，那么就到该代理服务器去下载文件。

4.如果同级的代理服务器没有对应文件，将文件查找请求传送给上级。现在我们就举一个该环境下的实际的例子，对于不同的文件类型，按照其对系统安全的影响，分为以下四个等级，并简单估计后果为：

1、关键系统补丁文件：如果没有及时打上该补丁，可能会照成系统崩溃或者影响网络中其他的主机运行(后果损失：100)。

2、病毒库更新文件：感染病毒，机器运行速度变慢，或者删除文件，照成数据丢失(后果损失：60)。

3、系统运行文件：直接影响操作系统运行的文件(后果损失：40)。

4、普通用户文件：普通的用户文件(后果损失：20)。

在某段时间内，出现的关键系统补丁文件有20个，病毒库更新文件：25个，系统运行文件30个，普通用户文件40个。代理之间用于交互的文件目录BBF表示为1000Bit。

第一步：根据文件的属性，将文件分为系统补丁文件、病毒库更新文件、系统运行文件和普通用户文件四类，完成BBF数据结构参数，就上面的例子，其表示为：BBF＝{{20，25，30，40}，{100，60，40，20}，1000，{k₁，k₂，k₃，k₄}}

第二步：建立查询失效引起的安全代价最小目标函数：

$F_{\mathrm{baskets}}\left(L\right)=\underset{i=1}{\overset{L}{\mathrm{\&Sigma;}}}{n}_i{c}_i{\left(\frac{1}{2}\right)}^{\mathrm{lm}2\&CenterDot;(r_i*1000/\left(\underset{i=1}{\overset{4}{\mathrm{\&Sigma;}}}{n}_i{r}_i\right))}$

第三步：利用类目标函数梯度遗传算法求解{r₁，r₂，r₃，r₄}，并获得最小安全失效代价。

第四步：利用{r₁，r₂，r₃，r₄}计算出{k₁，k₂，k₃，k₄}＝{8，8，6，6}。

那么对于第一类文件(关键系统补丁文件)，在进行元素查找时利用8个哈希函数映射，第二类的文件(病毒库更新文件)利用8个哈希函数，第三类的文件(系统运行文件)用6个哈希函数映射，第四类的文件(用户文件)用6个哈希函数映射。

如用SBF，系统一共需要付出的安全代价为：78.1250。用BBF需要付出的安全代价为：42.9688。使用BBF使得这段时间的系统安全损失减少了45％，显著减少了系统的损失，提高了计算机系统的安全性。

Claims (1)

1、一种基于分档Bloom Filter结构的查询方法，其特征是将集合中的元素按照查询失效代价分为不同的子集合，并区分对待各子集合，为不同子集合分配不同的哈希映射函数个数，使得集合整体查询失效代价最小，该方法的步骤为：

(1)按照集合中元素的查询代价分为不同的子集合；

设集合S包含L档，则：

                   S＝{{S₁}，{S₂}，L，{S_L}}

(2)建立由每档子集合最低假阳性率表示的集合整体最小查询代价目标函数：

$F_{\mathrm{baskets}}\left(L\right)=\underset{i=1}{\overset{L}{\mathrm{\&Sigma;}}}{n}_i{c}_i{f}_i=\underset{i=1}{\overset{L}{\mathrm{\&Sigma;}}}{n}_i{c}_i{\left(\frac{1}{2}\right)}^{\ln 2\&CenterDot;\left(\frac{r_{i}m}{\underset{i=1}{\overset{L}{\mathrm{\&Sigma;}}}{n}_j{r}_j}\right)}$

上式中，每档子集合的元素个数为n_i＝|S_i|，子集合S_i中元素发生查询失效时，所需的额外I/O操作代价为c_i(1≤i≤L)，子集合S_i所需要的哈希映射函数个数为k_i(1≤i≤L)，对应的假阳性概率为f_i(1≤i≤L)，映射到长度为m的位串向量V。其中r_i＝ln(f_i)(1≤i≤L)；

(3)利用类目标函数梯度遗传算法求解最小查询代价目标函数，获得r_i(1≤i≤L)，步骤是：

步骤1：随机产生规模为n二进制编码染色体，每个染色体代表一个r₁，r₂，L，r_L序列；

步骤2：利用类目标函数梯度适应值函数计算每个染色体的适应值；

类目标函数梯度适应值函数为：

                    F(L)＝λf(L)+(1-λ)f(L)/inverse_number

其中inverse_number＝τ(r₁，r₂，L，r_L)为逆序数

$f\left(L\right)=\left\{\begin{array}{cc}{C}_{\max }-F_{\mathrm{basket}}\left(L\right),& \mathrm{if\; f}\left(L\right)<C_{\max }\\ 0& \mathrm{if\; f}\left(L\right)\&GreaterEqual;C_{\max }\end{array}\right.$

步骤3：检查是否已经达到最优结果，如果是转到步骤6，返回最优的染色体，否则继续；

步骤4：使用选择、交叉、变异，产生新一代n个染色体；

步骤5：利用新一带染色体代替老的染色体，转到步骤2：

步骤6：将染色体解码，获得r₁，r₂，L，r_L；

步骤7：求解获得每档映射哈希函数个数k_i(1≤i≤L)：

$k_i=\ln 2\&CenterDot;\left(\frac{r_{i}m}{\underset{j=1}{\overset{L}{\mathrm{\&Sigma;}}}{n}_j{r}_j}\right)$

(4)利用k_i(1≤i≤L)完成集合到向量的映射与集合元素查找。

Images