CN102902713A - 一种基于图形处理单元的非确定有限自动机的匹配方法及装置 - Google Patents

Abstract

本发明公开了一种基于图形处理单元的非确定有限自动机的匹配方法及装置，其包括：首先，计算非确定有限自动机NFA中所有状态两两之间的相容性，并根据所述相容性对所述各个状态进行编码形成虚拟NFA，获得虚拟NFA对应的虚拟NFA状态转换表；其中，所述相容性是指，若NFA中的两个状态在NFA匹配过程中不同时处于活跃状态，则该两个状态相容，否则，为不相容；之后，将所述虚拟NFA状态转换表存储在图形处理单元GPU的全局存储器中，并基于该虚拟NFA状态转换表匹配经过交织处理的待处理数据包中数据。本发明实施例的实现可以有效降低匹配过程中的复杂程度，提高基于NFA的匹配速度，很好地当前克服了现有技术中存在的问题。

Description

一种基于图形处理单元的非确定有限自动机的匹配方法及装置

技术领域

本发明涉及计算机应用技术领域，尤其涉及一种基于GPU（graphic processing unit，图形处理单元）的NFA（non-deterministic finite automaton，非确定性有限自动机）的匹配方法及装置。 

背景技术

在计算机技术领域中，正则表达式是用来描述或者匹配一系列符合某个句法规则的字符串的单个字符串。在很多文本编辑器或其他工具里，正则表达式通常被用来检索和/或替换那些符合某个模式的文本内容。目前，许多程序设计语言都支持利用正则表达式进行字符串操作。正则表达式在现代计算机应用领域使用十分广泛，正则表达式因其简洁、高效、强大的文本处理能力得到普遍认可和采用。 

一个正则表达式是一个模式，描述符合一系列句法规则的字符串；在具体匹配操作当中，通常是将正则表达式通过标准的Thompson算法或者Glushkov算法等算法转换为NFA（non-deterministic finite automaton，非确定性有限自动机）或者DFA（deterministic finite automaton，确定性有限自动机），然后借助有限自动机完成匹配操作。基于有限自动机的正则表达式匹配技术需要解决的两大难题：存储体积和匹配速度，亦即时间复杂度和空间复杂度；在这两个衡量指标上DFA和NFA互有优劣。 

其中，DFA中每个源状态对于输入字符转移到一个唯一的目的状态，即在DFA运行过程中，有且仅有一个活跃状态，DFA的匹配特征是确定和简单的，但是DFA需要存储状态的空间可能呈现指数级膨胀，最极端的情况下，具有N个状态的NFA其等价的DFA可能有多大2^N个状态。 

相比DFA，相应的NFA的存储体积不存在指数膨胀问题，与正则表达式规则集大小呈现线性增长关系，但是在NFA匹配过程中，NFA包含的每一个状态对于一个输入字符，可能会有多个目的状态被激活，因此在NFA的运行过程中会有数目不确定的状态处于激活状态，这些活跃状态组成一个活跃状态集合，因此，在NFA的匹配过程中，需要维护一个活跃状态集合，针对输入字符的转换表现为状态集合之间的转换，相应的匹配过程比DFA下的匹配过程复杂，导致NFA匹配效率较低。目前还没有一种方式能够降低NFA匹配过程中的复杂程度，以有效提高相应的NFA匹配过程中的效率。 

发明内容

本发明的目的是提供一种基于图形处理单元的非确定有限自动机的匹配方法及装置，从而可以降低NFA匹配过程中的复杂程度，有效提高NFA匹配效率。 

本发明的目的是通过以下技术方案实现的： 

一种基于图形处理单元的非确定有限自动机的匹配方法，包括： 

计算非确定有限自动机NFA中所有状态两两之间的相容性，并根据所述相容性对所述各个状态进 行编码形成虚拟NFA，以获得虚拟NFA对应的虚拟NFA状态转换表；其中，所述相容性是指，若NFA中的两个状态在NFA匹配过程中不同时处于活跃状态，则该两个状态相容，否则，为不相容； 

将所述虚拟NFA状态转换表存储在图形处理单元GPU的全局存储器中，并基于该虚拟N FA状态转换表匹配经过交织处理的待处理数据包中数据。 

可选地，所述计算NFA中所有状态两两之间的相容性的步骤包括： 

针对NFA状态建立N×N的二维表，N为NFA的状态数目，NFA状态依次为0，1，2，…，N-1；在该二维表中，第i+1行和第j+1列的表项由[i，j]表示；如果状态i和j是相容的，则表项[i，j]内容设置为true，如果状态i和j是不相容的，则表项[i，j]内容设置为false；其中，分别将表项[0，0]，[1，1]，[2，2]，…，[N-1，N-1]的内容置为false； 

建立初始为空的第一队列queue并进行初始化，依次将状态对(0，0)，(1，1)，(2，2)，…，(N-1，N-1)压入第一队列queue中； 

弹出第一队列queue首部的状态对(i，j)，使用状态i，j遍历全部可能的输入字符0-255查询NFA状态，其中，以当前输入字符作为转换字符，以状态i为源状态，查询该NFA状态获得目的状态集合Di，以状态j为源状态，查询该NFA状态获得目的状态集合Dj；检查状态集合Di和状态集合Dj的并集Di∪Dj，并将该并集当中的任意两个状态所组成的状态对（s，t）对应的所述二维表表项内容置为false，若状态对（s，t）所对应的二维表表项中的内容之前记录为true，则还需要将状态对（s，t）压入第一队列queue的尾部； 

判断第一队列queue是否非空，如果是，过程结束，否则，继续再执行所述弹出第一队列queue首部的状态对(i，j)的步骤。 

可选地，所述根据所述相容性对所述各个状态进行编码形成虚拟NFA的步骤包括： 

根据所述相容性将NFA中的所有状态分组，获得至少一个相容组，所述相容组中的任意两个状态之间相容； 

将得到的所述相容组合并获得超级相容组，再对所述超级相容组进行编码形成虚拟状态，并获得虚拟NFA。 

可选地，所述根据所述相容性将NFA中的所有状态分组，获得至少一个相容组的步骤包括： 

获得空的第二队列queue，在建立的无向图中一次或多次选取边度数最大的一条边，将该边对应的两个顶点对应的状态压入所述第二队列queue，并从该无向图当中去除这条边，更新剩余无向图当中各项顶点度数和边度数；其中，所述无向图的顶点为NFA的一个状态，边为NFA中两个不相容的状态对应的顶点之间的连线，顶点度数为与该顶点相连的边的总数目，边度数为该边所关联的两个顶点的顶点度数之和； 

在建立的无向图中一次或多次选取边度数最大的一条边的过程中，若当前被选中边从无向图当中移除，剩余图变为空，则这条边不压入第二队列queue，拆分这条边的两个关联顶点，各自构成一个单元素的独立集，再使用第二队列queue中收集的边对应的状态对构成新的无向图，并执行所述获得空的第二队列queue的步骤，所述的独立集对应一个相容组；若剩余无向图中不存在边并且非空，则将无向图中剩余顶点构成一个顶点独立集，将第二队列queue中与该独立集中的状态相容的NFA状态 加入该独立集中，再使用第二队列queue中剩余的顶点构成新的无向图，并执行所述获得空的第二队列queue的步骤；若第二队列queue空，则过程结束。 

可选地，所述将得到的所述相容组合并获得超级相容组的步骤包括： 

按照相容组状态数的大小进行降序排序，得到降序排列的相容组集合； 

从所述降序排列的相容组集合中依次顺序取出相容组并加入到当前占用比特数最少的超级相容组当中，同时更新该超级相容组占用的比特数，其中，每个超级相容组初始占用的比特数为0。 

6、根据权利要求3所述的方法，其特征在于，所述获得虚拟NFA的步骤包括： 

在超级相容组中，对各个相容组包含的状态进行编码，获得相容组的组内状态的编码作为组状态编码结果，还对超级相容组的组编号进行编码，获得组编号编码结果； 

将所述组状态编码结果与所述组编号编码结果联结，构成该超级相容组中虚拟状态的完整的编码，获得虚拟NFA的状态，还建立所述虚拟NFA状态之间的转换关系，获得包含虚拟NFA状态和虚拟NFA状态之间的转换关系的虚拟NFA，用于获得虚拟NFA对应的虚拟NFA状态转换表。 

可选地，建立所述虚拟NFA状态之间的转换关系的处理包括： 

以所述虚拟状态作为源状态，对于输入字符进行状态转换，根据所述组状态编码结果，分别针对输入字符按照NFA中状态转换关系进行状态转换，得到各自的目的状态集合，再将目的状态集合当中的状态按照所属的相容组的不同归入不同的超级相容组当中，并进行连接构成目的虚拟状态，以建立源虚拟状态到目的虚拟状态间的转换关系，即建立虚拟NFA之间的转换关系。 

可选地，所述交织处理包括： 

若图形处理单元GPU并行处理的数据包的数目为P，则将数据包内的数据划分为等长W字节的数据分片，并在存储所述数据包时，相邻的数据分片彼此相距P×W字节的存储，以实现针对所述数据包的交织处理；其中，对于数据包进行数据分片的划分时，如果存在数据分片的实际长度小于W字节，则使用0x00进行填充直至满足W字节。 

可选地，所述基于该虚拟NFA匹配经过交织处理的待处理数据包中数据的步骤包括： 

线程分片中的各个线程依据自身线程编号计算索引值来读出位于全局存储器的数据包中不同的数据，并将读出的数据存入共享存储器，其中，所述线程分片是由GPU线程束中的连续若干个线程构成； 

线程分片中的各个线程依据自身线程编号计算出索引值访问位于共享存储器当中的活跃状态表中不同的位置，各个线程读出一个活跃状态编号，并清空该活跃状态表； 

线程分片从所述共享存储器中直接读取所述数据，并将其各个字节作为输入字符，再以各个线程所持有的状态编号作为行坐标，以当前的输入字符作为列坐标，索引查询所述虚拟NFA对应的虚拟NFA状态转换表，分别得到状态集合；其中，所述虚拟NFA状态转换表包括超级相容组当中的虚拟NFA状态以及各个虚拟NFA状态之间的转换关； 

在得到的所述状态集合中，对于任一个集合中的各个状态，根据各个线程的线程编号及对应的各个线程读出的活跃状态编号中集成的组编号，确定该状态在所述活跃状态表当中存储的位置，并将该状态的组编码值写入至所述活跃状态表中的该位置，所述的组编码值包含对超级相容组中的虚拟NFA 状态进行编码获得的组状态编码结果和对超级相容组的组编号进行编码获得组编号编码结果； 

若当前处理的状态为接受状态时，则标记当前正处理的数据包，否则不标记； 

继续处理所述数据包中后续数据，直至数据包中的数据处理完毕。 

一种基于图形处理单元的非确定有限自动机的匹配装置，包括： 

虚拟NFA建立模块，用于计算非确定有限自动机NFA中所有状态两两之间的相容性，并根据所述相容性对所述各个状态进行编码形成虚拟NFA，获得虚拟NFA对应的虚拟NFA状态转换表；其中，所述相容性是指，若NFA中的两个状态在NFA匹配过程中不同时处于活跃状态，则该两个状态相容，否则，为不相容； 

匹配处理模块，用于将所述虚拟NFA建立模块获得的虚拟NFA状态转换表存储在图形处理单元GPU的全局存储器中，并基于该虚拟NFA状态转换表匹配经过交织处理的待处理数据包中数据。 

可选地，所述虚拟NFA建立模块为执行计算NFA中所有状态两两之间的相容性的处理，则包括： 

状态表建立模块，用于针对NFA状态建立N×N的二维表，N为NFA的状态数目，NFA状态依次为0，1，2，…，N-1；在该二维表中，第i+1行和第j+1列的表项由[i，j]表示；如果状态i和j是相容的，则表项[i，j]内容设置为true，如果状态i和j是不相容的，则表项[i，j]内容设置为false；其中，分别将表项[0，0]，[1，1]，[2，2]，…，[N-1，N-1]的内容置为false； 

第一队列建立模块，用于建立初始为空的第一队列queue并进行初始化，依次将状态对(0，0)，(1，1)，(2,2)，…，(N-1，N-1)压入第一队列queue中； 

二维表调整模块，用于弹出所述第一队列建立模块建立的第一队列queue首部的状态对(i，j)，使用状态i，j遍历全部可能的输入字符0-255查询NFA状态，其中，以当前输入字符作为转换字符，以状态i为源状态，查询该NFA状态获得目的状态集合Di，以状态j为源状态，查询该NFA状态获得目的状态集合Dj；检查状态集合Di和状态集合Dj的并集Di∪Dj，并将该并集当中的任意两个状态所组成的状态对（s，t）对应的所述状态表建立模块建立的二维表表项内容置为false，若状态对（s，t）所对应的二维表表项中的内容之前记录为true，则还需要将状态对（s，t）压入第一队列queue的尾部； 

判断模块，用于在所述二维表调整模块执行操作后，判断所述第一队列queue是否非空，如果是，过程结束，否则，通知所述二维表调整模块，以继续再执行所述弹出第一队列queue首部的状态对(i，j)的步骤。 

可选地，所述虚拟NFA建立模块为执行根据所述相容性对所述各个状态进行编码形成虚拟NFA的处理，则包括： 

相容组建立模块，用于根据所述相容性将NFA中的所有状态分组，获得至少一个相容组，所述相容组中的任意两个状态之间相容； 

获得虚拟NFA模块，用于将所述相容组建立模块得到的所述相容组合并获得超级相容组，再对所述超级相容组进行编码形成虚拟状态，获得虚拟NFA。 

可选地，所述相容组建立模块包括： 

第二队列处理模块，用于获得空的第二队列queue，在建立的无向图中一次或多次选取边度数最大的一条边，将该边对应的两个顶点对应的状态压入所述第二队列queue，并从该无向图当中去除这 条边，更新剩余无向图当中各项顶点度数和边度数；其中，所述无向图的顶点为NFA的一个状态，边为NFA中两个不相容的状态对应的顶点之间的连线，顶点度数为与该顶点相连的边的总数目，边度数为该边所关联的两个顶点的顶点度数之和； 

无向图处理模块，用于所述第二队列处理模块在建立的无向图中一次或多次选取边度数最大的一条边的过程中，若当前被选中边从无向图当中移除，剩余图变为空，则通知所述第二队列处理模块这条边不压入第二队列queue，拆分这条边的两个关联顶点，各自构成一个单元素的独立集，再使用第二队列queue中收集的边对应的状态对构成新的无向图，并通知所述第二队列处理模块执行所述获得空的第二队列queue的处理，所述的独立集对应一个相容组；若剩余无向图中不存在边并且非空，则将无向图中剩余顶点构成一个顶点独立集，将所述第二队列queue中与该独立集中的状态相容的NFA状态加入该独立集中，再使用第二队列queue中剩余的顶点构成新的无向图，并通知所述第二队列处理模块执行所述获得空的第二队列queue的处理；若第二队列queue空，则过程结束。 

可选地，所述获得虚拟NFA模块为执行将得到的所述相容组合并获得超级相容组的处理，则包括： 

排序处理模块，用于按照相容组状态数的大小进行降序排序，得到降序排列的相容组集合； 

超级相容组建立模块，用于从所述排序处理模块得到的降序排列的相容组集合中依次顺序取出相容组并加入到当前占用比特数最少的超级相容组当中，并同时更新该超级相容组占用的比特数，其中，每个超级相容组初始占用的比特数为0。 

可选地，所述获得虚拟NFA模块为执行获得虚拟NFA的处理，则包括： 

相容组编码模块，用于在所述超级相容组建立模块建立的超级相容组中，对各个相容组包含的状态进行编码，获得相容组的组内状态的编码作为组状态编码结果，还对超级相容组的组编号进行编码，获得组编号编码结果； 

虚拟NFA获得子模块，用于将所述相容组编码模块获得的组状态编码结果与组编号编码结果联结，构成该超级相容组中虚拟状态的完整的编码，获得虚拟NFA的状态，还建立所述虚拟NFA状态之间的转换关系，获得包含虚拟NFA状态和虚拟NFA状态之间的转换关系的虚拟NFA。 

可选地，所述虚拟NFA获得子模块建立所述虚拟NFA状态之间的转换关系的处理包括： 

以所述虚拟状态作为源状态，对于输入字符进行状态转换，根据所述组状态编码结果，分别针对输入字符按照NFA中状态转换关系进行状态转换，得到各自的目的状态集合，再将目的状态集合当中的状态按照所属的相容组的不同归入不同的超级相容组当中，并进行连接构成目的虚拟状态，以建立源虚拟状态到目的虚拟状态间的转换关系，即建立虚拟NFA之间的转换关系。 

可选地，所述匹配处理模块执行的交织处理具体包括： 

若图形处理单元GPU并行处理的数据包的数目为P，则将数据包内的数据划分为等长W字节的数据分片，并在存储所述数据包时，相邻的数据分片彼此相距P×W字节的存储，以实现针对所述数据包的交织处理；其中，对于数据包进行数据分片的划分时，如果存在数据分片的实际长度小于W字节，则使用0x00进行填充直至满足W字节。 

可选地，所述匹配处理模块为执行基于该虚拟NFA匹配经过交织处理的待处理数据包中数据的处 理，则包括： 

数据读取模块，用于通过线程分片中的各个线程依据自身线程编号计算索引值来读出位于全局存储器的数据包中不同的数据，并将读出的数据存入共享存储器，其中，所述线程分片是由GPU线程束中的连续若干个线程构成； 

活跃状态表操作模块，用于通过线程分片中的各个线程依据自身线程编号计算出索引值访问位于共享存储器当中的活跃状态表中不同的位置，各个线程读出一个活跃状态编号，并清空该活跃状态表； 

状态匹配模块，用于通过线程分片从所述数据读取模块存储有数据的共享存储器中直接读取所述数据，并将其各个字节作为输入字符，再以各个线程所持有的通过所述活跃状态表操作模块读出的活跃状态编号作为行坐标，以该输入字符作为列坐标，索引查询虚拟NFA对应的虚拟NFA状态转换表，分别得到状态集合；其中，所述虚拟NFA状态转换表包括超级相容组当中的虚拟NFA状态以及各个虚拟NFA状态之间的转换关系； 

活跃状态表更新模块，用于在所述状态匹配模块得到的所述状态集合中，对于任一个集合中的各个状态，根据各个线程的线程编号及对应的所述各个线程读出的活跃状态编号中集成的组编号，确定该状态在所述活跃状态表当中存储的位置，并将该状态的组编码值写入至所述活跃状态表中的该位置，所述的组编码值包含对超级相容组中的虚拟NFA状态进行编码获得的组状态编码结果和对超级相容组的组编号进行编码获得组编号编码结果； 

数据包标记模块，用于在所述活跃状态表更新模块当前处理的状态为接受状态时，则标记当前正处理的数据包，否则不标记；之后，通知继续处理所述数据包中后续数据，直至数据包中的数据处理完毕。 

由上述本发明提供的技术方案可以看出，本发明实施例提供的技术方案中，采用了将NFA转换为等价的虚拟NFA的技术手段，在虚拟NFA中包含了各个状态之间的相容状况，使得在应用虚拟NFA匹配数据过程中能够有效降低匹配过程中的复杂程度，提高基于NFA的匹配速度，很好地当前克服了现有技术中存在的问题。 

附图说明

为了更清楚地说明本发明实施例的技术方案，下面将对实施例描述中所需要使用的附图作简单地介绍，显而易见地，下面描述中的附图仅仅是本发明的一些实施例，对于本领域的普通技术人员来讲，在不付出创造性劳动的前提下，还可以根据这些附图获得其他附图。 

图1为本发明实施例提供的匹配方法的流程图； 

图2为本发明实例提供的用于匹配正则表达式ab.＊cd和ef.＊gh的NFA的示意图； 

图3为本发明实例提供的计算NFA状态间相容性的示意图； 

图4为本发明实例提供的将NFA中状态划分为相容组时所构造的无向图的示意图； 

图5为本发明实例提供的将图2中NFA状态划分得到的相容组的示意图； 

图6为本发明实例提供的对于超级相容组当中状态进行编码的示意图； 

图7为本发明实例提供的将数据报数据进行交织存储的示意图； 

图8为本发明实例提供的GPU并行线程使用虚拟NFA处理数据的示意图； 

图9为本发明实例提供的匹配装置的结构示意图。 

具体实施方式

下面结合本发明实施例中的附图，对本发明实施例中的技术方案进行清楚、完整地描述，显然，所描述的实施例仅仅是本发明一部分实施例，而不是全部的实施例。基于本发明的实施例，本领域普通技术人员在没有做出创造性劳动前提下所获得的所有其他实施例，都属于本发明的保护范围。 

本发明实施例提供的一种基于图形处理单元的非确定有限自动机的匹配方法的具体实现过程可以包括： 

步骤1，计算非确定有限自动机NFA中所有状态两两之间的相容性，其中，相应的相容性是指，若NFA中的两个状态在NFA匹配过程中不同时处于活跃状态，则该两个状态相容，否则，为不相容； 

所述计算NFA中所有状态两两之间的相容性的步骤包括： 

针对NFA状态建立N×N的二维表，N为NFA的状态数目，NFA状态依次为0，1，2，…，N-1；在该二维表中，第i+1行和第j+1列的表项由[i，j]表示；如果状态i和j是相容的，则表项[i，j]内容设置为true，如果状态i和j是不相容的，则表项[i，j]内容设置为false；其中，分别将表项[0，0]，[1，1]，[2，2]，…，[N-1，N-1]的内容置为false； 

建立初始为空的第一队列queue并进行初始化，依次将状态对(0，0)，(1，1)，(2,2)，…，(N-1，N-1)压入第一队列queue中； 

弹出第一队列queue首部的状态对(i，j)，并使用该状态对i，j遍历全部可能的输入字符0-255查询NFA状态，其中，以当前输入字符作为转换字符，以状态i为源状态，查询该NFA状态获得目的状态集合Di，以状态j为源状态，查询该NFA状态获得目的状态集合Dj；再检查状态集合Di和状态集合Dj的并集Di∪Dj，并将该并集当中的任意两个状态所组成的状态对（s，t）对应的在所述二维表表项中的内容置为false，若状态对（s，t）所对应的二维表表项中的内容之前记录为true，则还需要将状态对（s，t）压入第一队列queue的尾部；即如果状态对（s，t）所对应的二维表表项中的内容已经为false，则该状态对(s，t)就不需要压入第一队列queue中； 

判断第一队列queue是否非空，如果是，过程结束，否则，继续再执行所述弹出第一队列queue首部的状态对(i，j)的步骤。 

步骤2，根据NFA状态之间的相容性对NFA状态包含的各个状态进行编码形成虚拟NFA，进而获得虚拟NFA对应的虚拟NFA状态转换表，具体地，在获得相应的虚拟NFA后便可以建立确定与其对应的虚拟NFA状态转换表，虚拟NFA状态转换表中记录了虚拟NFA状态和虚拟NFA状态之间的转换关系； 

其中，根据相容性对NFA包含的各个状态进行编码形成虚拟NFA的步骤包括： 

步骤21，根据NFA状态之间的相容性将NFA中的所有状态分组，获得至少一个相容组，在每个相容组中的任意两个状态之间相容； 

进一步地，根据所述相容性将NFA中的所有状态分组，获得至少一个相容组的步骤包括： 

获得空的第二队列queue，在建立的无向图中一次或多次选取边度数最大的一条边，将该边对应的两个顶点对应的状态压入所述第二队列queue，并从该无向图当中去除这条边，更新剩余无向图当中各项顶点度数和边度数；其中，所述无向图的顶点为NFA的一个状态，边为NFA中两个不相容的状态对应的顶点之间的连线，顶点度数为与该顶点相连的边的总数目，边度数为该边所关联的两个顶点的顶点度数之和； 

在建立的无向图中一次或多次选取边度数最大的一条边的过程中，若当前被选中边从无向图当中移除，剩余图变为空，则这条边不压入第二队列queue，拆分这条边的两个关联顶点，各自构成一个单元素的独立集，再使用第二队列queue中收集的边对应的状态对构成新的无向图，并执行所述获得空的第二队列queue的步骤，所述的独立集对应一个相容组；若剩余无向图中不存在边并且非空，则将无向图中剩余顶点构成一个顶点独立集，将第二队列queue中与该独立集中的状态相容的NFA状态加入该独立集中，再使用第二队列queue中剩余的顶点构成新的无向图，并执行所述获得空的第二队列queue的步骤；若第二队列queue空，则过程结束。 

步骤22，将得到的相容组合并获得超级相容组； 

具体地，将得到的相容组合并获得超级相容组的步骤具体可以包括： 

首先，按照相容组状态数的大小进行降序排序，得到降序排列的相容组集合； 

之后，从该降序排列的相容组集合中依次顺序取出相容组并加入到当前占用比特数最少的超级相容组当中，同时更新该超级相容组占用的比特数，以便于后续过程中再次将取出相容组准确地加入到当前占用比特数最少的超级相容组中，其中，每个超级相容组初始占用的比特数为0，之后，则根据加入到其中的相容组的情况实时调整对应的超级相容组占用的比特数。 

步骤23，对相应的超级相容组进行编码形成虚拟状态，获得虚拟NFA； 

进一步地，相应的获得虚拟NFA的步骤可以包括： 

首先，在超级相容组中，对各个相容组包含的状态进行编码，获得相容组的组内状态的编码作为组状态编码结果，还对超级相容组的组编号进行编码，即对若干个超级相容组的组编号（即当前超级相容组在所有超级相容组中的序号）进行编码，获得各个超级相容组的组编号编码结果，例如，假设有3个超级相容组，则相应的3个超级相容组的组编号二进制编码结果分别可以为：00,01，10； 

之后，再将上述组状态编码结果与组编号编码结果联结，构成该超级相容组中虚拟状态的完整的编码，获得虚拟NFA的状态，还建立所述虚拟NFA状态之间的转换关系，获得包含虚拟NFA状态和虚拟NFA状态之间的转换关系的虚拟NFA，以便于后续过程中可以基于该虚拟NFA获得虚拟NFA对应的虚拟NFA状态转换表； 

其中，建立相应的虚拟NFA状态之间的转换关系的处理可以包括： 

以所述虚拟状态作为源状态，对于输入字符进行状态转换，根据所述组状态编码结果，分别针对输入字符按照NFA中状态转换关系进行状态转换，得到各自的目的状态集合，再将目的状态集合当中的状态按照所属的相容组的不同归入不同的超级相容组当中，并进行连接构成目的虚拟状态，以建立源虚拟状态到目的虚拟状态间的转换关系，即建立虚拟NFA之间的转换关系。 

步骤3，将所述虚拟NFA状态转换表存储在图形处理单元GPU的全局存储器中，并基于该虚拟NFA状态转换表匹配经过交织处理的待处理数据包中数据； 

在该步骤中，相应的交织处理过程具体可以包括： 

若图形处理单元GPU并行处理的数据包的数目为P，则将数据包内的数据划分为等长W字节的数据分片，并在存储所述数据包时，相邻的数据分片彼此相距P×W字节的存储，以实现针对所述数据包的交织处理；其中，对于数据包进行数据分片的划分时，如果存在数据分片的实际长度小于W字节，则使用0x00进行填充直至满足W字节。 

进一步地，该步骤中的基于该虚拟NFA匹配经过交织处理的待处理数据包中数据的步骤具体可以包括： 

线程分片中的各个线程依据自身线程编号计算索引值来读出位于全局存储器的数据包中不同的数据，并将读出的数据存入共享存储器，其中，所述线程分片是由GPU线程束中的连续若干个线程构成； 

线程分片中的各个线程依据自身线程编号计算出索引值访问位于共享存储器当中的活跃状态表中不同的位置，各个线程读出一个活跃状态编号，并清空该活跃状态表； 

线程分片从所述共享存储器中直接读取所述数据，并将其各个字节作为输入字符，再以各个线程所持有的状态编号作为行坐标，以该输入字符作为列坐标，索引查询虚拟NFA对应的虚拟NFA状态转换表，分别得到状态集合；其中，所述虚拟NFA状态转换表由超级相容组当中的虚拟NFA状态以及各个虚拟NFA状态之间的转换关系构成； 

在得到的所述状态集合中，对于任一个集合中的各个状态，根据各个线程的线程编号及对应的各个线程读出的活跃状态编号中集成的组编号，确定该状态在所述活跃状态表当中存储的位置，并将该状态的组编码值写入至所述活跃状态表中的该位置，所述的组编码值包含对超级相容组中的虚拟NFA状态进行编码获得的组状态编码结果和对超级相容组的组编号进行编码获得组编号编码结果； 

若当前处理的状态为接受状态时，则标记当前正处理的数据包，否则不标记； 

继续处理所述数据包中后续数据，直至数据包中的数据处理完毕。 

为使本发明方案的目的、技术方案和创新点更加清楚，下面将结合附图，对本发明实施例进行清晰、完整地描述。 

本发明实施例提供的匹配方法的具体实现流程如图1所示，可以包括： 

步骤S101，计算NFA中所有状态彼此之间的相容性； 

上述相容性是指对于NFA中的任意两个状态i和j，如果它们在NFA的匹配过程当中不会同时处于活跃状态，则称这两个状态之间相容，否则称这两个状态之间是不相容； 

在确定NFA中的状态之间的相容性的过程中，具体可以采用逐步迭代的方式计算确定，相应的计算确定NFA所有状态两两之间的相容性过程可以包括： 

（11）假设NFA的状态数目记为N，且其状态依次为0，1，2，…，N-1，则建立一个N×N的二维表，记为compatible-table，用于记录NFA中的各状态之间的相容性； 

在compatible-table中，第i+1行和第j+1列的表项由compatible-table[i][j]表示（0≤i，j<N）；如果状态i和j之间相容，则表项compatible-table[i][j]和compatible-table[j][i]内容为true（真），如果状态i和j之间不相容，则表项compatible-table[i][j]和compatible-table[j][i]的内容均为false（假）； 

（12）建立第一队列queue并进行初始化；第一队列queue初始为空队列，对于NFA状态0，1，2，…，N-1，分别将表项compatible-table[0][0]，compatible-table[1][1]，compatible-table[2][2]，…，compatible-table[N-1][N-1]的内容置为false，其余表项均为true；同时依次将状态对(0，0)，(1，1)，(2，2)，…，(N-1，N-1)压入相应的第一队列queue中； 

（13）如果第一队列queue非空，则弹出队列首部的状态对(i，j)，使用这两个状态i和j遍历0-255共256种输入查询NFA；对于当前的某个输入字符c，以状态i为源状态，字符c为转换字符，查询该NFA获得目的状态集合Di；以状态j为源状态，字符c为转换字符，查询该NFA获得目的状态集合Dj； 

（14）获得步骤（13）中得到的状态集合Di和状态集合Dj的并集Di∪Dj，对于该并集当中的任意两个状态所组成的状态对(s，t)，如果表项compatible-table[s][t]（或者compatible-table[t][s]）的内容为true，则将该表项内容置为false，同时将状态对(s，t)压入队列queue的尾部，以实现针对建立的二维表中的各状态之间的相容性的识别记录； 

（15）判断上述第一队列是否非空，如果第一队列queue非空，返回执行步骤（13），否则，过程结束。 

通过上述计算处理过程可以看出，计算NFA所有状态之间相容性的过程中，若NFA的状态数为N，则至多需要进行N2次迭代就可以完成对所有状态的相容性计算。 

步骤S102，利用上述计算确定的相容性，将NFA状态划分到相容组中，该相容组是指在该相容组对应的一个状态集合中，任意两个状态之间均相容； 

在进行相容组的划分过程中，具体可以将NFA状态依据相容性进行分组的问题转换为等价的图论中求无向图独立集的问题。为便于对无向图的理解，下面首先对无向图中涉及的若干个概念进行描述，具体如下： 

顶点，在NFA中的一个状态即为无向图中的一个顶点； 

边，NFA中如果两个状态不相容，则在这两个状态所代表的顶点之间连接一条边，称为无向图中的边； 

顶点度数，对于无向图中的一个顶点，与该顶点连接的边的总的数目称作是该顶点的顶点度数； 

边度数，无向图中一条边所关联的两个顶点的顶点度数之和称作该边的边度数。 

下面将对通过求解无向图独立集的方式进行相容组的划分的过程进行描述。在该过程中，是在将NFA中的状态和状态间相容性关系转换为一张无向图后，计算无向图顶点独立集，每个独立集对应一个相容组。具体的处理步骤包括： 

（21）获得第二队列queue，如果第二队列queue已存在，则清空该队列，否则建立空的第二队列queue； 

（22）在当前的无向图中选取边度数最大的一条边，将该边压入第二队列queue中，同时从该无向图当中去除这条边，并更新剩余无向图当中各顶点度数和边度数； 

（23）判断是否出现以下任一种情况，若没有，则重复执行步骤（22），否则，执行以下两种情况中对应的处理： 

情况一，当某一条边被选中并从无向图当中移除时，剩余图变为空，则这条边不压入第一队列queue，而拆分这条边的两个关联顶点，各自构成一个单元素的独立集，然后使用第一队列queue当中收集的边对应的状态对（即一个边对应一个状态对）构成新的无向图，并重新执行步骤（21）； 

情况二，当剩余图中不存在边并且第二队列queue非空，则将剩余图中顶点构成一个顶点独立集，还将第二队列queue中可以放入该独立集的顶点加入到该独立集当中，之后使用队列当中剩余的顶点构成新的无向图，并重新执行步骤（21）；其中，可以放入该独立集的顶点是指第二队列queue中与上述一个顶点独立集中的状态相容的顶点。 

在上述处理过程中，如果第二队列queue为空，即NFA中的各个状态均划分到相应的相容组中，则处理过程结束。 

完成上述处理过程后，NFA中状态对应的顶点集合被划分为一个或者多个顶点独立集，即NFA中的状态被划分为与顶点独立集数目相同的相容组，每个顶点独立集中顶点由所代表的状态替换后便得到相应的一个相容组，整个NFA中状态最终被分入一个或多个相容组中，从而完成了相容组的划分操作。 

步骤S103，将上述步骤S102获得的相容组合并为超级相容组，该超级相容组是由一个或者多个相容组中的状态集合在一个分组中获得； 

在该步骤中，合并生成超级相容组的具体处理过程可以包括： 

（31）若将M个相容组{C₀，C₁，C₂，...，C_M-1}合并成K个超级相容组{S₀，S₁，S₂，...，S_K-1}，其中0<K≤M，K和M均为正整数，则需要按照各个相容组内状态数的大小进行降序排序，得到{C′₀，C′₁，C′₂，...，C′_M-1}，对于相容组C_i，其状态数记为|C_i|，对该集合中所有状态完成编码，至少需要的比特数为 

（32）建立K个超级相容组{S₀，S₁，S₂，...，S_K-1}，各个超级相容组初始时均为空集，即其所占用比特数均为0； 

（33）从降序排列的相容组集合{C′₀，C′₁，C′₂，...，C′_M-1}当中顺序依次取出相容组 

并将其加入到当前占用比特数最少的超级组S_k当中，并更新该超级相容组S_k占用的比特数；每个超级相容组当前占用的比特数为其所包含的相容组各自所占比特数之和，假设超级相容组S_k原有占用的比特数为B，加入相容组 

之后，所占用的比特数                                                   

步骤S104，对于超级相容组组内的状态进行重新编码，形成虚拟状态（即虚拟NFA的状态），并构造出虚拟NFA； 

通常一个超级相容组由若干个相容组组成，由这若干个相容组各自提供自身组内的一个状态进行联结，所构成的复合状态即为超级相容组的状态，称为虚拟状态，或称为虚拟NFA的状态； 

由于超级相容组首先是由相容组合并得来，因此，对于超级相容组中状态进行编码时，首先要完成对于相容组中的NFA状态的编码，在这些编码基础上构造出超级相容组中的状态的编码。具体的重新编码过程可以包括： 

（41）当前共有K个超级相容组{S₀，S₁，S₂，...，S_K-1}，依次对于各个超级相容组S_k进行编码，获得针对各个超级相容组S_k的组状态编码结果； 

具体地，超级相容组S_k由m（m>0)个相容组{C₀，C₁，C₂，...，C_m-1}组成，对于各个相容组C_j的组内状态进行编码，相容组C_j的状态数为|C_j|，编码后的状态编号为1，2，3，…，|C_j|，编码所需要的比特数为 

其中，编码值0分配给空状态，用于表示无效的状态；由于超级相容组S_k中单个状态S_j是一个比特向量，分别由来自构成超级相容组S_k的m个相容组的m个状态编码联结而成，因此S_j状态编码所占用的总比特数为 

（42）对超级相容组的组编号进行编码，获得若干个超级相容组的组编号编码结果；由于超级相容组数目为K，则对于组编号进行编码所需的比特数目为 

还将上述组状态编码结果与该组编号编码结果联结，即将该组编号与步骤（41）中编码得到的比特向量联结，构成该超级相容组中虚拟状态的完整的编码，即获得相应的虚拟NFA的状态； 

在上述处理过程结束时，即完成了对于各个超级相容组中虚拟状态的编码后，则以该虚拟状态作为源状态，对于输入字符进行状态转换，根据等价于构成虚拟状态编码的各个相容组编码（即相应的组状态编码结果），分别针对输入字符按照NFA中状态转换关系进行状态转换，得到各自的目的状态集合，再将目的状态集合当中的状态按照所属的相容组的不同归入不同的超级相容组当中，并进行连接构成目的虚拟状态，由此建立了源虚拟状态到目的虚拟状态间的转换关系，即建立虚拟NFA之间的转换关系。根据计算出的所有虚拟NFA之间的转换关系，再结合虚拟NFA状态，便组成了相应的虚拟NFA。 

步骤S105，对于待处理的输入数据包中数据进行交织处理； 

对于待处理的数据包中数据进行交织处理，目的是为了降低GPU在进行匹配操作时读入数据包数据的开销，提高匹配的吞吐率。 

假设GPU并行处理的数据包的数目为P，将数据包内的数据划分为等长（D字节）的数据分片，则具体采用的交织处理方式可以为：在存储相应的数据分片时，以相邻的数据分片彼此相距P×D字节的方式存储；其中，假设GPU的一个线程束中D个线程并行处理一个数据包当中的数据，D个线程可并行读入当前显存当中待处理数据包的D字节数据进入共享存储器（shared memory），此时称属于同一数据包的连续D字节数据称为一个数据分片，D为2的幂次且D≥W，W为GPU的一个线程束中的一个线程分片包含的连续的线程数量，即W个线程的线程编号是连续的； 

在上述处理过程中，在对于数据包进行数据分片的划分时，如果存在数据分片的实际长度小于D 字节的情形，则使用0x00进行填充直至满足D字节。 

步骤S106，利用GPU完成虚拟NFA匹配待处理数据包中的数据； 

将虚拟NFA状态之间的转换关系及相应的虚拟NFA状态以一张二维数组表示，二维数据的行数与虚拟NFA的状态数相等（该二维数组即为虚拟NFA状态转换表），二维数组的列数则为固定的256，对应256种输入字符，每一个表项为一个目的状态集合，由输入字符和源状态进行索引。该二维数组存入GPU的全局存储器当中，然后将这一存储器区域与纹理绑定使之成为纹理存储器； 

假设将M个相容组合并为K个超级相容组，且K=4；对待处理的数据包当中数据进行交织处理时，线程分片规模为W=4，数据分片大小为D=4；GPU一个线程束（warp）包含32个线程，按照线程编号顺序，每W=4个线程被划分为一个线程分片负责处理一个数据包，共可同时处理和匹配    

个数据包当中的数据。 

基于上述假设，在线程束当中，每W=4个编号相邻的线程组成一个线程分片，负责处理已经过交织的数据包中的数据，具体的处理步骤包括： 

（61）线程分片当中的各个线程依据自身线程编号计算索引值来访问位于全局存储器的数据包当中不同的数据，并将读出的数据存入共享存储器，每次访存W=4个线程共将D=4字节的数据存入共享存储器； 

（62）线程分片当中的各个线程依据自身线程编号计算出索引值，根据该索引值来访问位于共享存储器当中的活跃状态表中不同的位置，读出该位置的内容，该内容为一个当前活跃状态编号或者空状态0，之后清空该活跃状态表； 

（63）线程分片依次处理步骤（61）中读出的各个字节作为输入字符c，然后以线程分片中各个线程所持有的从步骤（62）得到的活跃状态编号作为行坐标，以字符c作为列坐标，索引查询相应的虚拟NFA状态转换表，分别得到状态集合{D0,D1，D2,D3}； 

（64）在步骤（63）中线程分片中各个线程共得到4个状态集合{D0,D1，D2,D3}，对于任一个集合Dj中的各个状态，根据各个线程的线程编号及对应的所述各个线程读出的活跃状态编号中集成的组编号，确定该状态在所述活跃状态表当中存储的位置，并将该状态的组编码值写入至活跃状态表中的该位置，具体可以将该状态NFA状态编号通过比特或（bitOR）操作写入至活跃状态表中的该位置，其中，相应的组编码值包含对超级相容组中的虚拟NFA状态进行编码获得的组状态编码结果和对超级相容组的组编号进行编码获得组编号编码结果； 

（65）当Dj的状态为接受状态时，则标记当前正处理的数据包，否则不标记。 

（66）判断数据包中的数据是否处理完毕，如果数据包中数据还未处理完毕，则返回步骤（61），否则，处理过程结束。 

通过上述处理可以看出，每个线程束包含32个线程，能够并行处理    

个数据包，同时借助交织技术有效降低各个线程读取数据包数据的代价，从而很好地提高了虚拟NFA匹配数据的速度。 

为便于对上述本发明实施例提供的处理过程的进一步理解，下面将结合具体的应用实例对本发明 实施例中涉及的各个处理过程所采用的处理方式进行详尽说明。 

（一）计算NFA所有状态两两之间的相容性的处理过程 

以下实施例均以正则表达式ab.＊cd和ef.＊gh所生成的NFA为例进行阐述，对于正则表达式ab.＊cd和ef.＊gh匹配的文本模式分别做一解释：正则表达式ab.＊cd首先匹配字符串ab，之后匹配任意字符出现零次或者任意多次，接下来匹配字符串cd；正则表达式ef.＊gh首先匹配字符串ef，之后匹配任意字符出现零次或者任意多次，接下来匹配字符串gh。 

使用标准的Thompson算法将上述两个正则表达式转换为NFA，如图2所示，图中圆圈中状态为NFA普通状态，双圈中状态为NFA接受状态，箭头表示NFA的状态转移关系，图2中7、8表示接受状态，7为对应于正则表达式ab.＊cd的接受状态，8为对应于正则表达式ef.＊gh的接受状态，0为起始状态。 

在图2中，NFA初始状态为0，此刻的活跃状态集合为{0}，在状态匹配过程的不断进行当中，活跃状态集合会不断发生变化，若输入字符串efg，则依次处理e，f，g过程中得到的活跃状态集合分别为{0，2}，{0，4}，{0，4，6}；从初始状态0出发，在匹配过程中得到的每个活跃状态集合遍历所有的输入字符，可以得到新的活跃状态集合，该过程结束可以得到所有的活跃状态集合，处于同一个活跃状态集合当中的任意两个状态不相容。 

相应的按照逐步迭代的方式计算NFA所有状态两两之间的相容性的处理过程包括： 

步骤1，NFA的状态数目记为N，其状态依次为0，1，2，…，N-1，在图2当中，NFA的状态数为9，即在图2示例中N=9； 

步骤2，建立一个N×N的二维表，记为compatible-table，第i+1行和第j+1列的表项由compatible-table[i][j]表示（0≤i，j<N）；如果状态i和j是相容的，那么表项compatible-table[i][j]和compatible-table[j][i]内容为true，如果状态i和j是不相容的，则表项compatible-table[i][j]和compatible-table[j][i]的内容为false； 

在图3当中，compatible-table的规模为9×9，如果状态i和状态j不相容，则compatible-table[i][j]和compatible-table[j][i]表项内容记为false，否则在图3中相应表项使用空白表示true；compatible-table在初始时各个表项均为空白，即表示各个表项的初始内容均为true； 

步骤3，建立第一队列queue并进行初始化，第一队列queue初始为空队列，对于NFA状态0，1，2，…，N-1，分别将表项compatible-table[0][0]，compatible-table[1][1]，compatible-table[2][2]，…，compatible-table[N-1][N-1]的内容置为false，其余表项均为true；同时依次将状态对(0，0)，(1，1)，(2，2)，…，(N-1，N-1)压入第一队列queue当中； 

在图3当中，相应的compatible[0][0]，compatible-table[1][1]，compatible-table[2][2]，…，compatible-table[9][9]的内容均修改为false； 

步骤4，如果第一队列queue非空，则弹出队列首部的状态对(i，j)，并使用这两个状态i和j遍历0-255这256种输入查询NFA；对于当前的某个输入字符c，以状态i为源状态，字符c为转换字符，查询该NFA获得目的状态集合Di；以状态j为源状态，字符c为转换字符，查询该NFA获得目的状态集合Dj； 

对于图2当中的NFA，第一队列queue弹出的第一个状态对为（0,0），得到两个状态0和0，遍历所有的256中输入，查询NFA，可以得到的状态集合为{0}，{0，1}，{0，2}，其中状态集合{0}等价于{0，0}；当第一队列queue弹出其余的状态对时，所做操作和查询第一个状态对（0,0）一样，查询当遍历256种输入时可能出现的目的状态集合； 

步骤5，检查步骤4中得到的状态集合Di和状态集合Dj的并集Di∪Dj，对于该并集当中的任意两个状态所组成的状态对(s，t)，如果表项compatible-table[s][t]或者compatible-table[t][s]的内容为true，则将该表项内容置为false，同时将状态对(s，t)压入第一队列queue的尾部；如果状态对（s，t）所对应的二维表表项内容已经为false，则该状态对(s，t)就不需要压入第一队列queue中； 

对于步骤2当中针对第一个弹出状态度{0，0}，得到了三个状态集合{0，0}，{0，1}，{0，2}，检查此刻的compatible-table，由于初始时compatible-table只有表项compatible-table[i][i](0≤i<9)的内容为false，其余位置的表象均为空白，这表明状态对（0,0）不需要压入第一队列queue，而状态对（0，1）和（0,2）需要被压入第一队列queue的尾部，同时将compatible-table[0][1]（compatible-table[1][0]）和compatible-table[0][2]（compatible-table[2][0]）的内容修改为false； 

对于由其他状态对查询NFA得到的状态集合，检查各个状态集合当中所有状态两两组合下的compatible-table表项是否为false，当检查完毕就完成了一轮迭代； 

步骤6，判断第一队列queue是否非空，如果第一队列queue非空，则返回执行步骤4，否则，处理过程结束。 

通过上述过程计算NFA所有状态彼此之间的相容性，若NFA的状态数为N，则至多只需要进行N²次迭代就可以完成对于所有状态对相容性的计算；例如，在图2表示的NFA当中，N=9，则至多有81个状态对，此时，至多只需进行81次迭代，以计算NFA所有状态彼此之间的相容性。 

（二）将NFA中的状态划分入相容组的处理过程 

在相容组对应的状态集合中，任意两个状态之间均为相容，如图3所示，状态0,3,4各自分别单独成为相容组{0}，{3}，{4}；而其余状态（1，2，5，6，7，8）彼此之间都是相容的，构成另一个相容组{1，2,5,6，7,8}。 

具体可以将NFA状态依据相容性分组的问题转换为等价的图论中求无向图独立集的问题，如图4所示，使用二维表来表示图2中NFA所对应的无向图，该二维表记为graph；由于图2的NFA状态数为9，因此在图4中共有9个顶点，编号为0-8，各个顶点的编号与其所代表的NFA状态编号相同；且在图4当中，如果顶点i和顶点j（i≠j）之间存有边，那么在图4中graph[i][j]和graph[j][i]的内容为“√”，否则为空白。 

对于图4中二维表graph所代表的无向图，其顶点i的顶点度数记为vertex-degree（i），则graph中各个顶点的顶点度数如下： 

vertex-degree（0）=8，vertex-degree（1）=3， 

vertex-degree（2）=3，vertex-degree（3）=8， 

vertex-degree（4）=8，vertex-degree（5）=3， 

vertex-degree（6）=3，vertex-degree（7）=3， 

vertex-degree（8）＝3。 

在图4当中graph中共有21条边，且包含环；对于顶点i和顶点j之间的边，使用（i，j）表示这条边；在图4中，最大的边度数为16，分别是边（0,3）（0,4）和（3,4），其余边的度数均为11。 

通过上述处理方式将NFA中的状态和状态间相容性关系转换为一张无向图后，相应的计算无向图顶点独立集（即相容组）的处理过程可以包括： 

步骤1，如果第二队列queue已存在，则清空该第二队列queue，否则，建立相应的空的第二队列queue； 

步骤2，在当前的无向图当中选取边度数最大的一条边，将该边压入第二队列queue，同时从该无向图当中去除这条边，并更新剩余无向图当中各项顶点度数和边度数；其中，相应的边是由两个顶点描述，而各个顶点对应着状态，所以压入第二队列queue的边实质压入的为边对应的状态对； 

图4中graph在初始时最大的边度数为16，对应的边有（0,3）、（0,4）和（3,4），任意选取其中之一，例如选取边（0,3），将（0,3）压入第二队列queue，同时在无向图中删除（0,3）这条边，即graph[0][3]和graph[3][0]的内容均修改为空白，同时计算并更新剩余无向图当中的顶点度数和边度数； 

相应的删除边（0,3）后剩余无向图的顶点度数为： 

vertex-degree（1）=1，vertex-degree（2）=1， 

vertex-degree（4）=6，vertex-degree（5）=1， 

vertex-degree（6）=1，vertex-degree（7）=1， 

vertex-degree（8）=1。 

删除边（0,3）后剩余图的边度数发生改变，各条边的度数均为7。 

步骤3，重复执行上述步骤2，直至遇到如下两种情况之一，则采用如下处理方式： 

步骤31，当某一条边被选中并从无向图当中移除时，剩余图变为空，则这条边不压入第二队列queue中，而是拆分这条边的两个关联顶点，各自构成一个单元素的独立集作为一个相容组，然后使用第二队列queue当中收集的边（即状态对）构成新的无向图，并执行步骤1； 

步骤32，若剩余图中不存在边并且第二队列queue非空，则将剩余无向图中的顶点构成一个顶点独立集，将第二队列queue中可以被放入该独立集的顶点加入到该独立集中，之后使用第二队列queue中剩余的顶点构成新的无向图，并执行步骤1； 

其中，在该步骤32中，判断是否可以被放入该独立集的方式可以包括：依次检查第二队列queue当中的状态，如果当前检查的状态s与新得到的独立集当中任何一个状态都是相容的，那么将该状态s从第二队列queue当中删除，并加入至新得到的独立集当中； 

在步骤2中，删除边（0,3）得到的剩余无向图中，各条边的边度数均为7，在这些具有相同边度数的边当中任意选择一条，这里选择边（4，1），则剩余图中不存在边，各个顶点此时的顶点度数均为0，则剩余的顶点（2,5,6,7,8）构成一个独立集{2，5，6，7，8}，检查队列当中所有的边边（0,3）和（4，1），发现顶点1可以加入独立集当中，将顶点1加入独立集得到新的独立集{1，2,5,6,7,8}； 

步骤4，判断第二队列queue是否为非空，如果第二队列queue非空，则返回步骤1，否则，过程 结束。 

重复执行上述步骤，又可获得三个独立集{0}，{3}，{4}； 

当步骤4执行完成后，NFA中状态对应的顶点集合被划分为一个或者多个顶点独立集，亦即NFA中包含的状态被划分为与顶点独立集数目相同的相容组，每个顶点独立集中顶点由所代表的状态对应地可以获得相应的一个相容组，整个NFA中状态最终被分入多个相容组当中。 

图2中的NFA，其9个顶点最终被划分为四个独立集：{0}，{3}，{4}，{1，2,5,6,7,8}，即NFA中的状态被划分为四个相容组，分别为{1，2,5,6,7,8}，{0}，{3}，{4}。 

（三）将相容组合并为超级相容组的处理过程 

如图5所示，其中是NFA中9个状态划分所形成的4个相容组，如果将相容组{0}{3}和{4}归入一个分组当中就构成了超级相容组{{0}，{3}，{4}}。 

本发明实施例提供的将相容组合并为超级相容组的具体处理过程可以包括： 

步骤1，将M个相容组{C₀，C₁，C₂，...，C_M-1}合并成K个超级相容组{S₀，S₁，S₂，...，S_K-1}，其中0<K≤M，并按照各个相容组内状态数的大小进行降序排序，得到{C′₀，C′₁，C′₂，...，C′_M-1}，对于相容组C_i,其状态数记为|C_i|，对该集合中所有状态完成编码，需要的比特数为    

对于图2中的NFA，生成M=4个相容组（如图5所示），分别占用的比特数为：{1，2，5，6，7，8}：3bits；{0}：1bit；{3}：1bit；{4}：1bit；相容组按照占用比特数进行降序排序得集合C={{1，2,5,6,7,8}，{0}，{3}，{4}}； 

具体可以对于这4个相容组将其合并为2个超级相容组，即选取K=2； 

（41）当前共有K个超级相容组{S₀，S₁，S₂，...，S_K-1}，依次对于各个超级相容组S_k进行编码，获得针对各个超级相容组S_k的组状态编码结果； 

具体地，超级相容组S_k由m（m>0)个相容组{C₀，C₁，C₂，...，C_m-1}组成，对于各个相容组C_j的组内状态进行编码，相容组C_j的状态数为|C_j|，编码后的状态编号为1，2，3，…，|C_j|，编码所需要的比特数为 

其中，编码值0分配给空状态，用于表示无效的状态；由于超级相容组S_k中单个状态S_j是一个比特向量，分别由来自构成超级相容组S_k的m个相容组的m个状态编码联结而成，因此S_j状态编码所占用的总比特数为 

步骤2，K个超级相容组{S₀，S₁，S₂，...，S_K-1}，各个组初始时均为空集，即所占用比特数均为0； 

针对图5中的相容组，可以构造K=2（即构造2）个超级相容组S₀和S₁，初始时超级相容组S₀ 和S₁均为空集； 

步骤3，从降序排列的相容组集合{C′₀，C′₁，C′₂，...，C′_M-1}当中顺序依次取出相容组 

并加入到当前占用比特数最少的超级组S_k当中，同时更新该超级组S_k占用的比特数；每个超级相容组当前占用的比特数为其所包含的相容组各自所占比特数之和，S_k原有占用的比特数为B，加入相容组 

之后，所占用的比特数    

初始时超级相容组S₀和S₁所占用的比特数均为0，从集合C中选取第一个相容组{1，2，5，6，7，8}，加入到S₀或者S₁中（由于S₀和S₁所占用的比特数均为0，所以加入任S₀或S₁中均可），例如可以加入到S₀当中，此时更新超级相容组S₀占用的比特数，由0增至3比特；接下来开始将相容组{0}加入到某个超级相容组当中，寻找当前占用比特数最少的超级相容组，S₀占用3比特，S₁占用0比特，因此后续过程会将{0}加入S₁当中，S₁占用比特数更新为1；按照相同的方式，可知相容组{3}和{4}都将被加入S₁当中，S₁在添加{3}和{4}之后所占用比特数更新为3比特； 

步骤3执行结束后，构造出的超级相容组，其进行编码时所占用的比特数最少。针对图5构造出的两个超级相容组分别为S₀＝{{1，2，5，6，7，8}}和S₁＝{{0}，{3}，{4}}。 

（四）对超级相容组中状态进行编码的处理过程 

在该实施例中提供了对于超级相容组当中状态进行编码的处理过程，以构造出与NFA等价的虚拟NFA。 

假设一个超级相容组由m个相容组组成，则由这m个相容组各自提供自身组内的状态进行联结所构成的复合状态，即超级相容组的状态，可以称为虚拟状态，或也可以称为虚拟NFA状态。 

对于针对图5构造的超级相容组S₀={{1，2，5，6，7，8}}，它由一个相容组组成，超级相容组S₀中的状态分别为： 

对于超级相容组S₁＝{{0}，{3}，{4}}，超级相容组S₁的状态分别为： 

表示一个空状态。 

由于超级相容组首先是由相容组合并得来，对于超级相容组中状态进行编码时，首先要完成对于相容组中的NFA状态的编码，在这些编码基础上构造出超级相容组中的状态的编码；相应的编码过程可以包括： 

步骤1，当前共有K个超级相容组{S₀，S₁，S₂，...，S_K-1}，依次对于各个超级相容组S_k进行编码，获得组状态编码结果； 

步骤11，超级相容组S_k由m（m>0)个相容组{C₀，C₁，C₂，...，C_m-1}组成，对于各个相容组C_j的组内状态进行编码，相容组C_j的状态数为|C_j|，编码后的状态编号为1，2，3，…，|C_j|，编码所需要的比特数为 

编码值0分配给空状态，表示无效的状态； 

对于超级相容组S₀所包含的相容组进行相容组内的重新编码，如图6所示，对于相容组{1，2，5，6，7，8}当中的NFA状态进行重新编码，得到的相容组组内编码值分别为1，2，3，4，5，6，在图6“相容组组内编码”一栏中使用二进制表示新的编码值；对于相容组{0}，{3}，{4}，由于各个相容组中只含有一个状态，所以相容组组内编码值均为1。 

步骤12，超级相容组S_k的中单个状态S_j是一个比特向量，分别由来自构成超级相容组S_k的m个相容组的m个状态编码联结而成，因此S_j状态编码所占用的总比特数为 超级相容组S_k的m个相容组的m个状态编码联结获得相应的比特向量也可以称为组状态编码结果； 

对于超级相容组S₀，它由一个相容组组成，S₀的单个状态的比特向量（即虚拟状态编码）表示即为其中相容组组内编码值，如图6在“虚拟状态编码”一栏所示，即S₀的单个状态的比特向量与相容组组内编码值相同。对于超级相容组S₁，它由三个相容组组成，S₁的单个状态的比特向量（即虚拟状态编码）表示为三个相容组中状态的组内编码的连接，其中，各个分组（即相容组）组内编码占用1个比特，三个分组的组内编码连接后共需占用3个比特，仍如图6中的“虚拟状态编码”一栏中所示，相容组{0}的组内编码占据比特向量的最高位，相容组{4}的组内编码占据比特向量的最低位，而相容组{3}的组内编码则占用中间位置，编码“100”表示该比特向量中仅有来自相容组{0}的状态是活跃的，类似的，编码“010”表示该比特向量中仅有来自相容组{3}的状态是活跃的，而编码“001”表示该比特向量中仅有来自相容组{4}的状态是活跃的；如果相容组{0}、{3}和{4}中状态均活跃，则相应虚拟状态编码应为“111”。 

步骤2，超级相容组数目为K，则对于组编号进行编码所需的比特数目为 

相应的针对组编号的编码结果为组编号编码结果，将该组编号编码结果与步骤1中得到的比特向量（即组状态编码结果）联结，便构成该超级相容组中虚拟状态的完整的编码，即获得相应的虚拟NFA状态； 

由于有两个超级相容组S₀和S₁（K=2），所以要使用1个比特对于两个组编码进行编码，0表示超级相容组S₀，1则表示S₁；将组编码添加至比特向量的最低位，则得到完整的虚拟状态编码，如图6“完整虚拟状态编码”一栏所示。 

在步骤2执行结束时，则完成了对于各个超级相容组中虚拟状态的编码，之后还需要基于获得的虚拟NFA状态确定相应的虚拟NFA，具体可以包括： 

以该虚拟状态（即虚拟NFA状态）作为源状态，对于输入字符进行状态转换，等价于构成虚拟状态编码的各个相容组编码分别针对输入字符按照NFA中状态转换关系进行相应的状态转换操作，得到各自的目的状态集合，再将得到的目的状态集合当中的状态按照所属的相容组的不同归入不同的超级相容组中，并进行连接构成目的虚拟状态，由此建立了源虚拟状态到目的虚拟状态间的转换关系。根据建立的源虚拟状态到目的虚拟状态间的转换关系，计算出所有虚拟NFA状态之间的转换关系，结合虚拟NFA状态，组成了相应的虚拟NFA。 

具体地，参照图6所示，以虚拟状态“111 1”为例，最低位的“1”表示组编号，高位的三个“1”表示分别来自相容组{0}{3}{4}中的NFA状态0,3和4当前均为活跃状态，如果当前输入字符为c，那么三个活跃状态查询NFA经过状态转换得到的目的状态集合为{0，3，4，5}，对应的虚拟状态编码就是“111 1”和“011 0”；因此虚拟状态“111 1”作为源状态，匹配输入字符c后得到目的状态“1111”和“011 0”；对于所有的虚拟状态，将它们作为源状态，遍历256种输入字符，就可以得到相应的目的状态集合，进而可以确定相应的虚拟NFA状态之间的转换关系，而这些虚拟NFA状态之间的转换关系结合相应的虚拟NFA状态便构成了相应的虚拟NFA。 

（五）将数据包中数据进行交织处理的处理过程 

对于待处理的数据包中数据进行交织处理，目的是为了降低在GPU进行匹配操作时读入数据包数据的开销，提高匹配的吞吐率。 

假设GPU并行处理的数据包的数目为P，将数据包内的数据划分为等长（D字节）的数据分片，则具体采用的交织处理方式是指在存储相应的数据分片时，以相邻的数据分片彼此相距P×D字节的方式存储；其中，假设GPU的一个线程束中D个线程并行处理一个数据包当中的数据，D个线程可并行读入当前显存当中待处理数据包的D字节数据进入共享存储器（shared memory）；且相应的数据分片是指属于同一数据包的连续D字节数据，且D为2的幂次且D≥W，W为GPU的一个线程束中的一个线程分片包含的连续的线程数量，即W个线程的线程编号是连续的； 

在上述处理过程中，在对于数据包进行数据分片的划分时，如果存在数据分片的实际长度小于D字节的情形，则使用0x00进行填充直至满足D字节。 

如图7所示，（a）表示原始的数据包的存储方式，即数据原始方式存储，其采用的方式是前一个数据包存储完毕后，其尾部紧接着存储下一个数据包的数据，在图7的（a）中的8个数据包依次首尾相连进行存储；（b）表示数据交织方式存储，即将每个数据包均分为多个数据分片，每个数据分片规模D=32字节，同时线程分片规模为W=32，图7中表示GPU线程并行处理的数据包为4个，那么属于同一个数据包的相邻两个数据分片在存储中相距为P×D=4＊32=128字节。 

（六）利用GPU实现虚拟NFA匹配经过交织存储的数据的处理过程 

将虚拟NFA状态之间的转换关系及相应的虚拟NFA状态以一张二维数组表示，二维数据的行数与虚拟NFA的状态数相等（该二维数组即为虚拟NFA状态转换表），二维数组的列数则为固定的256，对应256种输入字符，每一个表项为一个目的状态集合，由输入字符和源状态进行索引。该二维数组存入GPU的全局存储器当中，然后将这一存储器区域与纹理绑定使之成为纹理存储器； 

假设将M个相容组合并为K个超级相容组，且K=4；对待处理的数据包当中数据进行交织处理时，线程分片规模为W=4，数据分片大小为D=4；GPU一个线程束（warp）包含32个线程，按照线程编号顺序，每W=4个线程被划分为一个线程分片负责处理一个数据包，共可同时处理和匹配    个数据包当中的数据。 

基于上述假设，在线程束当中，每W=4个编号相邻的线程组成一个线程分片，负责处理已经过交织的数据包中的数据，具体的处理步骤可以包括： 

步骤1，线程分片当中的各个线程依据自身线程编号计算索引值来访问位于全局存储器的数据包当中不同的数据，并将读出的数据存入共享存储器，每次访存W=4个线程共将D=4字节的数据存入共享存储器； 

线程的总数目为T（T>0且T为2的幂次），由于数据分片规模和线程分片规模均为W=D=4，则线程在批处理的数据包数目为    

步骤2，线程分片当中的各个线程依据自身线程编号计算出索引值，根据该索引值来访问位于共享存储器当中的活跃状态表中不同的位置，各个线程所读出的该位置的内容为一个当前活跃状态编号或者空状态0，之后清空该活跃状态表； 

如图8所示，其表示一个线程束（包含32个线程）中的首个线程分片（W=4）状态转换的过程，线程束中32个线程编号为1-32，将活跃状态表记为active-table，第k个位置记为active-table[k-1]；该线程分片当中线程的编号依次为1，2，3，4，这四个线程并行地从图8中长度为32（对应一个线程束）的活跃状态表中按照自身编号读出第1个位置到第4个位置的内容，该内容为一个活跃状态编号，或者是空状态的编号0，并分别将读取位置当中的内容清零；四个线程读取的内容分别为Sid1，Sid2,Sid3和Sid4，其中， 

Sid1=active-table[0]；active-table[0]=0，即将读取后的活跃状态表active-table的相应表项内容清零； 

Sid2=active-table[1]；active-table[1]=0； 

Sid3=active-table[2]；active-table[2]=0； 

Sid4=active-table[3]；active-table[3]＝0。 

步骤3，线程分片依次处理步骤1当中读出的各个字符作为输入字符c，然后以线程分片中各个线程所持有的从步骤2得到的活跃状态编号作为行坐标，以字符c作为列坐标，索引查询虚拟NFA状态转换表，分别得到状态集合{D0,D1，D2,D3}； 

图8中，当前输入字符为c，同一个线程分片中的四个线程各自持有当前活跃状态（Sid1，Sid2,Sid3,Sid4），将虚拟NFA状态转换表记为virtual-table，其第i+1行，第j+1列的内容为virtual-table[i][j]，四个线程分别查询该虚拟NFA转换表，并得到四个目的状态集合D0,D1，D2和D3，其中： 

D0=virtual-table[Sid1][c]；D1=virtual-table[Sid2][c]； 

D2=virtual-table[Sid3][c]；D3=virtual-table[Sid4][c]。 

步骤4，在步骤3当中线程分片中各个线程共得到4个状态集合{D0,D1，D2,D3}，对于任一个集合Dj中的各个状态，根据各个线程的线程编号及对应的所述各个线程读出的活跃状态编号中集成的组编号，确定该状态在所述活跃状态表当中存储的位置，并将该状态的组编码值写入至活跃状态表中的该位置，具体可以将该状态NFA状态编号通过比特或（bitOR）操作写入至活跃状态表中的该位置，其中，相应的组编码值包含了对超级相容组中的虚拟NFA状态进行编码获得的组状态编码结果和对超级相容组的组编号进行编码获得组编号编码结果； 

在图8中，线程分片当中的四个线程分别处理各自获得的目的状态集合，由于超级相容组数目为4，那么在进行虚拟状态编码获得组编码值时，相应的组编码值的低2 

位比特用于记录当前状态所属的超级相容组的编号；各个线程读取该组编码值（0-3），并按照组编码值将相应的虚拟NFA状态写入活跃状态表，例如，当组编码为g，则对应虚拟NFA状态写入活跃状态表active-table[g]。 

步骤5，当Dj的状态为接受状态时，标记当前正处理的数据包，否则不标记； 

进一步地，当上述步骤4执行结束后，active-table中的内容由0被重写为新的状态编号，如图8中所示的New Sid1，New Sid2，New Sid3，New Sid4；活跃状态表中的这些新的内容将在处理下一个输入字符时使用。 

步骤6，判断数据包是否处理完毕，如果数据包中数据还未处理完毕，则返回步骤1，否则，过程结束。 

通过上述处理方式可以看出，由于每个线程束包含32个线程，因而，其能够并行处理    个数据包，同时还借助针对待处理数据包的交织处理技术，以有效降低各个线程读取数据包数据的代价，从而提高了虚拟NFA匹配数据的速度。 

本发明实施例还提供了一种基于图形处理单元的非确定有限自动机的匹配装置，其具体实现结构如图9所示，可以包括： 

虚拟NFA建立模块91，用于计算非确定有限自动机NFA中所有状态两两之间的相容性，并根据所述相容性对所述各个状态进行编码形成虚拟NFA，获得虚拟NFA对应的虚拟NFA状态转换表；其中，所述相容性是指，若NFA中的两个状态在NFA匹配过程中不同时处于活跃状态，则该两个状态相容，否则，为不相容； 

匹配处理模块92，用于将所述虚拟NFA建立模块91获得的虚拟NFA状态转换表存储在图形处理单元GPU的全局存储器中，并基于该虚拟NFA状态转换表匹配经过交织处理的待处理数据包中数据。 

可选地，在虚拟NFA建立模块91为执行计算NFA中所有状态两两之间的相容性的处理，则具体可以包括以下模块： 

状态表建立模块911，用于针对NFA状态建立N×N的二维表，N为NFA的状态数目，NFA状态依次为0，1，2，…，N-1；在该二维表中，第i+1行和第j+1列的表项由[i，j]表示；如果状态i和j是相容的，则表项[i，j]内容设置为true，如果状态i和j是不相容的，则表项[i，j]内容设置为false；其中，分别将表项[0，0]，[1，1]，[2，2]，…，[N-1，N-1]的内容置为false； 

第一队列建立模块912，用于建立初始为空的第一队列queue并进行初始化，依次将状态对(0，0)，(1，1)，(2，2)，…，(N-1，N-1)压入第一队列queue中； 

二维表调整模块913，用于弹出所述第一队列建立模块912建立的第一队列queue首部的状态对(i，j)，并使用弹出的状态对i，j遍历全部可能的输入字符0-255查询NFA状态，其中，以当前输入字符作为转换字符，以状态i为源状态，查询该NFA状态获得目的状态集合Di，以状态j为源状态，查询该NFA 状态获得目的状态集合Dj；再检查状态集合Di和状态集合Dj的并集Di∪Dj，并将该并集当中的任意两个状态所组成的状态对（s，t）对应的在所述状态表建立模块911建立的二维表表项中的内容置为false，若状态对（s,t）所对应的二维表表项中的内容之前记录为true，则还需要将状态对（s，t）压入第一队列queue的尾部；即如果状态对（s，t）所对应的二维表表项中的内容已经为false，则该状态对(s，t)不需要压入第一队列queue中； 

判断模块914，用于在所述二维表调整模块913执行操作后，判断所述第一队列queue是否非空，如果是，过程结束，否则，通知所述二维表调整模块913，以继续再执行所述弹出第一队列queue首部的状态对(i，j)的步骤。 

进一步地，上述虚拟NFA建立模块91为执行根据相容性对各个状态进行编码形成虚拟NFA的处理，则具体可以包括以下模块： 

相容组建立模块915，用于根据所述相容性将NFA中的所有状态分组，获得至少一个相容组，所述相容组中的任意两个状态之间相容； 

获得虚拟NFA模块916，用于将所述相容组建立模块915得到的所述相容组合并获得超级相容组，再对所述超级相容组进行编码形成虚拟状态，获得虚拟NFA。 

在该实施例中，上述相容组建立模块具体可以包括： 

第二队列处理模块9151，用于获得空的第二队列queue，在建立的无向图中一次或多次选取边度数最大的一条边，将该边对应的两个顶点对应的状态压入所述第二队列queue，并从该无向图当中去除这条边，更新剩余无向图当中各项顶点度数和边度数；其中，所述无向图的顶点为NFA的一个状态，边为NFA中两个不相容的状态对应的顶点之间的连线，顶点度数为与该顶点相连的边的总数目，边度数为该边所关联的两个顶点的顶点度数之和； 

无向图处理模块9152，用于所述第二队列处理模块9151在建立的无向图中一次或多次选取边度数最大的一条边的过程中，若当前被选中边从无向图当中移除，剩余图变为空，则通知所述第二队列处理模块9151这条边不压入第二队列queue，拆分这条边的两个关联顶点，各自构成一个单元素的独立集，再使用第二队列queue中收集的边对应的状态对构成新的无向图，并通知所述第二队列处理模块9151执行所述获得空的第二队列queue的处理，所述的独立集对应一个相容组；若剩余无向图中不存在边并且非空，则将无向图中剩余顶点构成一个顶点独立集，将所述第二队列queue中与该独立集中的状态相容的NFA状态加入该独立集中，再使用第二队列queue中剩余的顶点构成新的无向图，并通知所述第二队列处理模块9151执行所述获得空的第二队列queue的处理；若第二队列queue空，则过程结束。 

可选地，上述获得虚拟NFA模块916为执行将得到的所述相容组合并获得超级相容组的处理，则具体可以包括： 

排序处理模块9161，用于按照相容组状态数的大小进行降序排序，得到降序排列的相容组集合； 

超级相容组建立模块9162，用于从所述排序处理模块9161得到的降序排列的相容组集合中依次顺序取出相容组并加入到当前占用比特数最少的超级相容组当中，并同时更新该超级相容组占用的比特数，其中，每个超级相容组初始占用的比特数为0。 

进一步地，上述获得虚拟NFA模块916为执行获得虚拟NFA的处理，则可以包括： 

相容组编码模块9163，用于在超级相容组中，对各个相容组包含的状态进行编码，获得相容组的组内状态的编码作为组状态编码结果，还对超级相容组包含的一个或多个相容组的组编号进行编码，获得组编号编码结果； 

虚拟NFA获得子模块9163，用于将所述相容组编码模块9163获得的组状态编码结果与组编号编码结果联结，构成该超级相容组中虚拟状态的完整的编码，获得虚拟NFA的状态，还建立所述虚拟NFA状态之间的转换关系，获得包含虚拟NFA状态和虚拟NFA状态之间的转换关系的虚拟NFA。 

该虚拟NFA获得子模块9163建立相应的虚拟NFA状态之间的转换关系的处理具体可以包括：以所述虚拟状态作为源状态，对于输入字符进行状态转换，根据所述组状态编码结果，分别针对输入字符按照NFA中状态转换关系进行状态转换，得到各自的目的状态集合，再将目的状态集合当中的状态按照所属的相容组的不同归入不同的超级相容组当中，并进行连接构成目的虚拟状态，以建立源虚拟状态到目的虚拟状态间的转换关系，即建立虚拟NFA之间的转换关系。 

本发明实施例中，相应的匹配处理模块92执行的交织处理具体可以包括： 

若图形处理单元GPU并行处理的数据包的数目为P，则将数据包内的数据划分为等长W字节的数据分片，并在存储所述数据包时，相邻的数据分片彼此相距P×W字节的存储，以实现针对所述数据包的交织处理；其中，对于数据包进行数据分片的划分时，如果存在数据分片的实际长度小于W字节，则使用0x00进行填充直至满足W字节。 

可选地，该匹配处理模块92为执行基于该虚拟NFA匹配经过交织处理的待处理数据包中数据的处理，则可以包括： 

数据读取模块921，用于通过线程分片中的各个线程依据自身线程编号计算索引值来读出位于全局存储器的数据包中不同的数据，并将读出的数据存入共享存储器，其中，所述线程分片是由GPU线程束中的连续若干个线程构成； 

活跃状态表操作模块922，用于通过线程分片中的各个线程依据自身线程编号计算出索引值访问位于共享存储器当中的活跃状态表中不同的位置，各个线程读出一个活跃状态编号，并清空该活跃状态表； 

状态匹配模块923，用于通过线程分片从所述数据读取模块921存储有数据的共享存储器中直接读取所述数据，并将其各个字节作为输入字符，再以各个线程所持有的通过上述活跃状态表操作模块922读出的活跃状态编号作为行坐标，以该输入字符作为列坐标，索引查询虚拟NFA对应的虚拟NFA状态转换表，分别得到状态集合；其中，所述虚拟NFA状态转换表由超级相容组当中的虚拟NFA状态以及各个虚拟NFA状态之间的转换关系构成； 

活跃状态表更新模块924，用于在所述状态匹配模块923得到的所述状态集合中，对于任一个集合中的各个状态，根据各个线程的线程编号及对应的所述各个线程读出的活跃状态编号中集成的组编号，确定该状态在所述活跃状态表当中存储的位置，并将该状态的组编码值写入至所述活跃状态表中的该位置，所述的组编码值包含了对超级相容组中的虚拟NFA状态进行编码获得的组状态编码结果和对超级相容组的组编号进行编码获得组编号编码结果； 

数据包标记模块925，用于在所述活跃状态表更新模块924当前处理的状态为接受状态时，则标记当前正处理的数据包，否则不标记；之后，通知继续处理所述数据包中后续数据，直至数据包中的数据处理完毕。 

本发明实施例通过多线程处理的方式，以实现对多个数据包的并行处理，提高针对数据包的处理效率；同时还借助针对待处理数据包的交织处理技术，以降低各个线程读取数据包数据的代价。因此，本发明实施例的应用能够有效地提高虚拟NFA匹配数据的速度，且相应的实现复杂程度较低。 

以上所述，仅为本发明较佳的具体实施方式，但本发明的保护范围并不局限于此，任何熟悉本技术领域的技术人员在本发明披露的技术范围内，可轻易想到的变化或替换，都应涵盖在本发明的保护范围之内。因此，本发明的保护范围应该以权利要求书的保护范围为准。 

Claims (10)

1.一种基于图形处理单元的非确定有限自动机的匹配方法，其特征在于，包括：

计算非确定有限自动机NFA中所有状态两两之间的相容性，并根据所述相容性对所述各个状态进行编码形成虚拟NFA，以获得虚拟NFA对应的虚拟NFA状态转换表；其中，所述相容性是指，若NFA中的两个状态在NFA匹配过程中不同时处于活跃状态，则该两个状态相容，否则，为不相容；

将所述虚拟NFA状态转换表存储在图形处理单元GPU的全局存储器中，并基于该虚拟NFA状态转换表匹配经过交织处理的待处理数据包中数据。

2.根据权利要求1所述的方法，其特征在于，所述计算NFA中所有状态两两之间的相容性的步骤包括：

针对NFA状态建立N×N的二维表，N为NFA的状态数目，NFA状态依次为0，1，2，…，N-1；在该二维表中，第i+1行和第j+1列的表项由[i，j]表示；如果状态i和j是相容的，则表项[i，j]内容设置为true，如果状态i和j是不相容的，则表项[i，j]内容设置为false；其中，分别将表项[0，0]，[1，1]，[2，2]，…，[N-1，N-1]的内容置为false；

建立初始为空的第一队列queue并进行初始化，依次将状态对(0，0)，(1，1)，(2,2)，…，(N-1，N-1)压入第一队列queue中；

弹出第一队列queue首部的状态对(i，j)，使用状态i，j遍历全部可能的输入字符0-255查询NFA状态，其中，以当前输入字符作为转换字符，以状态i为源状态，查询该NFA状态获得目的状态集合Di，以状态j为源状态，查询该NFA状态获得目的状态集合Dj；检查状态集合Di和状态集合Dj的并集Di∪Dj，并将该并集当中的任意两个状态所组成的状态对（s，t）对应的所述二维表表项内容置为false，若状态对（s，t）所对应的二维表表项中的内容之前记录为true，则还需要将状态对（s，t）压入第一队列queue的尾部；

判断第一队列queue是否非空，如果是，过程结束，否则，继续再执行所述弹出第一队列queue首部的状态对(i，j)的步骤。

3.根据权利要求1或2所述的方法，其特征在于，所述根据所述相容性对所述各个状态进行编码形成虚拟NFA的步骤包括：

根据所述相容性将NFA中的所有状态分组，获得至少一个相容组，所述相容组中的任意两个状态之间相容；

将得到的所述相容组合并获得超级相容组，再对所述超级相容组进行编码形成虚拟状态，并获得虚拟NFA。

4.根据权利要求3所述的方法，其特征在于，所述根据所述相容性将NFA中的所有状态分组，获得至少一个相容组的步骤包括：

获得空的第二队列queue，在建立的无向图中一次或多次选取边度数最大的一条边，将该边对应的两个顶点对应的状态压入所述第二队列queue，并从该无向图当中去除这条边，更新剩余无向图当中各项顶点度数和边度数；其中，所述无向图的顶点为NFA的一个状态，边为NFA中两个不相容的状态对应的顶点之间的连线，顶点度数为与该顶点相连的边的总数目，边度数为该边所关联的两个顶点的顶点度数之和；

在建立的无向图中一次或多次选取边度数最大的一条边的过程中，若当前被选中边从无向图当中移除，剩余图变为空，则这条边不压入第二队列queue，拆分这条边的两个关联顶点，各自构成一个单元素的独立集，再使用第二队列queue中收集的边对应的状态对构成新的无向图，并执行所述获得空的第二队列queue的步骤，所述的独立集对应一个相容组；若剩余无向图中不存在边并且非空，则将无向图中剩余顶点构成一个顶点独立集，将第二队列queue中与该独立集中的状态相容的NFA状态加入该独立集中，再使用第二队列queue中剩余的顶点构成新的无向图，并执行所述获得空的第二队列queue的步骤；若第二队列queue空，则过程结束。

5.根据权利要求3所述的方法，其特征在于，所述将得到的所述相容组合并获得超级相容组的步骤包括：

按照相容组状态数的大小进行降序排序，得到降序排列的相容组集合；

从所述降序排列的相容组集合中依次顺序取出相容组并加入到当前占用比特数最少的超级相容组当中，同时更新该超级相容组占用的比特数，其中，每个超级相容组初始占用的比特数为0。

6.一种基于图形处理单元的非确定有限自动机的匹配装置，其特征在于，包括：

虚拟NFA建立模块，用于计算非确定有限自动机NFA中所有状态两两之间的相容性，并根据所述相容性对所述各个状态进行编码形成虚拟NFA，获得虚拟NFA对应的虚拟NFA状态转换表；其中，所述相容性是指，若NFA中的两个状态在NFA匹配过程中不同时处于活跃状态，则该两个状态相容，否则，为不相容；

匹配处理模块，用于将所述虚拟NFA建立模块获得的虚拟NFA状态转换表存储在图形处理单元GPU的全局存储器中，并基于该虚拟NFA状态转换表匹配经过交织处理的待处理数据包中数据。

7.根据权利要求6所述的装置，其特征在于，所述虚拟NFA建立模块为执行计算NFA中所有状态两两之间的相容性的处理，则包括：

状态表建立模块，用于针对NFA状态建立N×N的二维表，N为NFA的状态数目，NFA状态依次为0，1，2，…，N-1；在该二维表中，第i+1行和第j+1列的表项由[i，j]表示；如果状态i和j是相容的，则表项[i，j]内容设置为true，如果状态i和j是不相容的，则表项[i，j]内容设置为false；其中，分别将表项[0，0]，[1，1]，[2，2]，…，[N-1，N-1]的内容置为false；

第一队列建立模块，用于建立初始为空的第一队列queue并进行初始化，依次将状态对(0，0)，(1，1)，(2，2)，…，(N-1，N-1)压入第一队列queue中；

二维表调整模块，用于弹出所述第一队列建立模块建立的第一队列queue首部的状态对(i，j)，使用状态i，j遍历全部可能的输入字符0-255查询NFA状态，其中，以当前输入字符作为转换字符，以状态i为源状态，查询该NFA状态获得目的状态集合Di，以状态j为源状态，查询该NFA状态获得目的状态集合Dj；检查状态集合Di和状态集合Dj的并集Di∪Dj，并将该并集当中的任意两个状态所组成的状态对（s，t）对应的所述状态表建立模块建立的二维表表项内容置为false，若状态对（s，t）所对应的二维表表项中的内容之前记录为true，则还需要将状态对（s，t）压入第一队列queue的尾部；

判断模块，用于在所述二维表调整模块执行操作后，判断所述第一队列queue是否非空，如果是，过程结束，否则，通知所述二维表调整模块，以继续再执行所述弹出第一队列queue首部的状态对(i，j)的步骤。

8.根据权利要求6或7所述的装置，其特征在于，所述虚拟NFA建立模块为执行根据所述相容性对所述各个状态进行编码形成虚拟N FA的处理，则包括：

相容组建立模块，用于根据所述相容性将NFA中的所有状态分组，获得至少一个相容组，所述相容组中的任意两个状态之间相容；

获得虚拟NFA模块，用于将所述相容组建立模块得到的所述相容组合并获得超级相容组，再对所述超级相容组进行编码形成虚拟状态，获得虚拟NFA。

9.根据权利要求8所述的装置，其特征在于，所述相容组建立模块包括：

第二队列处理模块，用于获得空的第二队列queue，在建立的无向图中一次或多次选取边度数最大的一条边，将该边对应的两个顶点对应的状态压入所述第二队列queue，并从该无向图当中去除这条边，更新剩余无向图当中各项顶点度数和边度数；其中，所述无向图的顶点为NFA的一个状态，边为NFA中两个不相容的状态对应的顶点之间的连线，顶点度数为与该顶点相连的边的总数目，边度数为该边所关联的两个顶点的顶点度数之和；

无向图处理模块，用于所述第二队列处理模块在建立的无向图中一次或多次选取边度数最大的一条边的过程中，若当前被选中边从无向图当中移除，剩余图变为空，则通知所述第二队列处理模块这条边不压入第二队列queue，拆分这条边的两个关联顶点，各自构成一个单元素的独立集，再使用第二队列queue中收集的边对应的状态对构成新的无向图，并通知所述第二队列处理模块执行所述获得空的第二队列queue的处理，所述的独立集对应一个相容组；若剩余无向图中不存在边并且非空，则将无向图中剩余顶点构成一个顶点独立集，将所述第二队列queue中与该独立集中的状态相容的NFA状态加入该独立集中，再使用第二队列queue中剩余的顶点构成新的无向图，并通知所述第二队列处理模块执行所述获得空的第二队列queue的处理；若第二队列queue空，则过程结束。

10.根据权利要求8所述的装置，其特征在于，所述获得虚拟NFA模块为执行将得到的所述相容组合并获得超级相容组的处理，则包括：

排序处理模块，用于按照相容组状态数的大小进行降序排序，得到降序排列的相容组集合；

超级相容组建立模块，用于从所述排序处理模块得到的降序排列的相容组集合中依次顺序取出相容组并加入到当前占用比特数最少的超级相容组当中，并同时更新该超级相容组占用的比特数，其中，每个超级相容组初始占用的比特数为0。

Images