CN1656471A - 使用可重编程硬件高速处理流数据以发现可重编程的模式并对其作出响应的方法、系统和装置 - Google Patents
使用可重编程硬件高速处理流数据以发现可重编程的模式并对其作出响应的方法、系统和装置 Download PDFInfo
- Publication number
- CN1656471A CN1656471A CNA038114712A CN03811471A CN1656471A CN 1656471 A CN1656471 A CN 1656471A CN A038114712 A CNA038114712 A CN A038114712A CN 03811471 A CN03811471 A CN 03811471A CN 1656471 A CN1656471 A CN 1656471A
- Authority
- CN
- China
- Prior art keywords
- data
- string
- logic
- std
- state
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Pending
Links
- 238000000034 method Methods 0.000 title claims abstract description 121
- 238000012545 processing Methods 0.000 title claims abstract description 42
- 230000009471 action Effects 0.000 claims abstract description 62
- 230000008672 reprogramming Effects 0.000 claims abstract description 14
- 230000004044 response Effects 0.000 claims abstract description 10
- 238000010168 coupling process Methods 0.000 claims description 139
- 238000005859 coupling reaction Methods 0.000 claims description 139
- 230000008878 coupling Effects 0.000 claims description 137
- 230000014509 gene expression Effects 0.000 claims description 48
- 238000012856 packing Methods 0.000 claims description 30
- 238000012986 modification Methods 0.000 claims description 24
- 230000004048 modification Effects 0.000 claims description 24
- 238000004458 analytical method Methods 0.000 claims description 16
- 230000005540 biological transmission Effects 0.000 claims description 13
- 241000700605 Viruses Species 0.000 claims description 12
- 238000013461 design Methods 0.000 claims description 11
- 230000000694 effects Effects 0.000 claims description 11
- 238000004891 communication Methods 0.000 claims description 7
- 230000015572 biosynthetic process Effects 0.000 claims description 6
- 238000001514 detection method Methods 0.000 claims description 6
- 238000013519 translation Methods 0.000 claims description 3
- 230000013011 mating Effects 0.000 claims description 2
- 238000012546 transfer Methods 0.000 claims description 2
- 230000008520 organization Effects 0.000 claims 9
- 230000008569 process Effects 0.000 abstract description 88
- 241001673391 Entandrophragma candollei Species 0.000 description 60
- 239000000872 buffer Substances 0.000 description 47
- 238000012360 testing method Methods 0.000 description 27
- 238000005516 engineering process Methods 0.000 description 16
- 101100113692 Caenorhabditis elegans clk-2 gene Proteins 0.000 description 11
- 101100003180 Colletotrichum lindemuthianum ATG1 gene Proteins 0.000 description 11
- 238000010586 diagram Methods 0.000 description 10
- 241001269238 Data Species 0.000 description 8
- 238000003860 storage Methods 0.000 description 8
- 230000003068 static effect Effects 0.000 description 6
- 239000011800 void material Substances 0.000 description 6
- 108010070126 GAWK Proteins 0.000 description 5
- 230000003542 behavioural effect Effects 0.000 description 5
- 230000008859 change Effects 0.000 description 5
- 239000000463 material Substances 0.000 description 5
- 238000011160 research Methods 0.000 description 5
- 238000003786 synthesis reaction Methods 0.000 description 4
- 238000012795 verification Methods 0.000 description 4
- ZPUCINDJVBIVPJ-LJISPDSOSA-N cocaine Chemical compound O([C@H]1C[C@@H]2CC[C@@H](N2C)[C@H]1C(=O)OC)C(=O)C1=CC=CC=C1 ZPUCINDJVBIVPJ-LJISPDSOSA-N 0.000 description 3
- 238000012217 deletion Methods 0.000 description 3
- 230000037430 deletion Effects 0.000 description 3
- 238000004886 process control Methods 0.000 description 3
- 230000000630 rising effect Effects 0.000 description 3
- 241000282326 Felis catus Species 0.000 description 2
- 235000000332 black box Nutrition 0.000 description 2
- 244000085682 black box Species 0.000 description 2
- 230000006870 function Effects 0.000 description 2
- 238000003780 insertion Methods 0.000 description 2
- 210000000056 organ Anatomy 0.000 description 2
- 238000006467 substitution reaction Methods 0.000 description 2
- 230000003319 supportive effect Effects 0.000 description 2
- 230000001360 synchronised effect Effects 0.000 description 2
- 101710082795 30S ribosomal protein S17, chloroplastic Proteins 0.000 description 1
- 241000115929 Anabolia appendix Species 0.000 description 1
- 238000006677 Appel reaction Methods 0.000 description 1
- 239000004606 Fillers/Extenders Substances 0.000 description 1
- 230000001133 acceleration Effects 0.000 description 1
- 238000003491 array Methods 0.000 description 1
- 238000004422 calculation algorithm Methods 0.000 description 1
- 238000004364 calculation method Methods 0.000 description 1
- 238000006243 chemical reaction Methods 0.000 description 1
- 230000001276 controlling effect Effects 0.000 description 1
- 238000009792 diffusion process Methods 0.000 description 1
- 230000008030 elimination Effects 0.000 description 1
- 238000003379 elimination reaction Methods 0.000 description 1
- 239000002360 explosive Substances 0.000 description 1
- 239000000284 extract Substances 0.000 description 1
- 238000000605 extraction Methods 0.000 description 1
- 239000000835 fiber Substances 0.000 description 1
- 238000001914 filtration Methods 0.000 description 1
- 230000008676 import Effects 0.000 description 1
- 230000006872 improvement Effects 0.000 description 1
- 230000037431 insertion Effects 0.000 description 1
- 238000012423 maintenance Methods 0.000 description 1
- 230000014759 maintenance of location Effects 0.000 description 1
- 238000012544 monitoring process Methods 0.000 description 1
- 230000001151 other effect Effects 0.000 description 1
- REQCZEXYDRLIBE-UHFFFAOYSA-N procainamide Chemical compound CCN(CC)CCNC(=O)C1=CC=C(N)C=C1 REQCZEXYDRLIBE-UHFFFAOYSA-N 0.000 description 1
- 230000008707 rearrangement Effects 0.000 description 1
- 238000011946 reduction process Methods 0.000 description 1
- 230000001105 regulatory effect Effects 0.000 description 1
- 230000008439 repair process Effects 0.000 description 1
- 230000035945 sensitivity Effects 0.000 description 1
- 238000010408 sweeping Methods 0.000 description 1
Images
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F15/00—Digital computers in general; Data processing equipment in general
- G06F15/16—Combinations of two or more digital computers each having at least an arithmetic unit, a program unit and a register, e.g. for a simultaneous processing of several programs
- G06F15/177—Initialisation or configuration control
-
- H—ELECTRICITY
- H04—ELECTRIC COMMUNICATION TECHNIQUE
- H04L—TRANSMISSION OF DIGITAL INFORMATION, e.g. TELEGRAPHIC COMMUNICATION
- H04L41/00—Arrangements for maintenance, administration or management of data switching networks, e.g. of packet switching networks
- H04L41/08—Configuration management of networks or network elements
-
- H—ELECTRICITY
- H04—ELECTRIC COMMUNICATION TECHNIQUE
- H04L—TRANSMISSION OF DIGITAL INFORMATION, e.g. TELEGRAPHIC COMMUNICATION
- H04L41/00—Arrangements for maintenance, administration or management of data switching networks, e.g. of packet switching networks
- H04L41/08—Configuration management of networks or network elements
- H04L41/0803—Configuration setting
Landscapes
- Engineering & Computer Science (AREA)
- Computer Networks & Wireless Communication (AREA)
- Signal Processing (AREA)
- Computer Hardware Design (AREA)
- Theoretical Computer Science (AREA)
- Software Systems (AREA)
- Physics & Mathematics (AREA)
- General Engineering & Computer Science (AREA)
- General Physics & Mathematics (AREA)
- Data Exchanges In Wide-Area Networks (AREA)
- Logic Circuits (AREA)
Abstract
公开说明了处理数据流的一种可重编程包处理系统。一个可重编程数据处理器被编程以确定一个数据流是否包括匹配于一个特定数据模式的数据串。如果是，则数据处理器进行一个指定的行动。该数据处理器可重新编程，以搜索数据包看其是否存在不同的数据模式和/或当检测到匹配串时进行不同的行动。一个重配置装置接收来自用户的指定数据模式和行动的输入，处理该输入以产生为重编程数据处理器所必须的配置信息，并将配置信息传送给包处理器用于对其重新编程。
Description
技术领域
本发明涉及高速处理数据，如在计算机网络上传输的数据包。更具体地说，本发明涉及处理包有效载荷，以(1)检测在那些有效载荷中是否存在匹配于一个可重定义的数据模式的串，以及(2)在检测到该串时采取一个可重定义的行动。
背景技术
高度希望有能力监视在计算机网络上传输的数据的内容。其动因不论是要识别含有诸如有版权的音频、影片/视频、软件、出版的文章和书籍内容等的数据文件的传输，要检测和消除计算机病毒，要把保密的数据限定在公司的内部计算机系统，要识别和定位可能是犯罪阴谋一部分(如两个计划犯罪的人之间的电子邮件传输)的数据包，还是要监视目标实体的数据传输，在当今的电子信息时代，从包有效载荷中搜索与指定数据模式匹配的数据串的能力是一个强有力的工作。再有，除了其他作用外，修改数据流的能力允许系统过滤数据、重新格式化数据、在不同语言之间进行翻译、提取信息、插入数据或通告其他人关于该内容的信息。
数据串匹配和模式匹配一直是大量研究工作的主题。在过去，基于软件的串匹配技术已被用于确定一个包有效载荷是否包括一个数据模式。然而，这种基于软件的技术不适于在计算机网络中广泛应用，因为软件的执行造成固有的慢的包处理速度。
例如，赋予Hile等的美国专利5,319,776号(其内容在这里被引入作为参考)公开了一个系统，在其中使用一个有限状态机测试源介质和目的地介质之间传送的数据，该状态机能确定该数据是否包括代表已知计算机病毒签名的任何数据串。然而，因为Hile的有限状态机是以软件实现的，所以Hile系统的速度慢。这样，Hile系统不适于用作能处理高速线速率(line rate)的网络设备，如OC-48，那里数据速率达到每秒2.5千兆位。再有，基于软件的技术在传统上和固有地比基于硬件的技术慢数个量级。
另一个基于软件的串匹配技术可在赋予Clayton等的美国专利5,101,424中找到(其内容在这里被引用作为参考)。Clayton公开了一种基于软件的AWK处理器，用于监视来自电话交换机的文本流。在Clayton的处理器中，通过电话交换机传送的数据流被加载到一个文本文件中。然后，Clayton的系统(1)处理该文本文件的内容以确定是否在其中发现了特定的数据串，以及(2)在发现了匹配时采取一个指定的行动。如上文描述的Hile系统那样，这一基于软件的技术太慢，以致不适于用作高速网络设备。
再有，本技术领域已知的一个称作SNORT的软件被开发出来用于搜索因特网包以找出报头和有效载荷的组合，这种组合指出在网络上的一台计算机是否已被泄密。这一软件程序是扫描到达网络接口的那些包的“开放源网络入侵检测系统”。通常，数据包到达一个媒体，如以太网。该程序将每个包与一个规则列表中说明的数据进行比较。如果在报头或部分有效载荷中的一些字段与规则匹配，则该程序完成响应任务，如在控制台上打印一条消息、发送一个通告消息或把一个事件记录到数据库中。SNORT的详细情况在SNORT网页http://www.snort.org上描述。如前述系统那样，由于是以软件实现的，SNORT在其匹配任务和响应任务两方面都遭到处理速度慢的影响。
在改进对包有效载荷处理速度的努力中，已设计出具有专用集成电路(ASIC)的系统，它扫描包有效载荷以找出特定的数据串。尽管在ASIC上实现有效载荷扫描表明比基于软件的技术大大地改善了速度，但基于ASIC的系统有很大的灵活性问题。就是说，基于ASIC的有效载荷处理装置不能改变数据包要与之比较的搜索串，因为搜索串的改变必须针对新的搜索串设计新的ASIC(并以新的ASIC替换先前的ASIC)。就是说，每次改变搜索串时都不得不替换进行串匹配的芯片。这种重新设计和替换努力特别耗费时间而且成本高。特别是当要广泛采用这种基于ASIC的系统的时候。
为避免基于软件的模式匹配的低处理速度和基于ASIC的模式匹配的不灵活性，已经利用可重编程硬件(如现场可编程门阵列(FPGA))进行模式匹配。这种基于FPGA的技术在Sidhu，R.和Prasanna，V.的“使用FPGA的快速规则表达式匹配”(IEEE关于现场可编程客户计算机器讨论会(FCCM 2001)，2001年4月)和Sidhu，R.等的“使用自配置在多重上下文FPGA上的串匹配”(FPGA’99：关于现场可编程门阵列的1999 ACM/SIGDA第七次国际讨论会的论文集，217-226页，1999年2月)中被公开说明，它们全文在这里被引用作为参考。
Sidhu的文章公开了一种技术，用于处理由用户指定的数据模式以产生一个非确定型有限自动机(NFA)，它在被编程到FPGA中时可进行操作以确定在应用于它的数据中是否包括与一个数据模式匹配的数据串。然而，Sidhu没能解决当在数据中找到匹配的数据串时一个装置如何还能被编程以进行指定行动等问题，例如对数据进行修改。这样，尽管Sidhu的技术使用FPGA对于可重定义的数据模式进行模式匹配，从而以硬件实现提供高速度并通过FPGA的可重编程方面提供重定义数据模式的灵活性，但Sidhu的技术没能满足本技术领域对这样一种装置的需求，该装置不仅检测匹配的数据串，而且当检测到匹配的串时还能完成指定的行动。
再有，尽管Sidhu的技术能扫描数据流以确定是否存在多个数据模式中的任何一个(如果在数据流中找到P1或P2或...或Pn，则找到一个匹配，其中Pi是数据模式)，但Sidhu的技术不能识别哪个(些)数据模式与数据流中的一个数据串匹配，也不能识别数据流中的哪个(些)数据串与数据模式中的任何一个匹配。
由于对现有的基于FPGA模式匹配技术的能力不满意，这里本发明已经试图设计一个包处理系统，它不仅能以高速和灵活的方式确定一个包的有效载荷中是否包括与一个数据模式匹配的数据串，而且当在该包的有效载荷中找到匹配的数据串时还能进行指定的行动。
这里的发明者之一在设计这样的系统时的早期尝试在这里被称作“世界你好应用”。见Lockwood，John和Lim，David的“世界你好：现场可编程端口扩展器(FPX)的简单应用”(华盛顿大学技术报告。WUCS-00-12，2000年7月11日，该文内容在这里被引用作为参考)。在该世界你好应用中，使用可重编程硬件进行包处理的平台(称作华盛顿大学现场可编程端口扩展器(FPX)(见图10)被以状态机编程，一个字计数器被设计成(1)识别何时在一个包有效载荷的头两个字中存在一个包含字“HELL”后跟字“OXXX”的串(其中每个*代表白空白(white space)，并且(2)当作为一个包有效载荷头两个字找到那个串时，以字“O*WO”代替字“O***”并附加字“RLD。”和“****”作为该包有效载荷的下两个字。由FPX使用的可重编程硬件是现场可编程门阵列(FPGA)。这样，世界你好应用的操作把在有效载荷中具有“HELLO”的包加以修改，以“HELLO WORLD”替换“HELLO”。
尽管世界你好应用的成功操作向这里的发明者们表明在可重编程硬件中实现能进行严格匹配和串替换的电路是可行的，但世界你好应用没有伴随任何能充分利用该应用的可重编程方面的任何装置。就是说，尽管被编程实现世界你好应用的FPGA潜在地是可重编程的，但尚未开发出一种技术允许以自动和有效的方式对FPGA重编程以扫描各包来搜索“HELLO”以外的其他串或以“HELLO WORLD”以外的其他替换串来替换该匹配的串。本发明针对重编程一个包处理器的流水线过程，用以扫描数据包以找出不同的可重定义的数据串并对包括匹配的数据串的包进行不同的可重定义的行动。为达到这一目标，本发明利用规则表达式和awk的能力创建一个可重编程的基于硬件的包处理器，它具有扩展的模式匹配能力和在检测到匹配的数据串时采取指定行动的能力。
规则表达式是公知的定义条件串的工具。一个规则表达式可能匹配若干个不同的数据串。通过在一个模式定义中引入各种规则表达式操作符，这样的模式定义可包括多个不同的数据串。例如，规则表达式操作符“.*”是指“任何数量的任何字符”。这样，规则表达式“c.*t”定义一个数据模式，它包括诸如“cat”、“coat”、“chevrolet”和“coldis the opposite of hot”等数据串。规则表达式操作符的另一个例子是“*”，它是指“零个或多个前面的表达式”。这样，规则表达式“a*b”定义一个数据模式，它包括“ab”、“aab”和“aaab”等数据串，但不包括“acb”或“aacb”。再有，规则表达式“(ab)*c”包括诸如“abc”、“ababc”等数据串，但不包括“abac”或“abdc”。再有，若干规则表达式操作符能组合在一起以在定义模式时具有更大的灵活性。例如，规则表达式“(ab)*c.*z”将包括诸如字母“abcdefghijklmnopqrstuvwxyz”、“ababcz”、“ababcqsrz”和“abcz”等数据串，但不包括“abacz”、“ababc”或“ababacxvhgfiz”。
由于规则表达式在本技术领域是公知的，故没有必要列出所有可能的规则表达式操作符(例如，还有OR(或)操作符“|”，它对“(a|b)”的含义是具有“a”或“b”的任何数据串)以及规则表达式操作符的组合。以上述背景材料中要理解的是，规则表达式向本发明的使用者提供有力的工具，用于定义包括感兴趣数据串的数据模式。
再有，awk是一个著名的模式匹配程序。Awk被广泛应用于在数据中搜索一个模式的具体存在，然后对该数据进行指定的行动。规则表达式能用于定义模式，数据要与该模式进行比较。一旦对规则表达式定义的模式所包含的数据串确定了位置，awk便允许对该数据进行各种指定的操作。指定操作的实例包括简单替换(代替)、背替换(backsubstitution)、保护性替换(guarded substitution)以及记录分离。这些实例只是用于说明，并不覆盖awk处理数据时可用操作的全部范围。
作为对世界你好应用的进一步改进，本发明向使用者提供灵活的定义搜索模式的能力，该搜索模式包括多个不同的搜索数据串，以及对数据包进行各种类似于awk的修改操作的能力。这些特性被纳入本发明的可重编程的硬件中以产生一个包处理器，它具有前所未知的灵活性和速度的组合。
发明内容
于是，这里公开说明一个用于数据流的可重编程数据处理系统。
该系统的一个部件包含一个可重编程数据处理器，用于接收数据流和通过一个可编程逻辑装置(PLD)处理那个数据，该可编程逻辑设备以一个数据处理模块编程，该模块可操作以(1)确定在该数据流中是否存在与可重定义的数据模式匹配的数据串，以及(2)在找到这样的匹配数据串时进行可重定义的行动。数据模式可由规则表达式定义，这样，它可包括多个不同的数据串。再有，由数据处理器处理的数据流可以是在计算机网络上传送的数据包流，在这种情况下，数据处理器是包处理器，数据处理模块是包处理模块。还有，这样的包处理模块可操作以确定所接收包的有效载荷是否包括与该数据模式匹配的数据串。优选地，PLD是一个现场可编程门阵列(FPGA)。
当检测到匹配数据串时，能由数据处理器进行的可重定义行动的实例是修改操作(例如串代替、背替换等awk任务)、删除操作、通告操作(其中，感兴趣的一方被告知已发生了匹配—该通告能包括不同水平的详细情况(包括该匹配数据串的包的副本、与一数据串匹配的数据模式的通告、匹配于一个数据模式的数据串的通告))以及记录保持/统计更新(其中诸如数据流内容等数据被收集)。
该系统的另一部件是用于产生配置信息的装置，可操作用于以数据处理模块对PLD编程，该装置包含：(1)输入端，可操作以接收来自使用者的数据模式和行动命令；(2)编译器，可操作以至少是部分地从所接收的数据模式和行动命令产生配置信息(该配置信息定义数据处理模块，该模块可操作以确定加到该模块的数据流是否包括匹配于所接收的数据模式的数据串)，其中该配置信息可操作以利用数据处理模块对PLD编程。一个发送器可用于将配置信息以编译器传送到PLD，从而将该数据处理模块编程到PLD中。
优选地，该编译器包括一个词汇分析器发生器，它能自动设计数据处理模块。该词汇分析器发生器处理所接收的数据模块，以至少是部分地从中产生模式匹配状态机的逻辑重表达。模式匹配状态机执行的任务是确定一个数据流是否包括与所接收的数据模式匹配的数据串。该模式匹配状态机至少是部分地定义该数据处理模块。
因为其任务是在硬件中进行的，所以本发明的数据处理器能以网络线路速度进行操作。再有，因为具有装置可产生对数据处理器编程所使用的配置信息，所以本发明的数据处理系统能容易地被重新编程，通过向其提供附加的或不同的数据模式，使能在数据包中搜索附加的或不同的数据模式，还能容易地被重新编程以采取附加的或不同的行动以响应对匹配的数据串的检测。一旦由使用者提供这样的输入，编译器便产生为进行重新编程所必须的配置信息，而发送器可能通过计算机网络将那个信息传送给数据处理器。该数据处理器不仅可被重新编程以在数据包中搜索不同的数据模式，而且它还可被同样技术编程以进行不同的包修改操作。因此，本发明的速度和灵活性是现有技术中不可达到的。
因为这一速度和灵活性，本发明的可能应用范围是广泛的。例如，本发明能用于病毒检测。用以固定在本发明包处理器的数据模式可以是包括已知计算机病毒的一个数据模式。这样，本发明可用于检测(并通过修改操作消除)在包传输中存在的任何已知计算机病毒。
再有，本发明能用于监督版权。包处理器能被一个数据模式固定，该数据模式将可靠地检测何时一方具有版权的材料被通过网络传输。例如，具有版权的歌曲、电影以及图像常常通过音频文件、视频文件和图像文件在万维网上传输。通过适当地设计数据模式，以检测何时在包通信内容中存在这类作为，本发明的实践者能利用包处理器检测这类具有版权的作品的传输并在检测到的时候采取适当的行动。
再有，本发明还能用于防止商业秘密和秘密文档的扩散。将商业秘密和/或保密文档存储在其内部计算机系统中的公司能利用本发明防止这类信息未授权地传输到公司内部网网之外。公司的网络防火墙能使用一个包处理器，它被固定为检测和去掉任何未授权的包，这些包被发现包括一个匹配于一个数据模式的数据串，而该数据模式包括那个公司的商业秘密和/或秘密信息。一个公司有广泛的选择来标记它们的保密的/商业秘密的信息，从向这类信息加电子水印(其中数据处理器由该水印固定(key))到为每个保密的/商业秘密的文档/文件设计单独的数据模式，它将可靠地检测何时那个文档/文件被传输。
再有，本发明可由政府调查机构利用，用于监视目标实体在计算机网络上的数据传输。包处理器能被一个数据模式固定，该数据模式包括感兴趣的关键词及其变体。例如，与炸药(即TNT等)、犯罪(即杀人、抢劫等)和/或想找的个人(如已知的恐怖分子、逃亡者等)有关的某些词能被固定于包处理器。一旦被如此配置，包处理器能检测在一个包流中是否存在那些关键词(或变体)，并在检测到的时候采取适当的行动(如通告感兴趣的政府机构或转发该数据供进一步自动处理)。
本发明应用的又一个实例是作为一个语言翻译器。包处理器的搜索和替换能力能被用于检测何时在包中存在一个第一语言的词，并在检测到的时候以其第二语言的翻译词代替它。例如，包处理器能用于在一数据包中检测到词“friend(朋友)”时以其西班牙语翻译“amigo”代替。本发明的包处理器具有在数据包中搜索多个不同数据模式的能力，利用这一事实，本发明能被用作大规模翻译设备，其中包处理器被以大的语言A到语言B字典固定。再有，本发明的实践者有可能开发出一些数据模式，它们不仅考虑词到词的翻译，还将考虑语法问题(例如，以名词后跟随形容词的西班牙语方法符合于名词前加形容词的英语方法)。
再有，本发明能用于监视/过滤包传输中的讨厌的内容。例如，父母可能希望使用本发明的包处理器来防止儿童在因特网上接收亵渎神圣/或色情的材料。通过固定数据处理器以搜索和删除亵渎神圣的或潜在的色情材料，父母能防止这类讨厌的材料达到他们家的计算机。
另一个可能的应用是作为加密/解密设备。包处理器能被设计成以其替换代码代替各种词或字母，从而加密为该网络设计的包。在接收端，包处理器能被装备成通过以原始数据代替替换代码来对加密的包解密。
这些只是本发明的可能应用的一少部分。本领域普通技术人员将会容易地认识到本发明的其他应用，因此，本发明的范围不应限定于上述应用，那些应用只是作为本发明具有的广泛用途的示例。在审阅下文的描述和所附权利要求后，将能确定本发明的全部范围。
附图说明
图1(a)是本发明的包处理系统的总体视图；
图1(b)是本发明的包处理器搜索和替换能力的示例；
图2总体说明如何能在高速计算机网络上实现本发明的包处理系统；
图3总体说明一个被编程到PLD中的模块，该PLD的操作能提供包处理能力；
图4总体说明一个被编程到PLD中的模块，该PLD的操作能提供包处理能力，其中该模块具有对不只一个数据模式的搜索和替换功能；
图5是搜索和替换逻辑的框图，该逻辑可操作以确定到来的数据是否包括一个匹配于指定数据模式的数据串并以替换串代替任何匹配的数据串；
图6说明一个包以及构成该包的那些字的内容；
图7(a)和7(b)是流程图，说明控制器如何确定一个匹配串的起始位置和终止位置；
图8是流程图，说明控制器如何控制数据输出，包括以替换串代替匹配串；
图9是流程图，说明替换缓存器的操作；
图10是流程图，说明字节到字转换器的操作；
图11是流程图，说明控制器如何考虑修改后的包的字节长度的改变；
图12显示现场可编程端口扩展器(FPX)平台；
图13总体说明本发明的重配置装置；
图14是流程图，说明编译器的操作。
图15显示搜索和替换逻辑的匹配路径的一个实现，其中多个模式匹配状态机并行操作；以及
图16是流程图，说明控制器如何控制数据输出，其中数据修改操作是背替换操作。
具体实施方式
在图1(a)和1(b)中显示本发明的包处理系统的总体视图。包处理器进行操作以接收在计算机网络上传送的数据包并扫描那些包，以确定它们是否包括与指定数据模式匹配的数据串。如果发现该包包括一个匹配的数据串，则包处理器进行指定的行动，如数据修改(如串替换)、包删除、通告或某种其他行动。例如，包处理器能被配置成确定一个包是否包括串“recieved”，如果发现那个串，则修改该包，以适当拼写的替换串“received”替代“recieved”的每个实例。或者，包处理器可被配置成确定一个包是否包括指示一个计算机病毒的串，如果发现这样的串，则删除该包。再有，包处理器可被配置成如果发现一个匹配串则向另一个装置发送通告包或通告信号。在检测到匹配串时包处理器可能进行的行动的这一列表只是演示性的，本发明可利用响应匹配检测的各种行动中的任何行动。
包处理器的一个重要特性是它是可以重新编程的，从而扫描数据包以发现不同的数据模式和/或进行不同的指定行动。驻留在包处理器上的一个可编程逻辑装置(PLD)被以一个模块编程，该模块可操作以提供模式匹配功能，并且，如果发现一个匹配，则进行指定的行动。通过重新配置PLD，包处理器能被以新的模块编程，这新的模块可操作扫描包以搜索不同的数据模式和/或在发现匹配时进行不同的行动。因为包处理器依赖硬件进行模式匹配，所以它能以网络线路速度扫描所接收的包。这样，包处理器能用作处理以网络速率(如OC_48)传输的数据流的网络装置。
为对包处理器重新编程，重配置装置通过网络向包处理器传送配置信息。该配置信息定义要被编程到PLD中的模块。在通过网络接收配置信息后，包处理器根据所接收的配置信息配置PLD。
重配置装置由用户输入产生配置信息。优选地，这一输入包括要将数据包与其进行比较的数据模式以及指定在检测到匹配模式时要采取的行动的行动命令。一旦收到来自用户的这一输入，重配置装置便从中产生配置信息，该配置信息定义一个固定于(keyed to)从用户接收的数据模式和行动命令的模块。
图1(b)说明包处理器如何操作以进行一个简单的搜索和替换任务。在图1(b)的例子中，被编程到包处理器中的模块以数据模式“U.*S.*A”调谐，它的意思是一个U，后跟任何数量的任何字符，后跟一个S，后跟任何数量的任何字符，后跟一个A。当在一个包中发现一个匹配于该模式的串时，该模块也被固定于以替换串“UnitedStates”代替匹配的串。这样，当由包处理器接收和处理一个包，该包的有效载荷部分包括串“I live in the USA”时，那个包将被修改，使得输出包的有效载荷部分包括串“I live in the United States”(串“USA”将被检测到并以“United States”替换)。
图2显示包处理器用作一个网络装置。在一个优选实现中，包处理器能被用作N×N包交换器和携带数据流进、出包交换器的线路卡之间的接口。当希望包处理器被重新编程以扫描数据包寻找一个不同的数据模式(或另一个数据模式)或在发现匹配时进行一个不同的行动(或另一个行动)时，重配置装置产生必要的信息并通过网络向包处理器传送该信息以对其重新编程。
图3是优选的要被编程到PLD中的包处理模块100的总体视图。首先由协议打包器(protocol wrapper)102处理到来的数据。在输入一侧，协议打包器102进行操作以处理到来的包中的各种报头信息并向搜索和替换逻辑(SRL)104提供控制信息，它允许SRL104勾划出包的不同部分。优选地，由协议打包器102向SRL104提供的控制信息是指示一包第一个字的帧起始(SOF)指示符、当该包中的后续字被传送到SRL104时断言的DATA_EN信号、标识UDP报头第一个字的数据报(datagram)起始(SOD)以及标识该包有效载荷最后一个字的帧结束(EOF)。
图6描绘一个数据包的各个部分和字的位置。第一个字是ATM报头。SOF信号以ATM报头的到达来认定，在ATM之后将有由至少5个字构成的IP报头。以IP报头第一个字开始断言DATA_EN信号，并对该包中所有后续的字保持断言。在IP报头字之后，UDP报头的第一个字位于字位置X。以UDP报头的第一个字断言SOD信号。UDP报头包含两个字，在字位置X+2，这是包有效载荷部分的开始。以在字位置X+n的有效载荷部分最后一个字断言EOF信号。这样，有效载荷包含数量L个字(L＝n-2)。接下来在字位置X+n+1和X+n+2的两个字包含该包的报尾。
协议打包器的一个优选实施例包括一个单元打包器(cellwrapper)，它确认到来(输入incoming)的包到达于适当的虚拟回路或流标识符上；一个帧打包器，它把到来的包分段成单元并把输出的单元组装成包；一个IP打包器，它确认每个到来的IP包有正确的校验和并为每个输出的IP包计算新的校验和及长度；以及UDP打包器，它确认每个到来的UDP包有正确的校验和及长度，并为每个输出的UDP包计算新的校验和及长度。
优选的作法是只对包的有效载荷部分进行模式匹配。在这种情况下，SRL 104使用来自协议打包器102的控制信息(SOF、DATA_EN、SOD和EOF)来识别包中构成有效载荷的那些字，并只对那些字进行模式匹配。
再有，如果希望的话，可由本发明的实践者包括附加的打包器，如TCP打包器。一个TCP打包器将读和计算校验和，从而使到来的包被组装成一个连续的数据流，该数据流与被传输的数据流完全相同。TCP打包器将去掉在同一包的多个副本中到达的数据并对失序到达的包重新排序。
协议打包器的设计和操作是本技术领域公知的。例如，见F.Braun，J.W.Lockwood和M.Weldvogel的“在可重配置的硬件中进行因特网包处理用的分层协议打包器”，华盛顿大学技术报告WU_CS_01_10，在St.Louis的华盛顿大学，计算机科学系，2001年6月，该文的内容在这里被纳入作为参考。
所接收的数据包作为32位字流到达SRL。再有，如前所述，SRL104将接收每个字的4位控制信息。SRL以来自重配置装置的数据模式调谐，并进行操作以确定在到来的字流中是否存在一个由那个数据模式包括的串。SRL 104还以一个替换串调谐，以当在到来的字流中发现匹配串时进行串修改操作。可由SRL 104进行的修改操作的实例是任何基于awk的修改命令，包括直接替换(以一个替换串代替包中的一个匹配串)、背替换(back substitution)(以一个替换串代替包中的一个匹配串，其中的替换串包括该包中发现的造成该匹配的实际串)以及被保护替换(在该包中造成该匹配的串之前或之后，添加一个串或从该包中去掉一个存在的串)。
如图4中所示，模块100可包括N个SRL 104，菊化链式链接在一起。每个SRL能被固定于一个与其他不同的数据模式和一个与其他不同的修改命令。通过允许本发明的包处理器对不只一个数据模式扫描数据包，包处理器的能力被大大增强。例如，如果已知在一个计算机网络上有3个不同的计算机病毒在散布，模块100能包括3个不同的SRL 104，每个被固定于为这些计算机病毒之一设计的数据模式。当这些SRL的任何一个检测到包中一个与其模式匹配的串时，该SRL能从该包中去掉该病毒。
图5中显示SRL 104的示意图以及电路中有关信号的列表。SRL104的操作在匹配路径110、数据路径112和控制器114之间划分。匹配路径110确定到来的数据流是否包括与指定数据模式匹配的数据串。数据路径112输出到来的数据流，并且，如果必要的话，根据指定的修改操作修改那个数据流。控制器114使用来自协议打包器的控制位和它从匹配路径接收的控制信号，以协调和控制匹配路径110和数据路径112二者的操作。
如前所述，匹配路径110的主要任务是确定一个输入流是否包括一个与指定数据模式匹配的数据串。匹配缓存器(MB)从协议打包器接收一个35位的流信号(S1)。32位将是该包的一个字，3位将是SOF指示符、SOD指示符和EOF指示符。优选地，这到来的字作为高32位存储在匹配缓存器(MB)中由来自控制器114的DATA_WR_ADD信号(CS1)标识的地址，而控制位作为低3位存储。如果匹配缓存器(MB)满，则控制器断言CONGESTION(阻塞)信号，它通知协议打包器停止发送S1上的数据。MB将输出缓存在其中由来自控制器114的MB_RD_ADD信号(CS2)指定地址的一个字。然后，从MB输出的上32位(到来包的词)(S2)被传送给字到字节转换器1(WBC1)。低3位(该字的控制位)被传送到控制器(S3)，从而控制器能决定如何处理与之对应的32位字。
WBC1进行操作以把到来的字流转换成输出的字节流。优选地，WBC1是一个多路转换器，它具有每片8位的4个输入组。每个输入组将是从MB输出的32位字的一个字节。来自控制器的WBC1_SELECT信号(CS3)标识该字的哪个字节要传送到WBC1的输出端(S4)。
由规则表达式有限状态机(REFSM)接收WBC1的输出。REFSM是模式匹配状态机，它处理到来的字节流以确定那个字节流是否包括与它所固定的数据模式匹配的数据串。优选地，REFSM模式匹配状态机是作为确定性有限自动化(DFA)实现的。当控制器断言REFSM_ENABLE信号(CS4)时REFSM处理来自WBC1的字节。优选地，只有当S4中存在该包有效载荷的一个字节时控制器才断言REFSM_ENABLE。
当处理一个字节时，REFSM将产生一个输出信号REFSM_STATUS，指出当前被处理的字节如何匹配或不匹配它所固定的数据模式。REFSM_STATUS可指出RUNNING(运行)状态(可能的匹配)、RESETTING(复位)状态(不匹配)或ACCEPTING(接受)状态(已发现一个匹配串)。REFSM_STATUS将标识REFSM的当前状态和下一个状态二者，这取决于正在被REFSM处理的当前字节。如果REFSM处理一个字节并确定该字节是可能匹配该数据模式的一个数据串的一部分(例如，已由REFSM看到的串是“abc”，当前字节是“d”，而数据模式是“abcde”)，则REFSM_STATUS的当前和下一个状态将是RUNNING。如果REFSM处理一个串的一个字节，而该串是该数据模式的充分匹配(现在“e”字节已被接收)，则由REFSM_STATUS标识的下一个状态将是ACCEPTING。然而，必须指出，当匹配赋值是一个最长匹配赋值时，ACCEPTING状态并不必定表明REFSM的模式匹配任务完成了。取决于数据模式被如何定义，由REFSM处理的后续字节也可能匹配该数据模式。例如，如在RE格式中表示的数据模式是“abc*”(意思是该数据模式是一个“a”后跟一个“b”，再后跟一个或多个“c”)，一旦REFSM已处理了一个字节流“abc”，则将是已经发生了一个匹配，REFSM将处在ACCEPTING状态。然而，如果下一个字节也是“c”，则串“abcc”也将匹配该数据模式。这样，当处在ACCEPTING状态时，REFSM将不得不保持为将要继续匹配的后续字节一直警觉着。REFSM将在接收和处理一个不是“c”的字节时才会知道已发生了一个完全匹配。
当其当前状态是ACCEPTING而其下一个状态是RESETTING(表明当前字节造成匹配失败，因而前一个字节是完全匹配)时，REFSM_STATUS将标识一个充分匹配。在上述举例中(其中RE是“abc*”)，当输入串是“abcccd”时，在处理“a”之后REFSM将开始RUNNING，当第一个“c”被处理时，REFSM将开始ACCEPTING，而当最后一个“c”被处理时REFSM将MATCH(匹配)，其后的“d”使状态机RESET(复位)。
RESET将向控制器114提供REFSM_STATUS信号(CS5)以向控制器通告它的当前状态和它的下一个状态(它将取决于当前字节)。控制器将处理REFSM_STATUS信号，以确定一个完全匹配的MB字地址及第一个和最后一个字节在那个字中的字节位置。图7(a)和7(b)说明在这一方面控制器如何控制匹配路径110的操作。
步骤7.1-7.7进行对匹配缓存器(MB)中的字所关联的控制位的处理，以识别MB中的构成包有效载荷的那些字。在步骤7.1，MB_RD_ADD信号被设为等于1。然后控制器断言MB_RD_ADD(步骤7.2)，并且在MB中存储于那个地址的字被作为S2输出，同时，与那个字关联的控制位被作为S3输出。在步骤7.3，控制器检验SOF位是否被断言。如果是，则控制器知道在MB中存储于MB_RD_ADD的字是该包的ATM报头。回来参考图6，已知UDP报头可能在字位置7开始(如果IP报头是5个字长的话)。这样，当希望REFSM只处理包的有效载荷时，控制器将调节MB_RD_ADD以开始搜索UDP报头(一旦发现UDP报头的第一个字，则已知有效载荷的第一个字是在两个字位置之后)。这样，在步骤7.4，控制器设置MB_RD_ADD等于MB_RD_ADD+6并环回到步骤7.2。
其后，在下一个过程中，控制器将到达步骤7.5，并检验存储在MB中由新调节的MB_RD_ADD信号标识的地址处的字所关联的SOD位。如果SOD位被断言，则控制器知道存储在MB中两个地址之后的那个字是有效载荷的第一个字。这样，如果SOD为高值，则控制器设置MB_RD_ADD等于MB_RD_ADD+2(步骤7.7)并在步骤7.8开始模式匹配过程。如果SOD位不是高值，则控制器使MB_RD_ADD增量，直至发现SOD位为高值的字为止(步骤7.6)。
从步骤7.8开始，开始模式匹配过程。包有效载荷的第一个字从MB中输出，REFSM_ENABLE信号被断言。接下来，在步骤7.9，参数BYTE_POS_IN被设置为1。这一参数用于标识被传送到WBC1输出端的S2中的字的字节。控制器断言WBC1_SELECT＝BYTE_POS_IN，从而把当前字的第一字节传送给REFSM(步骤7.10)。
然后，REFSM处理那个字节并相应地断言REFSM_STATUS信号。控制器将读这一信号(步骤7.11)。接下来，在步骤7.12，控制器检验REFSM_STATUS信号是否指出REFSM的当前状态是RUNNING状态。如果当前状态是RUNNING，则控制器前进到步骤7.13并把MB_RD_ADD和BYTE_POS_IN作为参数BACK_PTR存储。控制器从那里前进到步骤7.20，在那里它开始寻找要处理的下一个字节的过程。参数BACK_PTR将是由REFSM处理的当前字节的运行(running)代表，直至REFSM的当前状态为RUNNING为止，在此时，BACK_PTR之值被冻结。由于REFSM中的双稳态(flip_flop)特性，在接收可能匹配的第二个字节之前REFSM_STATUS将不把当前状态标识为RUNNING。这样，当REFSM_STATUS标识当前状态为RUNNING且BACK_PTR被冻结时，由BACK_PTR标识的字和字节位置将是可能匹配串的第一字节。
如果在步骤7.12控制器由REFSM_STATUS确定REFSM的当前状态为RUNNING(意思是当前字节可能为一个匹配串的一部分)，则控制器将前进到步骤7.14并检验由REFSM_STATUS信号标识的下一个状态是否为RESETTING。如果下一个状态是RESETTING，则表明当前字节已使这部分匹配失败。如果下一个状态不是RESETTING，则控制器(在步骤7.15)检验下一个状态是否为ACCEPTING。如果下一个状态既不是RESETTING也不是ACCEPTING，则表明下一个状态仍为RUNING，在这种情况下控制器前进到步骤7.20，跟随得到有效载荷下一个字节的过程。
如果在步骤7.15控制器确定下一个状态是ACCEPTING，则表明REFSM已发现一个完全匹配，但尚未确定该匹配的完全边界。然而，控制器的确知道当前字节的字地址和字节位置可能是该匹配的最后字节的字地址和字节位置。这样，控制器在步骤7.16将MB_RD_ADD和BYTE_POS_IN作为值ACCEPT_PTR存储。然后，在步骤7.17，控制器通告已发生一个匹配并前进到步骤7.20以得到下一个字节。
当下一个字节被处理并再次到达步骤7.14时，控制器将再次检验由REFSM_STATUS标识的下一个状态是否为RESETTING。如果下一个状态是RESETTING，则控制器前进到步骤7.18，在那里它检验是否先前已由控制器通告了一个匹配。如果尚没有被通告的匹配，控制器将确定以BACK_PTR标识的字节开始的数据串不是该数据模式的一个匹配。这样，控制器需要设置MB_RD_ADD和BYTE_POS_IN，使得REFSM将处理紧跟在BACK_PTR之后的字节，因为存储在那个地址的字节需被检验以确定它是否可以是一个匹配串的开始。控制器通过把MB_RD_ADD和BYTE_POS_IN设置为等于存储在BACK_PTR中的值(步骤7.19)来实现这一点。控制器从那里前进到步骤7.20以得到下一个字节。
然而，在该例中控制器已在步骤7.17通告发生了一个匹配，于是，当控制器其后到达步骤7.18时，控制器将前进到步骤7.29。当达到步骤7.29时，则表明已由REFSM处理了一个匹配串的完全边界。当前字节已使REFSM确定它的下一个状态是RESETTING。然而，前一个字节(它的位置由ACCEPT_PTR标识)将是该匹配串的最后一个字节。再有，BACK_PTR的值将是该匹配串的第一个字节的地址。这样，控制器将知道包有效载荷中的最长匹配串的第一个和最后一个字节的地址。在步骤7.29，控制器将把BACK_PTR之值作为START_ADD(图5中的CS6)存储在FIFO A中，再有，控制器将把ACCEPT_PTR之值作为END_ADD(图5中的CS8)存储在FIFO中。接下来，在步骤7.30，控制器将清除它的匹配通告。然后，在步骤7.31，控制器将把MB_RD_ADD和BYTE_POS_IN设置为在ACCEPT_PTR中存储的值并前进到步骤7.20，从而处理紧跟在由ACCEPT_PTR标识的字节之后的字节。一旦START_ADD在FIFO A中排队和END_ADD在FIFO B中排队，控制器将能够适当地修改输出包，因为它将知道要修改的包中最长匹配串的边界。
从步骤7.20起，控制器开始获得下一个字节的过程。在步骤7.20，BYTE_POS_IN被增量，然后在步骤7.21控制器检验BYTE_POS_IN是否大于4。如果BYTE_POS_IN不大于4，则控制器知道在WBC1输入线上的当前字的另一字节需要处理。这样，控制器循环回到步骤7.10，开始处理那个字节。如果BYTE_POS_IN大于4，则控制器知道当前字的全部字节已被处理需要获得MB中的下一个字。在得到下一个字之前，控制器检验当前字的EOF位是否为高值(步骤7.22)。
如果EOF位为高值，则表明当前字是有效载荷的最后一个字，在这种情况下，对于该包的模式匹配过程完成。REFSM_ENABLE被否认，MB_RD_ADD被设置为等于MB_RD_ADD+3，于是开始处理下一包(步骤7.27和7.28)。再有，考虑到该包有效载荷的最后一个字的最后一个字节是造成存在完全匹配条件的情况，控制器通过步骤7.24、7.25和7.26前进，这些步骤平行步骤7.18、7.29和7.30。如果EOF位不为高值，则表明当前字不是该有效载荷的最后一个字，于是下一个字的各字节需要通过REFSM处理。这样，控制器对MB_RD_ADD增量(步骤7.23)并循环回到步骤7.8以开始处理在MB中存储在MB_RD_ADD处的字。
数据路径112的主要任务是输出到来的数据并在必要时修改那个数据。在数据路径中的替换缓存器(REPBUF)存储要插入数据流中以替代每个匹配串的替换串。如下文中解释的那样，REPBUF和MUX一起作为一个串替换机。REPBUF中的替换串是在第一次产生包处理模块时由用户提供的。
数据缓存器(DB)将像MB那样接收这同样的35位(S1)。控制器也将使用这同一个DATA_WR_ADD(CS1)控制向DB写入字，如它对MB所做的那样。DB和MB将是完全相同的缓存器。控制器将使用DB_RD_ADD信号(CS11)控制要从DB中读取哪些字。
字到字节转换器2(WBC2)将像WBC1那样操作；它将把到来的32位字(S7)分开成4个字节并根据WBC2_SELECT信号(CS12)把那些字节送到WBC2的输出端。信号S6将携带从DB中的地址DB_RD_ADD读出的字所关联的3个控制位。
在匹配路径已确定一个字节是否是一个匹配串的一部分之前，该字节不能用于从数据路径输出。图8说明如何实现这一保护。在DB_RD_ADD和BYTE_POS_OUT被初始化(步骤8.1和8.2)之后，控制器将DB_RD_ADD与存储在BACK_PTR中的MB_RD_ADD进行比较(步骤8.3)。如果一个字的地址大于或等于存储在BACK_PTR中的MD_RD_ADD，则控制器将不从DB中读出那个字。在这种情况下，控制器等待BACK_PTR中的MB_RD_ADD增大到超过DB_RD_ADD。当DB_RD_ADD小于BACK_PTR中的MB_RD_ADD时，控制器前进到步骤8.4并检验匹配路径是否已发现一个匹配(FIFOA是空的吗？)。如果尚未由匹配路径发现匹配，则控制器遵循步骤8.6至8.11输出那个字的各字节。
在步骤8.6，DB_RD_ADD被断言，从而把DB中存储在那个地址的字传送到WBC2(S7)。在步骤8.7，WBC2_SELECT被设置为等于BYTE_POS_OUT，从而使BYTE_POS_OUT所标识的字节传送到WBC2输出端(S9)。然后，在步骤8.8，MUX_SELECT被断言，以把WBC2的输出传送到MUX的输出端(S10)。然后，控制器使BYTE_POS_OUT增量并重复步骤8.7至8.10，直至当前字的每个字节被传过MUX。当所有字节已传过MUX时，DB_RD_ADD被增量(步骤8.11)，控制器循环回到步骤8.2。
如果步骤8.4的结果是确定存在START_ADD在FIFO A中排队，则控制器将DB_RD_ADD与以FIFOA开头处的START_ADD存储的MB_RD_ADD进行比较(步骤8.5)。如果DB_RD_ADD小于以START_ADD存储的MB_RD_ADD，到遵循步骤8.6至8.11，因为在DB_RD_ADD的字不是一个匹配串的一部分。然而，如果DB_RD_ADD等于以被解除排队的START_ADD存储的MB_RD_ADD，则接下来控制器需要识别当前字(在DB_RD_ADD的字)的哪个字节是该匹配串的起始字节。这样，在步骤8.13(在步骤8.12 START_ADD被从FIFOA中解除排队之后)，控制器将BYTE_POS_OUT与存储在START_ADD中的BYTE_POS_IN进行比较。如果BYTE_POS_OUT不等于存储在START_ADD中的BYTE_POS_IN，则那个字节不是匹配串的一部分，于是控制器遵循步骤8.14至8.16，将那个字节传送到MUX输出。步骤8.14至8.16平行于步骤8.7至8.9。最终，当控制器返回到步骤8.13时，BYTE_POS_OUT将匹配于以被解除排队的START_ADD存储的BYTE_POS_IN。当这一情况发生时，控制器在步骤8.17启动串替换过程。
在步骤8.17，控制器断言REPBUF_ENABLE(CS13)，然后断言MUX_SELECT，使得替换缓存器(REPBUF)的输出(S8)被传送到MUX输出端。当REPBUF被允许时，它开始输出在其中存储的替换串的字节。因为MUX_SELECT被断言把S8传送到MUX输出端，数据路径将把REPBUF中存储的替换串插入到数据流中。通过把替换串传送到MUX输出端而不是传送匹配串，从而使数据路径以替换串代替数据流中的匹配串。图9说明REPBUF的操作。
REPBUF将有一个存储替换串各字节的阵列。指针ARRAY_RD_ADD将标识替换串的哪个字节要被输出。在步骤9.1对ARRAY_WD_ADD初始化之后，REPBUF检验来自控制器的REPBUF_ENABLE信号(步骤9.2)。一旦接收到REPBUF_ENABLE信号，REPBUF便输出存储在ARRAY_RD_ADD的字节。在步骤9.3，REPBUF检验ARRAY_RD_ADD是否指向替换串的最后一个字节。如果不是，则ARRAY_RD_ADD被增量并输出下一个字节(步骤9.6，返回9.3)。当REPBUF_RD_ADD达到替换串的最后一个字节时，REPBUF_DONE(CS14)被断言以通知控制器整个替换串已被输出(步骤9.5)，并使ARRAY_RD_ADD复位到它的初始值。返回图8，在REPBUF_ENABLE被断言和MUX_SELECT被断言以把S8传送到S10之后，控制器等待来自REPBUF的REPBUF_DONE信号(步骤8.19)。一旦收到REPBUF_DONE信号，控制器确定通过数据路径处理的下一个字节。这下一个字节将是紧跟在匹配串最后一个字节之后的字节。控制器通过使END_ADD从FIFOB的开头解除排队(步骤8.20)、和设置DB_RD_ADD及BYTE_POS_OUT等于END_ADD中的值(步骤8.21)来实现这一目的，然后返回步骤8.3。
退出MUX的字节流(S10)一旦已被转换成字流便准备退出SRL。字节到字转换器(BWC)将完成这一任务。图10说明BWC的操作。控制器从BWC_ENABLE信号(CS16)控制BWC的操作。BWC中的计数器将跟踪所接收的每个字节。计数器被初始化在0处(步骤10.1)。BWC还跟踪需要多少补充字节来完成一个字。例如，如果由BWC组装的字是有效载荷的最后一个字，而且对那个字只收到两个字节，则需要补充两个字节来完成那个字。这样，参数PADDING_COUNT将用作BWC还需要多少字节来完成该字的滑动(running)表达。在步骤10.2，PADDING_COUNT被设置为等于(4-计数器)。在步骤10.3，BWC检验控制器是否已断言BWC_ENABLE信号。如果是，则BWC从MUX输出端接收一个字节(或者可能通过S12从控制器接收一个补充字节)(步骤10.4)。在步骤10.5，BWC检验计数器是否等于3。当计数器等于3时，BWC将知道它已接收的当前字节是一个字的最后一个字节。在这种情况下，当前字节与BWC已存储的其他3个字节一起被作为32位字传送到BWC输出端(S11)(步骤10.6)。再有，因为该字中没有任何字节是补充字节，所以PADDING_COUNT将等于0。BWC向控制器提供PADDING_COUNT信号(CS17)。于是控制器能决定是否需要通过信号S12向BWC传送补充字节。从步骤10.6，BWC返回步骤10.1并使计数器复位。
如果在步骤10.5计数器不等于3，则在步骤10.7WBC将所接收的字节存储在一个内部地址BWC_ADD，这里BWC_ADD等于计数器值。然后，计数器被增量(步骤10.8)。BWC返回到步骤10.2。
图11显示控制器如何处理来自BWC的PADDING_COUNT信号以确定是否需要向BWC提供补充字节。在步骤11.1，控制器接收来自BWC的PEDDING_COUNT，在步骤11.2，控制器设置参数TRACK_PADDING等于PADDING_COUNT。然后，控制器检验在由BWC构建的字是否是该包有效载荷的最后一个字(步骤11.3)。由于该替换过程，有效载荷的长度可能被改变，这可能造成需要使用补充字节来充满有效载荷的最后一个字。如果在构建的字是有效载荷的最后一个字，则在步骤11.4，控制器检验TRACK_PADDING是否大于0。如果是，则在步骤11.5一个补充字节被发送到BWC(S12)，TRACK_PADDING被增量(步骤11.6)，于是控制器返回到步骤11.4。如果11.4的结果是确定TRACK_PADDING等于0，则不需要补充字节，控制器返回到步骤11.1。
再有，串替换过程可能造成需要改变包的报头和报尾。控制器被配置成对报头和报尾进行必要的改变。通过S11退出BWC的字将被传送到协议打包器102供最终输出。由控制器断言输出字的控制位作为S13并传送给协议打包器102。
因为已描述了包处理模块，注意力可转移到在其中实现该模块的硬件。用于包处理器的一个优选平台是华盛顿大学的现场可编程端口扩展器(FPX)。然而，必须指出，本发明能在其他平台上实现，只要该平台包括具有支持装置的PLD，该支持装置能以不同的模块对该PLD重新编程。
关于FPX平台的详情是本技术领域公知的。例如，见JohnLockwood等的“在现场可编程端口扩展器(FPX)上的可重编程网络包处理”，关于现场可编程门阵列的ACM国际讨论会(FPGA 2001)，Monterey，CA，2001年2月11-12；还可见John Lookwood的“可演变的因特网硬件平台”，关于可演变硬件的NASA/DOD工作组(EHW’01)，Long Beach，CA，2001年7月12-14，第271-279页；以及John Lockwood等的“用于分布式引导路由和排队的现场可编程端口扩展器”，关于现场可编程门阵列的ACM国际讨论会(FPGA2000)，Monterey，CA，2000年2月，第137-144页，它们的内容在这里被纳入作为参考。FPX的框图示于图12中。FPX 120的主要部件是可重编程应用装置(RAD)122和网络接口装置(NID)124。
RAD 122是一个现场可编程门阵列(FPGA)。一个优选的FPGA是由Xilinx公司(San Jose，CA)制造的Xilinx XCV 100E。然而，在其上具有足够多的门以处置本发明的包处理模块的任何FPGA都是适用的。被编程到RAD 122中的将是如结合图3-11描述的包处理模块。在一个优选实施例中，RAD 122能被以两个模块编程，一个处置到来的传输量(从线路卡到交换器的数据)，一个处置输出的传输量(从交换器回到线路卡的数据)。为进行进、出处理，一组SRAM和SDRAM用于缓存到达的数据，而另一组SRAM和SDRAM用于缓存离开的数据。然而，应该指出，RAD 122能以任何数量的模块实现，取决于FPGA上的门个数。
NID 124通过识别到来的传输量(它可能是来自交换器或线路卡)并将其引导到适当的模块和识别输出的传输量(它可能是去向交换器或线路卡)并将其引导到适当的输出端来实现RAD与外部世界的接口。优选地，NID也是一个FPGA，但不需如此。NID 124的另一个任务是控制RAD的编程。当重配置装置将配置信息传给包处理器从而以新的模块对包扫描器重新编程时，NID 124将通过读取由重配置装置放在配置信息所驻留的包内的报头，把该配置信息识别为配置信息。当NID接收配置信息时，该配置信息被存储在RAD编程SRAM126中。一旦NID已将全部配置信息存储在RAD编程SRAM中，NID将等待来自重配置装置的一个指令包，它指示NID以存储在SRAM126中的配置信息所定义的模块对RAD重新编程。一旦接收了指令包，NID便通过从SRAM 126中读出配置信息并将其写入FPGA的重配置端口来把配置信息加载到RAD中。
使得要把FPX用于本发明的另一个FPX特性是FPX能部分地重编程RAD而同时RAD仍能以存在的模块执行任务。FPX通过允许配置流包含一些指令来支持RAD的部分重编程，这些指令只指定RAD上的一部分逻辑要被编程。不是发出命令初始化该装置，NID只是向RAD的重编程端口写入配置信息帧。这样，在RAD上的现有模块能在部分配置过程中继续处理数据包。
本发明的重配置装置的总体视图示于图13中。重配置装置的主要部件是一个编译器和一个发送器，该编译器接收来自用户的输入并由该输入产生配置信息，用于对包处理器重编程，该发送器通过网络将配置信息传送给包处理器。优选地，该重配置装置在连接于网络的通用计算机上实现，其中该编译器优选为驻留其上的软件，而且其中的发送器利用也驻留在该计算机上的网络接口。然而，本领域普通技术人员会容易地认识到其他实现。
本发明的编译器是一个有力的工具，它允许用户以最小的努力对可重编程的包处理器重新编程。要用户做的全部事情是向编译器提供一个数据模式和一个行动命令，而编译器自动地完成设计模块和创建为把该模块编程到包处理器中所必须的配置信息等高强度任务。这一流水线过程提供了对高速包扫描器重新编程时的灵活性，而这是本技术领域先前不知道的。
作为输入，编译器从用户接收两个项目：(1)规则表达式，它定义扫描包时所针对的数据模式；(2)行动命令，它指出当发现有匹配串的包时包处理器要如何响应。由这一输入信息，编译器产生图5的两个动态部件——模式匹配状态机(REFSM)和替换缓存器(REPBUF)。REFSM将被调谐到确定施加于它的数据是否包括与用户指定数据模式匹配的数据串，而当行动命令指定一个串替换操作时，REPBUF将被调谐在由控制器激活时根据用户指定的替换命令输出一个替换串。
再有，编译器将检索存储在存储器中的图3-5所示静态部件(协议打包器、孪生字缓存器MB和DB、字到字节转换器WBC1和WBC2、控制器、MUX以及字节到字转换器BWC)的VHDL表示。编译器将把动态创建的部件与静态部件集成以创建包处理模式的逻辑表示(优选VHDL表示)。在本技术领域可得到的FPGA合成工具能把该模块的VHDL表示转换成可操作的位图，用于以该模块对FPGA编程。模块的位图用作通过网络传送到包处理器的配置信息。
发送器进行操作使配置信息打包，从而能在网络上传送给包处理器。对以计算机网络为目的地的数据打包是本技术领域公知的，无需在此重复。然而，应该指出，发送器需要在含有配置信息的包的报头中包括信息，以允许包处理器把那些包认作含有配置信息(从而包处理器能以那个配置信息对本身重新编程)。
图14说明本发明的编译器的操作。在步骤14.1，编译器从用户接收N个输入行。这一输入可通过输入设备(如键盘)直接来自用户，或者可以通过万维网接口间接地来自用户，或者可以通过附加软件间接地来自用户。优选地，这一输入以RE和awk格式提供。在附录A中包括一个用户能提供给编译器的输入实例。附录A中所示实例是一个搜索和替换操作，其中的数据模式(由RE定义)是“t.*t”，替换串是“this is a test”。编译器将从这一输入产生配置信息，它定义的一个模块可操作以检测包中匹配于模式“t.*t”的串，然后以“this is a test”替换那个串。
由编译器运行一个称作Build App的高级脚本，以开始产生配置信息。用于BuildApp的代码也包括在附录A中。步骤14.2至14.10由BuildApp进行。在步骤14.2下标k被初始化为1之后，编译器开始产生模式匹配状态机(REFSM)和串替换机(REPBUF)。
本发明在自动创建REFSM时使用的一个重要工具是词汇(lexical)分析器发生器。词汇分析器发生器是一个强有力的工具，它可执行以接收规则表达式并从中产生模式匹配状态机的逻辑表示，它可操作以确定一个输入流是否包括一个数据串匹配于由规则表达式定义的数据模式。词汇分析器发生器是本技术领域已知的，这里本发明已发现称作JLex的词汇分析器发生器是可结合本发明使用的一个极好的词汇分析器发生器。JLex是由Elliot Joel Berk开发的公共可得到的软件，它能在因特网上从网址http://www.cs.princeton.edu/～appel/modern/jave/JLex/得到。
在步骤14.3，编译器将用户输入的第k行转换成可由词汇分析器发生器读出的格式，用于创建模式匹配状态机的逻辑表示。优选地，当JLex用作词汇分析器发生器时，步骤14.3的操作将输入的第k行转换成JLex所使用的格式。一个称作CreateRegEx的脚本被BuildApp调用，以完成这一任务。CreateRegEx的代码被包括在附录A中。附录A还包括用于上例的CreateRegEx输出，那里RE输入是“t.*t”。
在步骤14.4，词汇分析器发生器被执行，以创建模式匹配状态机(REF SM)的表示，该状态机被以用户输入的第k行中发现的规则表达式所定义的数据模式调谐。如果JLex用作词汇分析器发生器，则JLex将创建REFSM的Java表示。附录A进一步包括用于示例RE“t.*t”的模式匹配状态机的Java表示(jlex_in.java)。
这样，在步骤14.5，需要一个附加操作将REFSM的Java表示转换成模式匹配状态机的VHDL表示。称作StateGen的脚本将语法分析该JLex输出(jlex_in.java)以创建模式匹配状态机的VHDL表示。StateGen也被包括在附录A中。由StateGen创建的VHDL实体被作为RegEx_FSM{k}.vhd保存(其中k是用户输入行，从中产生该REFSM。附录A还包括由RE为“t.*t”的实例造成的模式匹配状态机的VHDL代码)(RegEx_FSM1.vhd)。
在步骤14.6，编译器由用户输入的第k行产生替换缓存器(REPBUF)的VHDL表示。称作ReplaceBufGen的脚本(见附录A)将控制创建替换缓存器。替换缓存器的VHDL表示将如结合图8描述的那样进行操作。附录A也包括上例中的REPBUF的VHDL代码，在上例中的替换串是“this is a test”。
在对用户输入行k＝1创建了动态部件之后，在步骤14.7，编译器检验是否有另一行输入。如果有，则编译器前进到步骤14.8对k增量，然后循环回到步骤14.3至14.6。一旦对用户输入的全部N行已产生了动态部件，则编译器将有全部N个REFSM和N个REPBUF的VHDL表示。
接下来，在步骤14.9，编译器通过BuildApp脚本定义搜索和替换逻辑(SRL)的全部静态和动态部件之间的互连和将在它们之间传送的信号。SRL的静态部件的VHDL表示将存储在可由编译器访问的存储器中。附录A包括这些静态部件的VHDL代码(controller.vhd(它包括控制器、字到字节转换器和MUX)、character.vhd(它包括字缓存器)以及wrd_bldr.vhd(它定义字节到字转换器))。SRL子模块的VHDL表示被作为RegEx_App.vhd列于附录A中。再有，编译器通过BuildApp脚本定义各打包器和SRL之间的互连及在它们之间传送的信号，以创建包扫描模块的VHDL表示。打包器的VHDL代码也将存储在可由编译器访问的存储器中。附录A包括打包器的VHDL代码，附录A包括生成的包扫描模块的VHDL代码(regex_module.vhd)。
然后，在步骤14.10，编译器通过BuildApp创建一个项目(project)文件，它包括该模块全部动态和静态部件VHDL表示的文件名列表。BuildApp调用一个称作MakeProject的脚本来完成这一任务。MakeProject被包括在附录A中，它的输出文件RegEx_App.prj也被包括在附录A中。
再有，在步骤14.11，编译器将合成项目文件中列出的各个部件以创建该模块的后端表示。本技术领域已知的合成工具可用于这一任务，本发明者已发明，来自Sunnyvale，CA，的Synplicity公司的合成工具Synplicity Synplify Pro高度适用。Synplicity Synplify Pro可在http://www.synplicity.com在线得到。然后，由合成工具创建的后端模块表示被提供给一个用于可重编程硬件的后端转换工具(优选一个FPGA转换工具，如Xilinx后端转换工具)以产生一个位图，它可进行操作以把包扫描模块编程到可重编程硬件中。这一位图是配置信息，它定义编程到包扫描器的PLD中的模块，其后该配置信息可通过网络传送给包交换器。
尽管已在上文中结合其优选实施例描述了本发明，但可对它做出各种修改，这些修改仍落入本发明的范围，如本领域普通技术人员将会理解的那样。
例如，已描述了本发明的包处理系统，其中，它的环境是一个计算机网络，它处理的数据流是在该网络上传送的数据包流。然而，这不是必须的情况。本发明的包处理系统可用于处理任何数据流，不管其来源如何。例如，本发明能用于处理从诸如盘驱动器、磁带驱动器、包无线电、卫星接收器、光纤电缆或其他这类介质等数据源读出的流数据。
再有，已描述了由包处理模块使用的SRL，其中单个REFSM用于扫描有效载荷字节。为加速SRL的操作，可并行的实现多个REFSM，每个固定于同一个数据模式。图15说明SRL的匹配路径110如何能实现并行的REFSM。每个REFSM能用于处理从一个不同字节开始的字节流。对于一个字节流{B1，B2，...，BN...BM}，控制器能激活MB_RD_ADD(1)和WBC1_SELECT(1)使字节流{B1...BM}提供给REFSM(1)，激活MB_RD_ADD(2)和WBC1_SELECT(2)使得字节流{B2...BM}传送给REFSM(2)，激活MB_RD_ADD(3)和WBC1_SELECT(3)使得字节流{B3...BM}传送给REFSM(3)，以及对N个REFSM同样做法。在这一配置中，将不会浪费时间去处理一个在字节1开始的非匹配串，因为另一个REFSM将已经在处理一个在字节2开始的可能匹配串。控制器能被修改成考虑不只一个REFSM检测到一个匹配的情况。例如，当REFSM(1)已发现一个对串{B1，B2，...，B6}的匹配，而REFSM(2)已发现一个对串{B2，B3，...，B6}的匹配，控制器能被设计成选择最长的匹配串(即{B1，B2，...，B6})。
再有，图15中的每个并行REFSM能被固定于一个不同的数据模式。同一个字节流能被提供给每个REFSM，控制器能处理每个REFSM_STATUS信号，以确定在数据流中存在哪些数据模式。
再有，上文已描述了包处理器，其中当发现匹配时所采取的行动是一个直接替换操作。然而，广泛多样的其他操作也能容易地实现。不是替换一个匹配串，处理器能被配置成通过不从处理模块中输出包括匹配串的包来丢掉这样的包。再有，处理逻辑的数据路径能被配置成当发现匹配串时向感兴趣方的地址输出通告包。这样的通告包可包括含有该匹配串的包的副本。再有，因为本发明允许包处理器不仅识别已发生的匹配，而且还识别该匹配串以及该串所匹配的数据模式，这样的信息能用于收集关于数据流的统计数据。适当的信号能传送到监视该数据流内容的进行统计的装置。
再有，当希望一个背替换操作而不是直接替换操作时(在背替换操作中，替换串将包括匹配串的至少一个副本)，图8的算法能根据图16加以修改。图16从图8中的步骤8.17抽取出来。在背替换中，替换串将包括一个字节，指出匹配串要被插入数据流中。当这一字节从REPBUF输出时，控制器冻结REPBUF和从DB读取匹配串并传送到WBC2再到MUX输出端。一旦匹配串被插入数据流，控制器重新激活REPBUF以继续输出替换串。
再有，通过在WBC1的输出端和REFSM的输入端之间添加一个大小写转换器(case converter)，SRL 104的匹配路径能被配置成对大小写不敏感的(其中大写字符和小写字符同样对待)。大小写转换器将是可操作以把每个到来的字节转换成共同的大小写(或者都是大写的或者都是下档的)，它匹配于REFSM被其调谐的数据模式的大小写。例如，大小写转换器将把数据流“abcDefghIJKlm”转换成数据流“ABCDEFGHIJKLM”，如果希望对大小写不敏感而且REFSM被以全部大写字母定义的数据模式调谐的话。
再有，已描述了包处理器，其中它是作为FPX上的单独装置实现的，它是线路卡和包交换器之间的接口。然而，本领域普通技术人员会容易理解，可重编程包处理器可作为任何网络处理装置(如包交换器)的一个内部部件来实现。
再有，本发明的包处理器可用于所有网络方式，如因特网或各种局域网(LAN)，包括无线LAN。例如，包处理器能与一个无线收发信机结合以接收和发送无线数据，从而把包处理器与无线网络(无线收发信机是本技术领域公知的)集成在一起。
在阅读了这里的教导之后，对优选实施例的这些和其他修改将是可理解的。这样，本发明的全部范围应由所附权利要求定义，并考虑上文的描述、附图和附录。
APPENDIX A
*Character Set
*SNRList
*BuildApp
*jlex_in
*jlex_in.java
*CreateRegEx
*StateGen
*ReplaceBufGen
*regex_app.vhd
*replace_buf1.vhd
*controller.vhd
*wrd_bldr.vhd
*character_buf.vhd
*regex_fsm1.vhd
*rad_loopback_core.vhd
*rad_loopback.vhd
*loopback_module.vhd
*blink.vhd
*regex_module.vhd
*MakeProject
*regex_app.prj
Character Set
0：NUL：″00000000″
1：SOH：″00000001″
2：STX：″00000010″
3：ETX：″00000011″
4：EOT：″00000100″
5：ENQ：″00000101″
6：ACK：″00000110″
7：BEL：″00000111″
8：BS：″00001000″
9：HT：″00001001″
10：LF：″00001010″
11：VT：″00001011″
12：FF：″00001100″
13：CR：″00001101″
14：SO：″00001110″
15：SI：″00001111″
16：DLE：″00010000″
17：DC1：″00010001″
18：DC2：″00010010″
19：DC3：″00010011″
20：DC4：″00010100″
21：NAK：″00010101″
22：SYN：″00010110″
23：ETB：″00010111″
24：CAN：″00011000″
25：EM：″00011001″
26：SUB：″00011010″
27：ESC：″00011011″
28：FSP：″00011100″
29：GSP：″00011101″
30：RSP：″00011110″
31：USP：″00011111″
32：′′：″00100000″
33：′！′：″00100001″
34：′″′：″00100010″
35：′#′：″00100011″
36：′$′：″00100100″
37：′％′：″00100101″
38：′&′：″00100110″
39：′′′：″00100111″
40：′(′：″00101000″
41：′)′：″00101001″
42：′*′：″00101010″
43：′+′：″00101011″
44：′，′：″00101100″
45：′-′：″00101101″
46：′.′：″00101110″
41：′/′：″00101111″
48：′0′：″00110000″
49：′1′：″00110001″
50：′2′：″00110010″
51：′3′：″00110011″
52：′4′：″00110100″
53：′5′：″00110101″
54：′6′：″00110110″
55：′7′：″00110111″
56：′8′：″00111000″
57：′9′：″00111001″
58：′：′：″00111010″
59：′；′：″00111011″
60：′＜′：″00111100″
<dp n="d33"/>
61：′＝′：″00111101″
62：′＞′：″00111110″
63：′？′：″00111111″
64：′@′：″01000000″
65：′A′：″01000001′
66：′B′：″01000010″
67：′C′：″01000011″
68：′D′：″01000100″
69：′E′：″01000101″
70：′F′：″01000110″
71：′G′：″01000111″
72：′H′：″01001000″
73：′I′：″01001001″
74：′J′：″01001010″
75：′K′：″01001011″
76：′L′：″01001100″
77：′M′：″01001101″
78：′N′：″01001110″
79：′O′：″01001111″
80：′P′：″01010000″
81：′Q′：″01010001″
82：′R′：″01010010″
83：′S′：″01010011″
84：′T′：″01010100″
85：′U′：″01010101″
86：′V′：″01010110″
87：′W′：″01010111″
88：′X′：″01011000″
89：′Y′：″01011001″
90：′Z′：″01011010″
91：′[′：″01011011″
92：′\′：″01011100″
93：′]′：″01011101″
94：′^′：″01011110″
95：′_′：″01011111″
96：′`′：″01100000″
97：′a′：″01100001″
98：′b′：″01100010″
99：′c′：″01100011″
100：′d′：″01100100″
101：′e′：″01100101″
102：′f′：″01100110″
103：′g′：″01100111″
104：′h′：″01101000″
105：′i′：″01101001″
106：′j′：″01101010″
107：′k′：″01101011″
108：′l′：″01101100″
109：′m′：″01101101″
110：′n′：″01101110″
111：′o′：″01101111″
112：′p′：″01110000″
113：′q′：″01110001″
114：′r′：″01110010″
115：′s′：″01110011″
116：′t′：″01110100″
117：′u′：″01110101″
118：′v′：″01110110″
119：′w′：″01110111″
120：′x′：″01111000″
121：′y′：″01111001″
<dp n="d34"/>
122：′z′：″01111010″
123：′{′：″01111011″
124：′|′：″01111100″
125：′}′：″01111101″
126：′～′：″01111110″
127：DEL：″01111111″
SNRList
s/t.*t/this is a test/g
BuildApp
#！/bin/gawk-f
BEGIN {
outfile＝″regex_app.vhd″
infile＝ARGV[1]
print″library ieee；″＞outfile
print″use ieee.std_logic_1164.all；″＞outfile
print″″＞outfile
print″entity regex_app is″＞outfile
print″ port(clk ：in std_logic；″＞outfile
print″ reset_l ：in std_logic；″＞outfile
print″ enable_l ：in std_logic；″＞outfile
print″ ready_l ：out std_logic；″＞outfile
print″″＞outfile
print″ dataEn_out_appl ：in std_logic；″＞outfile
print″ d_out_appl ：in std_logic_vector(31 downto 0)；″＞
outfile
print″ sof_out_appl ：in std_logic；″＞outfile
print″ eof_out_appl ：in std_logic；″＞outfile
print″ sod_out_appl ：in std_logic；″＞outfile
print″ tca_appl_in ：in std_logic；″＞outfile
print″″＞outfile
print″ dataEn_appl_in ：out std_logic；″＞outfile
print ″ d_appl_in ：out std_logic_vector(31 downto 0)；″＞
outfile
print″ sof_appl_in ：out std_logic；″＞outfile
print″ eof_appl_in ：out std_logic；″＞outfile
print″ sod_appl_in ：out std_logic；″＞outfile
print″ tca_out_appl ：out std_logic)；″＞outfile
print″end regex_app；″＞outfile
print″″＞outfile
print″″＞outfile
print″architecture regex_app_arch of regex_app is″＞outfile
print″″＞outfile
#print the flopped signals
print″ signal dataEn_in ：std_logic；″＞outfile
print″ signal data_in ：std_logic_vector(31 downto
0)；″＞outfile
print″ signal sof_in ：std_logic；″＞outfile
print″ signal eof_in ：std_logic；″＞outfile
print″ signal sod_in ：std_logic；″＞outfile
print″ signal tca_in ：std_logic；″＞outfile
print″ signal dataEn_out ：std_logic；″＞outfile
print″ signal data_out ：std_logic_vector(31 downto
0)；″＞outfile
print″ signal sof_out ：std_logic；″＞outfile
print″ signal eof_out ：std_logic；″＞outfile
print″ signal sod_out ：std_logic；″＞outfile
print″ signal tca_out ：std_logic；″＞outfile
print″″＞outfile
# create the list of signals needed to daisy chain all the modules
n＝0
while(getline line＜infile)
{
n++
print″--signals for machine #″n＞outfile
print″ signal ready_l″n″ ：std_logic；″＞outfile
<dp n="d39"/>
print″″＞outfile
print″ signal regex_en″n″ ：std_logic；″＞outfile
print″ signal regex_in″n″ ：std_logic_vector(7 downto
0)；″＞outfile
print″ signal running″n″ ：std_logic；″＞outfile
print″ signal accepting″n″ ：std_logic；″＞outfile
print″ signal reseting″n″ ：std_logic；″＞outfile
print″″＞outfile
print″ signal start_replacing″n″：std_logic；″＞outfile
print″ signal done_replacing″n″ ：std_logic；″＞outfile
print″ signal new_char″n″ ：std_logic_vector(7 downto
0)；″＞outfile
print″″＞outfile
if(n ！＝1)
{
print″ signal tca_out_appl″n″ ：std_logic；″＞outfile
print″ signal dataEn_out_appl″n″ ：std_logic；″＞outfile
print″ signal d_out_appl″n″ ：std_logic_vector(31 downto
0)；″＞outfile
print″ signal sof_out_appl″n″ ：std_logic；″＞outfile
print″ signal eof_out_appl″n″ ：std_logic；″＞outfile
print″ signal sod_out_appl″n″ ：std_logic；″＞outfile
print″″＞outfile
}
}
totalMachines＝n
close(infile)
print″″＞outfile
print″″＞outfile
print″″＞outfile
# create instantiations for each component
n＝0
while(getline line＜infile)
{
n++
len＝split(line，snr，″/″)
if(len ！＝4)
{
print″\nERROR(line″n″)：incorrect SNRlist file format！！\n″
print″ FORMAT：″
print″ ′(regular expression)′′(replacement string}′″
print″″
break
}
# create the necessary files for the job
system(″./createRegex -v regex＝′″snr[2]″′-v n＝′″n″′″)
system(″./replaceBufGen -v replacement＝′″snr[3]″′-v n＝′″n″′″)
print″component regex_fsm″n＞outfile
print″ port(clk ：in std_logic；″＞outfile
print″ reset_l ：in std_logic；″＞outfile
print″ regex_en ：in std_logic；″＞outfile
<dp n="d40"/>
print″ regex_in ：in std_logic_vector(7 downto
0)；″＞outfile
print″ running ：out std_logic；″＞outfile
print″ accepting ：out std_logic；″＞outfile
print″ reseting ：out std_logic)；″＞outfile
print″ end component；″＞outfile
print″″＞outfile
print″″＞outfile
print″″＞outfile
print″ component replace_buf″n＞outfile
print″ port(clk ：in std_logic；″＞outfile
print″ reset_l ：in std_logic；″＞outfile
print″ start_replacing ：in std_logic；″＞outfile
print″ done_replacing ：out std_logic；″＞outfile
print″ new_char ：out std_logic_vector(7 downto
0))；″＞outfile
print″ end component；″＞outfile
print″″＞outfile
print″″＞outfile
print″″＞outfile
}
close(infile)
print″ component controller″＞outfile
print″ port(clk ：in std_logic；″＞outfile
print″ reset_l ：in std_logic；″＞outfile
print″ enable_l ：in std_logic；″＞outfile
print″ ready_l ：out std_logic；″＞outfile
print″″＞outfile
print″ dataEn_out_appl ：in std_logic；″＞outfile
print″ d_out_appl ：in std_logic_vector(31 downto
0)；″＞outfile
print″ sof_out_appl ：in std_logic；″＞outfile
print″ eof_out_appl ：in std_logic；″＞outfile
print″ sod_out_appl ：in std_logic；″＞outfile
print″ tca_appl_in ：in std_logic；″＞outfile
print″″＞outfile
print″ dataEn_appl_in ：out std_logic；″＞outfile
print″ d_appl_in ：out std_logic_vector(31 downto
0)；″＞outfile
print″ sof_appl_in ：out std_logic；″＞outfile print″ eof appl_in ：out std_logic；″＞outfile
print″ sod_appl_in ：out std_logic；″＞outfile
print″ tca_out_appl ：out std_logic；″＞outfile
print″″＞outfile
print″ regex_en ：out std_logic；″＞outfile
print″ regex_in ：out std_logic_vector(7 downto 0)；″＞
outfile
print″ running ：in std_logic；″＞outfile
print″ accepting ：in std_logic；″＞outfile
print″ reseting ：in std_logic；″＞outfile
print″″＞outfile
print″ start_replacing ：out std_logic；″＞outfile
print″ done_replacing ：in std_logic；″＞outfile
print″ new_char ：in std_logic_vector(7 downto
0))；″＞outfile
print″ end component；″＞outfile
print″″＞outfile
print″″＞outfile
print″″＞outfile
<dp n="d41"/>
print″begin″＞outfile
print″″＞outfile
for(n＝1；n＜＝totalMachines；n++)
{
print″ regular_expression_machine″n″：regex_fsm″n＞outfile
print″ port map(clk ＝＞clk，″＞outfile
print″ reset_l ＝＞reset_l，″＞outfile
print″ regex_en ＝＞regex_en″n″，″＞outfile
print″ regex_in ＝＞regex_in″n″，″＞outfile
print″ running ＝＞running″n″，″＞outfile
print″ accepting ＝＞accepting″n″，″＞outfile
print″ reseting ＝＞reseting″n″)；″＞outfile
print″″＞outfile
print″″＞outfile
print″ replacement_buffer″n″ ： replace_buf″n＞outfile
print″ port map(clk ＝＞clk，″＞outfile
print″ reset_l ＝＞reset_l，″＞outfile
print″ start_replacing ＝＞start_replacing″n″，″＞
outfile
print″ done_replacing ＝＞done_replacing″n″，″＞outfile
print″ new_char ＝＞new_char″n″)；″＞outfile
print″″＞outfile
print″″＞outfile
print″ controller″n″：controller″＞outfile
print″ port map(clk ＝＞clk，″＞outfile
print″ reset_l ＝＞reset_l，″＞outfile
print″ enable_l ＝＞enable_l，″＞outfile
print″ ready_l ＝＞ready_l″n″，″＞outfile
print″″＞outfile
##################$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$
# if(n＝＝1)m＝″″
# else m＝n
if(n＝＝1)
{
print″ dataEn_out_appl ＝＞dataEn_in，″＞outfile
print″ d_out_appl ＝＞data_in，″ ＞outfile
print″ sof_out_appl ＝＞sof_in，″ ＞outfile
print″ eof_out_appl ＝＞eof_in，″ ＞outfile
print″ sod_out_appl ＝＞sod_in，″ ＞outfile
}
else
{
print″ dataEn_out_appl ＝＞dataEn_out_appl″n″，″＞
outfile
print″ d_out_appl ＝＞d_out_appl″n″，″＞outfile
print″ sof_out_appl ＝＞sof_out_appl″n″，″＞outfile
print″ eof_out_appl ＝＞eof_out_appl″n″，″＞outfile
print″ sod_out_appl ＝＞sod_out_appl″n″，″＞outfile
}
if(n＝＝totalMachines)
print″ tca_appl_in ＝＞tca_in， --take in from
<dp n="d42"/>
downstream mod″＞outfile
else
print″ tca_appl_in ＝＞tca_out_appl″n+1″， --
take in from downstream mod″＞outfile
print″″＞outfile
if(n＝＝totalMachines)
{
print″ dataEn_appl_in ＝＞dataEn_out， --send to
downstream mod″＞outfile
print″ d_appl_in ＝＞data_out，″ ＞outfile
print″ sof_appl_in ＝＞sof_out，″＞outfile
print″ eof_appl_in ＝＞eof_out，″＞outfile
print″ sod_appl_in ＝＞sod_out，″＞outfile
}
else
{
print″ dataEn_appl_in ＝＞dataEn_out_appl″n+1″，″＞
outfile
print″ d_appl_in ＝＞d_out_appl″n+1″，″ ＞
outfile
print″ sof_appl_in ＝＞sof_out_appl″n+1″，″ ＞
outfile
print″ eof_appl_in ＝＞eof_out_appl″n+1″，″ ＞
outfile
print″ sod_appl_in ＝＞sod_out_appl″n+1″，″ ＞
outfile
}
if(n＝＝1)
print″ tca_out_appl ＝＞tca_out，″＞outfile
else
print″ tca_out_appl ＝＞tca_out_appl″n″，″＞outfile
print″″＞outfile
##################$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$
print″--SIGNALS FOR SEARCH AND REPLACE″＞outfile
print″ regex_en ＝＞regex_en″n″，″＞outfile
print″ regex_in ＝＞regex_in″n″，″＞outfile
print″ running ＝＞running″n″，″＞outfile
print″ accepting ＝＞accepting″n″，″＞outfile
print″ reseting ＝＞reseting″n″，″＞outfile
print″″＞outfile
print″ start_replacing ＝＞start_replacing″n″，″＞
outfile
print″ done_replacing ＝＞done_replacing″n″，″＞outfile
print″ new_char ＝＞new_char″n″)；″＞outfile
print″″＞outfile
print″″＞outfile
print
″-----------------------------------------------------------------------
------″＞outfile
<dp n="d43"/>
print″″＞outfile
}
print″ flop_signals：process(clk)″＞outfile
print″ begin″＞outfile
print″ if clk′event and clk＝′l′then″＞outfile
print″ dataEn_in ＜＝dataEn_out_appl；″＞outfile
print″ data_in ＜＝d_out_appl；″＞outfile
print″ sof_in ＜＝sof_out_appl；″＞outfile
print″ eof_in ＜＝eof_out_appl；″＞outfile
print″ sod_in ＜＝sod_out_appl；″＞outfile
print″ tca_in ＜＝tca_appl_in；″＞outfile
print″″＞ outfile
print ″ dataEn_appl_in ＜＝dataEn_out；″＞outfile
print″ d_appl_in ＜＝data_out；″ ＞outfile
print″ sof_appl_in ＜＝sof_out；″ ＞outfile
print″ eof_appl_in ＜＝eof_out；″ ＞outfile
print″ sod_appl_in ＜＝sod_out；″ ＞outfile
print″ tca_out_appl ＜＝tca_out；″ ＞outfile
print″ end if；″＞outfile
print″ end process flop_signals；″＞outfile
print″″＞outfile
print″″＞outfile
## make sure ALL machines are ready_l
printf″ ready_l＜＝″＞outfile
for(n＝1；n＜totalMachines；n++)
{
printf″ready_l″n″and″＞outfile
}
print″ready_l″n″；″＞outfile
print″″＞outfile
print″″＞outfile
print″end regex_app_arch；″＞outfile
## now create the project file
system(″./makeProject-v n＝′″totalMachines″′″)
}
jlex_in
％％
％％
″t″.*″t″
{ }
jlex_in.java
class Yylex {
private final int YY_BUFFER_SIZE＝512；
private final int YY_F＝-1；
private final int YY_NO_STATE＝-1；
private final int YY_NOT_ACCEPT＝0；
private final int YY_START＝1；
private final int YY_END＝2；
private final int YY_NO_ANCHOR＝4；
private final int YY_BOL＝128；
private final int YY_EOF＝129；
private java.io.BufferedReader yy_reader；
private int yy_buffer_index；
private int yy_buffer_read；
private int yy_buffer_start；
private int yy_buffer_end；
private char yy_buffer[]；
private boolean yy_at_bol；
private int yy_lexical_state；
Yylex(java.io.Reader reader){
this()；
<paragraph id="d139">
if(null＝＝reader){</paragraph>
throw(new Error(″Error：Bad input stream
initializer.″))；
}
yy_reader＝new java.io.BufferedReader(reader)；
}
Yylex(java.io.InputStream instream){
this()；
if(null＝＝instream){
throw(new Error(″Error：Bad input stream
initializer.″))；
}
yy_reader＝new java.io.BufferedReader(new
java.io.InputstreamReader(instream))；
}
private Yylex(){
yy_buffer＝new char[YY_BUFFER_SIZE]；
yy_buffer_read＝0；
yy_buffer_index＝0；
yy_buffer_start＝0；
yy_buffer_end＝0；
yy_at_bol＝true；
yy_lexical_state＝YYINITIAL；
}
private boolean yy_eof_done＝false；
private final int YYINITIAL＝0；
private final int yy_state_dtrans[]＝{
0
}；
private void yybegin(int state){
yy_lexical_state＝state；
}
private int yy_advance()
throws java.io.IOException{
int next_read；
<dp n="d48"/>
int i；
int j；
if(yy_buffer_index＜yy_buffer_read){
return yy_buffer[yy_buffer_index++]；
}
if(0！＝yy_buffer_start){
i＝yy_buffer_start；
j＝0；
while(i＜yy_buffer_read){
yy_buffer[j]＝yy_buffer[i]；
++i；
++j；
}
yy_buffer_end＝yy_buffer_end-yy_buffer_start；
yy_buffer_start＝0；
yy_buffer_read＝j；
yy_buffer_index＝j；
next_read＝yy_reader.read(yy_buffer，
yy_buffer_read，
yy_buffer.length-yy_buffer_read}；
if(-1＝＝next_read){
return YY_EOF；
}
yy_buffer_read＝yy_buffer_read+next_read；
}
while(yy_buffer_index＞＝yy_buffer_read){
if(yy_buffer_index＞＝yy_buffer.length){
yy_buffer＝yy_double(yy_buffer)；
}
next_read＝yy_reader.read(yy_buffer，
yy_buffer_read，
yy_buffer.length-yy_buffer_read)；
if(-1＝＝next_read){
return YY_EOF；
}
yy_buffer_read＝yy_buffer_read+next_read；
}
return yy_buffer[yy_buffer_index++];
}
private void yy_move_end(){
if(yy_buffer_end＞yy_buffer_start&&
′\n′＝＝yy_buffer[yy_buffer_end-1])
yy_buffer_end--；
if(yy_buffer_end＞yy_buffer_start&&
′\r′＝＝yy_buffer[yy_buffer_end-1])
yy_buffer_end--;
}
private boolean yy_last_was_cr＝false；
private void yy_mark_start(){
yy_buffer_start＝yy_buffer_index；
}
private void yy_mark_end(){
yy_buffer_end＝yy_buffer_index；
}
private void yy_to_mark(){
yy_buffer_index＝yy_buffer_end；
yy_at_bol＝(yy_buffer_end＞yy_buffer_start)&&
(′\r′＝＝yy_buffer[yy_buffer_end-1]||
<dp n="d49"/>
′\n′＝＝yy_buffer[yy_buffer_end-1]||
2028/*LS*/＝＝yy_buffer[yy_buffer_end-1]||
2029/*PS*/＝＝yy_buffer[yy_buffer_end-1])；
}
private java.lang.String yytext(){
return(new java.lang.String(yy_buffer，
yy_buffer_start，
yy_buffer_end-yy_buffer_start))；
}
private int yylength(){
return yy_buffer_end-yy_buffer_start；
}
private char[]yy_double(char buf[]){
int i；
char newbuf[]；
newbuf＝new char[2*buf.length]；
for(i＝0；i＜buf.length；++i){
newbuf[i]＝buf[i]；
}
return newbuf；
}
private final int YY_E_INTERNAL＝0；
private final int YY_E_MATCH＝1；
private java.lang.String yy_error_string[]＝{
″Error：Internal error.\n″，
″Error：Unmatched input.\n″
}；
private void yy_error(int code，boolean fatal){
java.lang.System.out.print(yy_error_string[code])；
java.lang.System.out.flush()；
if(fatal){
throw new Error(″Fatal Error.\n″)；
}
}
private int[][]unpackFromString(int size1，int size2，String st)
int colonIndex＝-1；
String lengthString；
int seguenceLength＝0；
int sequenceInteger＝0；
int commaIndex；
String workString；
int res[][]＝new int(size1][size2]；
for(int i＝0；i＜size1；i++){
for(int j＝0；j＜size2；j++){
if(sequenceLength ！＝0){
res[i][j]＝sequenceInteger；
sequenceLength--；
continue；
}
commaIndex＝st.indexOf(′，′)；
workString＝(commaIndex＝＝-1)？st：
st.substring(0，commaIndex)；
st＝st.substring(commaIndex+1)；
colonIndex＝workString.indexOf(′：′)；
if(colonIndex＝＝-1){
res[i][j]＝Integer.parseInt(workString)；
continue；
}
<dp n="d50"/>
lengthString＝
workString.substring(colonIndex+1)；
sequenceLength＝Integer.parseInt(lengthString)；
workString＝workString.substring(0，colonIndex)；
sequenceInteger＝Integer.parseInt(workString}；
res[i][j]＝sequenceInteger；
sequenceLength--；
}
}
return res；
}
private int yy_acpt[]＝{
/*0*/YY_NOT_ACCEPT，
/*1*/YY_NO_ANCHOR，
/*2*/YY_NO_ANCHOR，
/*3*/YY_NOT_ACCEPT
}；
private int yy_cmap[]＝unpackFromString(1，130，
″2:10，0，2:2，0，2:102，1，2:11，3:2″)[0]；
private int yy_rmap[]＝unpackFromString(1，4，
″0，1，2:2″)[0]；
privateint yy_nxt[][]＝unpackFromString(3，4，
″-1，3，-1，1，-1:5，2，3，-1″)；
public Yytoken yylex()
throws java.io.IOException{
int yy_lookahead；
int yy_anchor＝YY_NO_ANCHOR；
int yy_state＝yy_state_dtrans[yy_lexical_state]；
int yy_next_state＝YY_NO_STATE；
int yy_last_accept_state＝YY_NO_STATE；
boolean yy_initial＝true；
int yy_this_accept；
yy_mark_start()；
yy_this_accept＝yy_acpt[yy_state]；
if(YY_NOT_ACCEPT ！＝yy_this_accept){
yy_last_accept_state＝yy_state；
yy_mark_end()；
}
while(true){
if(yy_initial&&yy_at_bol)yy_lookahead＝YY_BOL；
else yy_lookahead＝yy_advance()；
yy_next_state＝YY_F；
yy_next_state＝yy_nxt[yy_rmap[yy_state]][yy_cmap
[yy_lookahead]]；
if(YY_EOF＝＝yy_lookahead&&true＝＝yy_initial){
return null；
}
if(YY_F ！＝yy_next_state){
yy_state＝yy_next_state；
yy_initial＝false；
yy_this_accept＝yy_acpt[yy_state]；
if(YY_NOT_ACCEPT ！＝yy_this_accept){
yy_last_accept_state＝yy_state；
yy_mark_end()；
}
}
else{
<dp n="d51"/>
if(YY_NO_STATE＝＝yy_last_accept_state){
throw(new Error(″Lexical Error：Unmatched
Input.″))；
}
else{
yy_anchor＝yy_acpt[yy_last_accept_state]；
if(0 ！＝(YY_END&yy_anchor)){
yy_move_end()；
}
yy_to_mark()；
switch(yy_lastaccept_state){
case 1：
case -2：
break；
case 2：
( )
case -3：
break；
default：
yy_error(YY_E_INTERNAL，false)；
case -1：
}
yy_initial＝true；
yy_state＝yy_state_dtrans
[yy_lexical_state]；
yy_next_state＝YY_NO_STATE；
yy_last_accept_state＝YY_NO__STATE；
yy_muark_start()；
yy_this_accept＝yy_acpt[yy_state]；
if(YY_NOT_ACCEPT ！＝yy_this_accept){
yy_last_accept_state＝yy_state；
yy_mark_end()；
}
}
CreateRegEx
#！/bin/gawk -f
BEGIN{
if(regex＝＝″″)
{
print″\nUSAGE：\n″
print″ createRegex -v regex＝{regular expression}[-v n＝
{identifier}]\n″
print″ (regular expression}：″
print″ -the regular expression you want the machine to look
for\n″
print″″
print″ {identifier}：″
print″ -an optional identifer that will be added to the
entity″
print″ name of thc rcgular cxprcssion machine\n\n\n″
}
print″％％″＞″jlex_in″
print″％％″＞″jlex_in″
x＝split(regex，chars，″″)
open＝0
for(i＝1；i＜＝x；i++)
{
if(chars[i]-″[A-Za-z0-9]″)
{
if(open＝＝0)
{
open＝1
printf″\″″chars[i]＞″jlex_in″
}
else
printf chars[i]＞″jlex_in″
}
else
{
if(open＝＝1)
{
open＝0
printf″\″″chars[i]＞″jlex_in″
}
else
printf chars[i]＞″jlex_in″
}
}
# one last closing bracket
if(open＝＝1) printf″\″″＞″jlex_in″
print″″＞″jlex_in″
printf″\{″＞″jlex_in″
printf″\}″＞″jlex_in″
system(″java JLex.Main jlex_in＞lexOut″)
# system(″rm -r jlex_in″)
# check to see if there were any errors created when we tried to
# create the java file
<dp n="d54"/>
while(getline＜″lexOut″)
{
found＝match($0，″rror″)
if(found ！＝0)
{
print″Error creating regex_fsm″n″.vhd：JLex failed to produce
output″
print″see file lexOut for more details″
break
}
}
# only create the vhdl file if there were no errors previously
if(found＝＝0)
system(″cat jlex_in.java | ./stateGen -v regex＝′″regex″′-v
n＝′″n″′″)
# system(″rm -r jlex_in.java″)
# system(″rm lexOut″)
}
StateGen
#！/bin/gawk -f
# This script will parse the output of JLex and
# convert the code into a VHDL state machine
BEGIN{
outfile＝″regex_fsm″n″.vhd″
# get to the important part of the input file
#############################################
while(getline}
{
found＝match($0，″yy_acpt\\[\\]″)
if(found ！＝0)
{
break
}
}
num_states＝0
while(getline)
{
found＝match($0，″\\}\\；″)
if(found ！＝0)
{
# do nothing here... we have found the end of the
# yy_acpt[]array
break；
}
else
{
gsub(/\/\*/，″″，$0)
gsub(/\*\//，″″，$0)
gsub(/\，/，″″，$0)
gsub(/\r/，″″，$0)
split($0，acpt，″″)
# the yy acpt contains all the acceptance information
# each array position on the array represents its
# respective state.if a l is stored in the array，
# then it is anaccepting state，otherwise it is not.
if(acpt[2]＝＝″YY_NOT_ACCEPT″)
{
yy_acpt[acpt[1]]＝0
}
e1se
{
yy_acpt[acpt[1]]＝1
}
num_states++
}
}
#################################################
#################################################
# now get to the cmap array
###########################
while(getline)
{
found＝match($0，″yy_cmap\\[\\]″)
<dp n="d57"/>
if(found ！＝0)
{
break
}
}
# get the line with all the character information
# and put it nicely into the cmap array
##################################################
# if the array spans more than one line in the file
# this will concatenate them all together before
# working with the array str＝″″
while(getline)
{
found＝match($0，″\\)\\[0\\]\\；″)
if(found ！＝0)
{
str＝str $1
break
}
else
{
str＝str $1
}
}
# clean it up a bit
gsub(/\″/，″″，str)
gsub(/\)\[0\]；/，″″，str}
gsub(/\r/，″″，str)
subs＝split(str，tmp，″，″)
cols＝0
for(i＝1；i＜＝subs；i++)
{
sp＝split(tmp[i]，tmp2，″：″)
if(sp＝＝1)
{
yy_cmap[cols]＝tmp[i]
cols++
}
else
{
for(j＝0；j＜tmp2[2]；j++)
{
yy_cmap[cols]＝tmp2[1]
cols++
}
}
}
#################################################
#################################################
# get the line with the yy_rmap array
# and break it up nicely
#######################################
while(getline)
{
found＝match($0，″yy_rmap\\[\\]″)
<dp n="d58"/>
if(found ！＝0)
{
break
}
}
str＝″″
while(getline)
{
found＝match($0，″\\)\\[0\\]\\；″)
if(found ！＝0)
{
str＝str $1
break
}
else
{
str＝str $1
}
}
# clean it up a bit
gsub(/\″/，″″，str)
gsub(/\)\[0\]；/，″″，str)
gsub(/\r/，″″，str)
subs＝split(str，tmp，″，″)
rows＝0
for(i＝1；i＜＝subs；i++)
{
sp＝split(tmp[i]，tmp2，″：″)
if(sp＝＝l)
{
yy_rmap[rows]＝tmp[i]
rows++
}
else
{
for(j＝0；j＜tmp2[2]；j++)
{
yy_rmap[rows]＝tmp2[1]
rows++
}
}
}
#################################################
#################################################
# get the line with the yy_nxt array
# and break it up nicely
#######################################
while(getline)
{
found＝match($0，″yy_nxt\\[\\]″)
if(found ！＝0)
{
break
}
<dp n="d59"/>
}
split($0，tmp，″\\(″)
split(tmp[2]，tmp2，″\\，″)
rows2＝tmp2[1]
cols2＝tmp2[2]
str＝″″
while(getline)
{
found＝match($0，″\\)\\；″)
if(found ！＝0)
{
str＝str $1
break
}
else
{
str＝str $1
}
}
# clean it up a bit
gsub(/\″/，″″，str)
gsub(/\)\；/，″″，str)
subs＝split(str，tmp，″，″)
xrow＝0
ycol＝0
for(i＝1；i＜＝subs；i++)
{
sp＝split(tmp[i]，tmp2，″：″)
if(sp＝＝1)
{
yy_nxt[xrow，ycol]＝tmp[i]
ycol++
if(ycol＝＝cols2)
{
xrow++
ycol＝0
}
}
else
{
for(j＝0；j＜tmp2[2]；j++)
{
yy_nxt[xrow，ycol]＝tmp2[1]
ycol++
if(ycol＝＝cols2)
{
xrow++
ycol＝0
}
}
}
}
#################################################
<dp n="d60"/>
#Now print out the VHDL
#################################################
printf″--This code was generated on″＞outfile
format＝″％a ％b ％e ％H：％M：％S ％Z ％Y″
print strftime(format)＞outfile
print″--by a GAWK script created by James Moscola(4-22-2001)″＞
outfile
print″--Regular Expression is： ″regex＞outfile
print″″＞outfile
print″library ieee；″＞outfile
print″use ieee.std_logic_1164.all；″＞outfile
print″use ieee.std_logic_arith.all；″＞outfil
print″″＞outfile
print″″＞outfile
print″cntity rcgcx_fsm″n″is″＞outfile
#######################################
# insert inputs here when determined #
#######################################
print″port(clk ：in std_logic；″＞outfile
print″ reset_l ：in std logic；″＞outfile
print″ regex_en ：in std_logic；″＞outfile
print″ regex_in ：in std_logic_vector(7 DOWNTO 0)；″＞outfile
print″ running ：out std_logic；″＞outfile
print″ accepting ：out std_logic；″＞outfile
print″ reseting ：out std_logic)；″＞outfile
print″end regex_fsm″n″；″＞outfile
print″″＞outfile
print″″＞outfile
print″architecture regex_arch″n″of regex_fsm″n″is″＞outfile
print″″＞outfile
printf″ type states is(″＞outfile
########################################
# put all the states in the state list #
########################################
for(x＝0；x＜num_states；x++)
(
if(x＝＝(num_states-1))
printf″s″x＞outfile
else
printf″s″x″，″＞outfile
# don′t want to many states on l line...
# don′t know how many columns the VHDL
# compiler can handle
if(x％15＝＝14)
{
print″″＞outfile
printf″ ″＞outfile
}
}
print″)；″＞outfile
print″″＞outfile
print″ signal state ：states ：＝s0；″＞outfile
<dp n="d61"/>
print″ signal nxt_state：states：＝s0；″＞outfile
print″″＞outfile
print″″＞outfile
print″begin″＞outfile
print″ next_state：process(clk)″＞outfile
print″ begin″＞outfile
print″ if(clk′eventand clk＝′l′)then″＞outfile
print″ if(reset_l＝′0′)then″＞outfile
print″ state＜＝s0；″＞outfile
print″ elsif(regex_en＝′1′)then″＞outfile
print″ state＜＝nxt_state；″＞outfile
print″ end if；″＞outfile
print″ end if；″＞outfile
print″ end process next_state；″＞outfile
print″″＞outfile
print″″＞outfile
################################
# insert sensitivity list here #
################################
print″ state_trans：process(state，regex_in，regex_en)″＞outfile
print″ begin″＞outfile
print″ nxt_state＜＝state；″＞outfile
print″ if(regex_en＝′1′)then″＞outfile
print″″＞outfile
print″ case state is″＞outfile
print″″＞outfile
###########################################
# determine next states from parsed input #
###########################################
FS＝″：″
for(current_state＝0；current_state＜num_states；current_state++)
{
else_checker＝-1
for(x＝1；x＜128；x++) # start at one so a′.′in our regex
{ # will not include the NUL character
nxt_state＝yy_nxt[yy_rmap[current_state]，yy_cmap[x]]
if(nxt_state ！＝-1)
{
if(else_checker＝＝current_state)
printf″ ELS″＞outfile
else
printf″ when s″current_state″＝＞″＞outfile
printf″if(regex_in＝″＞outfile
while(getline＜″characterSet″)
{
if($1＝＝x)
{
if(x)＝58)
printf $3＞outfile
# we need a special case for semicolon since it is the
# Field Separator
else
printf $4＞outfile
break
<dp n="d62"/>
}
}
close(″characterSet″)
if(x ！＝58)
print″)then --″$2＞outfile
else
print″)then --′：′″＞outfile
print″ nxt_state＜＝s″nxt_state″；″＞
outfile
else_checker＝current_state
}
}
if(else_checker＝＝-1)
print″ when s″current_state″＝＞nxt_state＜＝s0；″＞
outfile
else
{
print″ else″＞outfile
print″ nxt state＜＝s0；″＞outfile
print″ end if；″＞outfile
}
print″″＞outfile
}
print″ end case；″＞outfile
print″ end if；″＞outfile
print″ end process state_trans；″＞outfile
print″---------------------------″＞outfile
print″-- CONCDRRENT STATEMENTS --″＞outfile
print″---------------------------″＞outfile
print″″＞outfile
##########################################
# determine concurrent statements needed
##########################################
more＝0
for(x＝0；x＜num states；x++)
{
if(yy_acpt[x]＝＝1)
{
if(more＝＝0)
printf″ accepting＜＝′1′when nxt_state＝s″x＞outfile
else
printf″or nxt_state＝s″x＞outfile
more++
if(more％10＝＝9)
{
print″″＞outfile
printf″ ″＞outfile
}
}
}
print″else′0′；″＞outfile
print″ reseting ＜＝′1′when(state/＝s0)and(nxt_state＝s0)
else′0′；″＞outfile
<dp n="d63"/>
print″ running ＜＝′1′when state/＝s0 else′0′；″＞outfile
print″″＞outfile
print″end regex_arch″n″；″＞outfile
}
ReplaceBufGen
#！/bin/gawk -f
BEGIN{
outfile＝″replace_buf″n″.vhd″
len＝length(replacement)
printf″--This code was generated on″＞outfile
format＝″％a ％b ％e ％H：％M：％S ％Z ％Y″
print strftime(format)＞outfile
print″--by a GAWK script created by James Moscola″＞outfile
print″--The buffer replaces with the word：″replacement＞outfile
print″″＞outfile
print″library ieee；″＞outfile
print″use ieee.std_logic 1164.all；″＞outfile
print″useieee.std_logic_arith.all；″＞outfile
print″″＞outfile
print″″＞outfilc
print″entity replace_buf″n″is″＞outfile
print″ port(clk ：in std_logic；″＞outfile
print″ reset_l ：in std_logic；″＞outfile
print″ start_replacing：in std_logic；″＞outfile
print″ done_replacing ：out std_logic；″＞outfile
print″ new_char ：out std_logic_vector(7 DOWNTO 0)) ；″＞
outfile
print″end replace_buf″n″；″＞outfile
print″″＞outfile
print″″＞outfile
print″architecture replacement_arch″n″of replace_buf″n″is″＞
outfile
print″″＞outfile
print″ type states is(idle，replace)；″＞outfile
print″ signal state ：states ：＝idle；″＞outfile
print″″＞outfile
print″ signal cntr ：integer ：＝ 0；″＞outfile
print″″＞outfile
FS＝″：″
if(len ！＝1)
{
print″ type my_array is array(0 TO″len-1″)of std_logic_vector(7
DOWNTO 0)；″＞outfile
print″ constant replacement ：my_array ：＝(″＞outfile
split(replacement，char_array，″″)
for(x＝1；x＜＝len；x++){
char＝″′″char_array[x]″′″
while(getline＜″characterSet″)
{
if($2＝＝char)
{
if(x ！＝len)
print″ ″$3″，--″
char＞outfile
else
print″ ″$3″)；--″
char＞outfile
break
}
}
close(″characterSet″)
}
}
<dp n="d66"/>
else
{
printf″ constant replacement ：std_logic_vector(7 DOWNTO 0)：＝″＞
outfile
char＝″′″replacement″′″
while(getline＜″characterSet″)
{
if($2＝＝char)
{
print $3″；--″char＞outfile
break
}
}
close(″characterSet″)
}
print″″＞outfile
print″″＞outfile
print″begin″＞outfile
print″″＞outfile
print″ state_machine：process(clk)″＞outfile
print″ begin″＞outfile
print″ if(clk′event and clk＝′1′)then″＞outfile
print″ if(reset_l＝′0′)then″＞outfile
print″ state＜＝idle；″＞outfile
print″ else″＞outfile
print″ case state is″＞outfile
print″ when idle ＝＞if start_replacing＝′1′then″＞
outfile
print″ state＜＝replace；″＞outfile
print″ cntr ＜＝ 0；″＞outfile
print″ end if；″＞outfile
print″ when replace ＝＞if cntr ＝″len-1″then″＞outfile
print″ state ＜＝idle；″＞outfile
print″ cntr ＜＝0；″＞outfile
print″ else″＞outfile
print″ cntr＜＝cntr+1；″＞outfile
print″ end if；″＞outfile
print″ end case；″＞outfile
print″ end if；″＞outfile
print″ end if；″＞outfile
print″ end process state_machine；″＞outfile
print″″＞outfile
print″″＞outfile
if(len ！＝1){
print″ new_char＜＝replacement(cntr)；″＞outfile
print″ done_replacing＜＝′1′when cntr＝″len-1″else′0′；″＞
outfile
}
else{
print″ new_char＜＝replacement；″＞outfile
print″ done_replacing＜＝′1′when state＝replace else′0′；″＞
outfile
}
print″″＞outfile
print″end replacement_arch″n″；″＞outfile
}
regex_app.vhd
library ieee；
use ieee.std_logic_1164.all；
entity regex_app is
port(clk ：in std_logic；
reset_l ：in std_logic；
enable_l ：in std_logic；
ready_l ：out std_logic；
dataEn_out_appl ：in std_logic；
d_out_appl ：in std_logic_vector(31 downto 0)；
sof_out_appl ：in std_logic；
eof_out_appl ：in std_logic；
sod_out_appl ：in std_logic；
tca_appl_in ：in std_logic；
dataEn_appl_in ：out std_logic；
d_appl_in ：out std_logic_vector(31 downto 0)；
sof_appl_in ：out std_logic；
eof_appl_in ：out std_logic；
sod_appl_in ：out std_logic；
tca_out_appl ：out std_logic)；
end regex_app；
architecture regex_app_arch of regex_app is
signal dataEn_in ：std_logic；
signal data_in ：std_logic_vector(31 downto 0)；
signal sof_in ：std_logic；
signal eof_in ：std_logic；
signal sod_in ：std_logic；
signal tca_in ：std_logic；
signal dataEn_out ：std_logic；
signal data_out ：std_logic_vector(31 downto 0)；
signal sof_out ：std_logic；
signal eof_out ：std_logic；
signal sod_out ：std_logic；
signal tca_out ：std_logic；
-- signals for machine #1
signal ready_ll ：std_logic；
signal regex_enl ：std_logic；
signal regex_inl ：std_logic_vector(7 downto 0)；
signal runningl ：std_logic；
signal acceptingl ：std_logic；
signal resetingl ：std_logic；
signal start_replacingl ：std_logic；
signal done_replacingl ：std_logic；
signal new_charl ：std_logic_vector(7 downto 0)；
component regex_fsml
port(clk ：in std_logic；
reset_l ：in std_logic；
regex_en ：in std_logic；
regex_in ：in std_logic_vector(7 downto 0)；
<dp n="d69"/>
running ：out std_logic；
accepting ：out std_logic；
reseting ：out std_logic)；
end component；
component replace_bufl
port(clk ：in std_logic；
reset_l ：in std_logic；
start_replacing ：in std_logic；
done_replacing ：out std_logic；
new_char ：out std_logic_vector(7 downto 0))；
end component；
component controller
port(clk ：in std_logic；
reaet_l ：in std_logic；
enable_l ：in std_logic；
ready_l ：out std_logic；
dataEn_out_appl ：in std_logic；
d_out_appl ：in std_logic_vector(31 downto 0)；
sof_out_appl ：in std_logic；
eof_out_appl ：in std_logic；
sod_out_appl ：in std_logic；
tca_appl_in ：in std_logic；
dataEn_appl_in ：out std_logic；
d_appl_in ：out std_logic_vector(31 downto 0)；
sof_appl_in ：out std_logic；
eof_appl_in ：out std_logic；
sod_appl_in ：out std_logic；
tca_out_appl ：out std_logic；
regex_en ：out std_logic；
regex_in ：out std_logic_vector(7 downto 0)；
running ：in std_logic；
accepting ：in std_logic；
reseting ：in std_logic；
start_replacing ：out std_logic；
done_replacing ：in std_logic；
new_char ：in std_logic_vector(7 downto 0))
end component；
begin
regular_expression_machinel ：regex_fsml
port map(clk ＝＞clk，
reset_l ＝＞reset_l，
regex_en ＝＞regex_enl，
regex_in ＝＞regex_inl，
running ＝＞runningl，
accepting ＝＞acceptingl，
reseting ＝＞resetingl)；
<dp n="d70"/>
replacement_bufferl ：replace_bufl
port map(clk ＝＞clk，
reset_l ＝＞reset_l，
start_replacing ＝＞start_replacingl，
done_replacing ＝＞done_replacingl，
new_char ＝＞new_charl)；
controllerl ：controller
port map(clk ＝＞clk，
reset_l ＝＞reset_l，
enable_l ＝＞enable_l，
ready_l ＝＞ready_ll，
dataEn_out_appl ＝＞dataEn_in，
d_out_appl ＝＞data_in，
sof_out_appl ＝＞sof_in，
eof_out_appl ＝＞eof_in，
sod_out_appl ＝＞sod_in，
tca_appl_in ＝＞tca_in， --take in from downstream
mod
dataEn_appl_in ＝＞dataEn_out， --send to downstream mod
d_appl_in ＝＞data_out，
sof_appl_in ＝＞sof_out，
eof_appl_in ＝＞eof_out，
sod_appl_in ＝＞sod_out，
tca_out_appl ＝＞tca_out，
-- SIGNALS FOR SEARCH AND REPLACE
regex_en ＝＞regex_enl，
regex_in ＝＞regex_inl，
running ＝＞runningl，
accepting ＝＞acceptingl，
reseting ＝＞resetingl，
start_replacing ＝＞start_replacingl，
done_replacing ＝＞done_replacingl，
new_char ＝＞new_charl)；
------------------------------------------------------------------------
-----
flop_signals：process(clk)
begin
if clk′event and clk ＝′1 ′then
dataEn_in ＜＝dataEn_out_appl；
data_in ＜＝d_out_appl；
sof_in ＜＝sof_out_appl；
eof_in ＜＝eof_out_appl；
sod_in ＜＝sod_out_appl；
tca_in ＜＝tca_appl_in；
dataEn_appl_in ＜＝dataEn_out；
d_appl_in ＜＝data_out；
sof_appl_in ＜＝sof_out；
eof_appl_in ＜＝eof_out；
sod_appl_in ＜＝sod_out；
tca_out_appl ＜＝tca_out；
<dp n="d71"/>
end if；
end process flop_signals；
ready_l ＜＝ready_ll
end regex_app_arch;
replace_buf1.vhd
-- This code was generated on Tue Jan 13:27:24 2002
-- by a GAWK script created by James Moscola
-- The buffer replaces with the word：this is a test
library ieee；
use ieee.std_logic_1164.all；
use ieee.std_logic_arith.all；
entity replace_buf1 is
port(clk ：in std_logic；
reset_l ：in std_logic；
start_replacing ：in std_logic；
done_replacing ：out std_logic；
new_char ：out std_logic_vector(7 DOWNTO 0))；
end replace_buf1；
architecture replacement_arch1 of replace_buf1 is
type states is(idle，replace)；
signal state ：states：＝idle；
signal cntr：integer：＝0；
type my_array is array(0 TO 13)of std_logic_vector(7 DOWNTO 0)；
constant replacement：my_array：＝(
″01110100″，--′t′
″01101000″，--′h′
″01101001″，--′i′
″01110011″，--′s′
″00100000″，--′ ′
″01101001″，--′i′
″01110011″，--′s′
″00100000″，--′ ′
″01100001″，--′a′
″00100000″，--′ ′
″01110100″，--′t′
″01100101″，--′e′
″01110011″，--′s′
″01110100″)；--′t′
begin
state_machine：process(clk)
begin
if(clk′event and clk ＝′1′)then
if(reset_l＝′0′)then
state＜＝idle；
else
case state is
when idle ＝＞if start_replacing＝′1′then
state ＜＝replace；
cntr ＜＝0；
end if；
when replace ＝＞if cntr＝13 then
state＜＝idle；
cntr＜＝0；
else
cntr＜＝cntr+1；
<dp n="d74"/>
end if；
end case；
end if；
end if；
end process state_machine；
new_char＜＝replacement(cntr)；
done_replacing＜＝′l′when cntr＝13 else′0′；
end replacement_arch1；
controller.vhd
-- increment headers and trailers by 4
-- fix reset on replace_buf(DONE) and maybe in otber places.
-- enable_l... don′t give ready until buffer is empty
-- give replace_buf ability to do a null replacement″
-- remove byte_ptr and use prev_addra(1 downto 0)instead
library ieee；
use ieee.std_logic_1154.all；
use ieee.std_logic_unsigned.all；
entity controller is
port(clk ：in std_logic；
reset_l ：in std_logic；
enable_l ：in std_logic；
ready_l ：out std_logic；
dataen_out_appl ：in std_logic；
d_out_appl ：in std_logic_vector(31 downto 0)；
sof_out_appl ：in std_logic；
eof_out_appl ：in std_logic；
sod_out_appl ：in std_logic；
tca_appl_in ：in std_logic；
dataen_appl_in ：out std_logic；
d_appl_in ：out std_logic_vector(31 downto 0)；
sof_appl_in ：out std_logic；
eof_appl_in ：out std_logic；
sod_appl_in ：out std_logic；
tca_out_appl ：out std_logic；
regex_en ：out std_logic；
regex_in ：out std_logic_vector(7 downto 0)；
running ：in std_logic；
accepting ：in std_logic；
reseting ：in std_logic；
start_replacing ：out std_logic；
done_replacing ：in std_logic；
new_char ：in std_logic_vector(7 downto 0))；
end controller；
architecture controller_arch of controller is
-----------------
-- signal list --
-----------------
signal prev_addra ：std_logic_vector(10 downto 0) ：＝(others＝＞
′0′)；
signal accept_ptr ：std_logic_vector(10 downto 0) ：＝(others＝＞
′0′) ；
signal cntr_addra_out ：std_logic_vector(10 downto 0) ：＝(others＝＞
′0′)；
signal out_ptr ：std_logic_vector(10 downto 0) ：＝(others＝＞
′0′)；
signal back_ptr ：std_logic_vector(10 downto 0) ：＝(others＝＞
′0′)；
signal cntr_ddrb_in ：std_logic_vector(8 downto 0) ：＝(others＝
<dp n="d77"/>
′0′)；
signal byte_ptr ：std logic_vector(1 downto 0) ：＝″00″；
signal byte_ptr2 ：std_logic_vector(1 downto 0) ：＝″00″；
signal web ：std_logic；
signal char_buf_out ：std_logic_vector(32 downto 0)；
signal out_buf_out ：std_logic_vector(32 downto 0)；
signal old_char ：std_logic_vector(7 downto 0)；
signal old_charen ：std_logic：＝′0′；
signal regex_enable ：std_logic；
signal start_replacing_out ：std_logic；
signal wrd_bldr_in_en ：std_logic：＝′0′；
signal wrd_bldr_in ：std_logic_vector(7 downto 0)；
signal wrd_bldr_cntr ：std_logic_vector(1 downto 0)；
signal wrd_bldr_out ：std_logic_vcctor(31 downto 0)；
signal wrd_bldr_out_en ：std_logic；
signal char_buf_addra ：std_logic_vector(8 downto 0)；
signal accepted ：std_logic：＝′0′；
signal buf_full ：std_logic：＝′0′；
signal fifo_full ：std_logic：＝′0′；
signal fifo_empty ：std_logic：＝′1′；
signal out_buf_en ：std_logic：＝′0′；
subtype fifo_loc is std_logic_vector(10 downto 0)；
type fifo is array(0 to 7)of fifo loc；
signal match_begin_fifo ：fifo：＝(others＝＞(others＝＞′0′)) ；
signal match_end_fifo ：fifo：＝(others＝＞(others＝＞′0′))；
signal fifo_rd_ptr ：std_logic_vector(2 downto 0)：＝″000″；
signal fifo_wr_ptr ：std_logic_vector(2 downto 0)：＝″000″；
signal dib：std_logic_vector(32 downto 0)；
type pkt_states is(atm_hdr，len，hdr，data，flush，trailer，
replace)；
signal fsm_state ：pkt_states ：＝atm_hdr；
signal out_state ：pkt_states ：＝atm_hdr；
signal pkt_len ：std_logic_vector(15 downto 0)：＝(others＝＞
′0′)；
signal pkt_len_cnt ：std_logic_vector(15 downto 0)：＝(others＝＞
′0′)；
signal pkt_len_cnt2 ：std_logic_vector(15 downto 0)：＝(others＝＞
′0 ′)；
signal pkt_len_out ：std_logic_vector(15 downto 0)：＝(others＝＞
′0′)；
signal trail_cntr ：std_logic_vector(2 downto 0) ：＝(others＝＞
′1′)；
alias is sof address ：std_logic is char_buf_out(32)；
alias is_sof_address2 ：std_logic is out_buf_out(32)；
<dp n="d78"/>
-- components --
----------------
component character_buf
port(addra ：in std_logic_vector(8 downto 0)；
clka ：in std_logic；
addrb ：in std_logic_vector(8 downto 0)；
clkb ：in std_logic；
dib ：in std_logic_vector(32 downto 0)；
web ：in std_logic；
doa ：out std_logic_vector(32 downto 0))；
end component；
component wrd_bldr
port(clk ：in std_logic；
reset_l ：in std_logic；
wrd_bldr_in_en ：in std_logic；
wrd_bldr_in ：in std_logic_vector(7 downto 0)；
wrd_bldr_cntr ：out std_logic_vector(1 downto 0)；
wrd_bldr_out ：out std_logic_vector(31 downto 0)；
wrd_bldr_out_en ：out std_logic)；
end component；
begin
---------------------
-- structural ties --
---------------------
character_buffer ：character_buf
port map(addra ＝＞char_buf_addra，
clka ＝＞clk，
addrb ＝＞cntr_addrb_in(8 downto 0)，
clkb ＝＞clk，
dib ＝＞dib，
web ＝＞web，
doa ＝＞char_buf_out)；
output_buffer ：character_buf
port map(addra ＝＞out_ptr(10 downto 2)，
clka ＝＞clk，
addrb ＝＞cntr_addrb_in(8 downto 0)，
clkb ＝＞clk，
dib ＝＞dib，
web ＝＞web，
doa ＝＞out_buf_out)；
word_builder：wrd_bldr
port map(clk ＝＞clk，
reset_l ＝＞reset_l，
wrd_bldr_in_en ＝＞wrd_bldr_in_en，
wrd_bldr_in ＝＞wrd_bldr_in，
wrd_bldr_cntr ＝＞wrd_bldr_cntr，
wrd_bldr_out ＝＞wrd_bldr_out，
wrd_bldr_out_en ＝＞wrd_bldr_out_en)；
<dp n="d79"/>
------------------------------------------------------------------------
-
-- the following process controls the pointer for the input side of
the
-- dual-port memory
------------------------------------------------------------------------
-
count_address_in：process(clk)
begin
if(clk′event and clk＝′1′)then
if(sof_out_appl＝′1 ′ or dataen out appl＝′1′)tnen
cntr_addrb_in＜＝cntr_addrb_in+1；
if((cntr_addrb in+92)＝out_ptr(10 downto 2))then
buf_full＜＝′1′；
end if；
end if；
if((cntr_addrb_in＝(cntr addra_out(10 downto 2)+1))and
(out_ptr(10 downto 2)/＝(cntr_addrb_in+1)))tnen
buf_full＜＝′0′；
end if；
end if；
end process count_address_in；
------------------------------------------------------------
-- the following processes are for controlling the input，
-- and the enable to the regular expression machine
------------------------------------------------------------
regex_input_machine：process(clk)
begin
if clk′event and clk ＝′1′then
if reset_l＝′0′then
fsm state＜＝atm hdr；
regex_enable＜＝′0′；
else
case fsm_state is
when atm_hdr＝＞if cntr_addra_out/＝cntr_addrb_in&″00″then
cntr_addra_out＜＝cntr addra out+1；
if is_sof_address＝′1′and byte_ptr＝″11″
then
fsm_state＜＝len；
end if；
end if；
when len ＝＞if cntr_addra_out /＝cntr_addrb_in&″00″then
cntr_addra_out＜＝cntr_addra_out+1；
pkt_len ＜＝char_buf_out(15 downto 0)；
pkt_len_cnt ＜＝char_buf_out(15 downto 0)-
1；
if is_sof_address＝′0′or byte_ptr/＝″11″
then -- this may be wrong
fsm_state＜＝hdr；
<dp n="d80"/>
d if；
end if；
when hdr ＝＞if cntr_addra_out/＝cntr_addrb_in&″00″then
cntr_addra_out＜＝cntr_addra_out+1；
pkt_len_cnt＜＝pkt_len_cnt-1；
end if；
if is_sof_address＝′1′and byte_ptr＝″11″
then
fsm_state＜＝len；
elsif pkt_len_cnt+x″1B″＝pkt_len then
fsm_state＜＝data；
regex_enable＜＝′1′；
end if；
when data ＝＞if reseting＝′1′then
if accepted＝′1′then
cntr_addra_out＜＝accept_ptr+1；
regex_enable＜＝′0′；
pkt len_cnt＜＝pkt_len_cnt+
(cntr_addra_out-(accept_ptr+1))；
else
cntr_addra_out＜＝back_ptr+1；
regex_enable＜＝′0′；
pkt_len_cnt＜＝pkt_len_cnt+
(cntr_addra_out-(back_ptr+1))；
end if；
elsif fifo_full＝′0′then
if cntr_addra_out/＝cntr_addrb_in&″00″
then
cntr_addra_out＜＝cntr_addra_out+1；
regex_enable＜＝′1′；
pkt_len_cnt＜＝pkt_len_cnt-1；
else
regex_enable＜＝′0′；
end if；
end if；
if is_sof_address＝′1′then
regex_enable＜＝′0′；
if byte_ptr＝″11″then
fsm state＜＝len；
end if；
end if；
if pkt_len_cnt＝x″00″and running＝′0′and
byte_ptr＝″00″then
fsm_state＜＝trailer；
regex_enable＜＝′0′；
end if；
when trailer ＝＞if cntr addra out/＝cntr addrb in&″00″then
cntr_addra_out＜＝cntr_addra_out+1；
pkt_len_cnt＜＝pkt_len_cnt-1；
end if；
if is_sof_address＝′1′and byte_ptr＝″11″
then
fsm_state ＜＝len；
elsif pkt_len_cnt＝x″FFF9″then
<dp n="d81"/>
fsm_state＜＝atm_hdr；
end if；
when others ＝＞null；
end case；
end if；
end if；
end process regex_input_machina；
------------------------------------------------------------------------
--------
-- these processes take care of a little book-keeping.
------------------------------------------------------------------------
--------
previous_address：process(clk)
begin
if(clk′event and clk＝′1′)then
prev_addra＜＝cntr_addra_out；
end if；
end process previous_address；
backtrack：process(clk)
begin
if(clk′event and clk＝′1′) then
if(running＝′0′)then
back_ptr＜＝prev_addra；
end if；
end if；
end process backtrack；
made_match：process(clk)
begin
if(clk′event and clk＝′1′)then
if(accepting＝′1′and regex_enable＝′1′) then
accepted＜＝′1′；
accept_ptr＜＝prev_addra；
elsif(reseting＝′1′)then
accepted＜＝′0′；
end if；
end if；
end process made_match；
------------------------------------------------------------------------
-
-- the following processes are for outputting the data
------------------------------------------------------------------------
-
<dp n="d82"/>
output_fsm_machine：process(clk)
begin
if clk′event and clk＝′1′then
if reset_l＝′0′then
out_state ＜＝atm_hdr；
old_char_en ＜＝′0′；
start_replacing_out ＜＝′0′；
else
old_char_en ＜＝′0′；
start_replacing_out ＜＝′0′；
case out_state_is
when atm_hdr＝＞if out_ptr/＝back_ptr then
out_ptr ＜＝out_ptr+1；
old_char_en＜＝′1′；
if is_sof_address2＝′1′and byte_ptr2＝
″11″then
out_state＜＝len；
end if；
end if；
trail_cntr＜＝″111″；
when len ＝＞if out_ptr/＝back_ptr then
out_ptr ＜＝out_ptr+1；
old_char_en＜＝′1′；
if is_sof_address2＝′0′or byte_ptr2/＝
″11″then
out_state＜＝hdr；
end if；
end if；
when hdr ＝＞if out_ptr/＝back_ptr then
out_ptr ＜＝out_ptr+1；
old_char_en＜＝′1′；
end if；
if is_sof_address2＝′1′and byte_ptr2＝″11″
then
out_state＜＝len；
elsif pkt_len_cnt2+x″1B″＝pkt_len_out then
out_state＜＝data；
end if；
when data ＝＞if out_ptr /＝back_ptr then
out_ptr ＜＝out_ptr+1；
old_char_en ＜＝′1′；
if is_sof_address2＝′1′and byte_ptr2＝
″11″then
out_state ＜＝len；
elsif match_begin_fifo(conv_integer
(fifo_rd_ptr)) ＝out_ptr and fifo_empty＝′0′then
out_state ＜＝replace；
old_charen＜＝′0′；
out_ptr ＜＝match_end_fifo(conv_integer
(fifo_rd_ptr))；
fifo_rd_ptr＜＝fifo_rd_ptr+1；
start_replacing_out＜＝′1′；
else
if pkt_len_cnt2＝x″01″then
if wrd_bldr_cntr＝″11″then
out_state＜＝trailer；
<dp n="d83"/>
else
out_ptr＜＝out_ptr；
old_char_en＜＝′0′；
out_state＜＝flush；
end if；
end if；
end if；
end if；
when flush ＝＞if wrd_bldr_cntr＝″11″then
out_ptr＜＝out_ptr+1；
old_char_en＜＝′1′；
out_state＜＝trailer；
end if；
when trailer＝＞if out_ptr/＝back_ptr then
out_ptr ＜＝out_ptr+1；
old_char_en＜＝′1′；
end if；
if trail_cntr＝″000″then
out_state ＜＝atm_hdr；
else
trail_cntr＜＝trail_cntr-1；
end if；
when replace＝＞if done replacing＝′1′then
if pkt_len_cnt2＝x″00″then
if wrd_bldr_cntr＝″11″then
out_state＜＝trailer ；
else
out_state＜＝flush；
end if；
else
out_state＜＝data；
end if；
end if；
end case；
end if；
end if；
nd process output_fsm_machine；
-- This process controls the pkt_len_cnt2 register.This register
-- keeps track of how many bytes are left to output in a packet.
packet_length_counter2：process(clk)
begin
if clk′event and clk＝′1′then
if out_state＝len then
pkt_len_cnt2＜＝out_buf_out(15 downto 0)-1；
elsif start_replacing_out＝′1′then
pkt_len_cnt2＜＝pkt_len_cnt2 -
(match_end_fifo(conv_integer(fifo_rd_ptr-1))-
match_begin_fifo(conv_integer(fifo_rd_ptr-
1))))；
elsif old_char_en＝′1′then
pkt_len_cnt2＜＝pkt_len_cnt2-1；
end if；
end if；
<dp n="d84"/>
end process packet_length_counter2；
-- This process controls the pkt_len_out register.This register
-- keeps track of the length of the current packet being output.
packet_length_out：process(clk)
begin
if clk′event and clk＝′1′then
if out state＝len then
pkt_len_out＜＝out_buf_out(15 downto 0)；
elsif start_replacing_out＝′1′then
pkt_len_out＜＝pkt_len_out-
(match_end_fifo(conv_integer(fifo_rd_ptr-1))
match_begin_fifo(conv_integer(fifo_rd_ptr-
1)))；
elsif start_replacing_out＝′0′and out_state＝replace then
pkt_len_out＜＝pkt_len_out+1；
end if；
end if；
end process packet_length_out；
-- Here are the control signals that are sent to the UDP Wrapper to
indicate：
-- start of frame，start of datagram，and end of frame.
sof_appl_in＜＝′1′when out state＝len else′0′；
sod_appl_in＜＝′1′when(pkt_len_cnt2＝pkt_len_out-x″18″)else′0′；
eof_appl_in＜＝′1′when out_state＝trailer and wrd_bldr_out_en＝′1′
and pkt_len_cnt2＜″011″else′0′；
-------------------------------------------------------------
-------------------------------------------------------------
-- the following processes control the found and replace fifo
-------------------------------------------------------------
fifo_write_pointer：process(clk)
begin
if(clk′event and clk＝′1′)then
if(reseting＝′1′and accepted＝′1′)then
match_begin_fifo(conv_integer(fifo_wr_ptr))＜＝back_ptr；
match_end_fifo(conv_integer(fifo_wr_ptr)) ＜＝accept_ptr+1；
-- stores the next position after the
fifo_wr_ptr＜＝fifo_wr_ptr+1；
-- replacement is complete
end if；
end if；
end process fifo_write_pointer；
fifo_full ＜＝′1′when fifo_wr_ptr+1＝fifo_rd_ptr else′0′；
fifo_empty＜＝′1′when fifo_rd_ptr＝fifo_wr_ptr else′0′；
<dp n="d85"/>
---------------------------------------------------------------
byte_counter：process(clk)
begin
if(clk′event and clk＝′1′)then
byte_ptr＜＝cntr_addra_out(1 downto 0)；
end if；
end process byte_counter；
byte_counter2：process(clk)
begin
if(clk′event and clk＝′1′)then
byte_ptr2＜＝out_ptr(1 downto 0)；
end if；
end process byte_counter2；
---------------------------
-- concurrent statements --
---------------------------
ready_l＜＝not enable_l；
regex_en ＜＝regex_enable；
start_replacing ＜＝start_replacing_out；
web＜＝′1′when sof_out_appl＝′1′or dataEn_out_appl＝′1′else′0′；
dib＜＝sof_out_appl&d_out_appl；
char_buf_addra＜＝cntr_addra_out(10 downto 2)；
regex_in＜＝″00000000″ when pkt_len_cnt＝x″00″else
char_buf_out(31 downto 24)when byte_ptr ＝ ″00″else
char_buf_out(23 downto 16)when byte_ptr ＝ ″01″else
char_buf_out(15 downto 8)when byte_ptr ＝ ″10″else
char_buf_out( 7 downto 0);
old_char＜＝x″00″when out_state＝flush and old_char_en/＝′1′else
pkt_len_out(15 downto 8)when trail_cntr＝″001″and
byte_ptr2＝″10″else
pkt_len_out(7 downto 0)when trail_cntr＝″000″and
byte_ptr2＝″11″else
out_buf_out(31 downto 24)when byte_ptr2＝″00″else
out_buf_out(23 downto 16)when byte_ptr2＝″01″else
out_buf_out(15 downto 8)when byte_ptr2＝″10″else
out_buf_out( 7 downto 0)；
wrd_bldr_in ＜＝new char when(out_state＝replace and
start_replacing_out＝′0′)else old_char；
wrd_bldr_in_en＜＝′1′wnen out_state＝flush or old_char_en＝′1′or
(out_state＝replace and
start_replacing_out＝′0′)else′0′；
<dp n="d86"/>
dataen_appl_in＜＝′1′when wrd_bldr_out_en＝′1′and out_state /＝len
else′0′；
d_appl_in＜＝wrd_bldr_out；
tca_out_appl ＜＝′0′when tca_appl_in＝′0′or buf_full＝′1′else
′1′；
end controller_arch；
wrd_bldr.vhd
library ieee；
use ieee.std_logic_1164.all；
use ieee.std_logic_arith.all；
entity wrd_bldr is
port(clk ：in std_logic；
reset_l ：in std_logic；
wrd_bldr_in_en ：in std_logic；
wrd_bldr_in ：in std_logic_vector(7 downto 0)；
wrd_bldr_cntr ：out std_logic_vector(1 downto 0)；
wrdd_bldr_out ：out std_logic_vector(31 downto 0)；
wrd_bldr_out_en ：out std_logic)；
end wrd_bldr；
architecture behavioral of wrd_bldr is
type rammemory is array(2 downto 0)of std_logic_vector(7 downto 0)；
signal ram ：rammemory；
signal ptr ：integer range 0 to 3：＝0；
begin
build_words：process(clk)
begin
if clk′event and clk＝′1′then
wrd_bldr_out_en＜＝′0′；
if reset_l＝′0′then
ptr＜＝0；
else
if(wrd_bldr_in_en＝′1′and ptr＝3)then
wrd_bldr_out_en＜＝′1′；
wrd_bldr_out(31 downto 24)＜＝ram(0)；
wrd_bldr_out(23 downto 16)＜＝ram(1)；
wrd_bldr_out(15 downto 8)＜＝ram(2)；
wrd_bldr_out(7 downto 0)＜＝wrd_bldr_in(7 downto 0)；
ptr＜＝0；
elsif wrd_bldr_in_en＝′1′then
ram(ptr)＜＝wrd_bldr_in；
ptr＜＝ptr+1；
end if；
end if；
end if；
end process build_words；
wrd_bldr_cntr＜＝conv_std_logic_vector(ptr，2)；
end behavioral；
<dp n="d89"/>
-- This code was generated on Tue Jan 13:27:24 2002
-- by a GAWK script created by James Moscola
-- The buffer replaces with the word：this is a test
library ieee；
use ieee.std_logic_1164.all；
use ieee.std_logic_arith.all；
entity replace_buf1 is
port(clk ：in std_logic；
reset_l ：in std_logic；
start_replacing ：in std_logic；
done_replacing ：out std_logic；
new_char ：out std_logic_vector(7 DOWNTO 0))；
end replace_buf1；
architecture replacement_arch1 of replace_buf1 is
type states is(idle，replace)；
signal state ：states：＝idle；
signal cntr ：integer ：＝0；
type my_array is array(0 TO 13)of std_logic_vector(7 DOWNTO 0)
constant replacement ：my_array ：＝(
″01110100″，--′t′
″01101000″，--′h′
″01101001″，--′i′
″01110011″，--′s′
″00100000″，--′ ′
″01101001″，--′i′
″01110011″，--′s′
″00100000″，--′ ′
″01100001″，--′a′
″00100000″，--′ ′
″01110100″，--′t′
″01100101″，--′e′
″01110011″，--′s′
″01110100″)；--′t′
begin
state_machine：process(clk)
begin
if(clk′event and clk＝′1′)then
if(reset_l＝′0′)then
state＜＝idle；
else
case state is
when idle ＝＞if start_replacing＝′1′then
state＜＝replace；
cntr ＜＝0；
end if；
when replace ＝＞if cntr＝13 then
state＜＝idle；
cntr ＜＝0；
else
cntr＜＝cntr+1；
<dp n="d90"/>
end if；
end case；
end if；
end if；
end process state_machine；
new_char＜＝replacement(cntr)；
done_replacing＜＝′1′when cntr＝13 else′0′；
end replacement_arch1；
characte_buf.vhd
library ieee；
use ieee.std_logic_1164.all；
use ieee.std_logic_arith.all；
-- synopsys translate_off
library XilinxCoreLib；
-- synopsys translate_on
entity character_buf is
port(addra：in std_logic_vector(8 downto 0)；
clka：in std_logic；
addrb：in std_logic_vector(8 downto 0)；
clkb：in std_logic；
dib：in std_logic_vector(32 downto 0)；
web：in std_logic；
doa：OUT std_logic_vcctor(32 downto 0))；
end character_buf；
architecture structure of character_buf is
component character_buf
port (
addra：IN std_logic_VECTOR(8 downto 0)；
clka：IN std_logic；
addrb：IN std_logic_VECTOR(8 downto 0)；
clkb：IN std_logic；
dib：IN std_logic_VECTOR(32 downto 0)；
web：IN std_logic；
doa：OUT std_logic_VECTOR(32 downto 0))；
end component；
-- Synplicity black box declaration
attribute black_box ：boolean；
attribute black_box of character_buf：component is true；
-- synopsys translate_off
for all ：character_buf use entity.XilinxCoreLib.C_MEM_DP_BLOCK_V1_0
(behavioral)
generic map(c_depth_b＝＞512，
c_depth_a＝＞512，
c_has_web＝＞1，
c_has_wea＝＞0，
c_has_dib＝＞1，
c_has_dia＝＞0，
c_clka_polarity＝＞1，
c_web_polarity＝＞1，
c_address_width_b＝＞9，
c_address_width_a＝＞9，
c_width_b＝＞33，
c_width_a＝＞33，
c_clkb_polarity＝＞1，
c_ena_polarity＝＞1，
c_rsta_polarity＝＞1，
c_has_rstb＝＞0，
c_has_rsta＝＞0，
c_read_mif＝＞0，
c_enb_polarity＝＞1，
c_pipe_stages＝＞0，
c_rstb_polarity＝＞1，
<dp n="d93"/>
c_has_enb＝＞0，
c_has_ena＝＞0，
c_mem_init_radix＝＞16，
c_default_data＝＞″0″，
c_mem_init_file＝＞″character_buf.mif″，
c_has_dob＝＞0，
c_generate_mif＝＞1，
c_has_doa＝＞1，
c_wea_polarity＝＞1)；
synopsys translate_on
begin
character_buffer ：character_buf
port map(addra＝＞addra，
clka＝＞clka，
addrb＝＞addrb，
clkb＝＞clkb，
dib＝＞dib，
web＝＞web，
doa＝＞doa)；
end structure；
regex_fsm1.vhd
-- This code was generated on Tue Jan 13:27:22 2002
-- by a GAWK script created by James Moscola(4-22-2001)
-- Regular Expression is： t.*t
library ieee；
use ieee.std_logic_1164.all；
use ieee.std_logic_arith.all；
entity regex_fsm1 is
port(clk ：in std_logic；
reset_l ：in std_logic；
regex_en ：in std_logic；
regex_in ：in std_logic_vector(7 DOWNTO 0)；
running ：out std_logic；
accepting ：out std_logic；
reseting ：out std_logic)；
end regex_fsm1；
architecture regex_arch1 of regex_fsm1 is
type states is(s0，s1，s2，s3)；
signal state ：states ：＝s0；
signal nxt_state ：states ：＝s0；
begin
next_state：process(clk)
begin
if(clk′event and clk＝′1′)then
if(reset_l＝′0′)then
state＜＝s0；
elsif(regex_en＝′1′)then
state＜＝nxt_state；
end if；
end if；
end process next_state；
state_trans：process(state，regex_in，regex_en)
begin
nxt state＜＝state；
if(regex_en＝′1′)then
case state is
when s0＝＞if(regex_in ＝″01110100″)then --′t′
nxt_state＜＝s3；
else
nxt_state＜＝s0；
end if；
when s1＝＞nxt_state＜＝s0；
when s2＝＞if(regex_in＝″00000001″)then -- SOH
nxt_state＜＝s3；
ELSif(regex_in＝″00000010″)then -- STX
nxt_state＜＝s3；
ELSif(regex_in＝″00000011″)then -- ETX
<dp n="d96"/>
nxt_state＜＝s3；
ELSif(regex_in＝″00000100″)then -- EOT
nxt_state＜＝s3；
ELSif(regex_in＝″00000101″)then -- ENQ
nxt_state＜＝s3；
ELSif(regex_in＝″00000110″)then -- ACK
nxt_state＜＝s3；
ELSif(regex_in＝″00000111″)then -- BEL
nxt_state＜＝s3；
ELSif(regex_in＝″00001000″)then -- BS
nxt_state＜＝s3；
ELSif(regex_in＝″00001001″)then -- HT
nxt_state＜＝s3；
ELSif(regex_in＝″00001011″)then -- VT
nxt_state＜＝s3；
ELSif(regex_in＝″00001100″)then -- FF
nxt_state＜＝s3；
ELSif(regex_in＝″00001110″)then -- SO
nxt_state＜＝s3；
ELSif(regex_in＝″00001111″)then -- SI
nxt_state＜＝s3；
ELSif(regex_in＝″00010000″)then -- DLE
nxt_state＜＝s3；
ELSif(regex_in＝″00010001″)then -- DC1
nxt_state＜＝s3；
ELSif(regex_in＝″00010010″)then -- DC2
nxt_state＜＝s3；
ELSif(regex_in＝″00010011″)then -- DC3
nxt_state＜＝s3；
ELSif(regex_in＝″00010100″)then -- DC4
nxt_state＜＝s3；
ELSif(regex_in＝″00010101″)then -- NAK
nxt_state＜＝s3；
ELSif(regex_in＝″00010110″)then -- SYN
nxt_state＜＝s3；
ELSif(regex_in＝″00010111″)then -- ETB
nxt_state＜＝s3；
ELSif(regex_in＝″00011000″)then -- CAN
nxt_state＜＝s3；
ELSif(regex_in＝″00011001″)then -- EM
nxt_state＜＝s3；
ELSif(regex_in＝″00011010″)then -- SUB
nxt_state＜＝s3；
ELSif(regex_in＝″00011011″)then -- ESC
nxt_state＜＝s3；
ELSif(ragex_in＝″00011100″)then -- FSP
nxt_state＜＝s3；
ELSif(regex_in＝″00011101″)then -- GSP
nxt_state＜＝s3；
ELSif(regex_in＝″00011110″)then -- RSP
nxt_state＜＝s3；
ELSif(regex_in＝″00011111″)then -- USP
nxt_state＜＝s3；
ELSif(regex_in＝″00100000″)then -- ′′
nxt_state＜＝s3；
ELSif(regex_in＝″00100001″)then -- ′！′
nxt_state＜＝s3；
ELSif(regex_in＝″00100010″)then -- ′″′
nxt_state＜＝s3；
ELSif(regex_in＝″00100011″)then -- ′#′
nxt_state＜＝s3;
<dp n="d97"/>
ELSif(regex_in＝″00100100″)then -- ′$′
nxt_state＜＝s3；
ELSif(regex_in＝″00100101″)then -- ′％′
nxt_state＜＝s3；
ELSif(regex_in＝″00100110″)then -- ′&′
nxt_state＜＝s3；
ELSif(regex_in＝″00100111″)then -- ′′′
nxt_state＜＝s3；
ELSif(regex_in＝″00101000″)then -- ′(′
nxt_state＜＝s3；
ELSif(regex_in＝″00101001″)then -- ′)′
nxt_state＜＝s3；
ELSif(regex_in＝″00101010″)then -- ′*′
nxt_state＜＝s3；
ELSif(regex_in＝″00101011″)then -- ′+′
nxt_state＜＝s3；
ELSif(regex_in＝″00101100″)then -- ′，′
nxt_state＜＝s3；
ELSif(regex_in＝″00101101″)then -- ′-′
nxt_state＜＝s3；
ELSif(regex_in＝″00101110″)then -- ′.′
nxt_state＜＝s3；
ELSif(regex_in＝″00101111″)then -- ′/′
nxt_state＜＝s3；
ELSif(regex_in＝″00110000″)then -- ′0′
nxt_state＜＝s3；
ELSif(regex_in＝″00110001″)then -- ′1′
nxt_state＜＝s3；
ELSif(regex_in＝″00110010″)then -- ′2′
nxt_state＜＝s3；
ELSif(regex_in＝″00110011″)then -- ′3′
nxt_state＜＝s3；
ELSif(regex_in＝″00110100″)then -- ′4′
nxt_state＜＝s3；
ELSif(regex_in＝″00110101″)then -- ′5′
nxt_state＜＝s3；
ELSif(regex_in＝″00110110″)then -- ′6′
nxt_state＜＝s3；
ELSif(regex_in＝″00110111″)then -- ′7′
nxt_state＜＝s3；
ELSif(regex_in＝″00111000″)then -- ′8′
nxt_state＜＝s3；
ELSif(regex_in＝″00111001″)then -- ′9′
nxt_state＜＝s3；
ELSif(regex_in＝″00111010″)then -- ′：′
nxt_state＜＝s3；
ELSif(regex_in＝″00111011″)then -- ′；′
nxt_state＜＝s3；
ELSif(regex in＝″00111100″)then -- ′＜′
nxt_state＜＝s3；
ELSif(regex in＝″00111101″)then -- ′＝′
nxt_state＜＝s3；
ELSif(regex_in＝″00111110″)then -- ′＞′
uxt_state＜＝s3；
ELSif(regex_in＝″00111111″)then -- ′？′
nxt_state＜＝s3；
ELSif(regex_in＝″01000000″)then -- ′@′
nxt_state＜＝s3；
ELSif(regex_in＝″01000001″)then -- ′A′
nxt_state＜＝s3；
ELSif(regex_in＝″01000010″)then -- ′B′
<dp n="d98"/>
nxt_state＜＝s3；
ELSif(regex_in＝″01000011″)then -- ′C′
nxt_state＜＝s3；
ELSif(regex_in＝″01000100″)then -- ′D′
nxt_state＜＝s3；
ELSif(regex_in＝″01000101″)then -- ′E′
nxt_state＜＝s3；
ELSif(regex_in＝″01000110″)then -- ′F′
nxt_state＜＝s3；
ELSif(regex_in＝″01000111″)then -- ′G′
nxt_state＜＝s3；
ELSif(regex_in＝″01001000″)then -- ′H′
nxt_state＜＝s3；
ELSif(regex_in＝″01001001″)then -- ′I′
nxt_state＜＝s3；
ELSif(regex_in＝″01001010″)then -- ′J′
nxt_state＜＝s3；
ELSif(regex_in＝″01001011″)then -- ′K′
nxt_state＜＝s3；
ELSif(regex_in＝″01001100″)then -- ′L′
nxt_state＜＝s3；
ELSif(regex_in＝″01001101″)then -- ′M′
nxt_state＜＝s3；
ELSif(regex in＝″01001110″)then -- ′N′
nxt_state＜＝s3；
ELSif(regex_in＝″01001111″)then -- ′O′
nxt_state＜＝s3；
ELSif(regex_in＝″01010000″)then -- ′P′
nxt_state＜＝s3；
ELSif(regex_in＝″01010001″)then -- ′Q′
nxt_state＜＝s3；
ELSif(regex_in＝″01010010″)then -- ′R′
nxt_state＜＝s3；
ELSif(regex_in＝″01010011″)then -- ′S′
nxt state＜＝s3；
ELSif(regex_in＝″01010100″)then -- ′T′
nxt_state＜＝s3；
ELSif(regex_in＝″01010101″)then -- ′U′
nxt_state＜＝s3；
ELSif(regex_in＝″01010110″)then -- ′V′
nxt_state＜＝s3；
ELSif(regex_in＝″01010111″)then -- ′W′
nxt_state＜＝s3；
ELSif(regex_in＝″01011000″)then -- ′X′
nxt_state＜＝s3；
ELSif(regex_in＝″01011001″)then -- ′Y′
nxt_state＜＝s3；
ELSif(regex_in＝″01011010″)then -- ′Z′
nxt_state＜＝s3；
ELSif(regex_in＝″01011011″)then -- ′[′
nxt_state＜＝s3；
ELSif(regex_in＝″01011100″)then -- ′\′
nxt_state＜＝s3；
ELSif(regex_in＝″01011101″)then -- ′]′
nxt_state＜＝s3；
ELSif(regex_in＝″01011110″)then -- ′^′
nxt_state＜＝s3；
ELSif(regex_in＝″01011111″)then -- ′_′
nxt_state＜＝s3；
ELSif(regex_in＝″01100000″)then -- ′`′
nxt_state＜＝s3；
<dp n="d99"/>
ELSif(regex_in＝″01100001″)then -- ′a′
nxt_state＜＝s3；
ELSif(regex_in＝″01100010″)then -- ′b′
nxt_state＜＝s3；
ELSif(regex_in＝″01100011″)then -- ′c′
nxt_state＜＝s3；
ELSif(regex_in＝″01100100″)then -- ′d′
nxt_state＜＝s3；
ELSif(regex_in＝″01100101″)then -- ′e′
nxt_state＜＝s3；
ELSif(regex_in＝″01100110″)then -- ′f′
nxt_state＜＝s3；
ELSif(regex_in＝″01100111″)then -- ′g′
nxt_state＜＝s3；
ELSif(regex_in＝″01101000″)then -- ′h′
nxt_state＜＝s3；
ELSif(regex_in＝″01101001″)then -- ′i′
nxt_state＜＝s3；
ELSif(regex_in＝″01101010″)then -- ′j′
nxt_state＜＝s3；
ELSif(regex_in＝″01101011″)then -- ′k′
nxt_state＜＝s3；
ELSif(regex_in＝″01101100″)then -- ′l′
nxt_state＜＝s3；
ELSif(regex_in＝″01101101″)then -- ′m′
nxt_state＜＝s3；
ELSif(regex_in＝″01101110″)then -- ′n′
nxt_state＜＝s3；
ELSif(regex_in＝″01101111″)then -- ′o′
nxt_state＜＝s3；
ELSif(regex_in＝″01110000″)then -- ′p′
nxt state＜＝s3；
ELSif(regex_in＝″01110001″)then -- ′q′
nxt_state＜＝s3；
ELSif(regex_in＝″01110010″)then -- ′r′
nxt_state＜＝s3；
ELSif(regex_in＝″01110011″)then -- ′s′
nxt_state＜＝s3；
ELSif(regex_in＝″01110100″)then -- ′t′
nxt_state＜＝s2；
ELSif(regex_in＝″01110101″)then -- ′u′
nxt_state＜＝s3；
ELSif(regex_in＝″01110110″)then -- ′v′
nxt_state＜＝s3；
ELSif(regex_in＝″01110111″)then -- ′w′
nxt_state＜＝s3；
ELSif(regex_in＝″01111000″)then -- ′x′
nxt_state＜＝s3；
ELSif(regex_in＝″01111001″)then -- ′y′
nxt_state＜＝s3；
ELSif(regex_in＝″01111010″)then -- ′z′
nxt_state＜＝s3；
ELSif(regex_in＝″01111011″)then -- ′{′
nxt_state＜＝s3；
ELSif(regex_in＝″01111100″)then -- ′|′
nxt_state＜＝s3；
ELSif(regex_in＝″01111101″)then -- ′}′
nxt_state＜＝s3；
ELSif(regex_in＝″01111110″)then -- ′～′
nxt_state＜＝s3；
ELSif(regex_in＝″01111111″)then -- DEL
<dp n="d100"/>
nxt_state＜＝s3；
else
nxt_state＜＝s0；
end if；
when s3＝＞if(regex_in＝″00000001″)then -- SOH
nxt_state＜＝s3；
ELSif(regex_in＝″00000010″)then -- STX
nxt_state＜＝s3；
ELSif(regex_in＝″00000011″)then -- ETX
nxt_state＜＝s3；
ELSif(regex_in＝″00000100″)then -- EOT
nxt_state＜＝s3；
ELSif(regex_in＝″00000101″)then -- ENQ
nxt_state＜＝s3；
ELSif(regex_in＝″00000110″)then -- ACK
nxt_state＜＝s3；
ELSif(regex_in＝″00000111″)then -- BEL
nxt_state＜＝s3；
ELSif(regex_in＝″00001000″)then -- BS
nxt_state＜＝s3；
ELSif(regex_in＝″00001001″)then -- HT
nxt_state＜＝s3；
ELSif(regex_in＝″00001011″)then -- VT
nxt_state＜＝s3；
ELSif(regex_in＝″00001100″)then -- FF
nxt_state＜＝s3；
ELSif(regex_in＝″00001110″)then -- SO
nxt_state＜＝s3；
ELSif(regex_in＝″00001111″)then -- SI
nxt_state＜＝s3；
ELSif(regex_in＝″00010000″)then -- DLE
nxt_state＜＝s3；
ELSif(regex_in＝″00010001″)then -- DC1
nxt_state＜＝s3；
ELSif(regex_in＝″00010010″)then -- DC2
nxt_state＜＝s3；
ELSif(regex_in＝″00010011″)then -- DC3
nxt_state＜＝s3；
ELSif(regex_in＝″00010100″)then -- DC4
nxt_state＜＝s3；
ELSif(regex_in＝″00010101″)then -- NAK
nxt_state＜＝s3；
ELSif(regex_in＝″00010110″)then -- SYN
nxt_state＜＝s3；
ELSif(regex_in＝″00010111″)then -- ETB
nxt_state＜＝s3；
ELSif(regex_in＝″00011000″)then -- CAN
nxt_state＜＝s3；
ELSif(regex_in＝″00011001″)then -- EM
nxt_state＜＝s3；
ELSif(regex_in＝″00011010″)then -- SUB
nxt_state＜＝s3；
ELSif(regex_in＝″00011011″)then -- ESC
nxt_state＜＝s3；
ELSif(regex_in＝″00011100″)then -- FSP
nxt_state＜＝s3；
ELSif(regex_in＝″00011101″)then -- GSP
nxt_state＜＝s3；
ELSif(regex_in＝″00011110″)then -- RSP
nxt_state＜＝s3；
<dp n="d101"/>
ELSif(regex_in＝″00011111″)then -- USP
nxt_state＜＝s3；
ELSif(regex_in＝″00100000″)then -- ′′
nxt_state＜＝s3；
ELSif(regex_in＝″00100001″)then -- ′！′
nxt_state＜＝s3；
ELSif(regex_in＝″00100010″)then -- ′″′
nxt_state＜＝s3；
ELSif(regex_in＝″00100011″)then -- ′#′
nxt_state＜＝s3；
ELSif(regex_in＝″00100100″)then -- ′$′
nxt_state＜＝s3；
ELSif(regex_in＝″00100101″)then -- ′％′
nxt_state＜＝s3；
ELSif(regex_in＝″00100110″)then -- ′&′
nxt_state＜＝s3；
ELSit(regex_in＝″00100111″)then -- ′′′
nxt_state＜＝s3；
ELSif(regex_in＝″00101000″)then -- ′(′
nxt_state＜＝s3；
ELSif(regex_in＝″00101001″)then -- ′)′
nxt_state＜＝s3；
ELSif(regex_in＝″00101010″)then -- ′*′
nxt_state＜＝s3；
ELSif(regex_in＝″00101011″)then -- ′+′
nxt_state＜＝s3；
ELSif(regex_in＝″00101100″)then -- ′，′
nxt_state＜＝s3；
ELSif(regex_in＝″00101101″)then -- ′-′
nxt_state＜＝s3；
ELSif(regex_in＝″00101110″)then -- ′.′
nxt_state＜＝s3；
ELSif(regex_in＝″00101111″)then -- ′/′
nxt_state＜＝s3；
ELSif(regex_in＝″00110000″)then -- ′0′
nxt_state＜＝s3；
ELSif(regex_in＝″00110001″)then -- ′1′
nxt_state＜＝s3；
ELSif(regex_in＝″00110010″)then -- ′2′
nxt_state＜＝s3；
ELSif(regex_in＝″00110011″)then -- ′3′
nxt_state＜＝s3；
ELSif(regex_in＝″00110100″)then -- ′4′
nxt_state＜＝s3；
ELSif(regex_in＝″00110101″)then -- ′5′
nxt_state＜＝s3；
ELSif(regex_in＝″00110110″)then -- ′6′
nxt_state＜＝s3；
ELSif(regex_in＝″00110111″)then -- ′7′
nxt_state＜＝s3；
ELSif(regex_in＝″00111000″)then -- ′8′
nxt_state＜＝s3；
ELSif(regex_in＝″00111001″)then -- ′9′
nxt_state＜＝s3；
ELSif(regex_in＝″00111010″)then -- ′：′
nxt_state＜＝s3；
ELSif(regex_in＝″00111011″)then -- ′；′
nxt_state＜＝s3；
ELSif(regex_in＝″00111100″)then -- ′＜′
nxt_state＜＝s3；
ELSif(regex_in＝″00111101″)then -- ′＝
<dp n="d102"/>
nxt_state＜＝s3；
ELSif(regex_in＝″00111110″)then -- ′＞′
nxt_state＜＝s3；
ELSif(regex_in＝″00111111″)then -- ′？′
nxt_state＜＝s3；
ELSif(regex_in＝″01000000″)then -- ′@′
nxt_state＜＝s3；
ELSif(regex_in＝″01000001″)then -- ′A′
nxt_state＜＝s3；
ELSif(regex_in＝″01000010″)then -- ′B′
nxt_state＜＝s3；
ELSif(regex_in＝″01000011″)then -- ′C′
nxt_state＜＝s3；
ELSif(regex_in＝″01000100″)then -- ′D′
nxt_state＜＝s3；
ELSif(regex_in＝″01000101″)then -- ′E′
nxt_state＜＝s3；
ELSif(regex_in＝″01000110″)then -- ′F′
nxt_state＜＝s3；
ELSif(regex_in＝″01000111″)then -- ′G′
nxt_state＜＝s3；
ELSif(regex_in＝″01001000″)then -- ′H′
nxt_state＜＝s3；
ELSif(regex_in＝″01001001″)then -- ′I′
nxt_state＜＝s3；
ELSif(regex_in＝″01001010″)then -- ′J′
nxt_state＜＝s3；
ELSif(regex_in＝″01001011″)then -- ′K′
nxt_state＜＝s3；
ELSif(regex_in＝″01001100″)then -- ′L′
nxt_state＜＝s3；
ELSif(regex_in＝″01001101″)then -- ′M′
nxt_state＜＝s3；
ELSif(regex_in＝″01001110″)then -- ′N′
nxt_state＜＝s3；
ELSif(regex_in＝″01001111″)then -- ′O′
nxt_state＜＝s3；
ELSif(regex_in＝″01010000″)then -- ′P′
nxt_state＜＝s3；
ELSif(regex_in＝″01010001″)then -- ′Q′
nxt_state＜＝s3；
ELSif(regex_in＝″01010010″)then -- ′R′
nxt_state＜＝s3；
ELSif(regex_in＝″01010011″)then -- ′S′
nxt_state＜＝s3；
ELSif(regex_in＝″01010100″)then -- ′T′
nxt_state＜＝s3；
ELSif(regex_in＝″01010101″)then -- ′U′
nxt_state＜＝s3；
ELSif(regex_in＝″01010110″)then -- ′V′
nxt_state＜＝s3；
ELSif(regex_in＝″01010111″)then -- ′W′
nxt_state＜＝s3；
ELSif(regex_in＝″01011000″)then -- ′X′
nxt_state＜＝s3；
ELSif(regex_in＝″01011001″)then -- ′Y′
nxt_state＜＝s3；
ELSif(regex_in＝″01011010″)then -- ′Z′
nxt_state＜＝s3；
ELSif(regex_in＝″01011011″)then -- ′[′
nxt_state＜＝s3；
<dp n="d103"/>
ELSif(regex_in＝″01011100″)then -- ′\′
nxt_state＜＝s3；
ELSif(regex_in＝″01011101″)then -- ′]′
nxt_state＜＝s3；
ELSif(regex_in＝″01011110″)then -- ′^′
nxt_state＜＝s3；
ELSif(regex_in＝″01011111″)then -- ′_′
nxt_state＜＝s3；
ELSif(regex_in＝″01100000″)then -- ′`′
nxt_state＜＝s3；
EISif(regex_in＝″01100001″)then -- ′a′
nxt_state＜＝s3；
ELSif(regex_in＝″01100010″)then -- ′b′
nxt_state＜＝s3；
ELSif(regex_in＝″01100011″)then -- ′c′
nxt_state＜＝s3；
ELSif(regex_in＝″01100100″)then -- ′d′
nxt_state＜＝s3；
ELSif(regex_in＝″01100101″)then -- ′e′
nxt_state＜＝s3；
ELSif(regex_in＝″01100110″)then -- ′f′
nxt_state＜＝s3；
ELSif(regex_in＝″01100111″)then -- ′g′
nxt_state＜＝s3；
ELSif(regex_in＝″01101000″)then -- ′h′
nxt_state＜＝s3；
ELSif(regex_in＝″01101001″)then -- ′i′
nxt_state＜＝s3；
ELSif(regex_in＝″01101010″)then -- ′j′
nxt_state＜＝s3；
ELSif(regex_in＝″01101011″)then -- ′k′
nxt_state＜＝s3；
ELSif(regex_in＝″01101100″)then -- ′l′
nxt_state＜＝s3；
ELSif(regex_in＝″01101101″)then -- ′m′
nxt_state＜＝s3；
ELSif(regex_in＝″01101110″)then -- ′n′
nxt_state＜＝s3；
ELSif(regex_in＝″01101111″)then -- ′o′
nxt_state＜＝s3；
ELSif(regex_in＝″01110000″)then -- ′p′
nxt_state＜＝s3；
ELSif(regex_in＝″01110001″)then -- ′q′
nxt_state＜＝s3；
ELSif(regex_in＝″01110010″)then -- ′r′
nxt_state＜＝s3；
ELSif(regex_in＝″01110011″)then -- ′s′
nxt_state＜＝s3；
ELSif(regex_in＝″01110100″)then -- ′t′
nxt_state＜＝s2；
ELSif(regex_in＝″01110101″)then -- ′u′
nxt_state＜＝s3；
ELSif(regex_in＝″01110110″)then -- ′v′
nxt_state＜＝s3；
ELSif(regex_in＝″01110111″)then -- ′w′
nxt_state＜＝s3；
ELSif(regex_in＝″01111000″)then -- ′x′
nxt_state＜＝s3；
ELSif(regex_in＝″01111001″)then -- ′y′
nxt_state＜＝s3；
ELSif(regex_in＝″01111010″)then -- ′z
<dp n="d104"/>
nxt_state＜＝s3；
ELSif(regex_in＝″01111011″)then -- ′{′
nxt_state＜＝s3；
ELSif(regex_in＝″01111100″)then -- ′|′
nxt_state＜＝s3；
ELSif(regex_in＝″01111101″)then -- ′}′
nxt_state＜＝s3；
ELSif(regex_in＝″01111110″)then -- ′～′
nxt_state＜＝s3；
ELSif(regex_in＝″01111111″)then -- DEL
nxt_state＜＝s3；
else
nxt state＜＝s0；
end if；
end case；
end if；
end process state_trans；
---------------------------
-- CONCURRENT STATEMENTS --
---------------------------
accepting＜＝′1′when nxt_state＝s1 or nxt state＝s2 else ′0′；
reseting ＜＝′1′when(state/＝s0)and(nxt_state＝s0)else ′0′；
running ＜＝′1′when state/＝s0 else ′0′；
end regex_arch1；
rad_loopback_core.vhd
-- applied research laboratory
-- washington university in st.louis
--
-- file： rad_loopback_core.vhd
-- top level structure for rad fpga with ingress/egress loopback
modules
-- created by： john w.lockwood(lockwood@arl.wustl.edu)，
-- davide.taylor(det3@arl.wustl.edu)
--
library ieee；
use ieee.std_logic_1164.all；
entity rad_loopback_core is
port(
-- clocks
rad_clk ：in std_logic；
rad_clkb ：in std_logic；
-- reset&reconfig
rad_reset ：in std_logic；
rad_ready ：out std_logic；
-- ingress path
-- input
soc_lc_nid ：in std_logic；
d_lc_nid ：in std_logic_vector(31 downto 0)；
tcaff_lc_rad ：out std_logic；
-- output
soc_lc_rad ：out std_logic；
d_lc_rad ：out std_logic_vector(31 downto 0)；
tcarr_lc_nid ：in std_logic；
-- egress path
-- input
soc_sw_nid ：in std_logic；
d_sw_nid ：in std_logic_vector(31 downto 0)；
tcaff_sw_rad ：out std_logic；
-- output
soc_sw_rad ：out std_logic；
d_sw_rad ：out std_logvc_vector(31 downto 0)；
tcaff_sw_nid ：in std_logic；
-- test connector pins
rad_test1 ：out std_logic_vector(15 downto 0)；
rad_test2 ：out std_logic_vector(15 downto 0)；
-- test led pins
rad_led1 ：out std logic；
rad_led2 ：out std_logic；
rad_led3 ：out std_logic；
rad_led4 ：out std_logic
)；
end rad_loopback_core；
------------------------------------------------------------------------
-------
architecture structure of rad_loopback_core is
-- conponent declarations
component loopback_module
port(
<dp n="d107"/>
clk ：in std_logic；
reset_l ：in std_logic；
soc_mod_in ：in std_logic；
d_mod_in ：in std_logic_vector(31 downto 0)；
tca_mod_in ：out std_logic；
soc_out_mod ：out std_logic；
d_out_mod ：out std_logic_vector(31 downto 0)；
tca_out_mod ：in std_logic；
test_data ：out std_logic_vector(31 downto 0)
)；
end component；
component regex_module
port(
clk ：in std_logic；
reset_l ：in std_logic；
soc_mod_in ：in std_logic；
d_mod_in ：in std_logic_vector(31 downto 0)；
tca_mod_in ：out std_logic；
soc_out_mod ：out std_logic；
d_out_mod ：out std_logic_vector(31 downto 0)；
tca_out_mod ：in std_logic；
enable_l ：in std_logic；
ready_l ：out std_logic；
test_data ：out std_logic_vector(31 downto 0)
)；
end component；
component blink
port(
clk1 ：in std_logic；
clk2 ：in std_logic；
reset_l ：in std_logic；
led1 ：out std_logic；
led2 ：out std_logic)；
end component；
-- signal declarations
signal ingress_test，egress_test ：std_logic_vector(31 downto 0)；
signal logic0，logic1 ：std_logic；
begin -- structural
rad_ready＜＝not(rad_reset)；
-- test pin flops
test_pin_ff ：process(rad_clk)
begin -- process test_pin_ff
if rad_clk′event and rad clk＝′1′then -- rising clock edge
rad_test2＜＝ingress_test(31 downto 16)；
rad_test1＜＝ingress_test(15 downto 0)；
rad_led3＜＝rad_reset；
rad_led4＜＝not rad_reset；
end if；
end process test_pin_ff；
logic0＜＝′0′；
logic1＜＝′1′；
<dp n="d108"/>
ingress ：regex_module
port map(
clk ＝＞rad_clk，
reset_l ＝＞rad_reset，
soc_mod_in ＝＞soc_lc_nid，
d_mod_in ＝＞d_lc_nid，
tca_mod_in ＝＞tcaff_lc_rad，
soc_out_mod ＝＞soc_lc_rad，
d_out_mod ＝＞d_lc_rad，
tca_out_mod ＝＞tcaff_lc_nid，
enable_l ＝＞logic0，
ready_l ＝＞open，
test_data ＝＞ingress_test)；
egress ：loopback_module
port map(
clk ＝＞rad_clkb，
reset_l ＝＞rad_reset，
soc_mod_in ＝＞soc_sw_nid，
d_mod_in ＝＞d_sw_nid，
tca_mod_in ＝＞tcaff_sw_rad，
soc_out_mod ＝＞soc_sw_rad，
d_out_mod ＝＞d_sw_rad，
tca_out_mod ＝＞tcaff_sw_nid，
test_data ＝＞egress_test)；
blink1 ：blink
port map(
clk1 ＝＞rad_clk，
clk2 ＝＞rad_clkb，
reset_l ＝＞rad_reset，
led1 ＝＞rad_led1，
led2 ＝＞rad_led2)；
end structure；
rad_loopback.vhd
-- applied research laboratory
-- washington university in st.louis
-- file： rad_loopback.vhd
-- top level structure for rad rpga wich ingress/egress loopback
modules
-- created by： john w.lockwood(lockwood@arl.wustl.edu)，
-- david e.taylor(det3@arl.wustl.edu)
--
------------------------------------------------------------------------
-------
library ieee；
use ieee.std logic 1164.all；
-- synthesis translate_off
library unisim；
-- synthesis translate_on
------------------------------------------------------------------------
-------
entity rad_loopback is
port(
-- clocks
rad_clk ：in std_logic；
rad_clkb ：in std_logic；
-- reset&reconfig
rad_reset ：in std_logic；
rad_ready ：out std_logic；
rad_reconfig ：inout std_logic_vector(2 downto 0)；
-- nid interface
--
-- ingress path
-- input
soc_lc_nid ：in std_logic；
d_lc_nid ：in std_logic_vector(31 downto 0)；
tcaff_lc_rad ：out std_logic；
-- output
soc_lc_rad ：out std_logic；
d_lc_rad ：out std_logic_vector(31 downto 0)；
tcaff_lc_nid ：in std_logic；
-- egress path
-- input
soc_sw_nid ：in std_logic；
d_sw_nid ：in std_logic_vector(31 downto 0)；
tcaff_sw_rad ：out std_logic；
-- output
soc_sw_rad ：out std_logic；
d_sw_rad ：out std_logic_vector(31 downto 0)；
tcaff_sw_nid ：in std_logic；
-- test connector pins
rad_test1 ：out std_logic_vector(15 downto 0)；
rad_test2 ：out std_logic_vector(15 downto 0)；
-- test led pins
rad_led1 ：out std_logic；
rad_led2 ：out std_logic；
rad_led3 ：out std_logic；
rad_led4 ：out std_logic
)；
<dp n="d111"/>
end rad loopback；
------------------------------------------------------------------------
-------
architecture structure of rad_loopback is
-- component declarations
component iobuf_f_12
port (
o ：out std_ulogic；
i ：in std_ulogic；
io ：inout std_logic；
t ：in std_logic
)；
end component；
component bufgdll
port ( o ：out std_ulogic；
i ：in std_ulogic
)；
end component；
-- synthesis translate_off
for all ：iobuf_f_12 use entity unisim.iobuf_f_12(iobuf_f_12_v)；
for all ：bufgdll use entity unisim.bufgdll(bufgdll_v)；
-- synthesis translate_on
component rad_loopback_core
port(
rad_clk ：in std_logic；
rad_clkb ：in std_logic；
rad_reset ：in std_logic；
rad_ready ：out std_logic；
soc_lc_nid ：in std_logic；
d_lc_nid ：in std_logic_vector(31 downto 0)；
tcaff_lc_rad ：out std_logic；
soc_lc_rad ：out std_logic；
d_lc_rad ：out std_logic_vector(31 downto 0)；
tcaff_lc_nid ：in std_logic；
soc_sw_nid ：in std_logic；
d_sw_nid ：in std_logic_vector(31 downto 0)；
tcaff_sw_rad ：out std_logic；
soc_sw_rad ：out std_logic；
d_sw_rad ：out std_logic_vector(31 downto 0)；
tcaff_sw_nid ：in std_logic；
rad_test1 ：out std_logic_vector(15 downto 0)；
rad_test2 ：out std_logic_vector(15 downto 0)；
rad_led1 ：out std_logic；
rad_led2 ：out std_logic；
rad_led3 ：out std_logic；
rad_led4 ：out std_logic)；
end component；
------------------------------------------------------------------------
-------
-- signal declarations
signal rad_clk_dll ：std_logic；--dll clock output
signal rad_clkb_dll ：std_logic；--dll clock output
signal rad_reset_i ：std_logic；
<dp n="d112"/>
signal rad_ready_i ：std_logic；
signal soc_lc_nid_i ：std_logic；
signal d_lc_nid_i ：std_logic_vettor(31 downto 0)；
signal tcaff_lc_rad_i ：std_logic；
signal soc_lc_rad_i ：std_logic；
signal d_lc_rad_i ：std_logic_vector(31 downto 0)；
signal tcaff_lc_nid_i ：std_logic；
signal soc_sw_nid_i ：std_logic；
signal d_sw_nid_i ：std_logic_vector(31 downto 0)；
signal tcaff_sw_rad_i ：std_logic；
signal soc_sw_rad_i ：std_logic；
signal d_sw_rad_i ：std_logic_vector(31 downto 0)；
signal tcaff_sw_nid_i ：std_logic；
signal rad_test1_i ：std_logic_vector(15 downto 0)；
signal rad_test2_i ：std_logic_vector(15 downto 0)；
signal rad_led1_i ：std_logic；
signal rad_led2_i ：std_logic；
signal rad_led3_i ：std_logic；
signal rad_led4_i ：std_logic；
signal rad_reset_pad ：std_logic；
signal rad_ready_pad ：std_logic；
signal soc_lc_nid_pad ：std_logic；
signal d_lc_nid_pad ：std_logic_vector(31 downto 0)；
signal tcaff_lc_rad_pad ：std_logic；
signal soc_lc_rad_pad ：std_logic；
signal d_lc_rad_pad ：std_logic_vector(31 downto 0)；
signal tcatr_lc_nid_pad ：std_logic；
signal soc_sw_nid_pad ：std_logic；
signal d_sw_nid_pad ：std_logic_vector(31 downto 0)；
signal tcaff_sw_rad_pad ：std_logic；
signal soc_sw_rad_pad ：std_logic；
slgnal d_sw_rad_pad ：std_logic_vector(31 downto 0)；
signal tcaff_sw_nid_pad ：std_logic；
signal rad_test1_pad ：std_logic_vector(15 downto 0)；
signal rad_test2_pad ：std_logic_vector(15 downto 0)；
signal rad_led1_pad ：std_logic；
signal rad_led2_pad ：std_logic；
signal rad led3_pad ：std_logic；
signal rad_led4_pad ：std_logic；
------------------------------------------------------------------------
-------
begin -- structural
rad_clk_dll ＜＝rad_clk；
rad_clkb_dll ＜＝rad_clkb；
-- purpose：double buffer all off-chip signals
iob_flops ：process(rad_clk_dll)
begin -- process iob_flops
if rad_clk_dll′event and rad_clk_dll＝′1′then -- rising clock
edge
rad_reset_pad ＜＝rad_reset；
rad_ready ＜＝rad_ready_pad；
soc_lc_nid_pad ＜＝soc_lc_nid；
d_lc_nid_pad ＜＝d_lc_nid；
tcaff_lc_rad ＜＝tcaff_lc_rad_pad；
soc_lc_rad ＜＝soc_lc_rad_pad；
d_lc_rad ＜＝d_lc_rad_pad；
tcaff_lc_nid_pad ＜＝tcaff_lc_nid；
soc_sw_nid_pad ＜＝soc_sw_nid；
<dp n="d113"/>
d_sw_nid_pad ＜＝d_sw_nid；
tcaff_sw_rad ＜＝tcaff_sw_rad_pad；
sot_sw_rad ＜＝soc_sw_rad_pad；
o_aw_rad ＜＝d_sw_rad_pad；
tcaff_sw_nid_pad ＜＝tcaff_sw_nid；
rad_test1 ＜＝rad_test1_pad；
rad_test2 ＜＝rad_test2_pad；
rad_led1 ＜＝rad_led1_pad；
rad_led2 ＜＝rad_led2_pad；
rad_led3 ＜＝rad_led3_pad；
rad_led4 ＜＝rad_led4_pad；
rad_reset_i ＜＝rad_reset_pad；
rad_ready_pad ＜＝rad_ready_i；
soc_lc_nid_i ＜＝soc_lc_nid_pad；
d_lc_nid_i ＜＝d_lc_nid_pad；
tcaff_ic_red_pad ＜＝tcaff_lc_rad_i；
soc_lc_rad_pad ＜＝soc_lc_rad_i；
d_lc_rad_pad ＜＝d_lc_rad_i；
tcaff_lc_nid_i ＜＝tcaff_ic_nid_pad；
soc_sw_nid_i ＜＝soc_sw_nid_pad；
d_sw_nid_i ＜＝d_sw_nid_pad；
tcaff_sw_rad_pad ＜＝tcaff_sw_rad_i；
soc_sw_rad_pad ＜＝soc_sw_rad_i；
d_sw_rad_pad ＜＝d_sw_rad_i；
tcaff_sw_nid_i ＜＝tcaff_sw_nid_pad；
rad_test1_pad ＜＝rad_test1_i；
rad_test2_pad ＜＝rad_test2_i；
rad_led1_pad ＜＝rad_led1_i；
rad_led2_pad ＜＝rad_led2_i；
rad_led3_pad ＜＝rad_led3_i；
rad_led4_pad ＜＝rad_led4_i；
end if；
end process iob_flops；
rad_loopback_core_1 ：rad_loopback_core
port map(
rad_clk ＝＞rad_clk_dll，
rad_clkb ＝＞rad_clkb_dll，
rad_reset ＝＞rad_reset_i，
rad_ready ＝＞rad_ready_i，
soc_lc_nid ＝＞soc_lc_nid_i，
d_lc_nid ＝＞d_lc_nid_i，
tcaff_lc_rad ＝＞tcaff_lc_rad_i，
soc_lc_rad ＝＞soc_lc_rad_i，
d_lc_rad ＝＞d_lc_rad_i，
tcaff_lc_nid ＝＞tcaff_lc_nid_i，
soc_sw_nid ＝＞soc_sw_nid_i，
d_sw_nid ＝＞d_sw_nid_i，
tcaff_sw_rad ＝＞tcaff_sw_rad_i，
soc_sw_rad ＝＞soc_sw_rad_i，
d_sw_rad ＝＞d_sw_rad_i，
tcarr_sw_nid ＝＞tcaff_sw_nid_i，
rad_test1 ＝＞rad_test1_i，
rad_test2 ＝＞rad_test2_i，
rad_led1 ＝＞rad_led1_i，
rad_led2 ＝＞rad_led2_i，
rad_led3 ＝＞rad_led3_i，
rad_led4 ＝＞rad_led4_i)；
end structure；
loopback_module.vhd
-- applied research laboratory
-- washington university in st.louis
--
-- file：loopback_module.vhd
-- entity declaration for rad module
-- created by：david e.taylor(det3@arl.wustl.edu)
-- created on：august，16 2000
-- last modified：august 18，2000@11:20am
--
-- important：refer to rad module interface specification
-- for explanations and timing specifications for all interface
-- signals.
library ieee；
use ieee.std_logic_1164.all；
entity loopback_module is
port(
-- clock&reset
clk ：in std_logic； -- 100mhz global clock
reset_l ：in std_logic； -- synchronous reset，asserted-
low
-- cell input interface
soc_mod_in ：in std_logic； -- start of cell
d_mod_in ：in std_logic_vector(31 downto 0)； -- 32-bit data
tca_mod_in ：out std_logic； -- transmit cell
available
-- cell output interface
soc_out_mod ：out std_logic； -- start of cell
d_out_mod ：out std_logic_vector(31 downto 0)；-- 32-bit data
tca_out_mod ：in std_logic； -- transmit
cell available
test_data ：out std_logic_vector(31 downto 0) --32-bit data
)；
end loopback_module；
architecture behavioral of loopback_module is
signal soc ：std_logic； -- start of cell
signal data ：std_logic_vector(31 downto 0)；-- 32-bit words of atm
cell
signal tca ：std_logic； -- transmit cell available
begin -- behavioral
-- pass cells through.on reconfig，hold tca low.
cell_io_ff ：process(clk)
begin -- process cell_ff
if(clk＝′1′and clk′event)then
if reset_l＝′0′then
soc＜＝′0′；
soc_out_mod＜＝′0′；
data＜＝(others＝＞′0′)；
d_out_mod＜＝(others＝＞′0′)；
tca＜＝′0′；
tca_mod_in＜＝′0′；
else
soc＜＝soc_mod_in；
<dp n="d116"/>
data＜＝d_mod_in；
soc_out_mod＜＝soc；
d_out_mod＜＝data；
tca＜＝tca_out_mod；
tca_mod_in＜＝tca；
end if；
end if；
end process cell_io_ff；
test_data＜＝data；
end behavioral；
blink.vhd
library ieee；
use ieee.std_logic_1164.all；
use ieee.std_logic_arith.all；
use ieee.std_logic_unsigned.all；
entity blink is
port(
clk1 ：in std_logic；
clk2 ：in std_logic；
reset_l ：in std_logic；
led1 ：out std_logic；
led2 ：out std_logic
)；
end blink；
architecture behav of blink is
signal led1_27 ：std_logic_vector(26 downto 0)；
signal led2_27 ：std_logic_vector(26 downto 0)；
begin
-- * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* * *
-- led1 is driven by a 27-bit counter clocked by the rad system clock
(100mhz)
-- led2 is driven by a 27-bit counter clocked by the rad system clock b
(100mhz)
-- * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* * *
-- a flip-flop is added after the last counter stage so that it can
-- sit in the iob.
-- led1 logic
led1_proc ：process(clk1，reset_l)
begin
if(reset_l＝′0′)then
led1＜＝′1′；
elsif(clk1′event and clk1＝′1′)then
led1＜＝led1_27(26)；
end if；
end process；
-- divide by 67 million
led1_cntr_proc ：process(clk1，reset_l)
begin
if(reset_l＝′0′)then
led1 27＜＝(others＝＞′0′)；
elsif(clk1′event and clk1＝′1′)then
led1_27＜＝unsigned(led1_27)+1；
end if；
end process；
-- * * * * * * * * * * * * * * * * * * * * * * * * * * * ** * * * * * *
* * *
-- led2 logic
led2_proc ：process(clk2，reset_l)
begin
<dp n="d119"/>
if(reset_l＝′0′)then
led2＜＝′1′；
elsif(clk2′event and clk2＝′1′)then
led2＜＝led2_27(26)；
end if；
end process；
-- divide by 67 million
led2_cntr_proc ：process(clk2，reset_l)
begin
if(reset_l＝′0′)then
led2_27＜＝(others＝＞′0′)；
elsif(clk2′event and clk2＝′1′)then
led2_27＜＝unsigned(led2_27)+1；
end if；
end process；
end behav；
regex_module.vhd
library ieee；
use ieee.std_logic_1164.all；
entity regex_module is
port(
-- clock&reset
clk ：in std_logic； -- 100mhz global clock
reset_l ：in std_logic； -- synchronous reset，asserted-
low
-- enable&ready
-- handshake for module reconfiguration.
enable_l ：in std_logic； -- asserted low
ready_l ：out std_logic； -- asserted low
-- cell input interface
soc_mod_in ：in std_logic； -- start of cell
d_mod_in ：in std_logic_vector(31 downto 0)；-- 32-bit data
tca_mod_in ：out std_logic； -- transmit cell
available
-- cell output interface
soc_out_mod ：out std_logic； -- start of cell
d_out_mod ：out std_logic_vector(31 downto 0)；-- 32-bit data
tca_out_mod ：in std_logic，
-- test data output
test_data ：out std_logic_vector(31 downto 0))；
end regex_module；
architecture struc of regex_module is
component udpwrapper
port(
clk ：in std_logic； -- clock
reset_l ：in std_logic； -- reset
enable_l ：in std_logic； -- enable
ready_l ：out std_logic； -- ready
soc_mod_in ：in std_logic； -- start of cell
d_mod_in ：in std_logic_vector(31 downto 0)；-- data
tca_mod_in ：out std_logic； -- transmit cell available
d_out_appl ：out std_logic_vector(31 downto 0)；-- data to
appl
dataen_out_appl ：out std_logic； -- data enable
sof_out_appl ：out std_logic； -- start of frame
eor_out_appl ：out std_logic； -- end of frame
sod_out_appl ：out std_logic； -- start of datagram
tca_out_appl ：in std_logic； -- congestion control
d_appl_in ：in std_logic_vector(31 downto 0)； --data
from appl
dataen_appl_in ：in std_logic； -- data enable
sof_appl_in ：in std_logic； -- start or frame
sof_appl_in ：in stg_login； -- end or frame
sod_appl_in ：in std_logic； -- start of datagram
tca_appl_in ：out std_logic； -- congestion control
soc_out_mod ：out std_logic； -- start or cell
d_out_mod ：out std_logic_vector(31 downto 0)； -- data
tca_out_mod ：in std_logic； -- transmit cell available
<dp n="d122"/>
jmos_soc_out_cell ：out std_logic；
jmos_soc_out_frame ：out std_logic；
jmos_soc_out_ip ：out std_logic；
jmos_soc_out_udp ：out std_logic)；
end component；
------------------------------------------------------------------------
-----
-- interface
------------------------------------------------------------------------
-----
component regex_app
port(
clk ：in std_logic； -- clock
reset_l ：in stg_logic； -- reset
enable_l ：in std_logic；
ready_l ：out std_logic；
dataen_out_appl ：in std_logic； -- data
enable
d_out_appl ：in std_logic_vector(31 downto 0)；-- data
sof_out_appl ：in std_logic； -- start of
frame
eof_out_appl ：in std_logic； -- end of
frame
sod_out_appl ：in std_logic； -- start of
datagram
tca_appl_in ：in std_logic； --
congestion control
dataen_appl_in ：out std_logic； -- data
enable
d_appl_in ：out std_logic_vector(31 downto 0)；-- data
sof_appl_in ：out std_logic； -- start of
frame
eof_appl_in ：out std_logic； -- end of
frame
sod_appl_in ：out std_logic； -- start of
datagram
tca_out_appl ：out std_logic)； --
congestion control
end component；
------------------------------------------------------------------------
-----
-- signals udpproc-application
-----------------------------------------------------------------------
-----
signal data_u2h ：std_logic_vector(31 downto 0)；-- data
signal dataen_u2h ：std_logic； -- data enable
signal sof_u2h ：std_logic； -- start of frame
signal eof_u2h ：std_logic； -- end of frame
signal sod_u2h ：std_logic； -- start of payload
signal tca_u2h ：std_logic； -- congestion
control
-----------------------------------------------------------------------
<dp n="d123"/>
-----
-- signals application-udpproc
------------------------------------------------------------------------
-----
signal data_h2u ：std_logic_vector(31 downto 0)；-- data
signal dataen_h2u ：std_logic； -- data enable
signal sor_h2u ：std_logic； -- start of frame
signal eof_h2u ：std_logic； -- end of frame
signal sod_h2u ：std_logic； -- start of payload
signal tca_h2u ：std_logic； -- congestion
control
signal ready1_l ：std_logic；
signal ready2_l ：std_logic；
signal jmos_soc_out_cell ：std_logic；
signal jmos_soc_out_frame ：std_logic；
signal jmos_soc_out_ip ：std_logic；
signal jmos_soc_out_udp ：std_logic；
begin -- struc
------------------------------------------------------------------------
-----
-- udpwrapper
------------------------------------------------------------------------
-----
upw ：udpwrapper port map(
clk ＝＞clk，
reset_l ＝＞reset_l，
enable_l ＝＞enable_l，
ready_l ＝＞readyl_l，
soc_mod_in ＝＞soc_mod_in，
d_mod_in ＝＞d_mod_in，
tca_mod_in ＝＞tca_mod_in，
soc_out_mod ＝＞soc_out_mod，
d_out_mod ＝＞d_out_mod，-- open
tca_out_mod ＝＞tca_out_mod，
d_out_appl ＝＞data_u2h，
dataen_out_appl ＝＞dataen_u2h，
sof_out_appl ＝＞suf_u2h，
eof_out_appl ＝＞eof_u2h，
sod_out_appl ＝＞sod_u2h，
tca_out_appl ＝＞tca_u2h，
d_appl_in ＝＞data_h2u，
dataen_appl_in ＝＞dataen_h2u，
sof_appl_in ＝＞sof_h2u，
eof_appl_in ＝＞eof_h2u，
sod_appl_in ＝＞sod_h2u，
tca_appl_in ＝＞tca_h2u，
jmos_soc_out_cell ＝＞jmos_soc_out_cell，
jmos_soc_out_frame ＝＞jmos_soc_out_frame，
jmos_soc_out_ip ＝＞jmos_soc_out_ip，
jmos_soc_out_utp ＝＞jmos_soc_out_udp)；
------------------------------------------------------------------------
-----
<dp n="d124"/>
-- regular expression application
------------------------------------------------------------------------
-----
app ：regex_app port map(
clk ＝＞clk，
reset_l ＝＞reset_l，
enable_l ＝＞enable_l，
ready_l ＝＞ready2_l，
dataen_out_appl ＝＞dataen_u2h，
d_out_appl ＝＞data_u2h，
sof_out_appl ＝＞sof_u2h，
eof_out_appl ＝＞eof_u2h，
sod_out_appl ＝＞sod_u2h，
tca_appl_in ＝＞tca_h2u，
dataen_appl_in ＝＞dataen_h2u，
d_appl_in ＝＞data_h2u，
sof_appl_in ＝＞sof_h2u，
eof_appl_in ＝＞eof_h2u，
sod_appl_in ＝＞sod_h2u，
tca_out_appl ＝＞tca_u2h)；
------------------------------------------------------------------------
-----
-- test pins
------------------------------------------------------------------------
-----
-- backside of my application
test_data(31) ＜＝sof_h2u；
test_data(30) ＜＝eof_h2u；
test_data(29) ＜＝sod_h2u；
test_data(28) ＜＝dataen_h2u；
test_data(27 downto 16) ＜＝data_h2u(11 downto 0)；
test_data(15) ＜＝jmos_soc_out_cell；
test_data(14) ＜＝jmos_soc_out_frame；
test_data(13) ＜＝jmos_soc_out_ip；
test_data(12) ＜＝jmos_soc out_udp；
test_data(11 downto 0) ＜＝″000000000000″；
-- test_data(15) ＜＝sof u2h；
-- test_data(14) ＜＝eof_u2h；
-- test_data(13) ＜＝sod_u2h；
-- test_data(12) ＜＝dataen_u2h；
-- test_data(11 downto 0) ＜＝data_u2h(11 downto 0)；
ready_l ＜＝readyl_l and ready2_l；
end struc；
<dp n="d125"/>
-- applied research laboratory
-- washington university in st.louis
-- file：rad_loopback_core.vhd
-- top level structure for rad fpga with ingress/egress loopback
modules
-- created by：john w.lockwood(lockwood@arl.wustl.edu)，
-- david e.taylor(det3@arl.wustl.edu)
--
library ieee；
use ieee.std_logic_1164.all；
entity rad_loopback_core is
port(
-- clocks
rad_clk ：in std_logic；
rad_clkb ：in std_logic；
-- reset&reconfig
rad_reset ：in std_logic；
rad_ready ：out std_logic；
-- ingress path
-- input
soc_lc_nid ：in std_logic；
d_lc_nid ：in std_logic_vector(31 downto 0)；
tcaff_lc_rad ：out std_logic；
-- output
soc_lc_rad ：out std_logic；
d_lc_rad ：out std_logic_vector(31 downto 0)；
tcaff_lc_nid ：in std_logic；
-- egress path
-- input
soc_sw_nid ：in std_logic；
d_sw_nid ：in std_logic_vector(31 downto 0)；
tcaff_sw_rad ：out std_logic；
-- output
soc_sw_rad ：out std_logic；
d_sw_rad ：out std_logic_vector(31 downto 0)；
tcaff_sw_nid ：in std_logic；
-- test connector pins
rad_test1 ：out std_logic_vector(15 downto 0)；
rad_test2 ：out std_logic_vector(15 downto 0)；
-- test led pins
rad_led1 ：out std_logic；
rad_led2 ：out std_logic；
rad_led3 ：out std_logic；
rad_led4 ：out std_logic
)；
end rad_loopback_core；
------------------------------------------------------------------------
-------
architecture structure of rad_loopback_core is
-- component declarations
component loopback_module
port(
<dp n="d126"/>
clk ：in std logic；
reset_l ：in std_logic；
soc_mod_in ：in std_logic；
d_mod_in ：in std_logic_vector(31 downto 0)；
tca_mod_in ：out std_logic；
soc_out_mod ：out std_logic；
d_out_mod ：out std_logic_vector(31 downto 0)；
tca_out_mod ：in std_logic；
test_data ：out std_logic_vector(31 downto 0)
)；
end component；
component regex_module
port(
clk ：in std_logic；
reset_l ：in std_logic；
soc_mod_in ：in std_logic；
d_mod_in ：in std_logic_vector(31 downto 0)；
tca_mod_in ：out std_logic；
soc_out_mod ：out std_logic；
d_out_mod ：out std_logic_vector(31 downto 0)；
tca_out_mod ：in std_logic；
enable_l ：in std_logic；
ready_l ：out std_logic；
test_data ：out std_logic_vector(31 downto 0)
)；
end component；
component blink
port(
clk1 ：in std_logic；
clk2 ：in std_logic；
reset_l ：in std_logic；
led1 ：out std_logic；
led2 ：out std_logic)；
end component；
-- signal declarations
signal ingress_test，egress_test ：std_logic_vector(31 downto 0)；
signal logic0，logic1 ：std_logic；
begin -- structural
rad_ready＜＝not(rad_reset)；
-- test pin flops
test_pin_ff ：process(rad_clk)
begin -- process test_pin_ff
if rad_clk′event and rad_clk＝′1′then -- rising clock edge
rad_test2＜＝ingress_test(31 downto 16)；
rad_test1＜＝ingress_test(15 downto 0)；
rad_led3＜＝rad_reset；
rad_led4＜＝not rad_reset；
end if；
end process test_pin_ff；
logic0＜＝′0′；
logic1＜＝′1′；
<dp n="d127"/>
ingress ：regex_module
port map(
clk ＝＞rad_clk，
reset_l ＝＞rad_reset，
soc_mod_in ＝＞soc_lc_nid，
d_mod_in ＝＞d_lc_nid，
tca_mod_in ＝＞tcaff_lc_rad，
soc_out_mod ＝＞soc_lc_rad，
d_out_mod ＝＞d_lc_rad，
tca_out_mod ＝＞tcaff_lc_nid，
enable_l ＝＞logic0，
ready_l ＝＞open，
test_data ＝＞ingress_test)；
egress ：loopback_module
port map(
clk ＝＞rad_clkb，
reset_l ＝＞rad_reset，
soc_mod_in ＝＞soc_sw_nid，
d_mod_in ＝＞d_sw_nid，
tca_mod_in ＝＞tcaff_sw_rad，
soc_out_mod ＝＞soc_sw_rad，
d_out_mod ＝＞d_sw_rad，
tca_out_mod ＝＞tcaff_sw_nid，
test_data ＝＞egress_test)；
blinkl ：blink
port map(
clk1 ＝＞rad_clk，
clk2 ＝＞rad_clkb，
reset_l ＝＞rad_reset，
led1 ＝＞rad_led1，
led2 ＝＞rad_led2)；
end structure；
MakeProject
#！/bin/gawk -f
BEGIN{
outfile＝″regex_app.prj″
if(n＝＝″″)
{
print″\nUSAGE：″
print″ makeProject-v n＝{number}\n″
print″ {number}： The number of machines this hardware
contains″
}else{
print″add_file-vhdl-lib work\″../vhdl/wrappers/framewrapper.vhd
\″″＞outfile
print″add_file-vhdl-lib work\″../vhdl/wrappers/ipwrapper.vhd
\″″＞outfile
print″add_file-vhdl-lib work\″../vhdl/wrappers/udpwrapper.vhd
\″″＞outfile
for(i＝1；i＜＝n；i++)
{
print″add_file-vhdl-lib work\″../vhdl/regex_fsm″i″.vhd\″″＞
outfile
print″add file-vhdl-lib work\″../vhdl/replace_buf″i″.vhd
\″″＞outfile
}
print″add_file-vhdl-lib work\″../vhdl/wrd_bldr.vhd\″″＞outfile
print″add_file-vhdl-lib work\″../vhdl/controller.vhd\″″＞
outfile
print″add_file-vhdl-lib work\″../vhdl/regex_app.vhd\″″＞outfile
print″add_file-vhdl-lib work
\″../vhdl/rad_loopback/regex_module.vhd\″″＞outfile
print″add_file-vhdl-lib work\″../vhdl/rad_loopback/blink.vhd
\″″＞outfile
print″add_file-vhdl-lib work
\″../vhdl/rad_loopback/loopback_module.vhd\″″＞outfile
print″add_file-vhdl-lib work
\″../vhdl/rad_loopback/rad_loopback_core.vhd\″″＞outfile
print″add_file-vhdl-lib work
\″../vhdl/rad_loopback/rad_loopback.vhd\″″＞outfile
print″″＞outfile
print″″＞outfile
print″impl-add regex_app″＞outfile
print″″＞outfile
print″set_option-technology VIRTEX-E″＞outfile
print″set_option-part XCV1000E″＞outrile
print″set_option-package FG680″＞outfile
print″set_option-speed_grade-7″＞outfile
print″″＞outfile
print″set_option-default_enum_encoding default″＞outfile
print″set_option-symbolic_fsm_compiler l″＞outfile
print″set_option-resource_sharing l″＞outfile
print″set_option-top_module\″rad_loopback\″″＞outfile
print″″＞outfile
print″set_option-frequency 100.000″＞outfile
print″set_option-fanout_limit 32″＞outfile
print″set_option-disable_io_insertion 0″＞outfile
print″set_option-pipe 0″＞outfile
print″set_option-modular 0″＞outfile
print″set_option-retiming 0″＞outfile
ptint″″＞outfile
<dp n="d130"/>
print″set_option-write_verilog 0″＞outfile
print″set_option-write_vhdl 0″＞outfile
print ″″＞outfile
print″set_option-write_apr_constraint 1″＞outfile
print″″＞outfile
print″project-result_format\″edif\″″＞outfile
print″project-result_file\″regex_app.edf\″″＞outfile
}
}
regex_app.prj
add_file-vhdl-lib work″../vhdl/wrappers/framewrapper.vhd″ add_file-vhdl-lib work″../vhdl/wrappers/ipwrapper.vhd″ add_file-vhdl-lib work″../vhdl/wrappers/udpwrapper.vhd″ add_file-vhdl-lib work″../vhdl/regex_fsm1.vhd″ add_fike-vhdl-lib work″../vhdl/replace_buf1.vhd″ add_file-vhdl-lib work″../vhdl/wrd_bldr.vhd″ add_file-vhll-lib work″../vhdl/controller.vhd″ add_file-vhdl-lib work″../vhdl/regex_app.vhd″ add_file-vhdl-lib work″../vhdl/rad_loopback/regex_module.vhd″add_file-vhdl-lib work″../vhdl/rad_loopback/blink.vhd″ add_file-vhdl-lib work″../vhdl/rad_loopback/loopback_module.vhd″ add_file-vhdl-lib work″../vhdl/rad_loopback/rad_loopback_core.vhd″ add_file-vhdl-lib work″../vhdl/rad_loopback/rad_loopback.vhd″ impl-add regex_app set_option-technology VIRTEX-E set_option-part XCV1000E set_option-package FG680 set_option-speed_grade-7 set_option-default_enum_encoding default set_option-symbolic_fsm_compiler 1 set_option-resource_sharing 1 set_option-top_module″rad_loopback″ set_option-frequency 100.000 set_option-fanout_limit 32 set_option-disable_io_lnsertion 0 set_option-plpe 0 set_option-modular 0 set_option-retiming 0 set_option-write_verilog 0 set_option-write_vhdl 0 set_option-write_apr_constraint 1 project-result_format″edif″ project-result_file″regex_app.e
Claims (67)
1.一种用于处理数据流的可重编程系统，所述系统包含：
可重编程数据处理器，用于接收数据流和通过可编程逻辑装置(PLD)处理所述接收的数据流，它被编程以(1)确定所述数据流是否包括匹配于可重定义的数据模式的数据串，以及(2)当发现所述数据流包括匹配于所述数据模式的数据串时进行可重定义的行动；以及
与所述数据处理器通信的重配置装置，它可操作从而以一组重定义数据模式和重定义行动中的至少一个对所述PLD重新编程。
2.根据权利要求1的系统，其中所述可重定义的行动是一个数据修改操作，而且其中所述PLD被编程，以通过修改被发现包括匹配串的数据流的至少一部分来完成所述数据修改操作。
3.根据权利要求2的系统，其中所述修改操作是串替换操作，所述串替换操作包括可重定义的替换串，而且其中所述PLD被编程，以通过用所述替换串代替所述数据流中的匹配串来执行所述串替换操作。
4.根据权利要求3的系统，其中所述PLD被编程，以通过用所述替换串代替所述数据流中的最长匹配串来执行所述串替换操作。
5.根据权利要求3的系统，其中所述数据处理器与一个计算机网络通信，从该计算机网络接收所述数据流，所述数据流包含在所述计算机网络上传送的数据包流。
6.根据权利要求5的系统，其中在所述包流中的每个包包括一个有效载荷部分，而且其中所述PLD被编程，以确定所述任何接收的包中的有效载荷部分是否包括一个匹配串。
7.根据权利要求6的系统，其中所述重配置装置通过所述计算机网络与所述数据处理器通信并进一步可操作以通过所述计算机网络对所述PLD重新编程。
8.根据权利要求6的系统，其中所述重配置装置包含：
重配置输入端，可操作以接收数据模式和替换串；
编译器，可操作以(1)从所述接收的数据模式和所述接收的替换串产生一个模块，它当被编程到所述PLD中时可操作以确定施加于它的包的有效载荷是否包括匹配于所述接收的数据模式的数据串，并且，如果在其中发现了匹配串，则以所述接收的替换串代替所述匹配串，以及(2)由所述产生的模块创建配置信息，它可操作以使用所述产生的模块对所述PLD编程；以及
发送器，可操作以在所述网络上将所述配置信息传送到所述数据处理器，用于以所述模块对所述PLD编程。
9.根据权利要求8的系统，其中所述数据处理器进一步包含一个与所述PLD及所述计算机网络通信的编程装置，它可操作以从所述发送器接收所述配置信息并根据所述接收的配置信息对所述PLD编程。
10.根据权利要求9的系统，其中所述重配置输入端进一步被配置成接收规则表达式格式的所述数据模式。
11.根据权利要求10的系统，其中所述编译器进一步被配置成部分地通过以词汇分析器发生器处理所述接收的数据模式来产生所述模块，从而创建一个模式匹配状态机的逻辑表示，它可操作以确定施加于它的数据是否包括匹配于所述接收的数据模式的数据串，所述模块包括所述模式匹配状态机表示。
12.根据权利要求11的系统，其中所述词汇分析器发生器是JLex。
13.根据权利要求11的系统，其中所述模块包括多个所述模式匹配状态机表示，用于并行处理所述包流。
14.根据权利要求11的系统，其中所述编译器进一步被配置成部分地通过处理所述接收的替换串来产生所述模块，从而由此创建一个串替换机的逻辑表示，该串替换机可操作以使用所述接收的替换串代替数据中发现的匹配串，所述模块包括所述串替换机表示。
15.根据权利要求14的系统，其中所述编译器进一步被配置成部分地通过协调所述模式匹配状态机表示和所述串替换机表示与一控制器的逻辑表示之间的关系来创建所述模块，所述控制器表示可操作以(1)与所述模式匹配状态机表示通信，从而确定一个匹配串的起始位置和终止位置，以及(2)处理所述已确定的起始和终止位置以控制所述串替换机表示，所述模块包括所述控制器表示。
16.根据权利要求4的系统，其中所述PLD是一个现场可编程门阵列(FPGA)。
17.根据权利要求4的系统，其中所述数据模式包括至少一个第一语言的字，而且其中所述替换串包含所述第一语言的所述至少一个字到第二语言的翻译。
18.根据权利要求4的系统，其中所述数据模式至少是部分地包括一个亵渎的语言(profanity)，而其中所述替换串包含的数据串中不包括所述亵渎的语言。
19.根据权利要求4的系统，其中所述数据模式包括一个被加密的数据串，而其中所述替换串包含对应于所述被加密数据串解密结果的数据串。
20.根据权利要求4的系统，其中所述数据模式包括一个数据串，其中所述替换串包含所述数据串的一个加密结果。
21.根据权利要求4的系统，其中所述数据模式包含一个计算机病毒的至少一部分，其中所述替换串包含一个不是计算机病毒的数据串。
22.根据权利要求3的系统，其中所述串替换操作是背替换操作。
23.根据权利要求3的系统，其中所述数据处理器与一个计算机网络通信，从该计算机网络接收所述数据流，所述数据流包含在所述计算机网络上传送的数据包流，其中所述可重定义的行动是包丢掉操作，并且其中所述PLD被编程以通过丢掉被发现包括匹配串的包来完成所述包丢掉操作。
24.根据权利要求1的系统，其中所述可重定义的行动是一个通告操作，其中所述PLD被编程以通过向一个感兴趣装置发送通告信号来完成所述通告操作，所述通告信号为操作性的，以标识所述数据流中一个匹配串的存在。
25.根据权利要求24的系统，其中所述数据处理器与一个计算机网络通信，从该计算机网络接收所述数据流，所述数据流包含在所述计算机网络上传送的数据包流，其中所述通告信号是为向感兴趣方传送而编址的通告包，其中所述通告包包括含有所述匹配串的包的副本。
26.根据权利要求1的系统，其中所述可重定义的行动是一个awk操作，并且其中所述PLD被编程以在所述数据流中发现匹配串时执行所述awk操作。
27.根据权利要求1的系统，其中所述数据模式包括下列一组中至少一个的至少一部分，该组包含图像文件、音频文件、视频文件、音频/视频文件、软件、受病毒感染的文件、文本文件、以及电子出版物文件。
28.根据权利要求1的系统，其中所述数据模式包括一个受版权保护的作品的至少一部分。
29.根据权利要求1的系统，其中所述数据模式包括一个商业秘密的至少一部分。
30.根据权利要求1的系统，其中所述数据模式包括一个数据串指出一个犯罪阴谋。
31.一种用于处理数据流的方法，所述方法包含：
编程一个可编程逻辑装置(PLD)以(1)确定施加于它的一个数据流是否包括匹配于一个数据模式的数据串，以及(2)如果发现所述数据流包括一个匹配串则进行一个响应行动；
通过所述被编程的PLD处理数据流以(1)确定所述数据流是否包括匹配于所述数据模式的数据串，以及(2)如果发现所述数据流包括一个匹配串则进行一个响应行动；以及
以一组不同的数据模式和不同的行动中的至少一个来重复所述编程步骤。
32.根据权利要求31的方法，其中所述编程步骤包括：
接收一个数据模式；
接收一个行动命令，所述行动命令指定一个如果发现所述数据流包括一个匹配串则要进行的行动；
从所述接收的数据模式和所述接收的行动命令产生配置信息，该配置信息定义一个模块，在被编程到所述PLD中之后可操作以(1)确定施加于它的数据流是否包括匹配于所述接收的数据模式的数据串，以及(2)如果发现所述数据流包括一个匹配串则进行所述响应行动；以及
以所述配置信息对所述PLD编程。
33.根据权利要求32的方法，其中所述行动命令接收步骤包括接收一个行动命令，它指定一个数据修改操作，所述数据修改操作标识如果发现数据流包括一个匹配串则如何修改该数据流。
34.根据权利要求33的方法，其中所述行动命令接收步骤包括接收一个行动命令，它指定一个串替换操作，所述串替换操作标识要插入数据流以替代一个匹配串的替换串。
35.根据权利要求32的方法，其中所述行动命令接收步骤包括接收一个行动命令，其中所述行动命令指定一个通告操作，所述通告操作指定一个当在所述数据流中发现一个匹配串时要被传送一个通告信号。
36.根据权利要求32的方法，其中所述数据流是在一个计算机网络上传送的包流，每个数据包包括一个有效载荷部分，其中所述处理步骤包括：
接收一个数据包流；
识别每个接收的数据包的有效载荷部分；以及
通过所述被编程的PLD处理每个接收的数据包的有效载荷部分，以(1)确定任何接收的数据包的有效载荷部分是否包括匹配于所述数据模式的数据串，以及(2)如果发现所述有效载荷部分包括一个匹配串则进行所述响应行动。
37.根据权利要求36的方法，其中所述以所述配置信息对所述PLD编程的步骤包括在所述计算机网络上将所述配置信息传送给所述PLD。
38.一种用于产生配置信息的装置，可操作以使用一个数据处理模块对一个可编程逻辑装置(PLD)编程，该数据处理模块可操作以接收和处理数据流，从而确定所述数据流是否包括一个数据模式，以及，如果是，则进行一个响应行动，所述装置包含：
输入端，可操作以从用户接收数据模式和行动命令，所述行动命令指定如果发现所述数据流包括匹配于所述数据模式的数据串时要进行的行动；
编译器，可操作以从所述接收的数据模式和所述接收的修改命令产生配置信息，所述配置信息定义一个数据处理模块，该数据处理模块在被编程到所述PLD中之后可操作以(1)确定施加于它的数据流是否包括匹配于所述接收的数据模式的数据串，以及(2)如果发现所述数据流包括一个匹配串则进行所述行动，所述配置信息可操作以使用所述数据处理模块对所述PLD编程。
39.根据权利要求38的装置，其中所述行动命令是一个修改命令，所述修改命令指定一个修改操作，如果发现所述数据流包括一个匹配串则对所述数据流进行这一修改操作，而且其中所述编译器还可操作以从所述修改命令产生配置信息，使得由此定义的所述模块在被编程到所述PLD中之后还可操作，以在发现所述数据流包括一个匹配串时对所述数据流进行所述修改操作。
40.根据权利要求39的装置，其中所述编译器还可操作以通过词汇分析器发生器处理所述接收的数据模式，从而产生一个模式匹配状态机的逻辑表示，该状态机可操作以确定施加于它的数据流是否包括匹配于所述接收的数据模式的数据串，所述模式匹配状态机表示部分地定义所述模块。
41.根据权利要求40的装置，其中由所述修改命令指定的修改操作是一个串替换操作，其中所述修改命令包括一个替换串，而其中所述编译器还可操作以处理所述接收的修改命令，从而产生一个串替换机的逻辑表示，该串替换机可操作以使用所述替换串代替所述数据流中的匹配串，所述串替换机表示部分地定义所述模块。
42.根据权利要求41的装置，其中所述编译器还可操作以通过所述词汇分析器发生器处理所述接收的数据模式，从而使所述模式匹配状态机表示包含至少一个确定型有限自动机(DFA)。
43.根据权利要求42的装置，其中所述数据流是包含在计算机网络上传送的多个数据包的包流，所述装置进一步包含一个使所述编译器与所述计算机网络接口的发送器，所述发送器可操作以从所述编译器接收所述配置信息并通过所述网络将所述配置信息传送给与所述PLD通信的一个编程装置，所述编程装置可操作以使用由此定义的所述模块对所述PLD进行编程。
44.根据权利要求43的装置，其中所述包流中的每个包包括一个有效载荷部分，而且其中所述编译器进一步可操作以产生所述配置信息，使得由此定义的所述模块当被编程到所述PLD时还可操作以确定构成所述包流的所述包的任何所述有效载荷是否包括匹配串。
45.根据权利要求44的装置，其中所述输入端还可操作以接收规则表达式格式的所述数据模式。
46.根据权利要求45的装置，其中所述输入端还可操作以从用户接收多个数据模式和多个所述修改命令，每个修改命令有一个相应的数据模式，而且其中所述编译器还可操作以产生所述配置信息，使得由此定义的所述数据处理模式还可操作，以对于每个数据模式和相应的修改命令执行所述匹配确定和所述串替换操作。
47.一种对可编程逻辑装置(PLD)进行编程以处理数据流的方法，所述方法包含：
接收一个数据模式；
接收一个与所述数据模式对应的修改命令，所述行动命令指定一个如果发现所述数据流包括一个匹配于所述数据模式的数据串则要进行的行动；
从所述接收的数据模式和所述接收的修改命令产生配置信息，它可操作以使用一个数据处理模块对所述PLD编程，该数据处理模块当被编程到所述PLD中时可操作以(1)确定施加于它的数据流是否包括匹配于所述数据模式的数据串，以及(2)如果发现所述数据流包括一个匹配串则执行由所述行动命令指定的行动；以及
将所述配置信息传送到与所述PLD通信的编程装置，所述编程装置可操作以使用所述配置信息对所述PLD编程。
48.根据权利要求47的方法，其中所述行动命令是一个修改命令，它指定一个对包括匹配串的数据流进行的修改操作，而且其中所述产生步骤包括产生所述配置信息，使得由此定义的所述模块还可操作以对所述数据流进行所述修改操作，如果发现所述数据流包括匹配串的话。
49.根据权利要求48的方法，其中所述修改操作是一个串替换操作，其中所述修改命令包括一个替换串，而且其中所述产生步骤包括产生所述配置信息，使得由此定义的所述模块还可操作以通过使用所述替换串代替所述数据流中的匹配串来执行所述串替换操作。
50.根据权利要求49的方法，其中所述产生步骤包括通过词汇分析器发生器处理所述数据模式，以从中产生一个模式匹配状态机的逻辑表示，所述模式匹配状态机部分地定义所述模块并可操作以确定施加于它的数据流是否包括匹配于所述数据模式的数据串。
51.根据权利要求50的方法，其中所述产生步骤包括从所述接收的修改命令创建一个串替换机的逻辑表示，所述串替换机部分地定义所述模块并可操作以使用所述替换串代替所述数据流中的匹配串。
52.根据权利要求51的方法，其中所述数据流是在一个计算机网络上传送的包含多个数据包的包流，而且其中所述传送步骤包括在所述网络上将所述配置信息传送到所述编程装置。
53.根据权利要求52的方法，其中每个所述数据包包括一个有效载荷部分，而且其中所述产生步骤包括产生所述配置信息，使得由此定义的所述模块当被编程到所述PLD中时还可操作以确定构成所述包流的所述包的任何所述有效载荷部分是否包括匹配串。
54.根据权利要求53的方法，其中所述数据模式接收步骤包括接收规则表达式格式的所述数据模式。
55.根据权利要求54的方法，其中所述数据模式接收步骤包括接收多个数据模式，其中所述修改命令接收步骤包括接收多个所述修改命令，每个修改命令对应于一个数据模式，而且其中所述产生步骤包括产生所述配置信息，使得由此定义的所述模块还可操作，以对每个数据模式和相应的修改命令(1)进行所述匹配确定，以及(2)进行所述串替换操作。
56.一种处理数据流的装置，所述装置包含：
可编程逻辑装置(PLD)，被编程以接收数据流并通过多个串行的可重定义逻辑结构处理所述数据流，每个逻辑结构被以相应的可重定义数据模式调谐，并可操作以确定在所述被处理的数据流中是否存在一个数据串匹配于那个逻辑结构所对应的数据模式。
57.根据权利要求56的装置，其中每个逻辑结构还被以相应的可重定义行动调谐，并进一步可操作以进行那个逻辑结构所对应的可重定义行动，如果发现所述被处理的数据流包括一个数据串匹配于那个逻辑结构所对应的数据模式的话。
58.根据权利要求57的装置，其中每个可重定义行动是一个串替换操作，每个串替换操作包括一个替换串，而且其中每个逻辑结构进一步可操作以使用那个逻辑结构所对应的替换串代替在所述被处理的数据流中发现的匹配于那个逻辑结构所对应的数据模式的数据串。
59.根据权利要求58的装置，其中所述PLD是与一个计算机网络通信的现场可编程门阵列(FPGA)，所述数据流包含在所述计算机网络上传送的数据包流。
60.一种处理数据流的装置，所述装置包含：
可编程逻辑装置(PLD)，被编程以接收数据流并通过多个并行的模式匹配状态机处理所述接收的数据流，所述多个模式匹配状态机中的每个模式匹配状态机被以一个数据模式调谐，并可操作以确定所述数据流是否包括一个数据串匹配于调谐该状态机的那个数据模式。
61.根据权利要求60的装置，其中所述多个模式匹配状态机中的每个模式匹配状态机被以同一数据模式调谐。
62.根据权利要求61的装置，其中所述数据流包含数据字节流，其中所述PLD还被以一个控制器编程，该控制器可操作以把所述数据流提供给所述多个并行的模式匹配状态机，使得每个模式匹配状态机接收以不同字节起始的所述数据流。
63.根据权利要求62的装置，其中所述控制器还可操作以与所述多个并行模式匹配状态机通信，从而在所述数据流中识别匹配于所述数据模式的最长数据串。
64.根据权利要求60的装置，所述多个模式匹配状态机中的每个模式匹配状态机被以不同的数据模式调谐。
65.一种用于处理数据流的可重编程系统，所述系统包含：
可重编程数据处理器，用于接收数据流和通过可编程逻辑装置(PLD)处理所述接收的数据流，该可编程逻辑装置被以至少一个确定型有限自动机(DFA)编程以确定所述数据流是否包括匹配于可重定义的数据模式的数据串；以及
与所述数据处理器通信的重配置装置，它可操作从而以一个不同的DFA对所述PLD重新编程，以确定数据流是否包括匹配于一个不同数据模式的数据串。
66.一种用于处理在计算机网络上传送的数据包流的网络处理器，所述网络处理器包含：
协议打包器，可操作接收来自所述计算机网络的数据并处理所述数据以从中产生一个数据包流，所述包流包含字流，每个字包括多个字节；
匹配路径，可操作以接收来自所述协议打包器的所述包流，并检测构成所述包流的任何包是否包括匹配于一个数据模式的数据串；
与所述匹配路径通信的控制器，它可操作以确定由所述匹配路径检测到的每个匹配串的起始字节位置和终止字节位置；
与所述控制器通信的数据路径，它可操作以从所述协议打包器接收所述包流并处理由所述控制器确定的每个匹配串的起始字节位置和终止字节位置，从而(1)输出所述包流中不对应于匹配串的每个字节，以及(2)以替换串代替所述包流中对应于匹配串的字节；
其中所述匹配路径、所述控制器以及所述数据路径是在可编程逻辑装置(PLD)上实现的。
67.根据权利要求66的网络处理器，其中所述协议打包器也在所述PLD上实现。
Applications Claiming Priority (2)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| US10/152,532 US7093023B2 (en) | 2002-05-21 | 2002-05-21 | Methods, systems, and devices using reprogrammable hardware for high-speed processing of streaming data to find a redefinable pattern and respond thereto |
| US10/152,532 | 2002-05-21 |
Publications (1)
| Publication Number | Publication Date |
|---|---|
| CN1656471A true CN1656471A (zh) | 2005-08-17 |
Family
ID=29548506
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CNA038114712A Pending CN1656471A (zh) | 2002-05-21 | 2003-05-21 | 使用可重编程硬件高速处理流数据以发现可重编程的模式并对其作出响应的方法、系统和装置 |
Country Status (8)
| Country | Link |
|---|---|
| US (1) | US7093023B2 (zh) |
| EP (1) | EP1506493A1 (zh) |
| JP (1) | JP2005527042A (zh) |
| KR (1) | KR20050010816A (zh) |
| CN (1) | CN1656471A (zh) |
| AU (1) | AU2003229337A1 (zh) |
| CA (1) | CA2485076A1 (zh) |
| WO (1) | WO2003100650A1 (zh) |
Cited By (7)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN105051711A (zh) * | 2013-03-15 | 2015-11-11 | 美光科技公司 | 用于提供由状态机引擎接收的数据的方法及设备 |
| CN105515849A (zh) * | 2015-12-02 | 2016-04-20 | 深圳市同创国芯电子有限公司 | 可编程器件、标识信息、编程数据流的配置方法及装置 |
| CN105550541A (zh) * | 2015-12-02 | 2016-05-04 | 深圳市国微电子有限公司 | 可编程器件、标识信息、编程数据流的配置方法及装置 |
| CN107093438A (zh) * | 2012-06-18 | 2017-08-25 | 谷歌公司 | 用于从混合音频记录选择性去除音频内容的系统和方法 |
| CN110658795A (zh) * | 2019-10-10 | 2020-01-07 | 北京航空航天大学 | 一种数字孪生数据精准融合方法和系统 |
| CN112134904A (zh) * | 2020-11-19 | 2020-12-25 | 北京智芯微电子科技有限公司 | 用于芯片间数据帧协议处理的帧打包器、方法及计量芯片 |
| CN113574517A (zh) * | 2019-03-14 | 2021-10-29 | 李亚东 | 生成分布式系统的规则编译器引擎装置、方法、系统和介质 |
Families Citing this family (135)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US7139743B2 (en) | 2000-04-07 | 2006-11-21 | Washington University | Associative database scanning and information retrieval using FPGA devices |
| US8095508B2 (en) | 2000-04-07 | 2012-01-10 | Washington University | Intelligent data storage and processing using FPGA devices |
| US6711558B1 (en) | 2000-04-07 | 2004-03-23 | Washington University | Associative database scanning and information retrieval |
| US7853833B1 (en) * | 2000-09-08 | 2010-12-14 | Corel Corporation | Method and apparatus for enhancing reliability of automated data processing |
| US7779117B2 (en) * | 2002-05-31 | 2010-08-17 | Aol Inc. | Monitoring digital images |
| US7716330B2 (en) | 2001-10-19 | 2010-05-11 | Global Velocity, Inc. | System and method for controlling transmission of data packets over an information network |
| WO2004002044A2 (en) * | 2002-02-01 | 2003-12-31 | John Fairweather | A system for exchanging binary data |
| US7711844B2 (en) | 2002-08-15 | 2010-05-04 | Washington University Of St. Louis | TCP-splitter: reliable packet monitoring methods and apparatus for high speed networks |
| US7134143B2 (en) * | 2003-02-04 | 2006-11-07 | Stellenberg Gerald S | Method and apparatus for data packet pattern matching |
| EP2528000B1 (en) | 2003-05-23 | 2017-07-26 | IP Reservoir, LLC | Intelligent data storage and processing using FPGA devices |
| US10572824B2 (en) | 2003-05-23 | 2020-02-25 | Ip Reservoir, Llc | System and method for low latency multi-functional pipeline with correlation logic and selectively activated/deactivated pipelined data processing engines |
| US7685254B2 (en) * | 2003-06-10 | 2010-03-23 | Pandya Ashish A | Runtime adaptable search processor |
| US8588069B2 (en) * | 2003-08-29 | 2013-11-19 | Ineoquest Technologies, Inc. | System and method for analyzing the performance of multiple transportation streams of streaming media in packet-based networks |
| US8838772B2 (en) | 2003-08-29 | 2014-09-16 | Ineoquest Technologies, Inc. | System and method for analyzing the performance of multiple transportation streams of streaming media in packet-based networks |
| US20150341812A1 (en) | 2003-08-29 | 2015-11-26 | Ineoquest Technologies, Inc. | Video quality monitoring |
| US20050165789A1 (en) * | 2003-12-22 | 2005-07-28 | Minton Steven N. | Client-centric information extraction system for an information network |
| US7602785B2 (en) * | 2004-02-09 | 2009-10-13 | Washington University | Method and system for performing longest prefix matching for network address lookup using bloom filters |
| IL161874A (en) | 2004-05-07 | 2012-09-24 | Yves Villaret | System and method for searching strings of records |
| US7685637B2 (en) * | 2004-06-14 | 2010-03-23 | Lionic Corporation | System security approaches using sub-expression automata |
| US7779464B2 (en) * | 2004-06-14 | 2010-08-17 | Lionic Corporation | System security approaches utilizing a hierarchical memory system |
| US7930742B2 (en) * | 2004-06-14 | 2011-04-19 | Lionic Corporation | Multiple-level data processing system |
| US8244542B2 (en) * | 2004-07-01 | 2012-08-14 | Emc Corporation | Video surveillance |
| US8560475B2 (en) | 2004-09-10 | 2013-10-15 | Cavium, Inc. | Content search mechanism that uses a deterministic finite automata (DFA) graph, a DFA state machine, and a walker process |
| US8392590B2 (en) * | 2004-09-10 | 2013-03-05 | Cavium, Inc. | Deterministic finite automata (DFA) processing |
| US8301788B2 (en) * | 2004-09-10 | 2012-10-30 | Cavium, Inc. | Deterministic finite automata (DFA) instruction |
| US8782200B2 (en) * | 2004-09-14 | 2014-07-15 | Sitespect, Inc. | System and method for optimizing website visitor actions |
| US8776206B1 (en) * | 2004-10-18 | 2014-07-08 | Gtb Technologies, Inc. | Method, a system, and an apparatus for content security in computer networks |
| US7356663B2 (en) * | 2004-11-08 | 2008-04-08 | Intruguard Devices, Inc. | Layered memory architecture for deterministic finite automaton based string matching useful in network intrusion detection and prevention systems and apparatuses |
| US7626940B2 (en) * | 2004-12-22 | 2009-12-01 | Intruguard Devices, Inc. | System and method for integrated header, state, rate and content anomaly prevention for domain name service |
| US7602731B2 (en) * | 2004-12-22 | 2009-10-13 | Intruguard Devices, Inc. | System and method for integrated header, state, rate and content anomaly prevention with policy enforcement |
| US7725938B2 (en) * | 2005-01-20 | 2010-05-25 | Cisco Technology, Inc. | Inline intrusion detection |
| JP2008532177A (ja) * | 2005-03-03 | 2008-08-14 | ワシントン ユニヴァーシティー | 生物学的配列類似検索を実行するための方法および装置 |
| US20070097976A1 (en) * | 2005-05-20 | 2007-05-03 | Wood George D | Suspect traffic redirection |
| US7499941B2 (en) * | 2005-09-05 | 2009-03-03 | Cisco Technology, Inc. | Pipeline regular expression matching |
| US7886068B1 (en) * | 2005-10-27 | 2011-02-08 | Network Appliance, Inc. | Management of streaming media playlists |
| US20070118358A1 (en) * | 2005-11-08 | 2007-05-24 | Tom Alexander S | Phrase processor |
| JP4635147B2 (ja) * | 2005-11-17 | 2011-02-16 | 国立大学法人 筑波大学 | パターンマッチング装置、その形成方法、それを用いたネットワーク不正侵入検知装置の動作方法、およびそれを用いた侵入防止システムの動作方法 |
| US7716100B2 (en) * | 2005-12-02 | 2010-05-11 | Kuberre Systems, Inc. | Methods and systems for computing platform |
| US7702629B2 (en) | 2005-12-02 | 2010-04-20 | Exegy Incorporated | Method and device for high performance regular expression pattern matching |
| KR100968285B1 (ko) * | 2005-12-19 | 2010-07-06 | 엔엑스피 비 브이 | 데이터 전송 방법 및 시스템 |
| US7954114B2 (en) * | 2006-01-26 | 2011-05-31 | Exegy Incorporated | Firmware socket module for FPGA-based pipeline processing |
| GB2434945B (en) * | 2006-01-31 | 2008-04-09 | Roke Manor Research | A method of filtering high data rate traffic |
| US8379841B2 (en) | 2006-03-23 | 2013-02-19 | Exegy Incorporated | Method and system for high throughput blockwise independent encryption/decryption |
| JP4878487B2 (ja) * | 2006-03-30 | 2012-02-15 | キヤノン株式会社 | 情報配信装置、情報配信システム、情報処理方法、およびプログラム |
| US20070237146A1 (en) * | 2006-03-31 | 2007-10-11 | Ilija Hadzic | Methods and apparatus for modeling and synthesizing packet processing pipelines |
| US7840482B2 (en) | 2006-06-19 | 2010-11-23 | Exegy Incorporated | Method and system for high speed options pricing |
| US7921046B2 (en) | 2006-06-19 | 2011-04-05 | Exegy Incorporated | High speed processing of financial information using FPGA devices |
| US20080086274A1 (en) * | 2006-08-10 | 2008-04-10 | Chamberlain Roger D | Method and Apparatus for Protein Sequence Alignment Using FPGA Devices |
| WO2008023424A1 (fr) | 2006-08-24 | 2008-02-28 | Duaxes Corporation | Système de gestion de communication et procédé de gestion de communication associé |
| JP4571184B2 (ja) | 2006-08-24 | 2010-10-27 | デュアキシズ株式会社 | 通信管理システム |
| US7973954B2 (en) * | 2006-08-28 | 2011-07-05 | Sharp Laboratories Of America, Inc. | Method and apparatus for automatic language switching for an imaging device |
| CN101573703A (zh) * | 2006-10-03 | 2009-11-04 | 朗讯科技公司 | 用于重配置ic架构的方法和装置 |
| KR100749820B1 (ko) * | 2006-11-06 | 2007-08-17 | 한국전자통신연구원 | 센서 네트워크로부터의 센싱 데이터 처리 시스템 및 그방법 |
| US7660793B2 (en) | 2006-11-13 | 2010-02-09 | Exegy Incorporated | Method and system for high performance integration, processing and searching of structured and unstructured data using coprocessors |
| US8326819B2 (en) | 2006-11-13 | 2012-12-04 | Exegy Incorporated | Method and system for high performance data metatagging and data indexing using coprocessors |
| WO2008063974A2 (en) * | 2006-11-13 | 2008-05-29 | Exegy Incorporated | Method and system for high performance integration, processing and searching of structured and unstructured data using coprocessors |
| US8156247B2 (en) * | 2007-04-30 | 2012-04-10 | Lsi Corportion | Systems and methods for reducing network performance degradation |
| EP2186250B1 (en) | 2007-08-31 | 2019-03-27 | IP Reservoir, LLC | Method and apparatus for hardware-accelerated encryption/decryption |
| US8819217B2 (en) * | 2007-11-01 | 2014-08-26 | Cavium, Inc. | Intelligent graph walking |
| US8180803B2 (en) * | 2007-11-27 | 2012-05-15 | Cavium, Inc. | Deterministic finite automata (DFA) graph compression |
| US7949683B2 (en) * | 2007-11-27 | 2011-05-24 | Cavium Networks, Inc. | Method and apparatus for traversing a compressed deterministic finite automata (DFA) graph |
| CZ2007850A3 (cs) * | 2007-12-04 | 2009-08-12 | Cesnet | Modulární programovatelná platforma pro vysokorychlostní hardwarové zpracování paketu |
| US10229453B2 (en) | 2008-01-11 | 2019-03-12 | Ip Reservoir, Llc | Method and system for low latency basket calculation |
| US8374986B2 (en) | 2008-05-15 | 2013-02-12 | Exegy Incorporated | Method and system for accelerated stream processing |
| US20090310513A1 (en) * | 2008-06-16 | 2009-12-17 | Subhabrata Sen | Method and apparatus for creating router configuration templates |
| US20100024031A1 (en) * | 2008-07-24 | 2010-01-28 | Sap Portals Israel Ltd | System and method for transforming hierarchical objects |
| US8676841B2 (en) * | 2008-08-29 | 2014-03-18 | Oracle International Corporation | Detection of recurring non-occurrences of events using pattern matching |
| US8473523B2 (en) | 2008-10-31 | 2013-06-25 | Cavium, Inc. | Deterministic finite automata graph traversal with nodal bit mapping |
| US8442931B2 (en) | 2008-12-01 | 2013-05-14 | The Boeing Company | Graph-based data search |
| US8208494B2 (en) * | 2008-12-03 | 2012-06-26 | Gigamon Llc | Intelligent packet slicing |
| US20120095893A1 (en) | 2008-12-15 | 2012-04-19 | Exegy Incorporated | Method and apparatus for high-speed processing of financial market depth data |
| CN101442540B (zh) * | 2008-12-30 | 2012-09-05 | 合肥昊特信息科技有限公司 | 基于现场可编程门阵列的高速模式匹配算法 |
| US20100192225A1 (en) * | 2009-01-28 | 2010-07-29 | Juniper Networks, Inc. | Efficient application identification with network devices |
| US8145859B2 (en) * | 2009-03-02 | 2012-03-27 | Oracle International Corporation | Method and system for spilling from a queue to a persistent store |
| US8387076B2 (en) | 2009-07-21 | 2013-02-26 | Oracle International Corporation | Standardized database connectivity support for an event processing server |
| US8321450B2 (en) | 2009-07-21 | 2012-11-27 | Oracle International Corporation | Standardized database connectivity support for an event processing server in an embedded context |
| US8527458B2 (en) | 2009-08-03 | 2013-09-03 | Oracle International Corporation | Logging framework for a data stream processing server |
| US8386466B2 (en) | 2009-08-03 | 2013-02-26 | Oracle International Corporation | Log visualization tool for a data stream processing server |
| US9083740B1 (en) | 2009-09-28 | 2015-07-14 | Juniper Networks, Inc. | Network traffic pattern matching using adaptive deterministic finite automata |
| US8959106B2 (en) | 2009-12-28 | 2015-02-17 | Oracle International Corporation | Class loading using java data cartridges |
| US9305057B2 (en) | 2009-12-28 | 2016-04-05 | Oracle International Corporation | Extensible indexing framework using data cartridges |
| US9430494B2 (en) | 2009-12-28 | 2016-08-30 | Oracle International Corporation | Spatial data cartridge for event processing systems |
| US8522199B2 (en) * | 2010-02-26 | 2013-08-27 | Mcafee, Inc. | System, method, and computer program product for applying a regular expression to content based on required strings of the regular expression |
| US20110219016A1 (en) * | 2010-03-04 | 2011-09-08 | Src, Inc. | Stream Mining via State Machine and High Dimensionality Database |
| US9507880B2 (en) * | 2010-06-30 | 2016-11-29 | Oracle International Corporation | Regular expression optimizer |
| US8713049B2 (en) | 2010-09-17 | 2014-04-29 | Oracle International Corporation | Support for a parameterized query/view in complex event processing |
| US9189280B2 (en) | 2010-11-18 | 2015-11-17 | Oracle International Corporation | Tracking large numbers of moving objects in an event processing system |
| JP6045505B2 (ja) | 2010-12-09 | 2016-12-14 | アイピー レザボア, エルエルシー.IP Reservoir, LLC. | 金融市場における注文を管理する方法および装置 |
| US8972497B2 (en) | 2011-04-06 | 2015-03-03 | International Business Machines Corporation | Automated encoding of field operators for absent fields |
| US8489492B2 (en) * | 2011-04-06 | 2013-07-16 | International Business Machines Corporation | Automated encoding of increment operators |
| US8983866B2 (en) | 2011-04-06 | 2015-03-17 | International Business Machines Corporation | Automated encoding of delta operators |
| US10360626B2 (en) | 2011-04-06 | 2019-07-23 | International Business Machines Corporation | Securities messages with automated encoding of field operators |
| US8990416B2 (en) | 2011-05-06 | 2015-03-24 | Oracle International Corporation | Support for a new insert stream (ISTREAM) operation in complex event processing (CEP) |
| US9329975B2 (en) | 2011-07-07 | 2016-05-03 | Oracle International Corporation | Continuous query language (CQL) debugger in complex event processing (CEP) |
| US9047243B2 (en) | 2011-12-14 | 2015-06-02 | Ip Reservoir, Llc | Method and apparatus for low latency data distribution |
| US10121196B2 (en) | 2012-03-27 | 2018-11-06 | Ip Reservoir, Llc | Offload processing of data packets containing financial market data |
| US9990393B2 (en) | 2012-03-27 | 2018-06-05 | Ip Reservoir, Llc | Intelligent feed switch |
| US11436672B2 (en) | 2012-03-27 | 2022-09-06 | Exegy Incorporated | Intelligent switch for processing financial market data |
| US10650452B2 (en) | 2012-03-27 | 2020-05-12 | Ip Reservoir, Llc | Offload processing of data packets |
| CN102799561A (zh) * | 2012-06-18 | 2012-11-28 | 龙芯中科技术有限公司 | 嵌入式可重构数据处理方法、装置及系统 |
| US9262479B2 (en) | 2012-09-28 | 2016-02-16 | Oracle International Corporation | Join operations for continuous queries over archived views |
| US9563663B2 (en) | 2012-09-28 | 2017-02-07 | Oracle International Corporation | Fast path evaluation of Boolean predicates |
| US9633093B2 (en) | 2012-10-23 | 2017-04-25 | Ip Reservoir, Llc | Method and apparatus for accelerated format translation of data in a delimited data format |
| EP2912579B1 (en) | 2012-10-23 | 2020-08-19 | IP Reservoir, LLC | Method and apparatus for accelerated format translation of data in a delimited data format |
| US10102260B2 (en) | 2012-10-23 | 2018-10-16 | Ip Reservoir, Llc | Method and apparatus for accelerated data translation using record layout detection |
| WO2014077615A1 (en) * | 2012-11-19 | 2014-05-22 | Samsung Sds Co., Ltd. | Anti-malware system, method of processing packet in the same, and computing device |
| US10956422B2 (en) | 2012-12-05 | 2021-03-23 | Oracle International Corporation | Integrating event processing with map-reduce |
| US9098587B2 (en) | 2013-01-15 | 2015-08-04 | Oracle International Corporation | Variable duration non-event pattern matching |
| US10298444B2 (en) | 2013-01-15 | 2019-05-21 | Oracle International Corporation | Variable duration windows on continuous data streams |
| US9390135B2 (en) | 2013-02-19 | 2016-07-12 | Oracle International Corporation | Executing continuous event processing (CEP) queries in parallel |
| US9047249B2 (en) | 2013-02-19 | 2015-06-02 | Oracle International Corporation | Handling faults in a continuous event processing (CEP) system |
| US9418113B2 (en) | 2013-05-30 | 2016-08-16 | Oracle International Corporation | Value based windows on relations in continuous data streams |
| JP5977209B2 (ja) * | 2013-07-18 | 2016-08-24 | 日本電信電話株式会社 | ステートマシン回路 |
| US9934279B2 (en) | 2013-12-05 | 2018-04-03 | Oracle International Corporation | Pattern matching across multiple input data streams |
| WO2015164639A1 (en) | 2014-04-23 | 2015-10-29 | Ip Reservoir, Llc | Method and apparatus for accelerated data translation |
| US9244978B2 (en) | 2014-06-11 | 2016-01-26 | Oracle International Corporation | Custom partitioning of a data stream |
| US9712645B2 (en) | 2014-06-26 | 2017-07-18 | Oracle International Corporation | Embedded event processing |
| US10120907B2 (en) | 2014-09-24 | 2018-11-06 | Oracle International Corporation | Scaling event processing using distributed flows and map-reduce operations |
| US9886486B2 (en) | 2014-09-24 | 2018-02-06 | Oracle International Corporation | Enriching events with dynamically typed big data for event processing |
| US20160117179A1 (en) * | 2014-10-24 | 2016-04-28 | Advanced Micro Devices, Inc. | Command replacement for communication at a processor |
| WO2017018901A1 (en) | 2015-07-24 | 2017-02-02 | Oracle International Corporation | Visually exploring and analyzing event streams |
| US9875045B2 (en) * | 2015-07-27 | 2018-01-23 | International Business Machines Corporation | Regular expression matching with back-references using backtracking |
| US10942943B2 (en) | 2015-10-29 | 2021-03-09 | Ip Reservoir, Llc | Dynamic field data translation to support high performance stream data processing |
| US9391908B1 (en) | 2015-12-12 | 2016-07-12 | International Business Machines Corporation | Unfusing operators from a streaming processing element to avoid congestion |
| US9973528B2 (en) | 2015-12-21 | 2018-05-15 | Fortinet, Inc. | Two-stage hash based logic for application layer distributed denial of service (DDoS) attack attribution |
| WO2017135837A1 (en) | 2016-02-01 | 2017-08-10 | Oracle International Corporation | Pattern based automated test data generation |
| WO2017135838A1 (en) | 2016-02-01 | 2017-08-10 | Oracle International Corporation | Level of detail control for geostreaming |
| US10223317B2 (en) | 2016-09-28 | 2019-03-05 | Amazon Technologies, Inc. | Configurable logic platform |
| WO2018119035A1 (en) | 2016-12-22 | 2018-06-28 | Ip Reservoir, Llc | Pipelines for hardware-accelerated machine learning |
| US10483981B2 (en) | 2016-12-30 | 2019-11-19 | Microsoft Technology Licensing, Llc | Highspeed/low power symbol compare |
| US9996328B1 (en) * | 2017-06-22 | 2018-06-12 | Archeo Futurus, Inc. | Compiling and optimizing a computer code by minimizing a number of states in a finite machine corresponding to the computer code |
| US10481881B2 (en) * | 2017-06-22 | 2019-11-19 | Archeo Futurus, Inc. | Mapping a computer code to wires and gates |
| US10990627B1 (en) * | 2018-12-11 | 2021-04-27 | Amazon Technologies, Inc. | Sharing character data across lookups to identify matches to a regular expression |
| US11960927B2 (en) * | 2021-07-12 | 2024-04-16 | Dell Products L.P. | Task correlation framework |
| US20230418854A1 (en) * | 2022-06-23 | 2023-12-28 | Vertiv It Systems, Inc. | System and method for serial-over-ip switch based character string pattern matching and detection |
Family Cites Families (47)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US3601808A (en) * | 1968-07-18 | 1971-08-24 | Bell Telephone Labor Inc | Advanced keyword associative access memory system |
| US3611314A (en) * | 1969-09-09 | 1971-10-05 | Texas Instruments Inc | Dynamic associative data processing system |
| US3824375A (en) * | 1970-08-28 | 1974-07-16 | Financial Security Syst Inc | Memory system |
| US3729712A (en) * | 1971-02-26 | 1973-04-24 | Eastman Kodak Co | Information storage and retrieval system |
| US3848235A (en) * | 1973-10-24 | 1974-11-12 | Ibm | Scan and read control apparatus for a disk storage drive in a computer system |
| US3906455A (en) * | 1974-03-15 | 1975-09-16 | Boeing Computer Services Inc | Associative memory device |
| US4298898A (en) * | 1979-04-19 | 1981-11-03 | Compagnie Internationale Pour L'informatique Cii Honeywell Bull | Method of and apparatus for reading data from reference zones of a memory |
| FR2481026B1 (zh) * | 1980-04-21 | 1984-06-15 | France Etat | |
| US4464718A (en) * | 1982-07-30 | 1984-08-07 | International Business Machines Corporation | Associative file processing method and apparatus |
| US4550436A (en) * | 1983-07-26 | 1985-10-29 | At&T Bell Laboratories | Parallel text matching methods and apparatus |
| US4941178A (en) * | 1986-04-01 | 1990-07-10 | Gte Laboratories Incorporated | Speech recognition using preclassification and spectral normalization |
| US4823306A (en) * | 1987-08-14 | 1989-04-18 | International Business Machines Corporation | Text search system |
| US5023910A (en) * | 1988-04-08 | 1991-06-11 | At&T Bell Laboratories | Vector quantization in a harmonic speech coding arrangement |
| US5179626A (en) * | 1988-04-08 | 1993-01-12 | At&T Bell Laboratories | Harmonic speech coding arrangement where a set of parameters for a continuous magnitude spectrum is determined by a speech analyzer and the parameters are used by a synthesizer to determine a spectrum which is used to determine senusoids for synthesis |
| US5050075A (en) * | 1988-10-04 | 1991-09-17 | Bell Communications Research, Inc. | High performance VLSI data filter |
| JPH0314075A (ja) * | 1989-06-13 | 1991-01-22 | Ricoh Co Ltd | 文書検索装置 |
| AU620994B2 (en) * | 1989-07-12 | 1992-02-27 | Digital Equipment Corporation | Compressed prefix matching database searching |
| US5163131A (en) * | 1989-09-08 | 1992-11-10 | Auspex Systems, Inc. | Parallel i/o network file server architecture |
| EP0565738A1 (en) * | 1990-01-05 | 1993-10-20 | Symbol Technologies, Inc. | System for encoding and decoding data in machine readable graphic form |
| US5319776A (en) * | 1990-04-19 | 1994-06-07 | Hilgraeve Corporation | In transit detection of computer virus with safeguard |
| US5497488A (en) * | 1990-06-12 | 1996-03-05 | Hitachi, Ltd. | System for parallel string search with a function-directed parallel collation of a first partition of each string followed by matching of second partitions |
| GB9016341D0 (en) * | 1990-07-25 | 1990-09-12 | British Telecomm | Speed estimation |
| US5101424A (en) * | 1990-09-28 | 1992-03-31 | Northern Telecom Limited | Method for generating a monitor program for monitoring text streams and executing actions when pre-defined patterns, are matched using an English to AWK language translator |
| GB9023096D0 (en) * | 1990-10-24 | 1990-12-05 | Int Computers Ltd | Database search processor |
| DE69229521T2 (de) * | 1991-04-25 | 2000-03-30 | Nippon Steel Corp | Datenbankauffindungssystem |
| US5477451A (en) * | 1991-07-25 | 1995-12-19 | International Business Machines Corp. | Method and system for natural language translation |
| US5488725A (en) * | 1991-10-08 | 1996-01-30 | West Publishing Company | System of document representation retrieval by successive iterated probability sampling |
| WO1993018505A1 (en) * | 1992-03-02 | 1993-09-16 | The Walt Disney Company | Voice transformation system |
| US5388259A (en) * | 1992-05-15 | 1995-02-07 | Bell Communications Research, Inc. | System for accessing a database with an iterated fuzzy query notified by retrieval response |
| GB9220404D0 (en) * | 1992-08-20 | 1992-11-11 | Nat Security Agency | Method of identifying,retrieving and sorting documents |
| US5721898A (en) * | 1992-09-02 | 1998-02-24 | International Business Machines Corporation | Method and system for data search in a data processing system |
| US6044407A (en) * | 1992-11-13 | 2000-03-28 | British Telecommunications Public Limited Company | Interface for translating an information message from one protocol to another |
| US5481735A (en) * | 1992-12-28 | 1996-01-02 | Apple Computer, Inc. | Method for modifying packets that meet a particular criteria as the packets pass between two layers in a network |
| US5432822A (en) * | 1993-03-12 | 1995-07-11 | Hughes Aircraft Company | Error correcting decoder and decoding method employing reliability based erasure decision-making in cellular communication system |
| US5544352A (en) * | 1993-06-14 | 1996-08-06 | Libertech, Inc. | Method and apparatus for indexing, searching and displaying data |
| DE69429061T2 (de) * | 1993-10-29 | 2002-07-18 | Advanced Micro Devices, Inc. | Superskalarmikroprozessoren |
| US5465353A (en) * | 1994-04-01 | 1995-11-07 | Ricoh Company, Ltd. | Image matching and retrieval by multi-access redundant hashing |
| JP2964879B2 (ja) * | 1994-08-22 | 1999-10-18 | 日本電気株式会社 | ポストフィルタ |
| SE505156C2 (sv) * | 1995-01-30 | 1997-07-07 | Ericsson Telefon Ab L M | Förfarande för bullerundertryckning genom spektral subtraktion |
| JPH0981574A (ja) * | 1995-09-14 | 1997-03-28 | Fujitsu Ltd | 検索集合表示画面を利用したデータベース検索法およびシステム |
| US5774839A (en) * | 1995-09-29 | 1998-06-30 | Rockwell International Corporation | Delayed decision switched prediction multi-stage LSF vector quantization |
| US5864738A (en) * | 1996-03-13 | 1999-01-26 | Cray Research, Inc. | Massively parallel processing system using two data paths: one connecting router circuit to the interconnect network and the other connecting router circuit to I/O controller |
| GB2314433A (en) * | 1996-06-22 | 1997-12-24 | Xerox Corp | Finding and modifying strings of a regular language in a text |
| US5930753A (en) * | 1997-03-20 | 1999-07-27 | At&T Corp | Combining frequency warping and spectral shaping in HMM based speech recognition |
| US6317795B1 (en) * | 1997-07-22 | 2001-11-13 | International Business Machines Corporation | Dynamic modification of multimedia content |
| JPH11110320A (ja) * | 1997-10-03 | 1999-04-23 | Matsushita Electric Ind Co Ltd | メッセージ交換装置 |
| US6711558B1 (en) | 2000-04-07 | 2004-03-23 | Washington University | Associative database scanning and information retrieval |
-
2002
- 2002-05-21 US US10/152,532 patent/US7093023B2/en not_active Expired - Lifetime
-
2003
- 2003-05-21 CN CNA038114712A patent/CN1656471A/zh active Pending
- 2003-05-21 EP EP03726929A patent/EP1506493A1/en not_active Withdrawn
- 2003-05-21 CA CA002485076A patent/CA2485076A1/en not_active Abandoned
- 2003-05-21 WO PCT/US2003/015910 patent/WO2003100650A1/en not_active Application Discontinuation
- 2003-05-21 JP JP2004508033A patent/JP2005527042A/ja active Pending
- 2003-05-21 KR KR10-2004-7018620A patent/KR20050010816A/ko not_active Application Discontinuation
- 2003-05-21 AU AU2003229337A patent/AU2003229337A1/en not_active Abandoned
Cited By (15)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN107093438A (zh) * | 2012-06-18 | 2017-08-25 | 谷歌公司 | 用于从混合音频记录选择性去除音频内容的系统和方法 |
| US11003413B2 (en) | 2012-06-18 | 2021-05-11 | Google Llc | System and method for selective removal of audio content from a mixed audio recording |
| CN107093438B (zh) * | 2012-06-18 | 2019-12-20 | 谷歌有限责任公司 | 用于从混合音频记录选择性去除音频内容的系统和方法 |
| US10372653B2 (en) | 2013-03-15 | 2019-08-06 | Micron Technology, Inc. | Apparatuses for providing data received by a state machine engine |
| US9747242B2 (en) | 2013-03-15 | 2017-08-29 | Micron Technology, Inc. | Methods and apparatuses for providing data received by a plurality of state machine engines |
| US10067901B2 (en) | 2013-03-15 | 2018-09-04 | Micron Technology, Inc. | Methods and apparatuses for providing data received by a state machine engine |
| CN105051711A (zh) * | 2013-03-15 | 2015-11-11 | 美光科技公司 | 用于提供由状态机引擎接收的数据的方法及设备 |
| CN105051711B (zh) * | 2013-03-15 | 2019-11-15 | 美光科技公司 | 用于提供由状态机引擎接收的数据的方法及设备 |
| CN105550541B (zh) * | 2015-12-02 | 2019-09-06 | 深圳市国微电子有限公司 | 可编程器件、标识信息、编程数据流的配置方法及装置 |
| CN105515849B (zh) * | 2015-12-02 | 2019-10-15 | 深圳市紫光同创电子有限公司 | 可编程器件、标识信息、编程数据流的配置方法及装置 |
| CN105550541A (zh) * | 2015-12-02 | 2016-05-04 | 深圳市国微电子有限公司 | 可编程器件、标识信息、编程数据流的配置方法及装置 |
| CN105515849A (zh) * | 2015-12-02 | 2016-04-20 | 深圳市同创国芯电子有限公司 | 可编程器件、标识信息、编程数据流的配置方法及装置 |
| CN113574517A (zh) * | 2019-03-14 | 2021-10-29 | 李亚东 | 生成分布式系统的规则编译器引擎装置、方法、系统和介质 |
| CN110658795A (zh) * | 2019-10-10 | 2020-01-07 | 北京航空航天大学 | 一种数字孪生数据精准融合方法和系统 |
| CN112134904A (zh) * | 2020-11-19 | 2020-12-25 | 北京智芯微电子科技有限公司 | 用于芯片间数据帧协议处理的帧打包器、方法及计量芯片 |
Also Published As
| Publication number | Publication date |
|---|---|
| EP1506493A1 (en) | 2005-02-16 |
| WO2003100650A8 (en) | 2004-04-22 |
| US20030221013A1 (en) | 2003-11-27 |
| JP2005527042A (ja) | 2005-09-08 |
| KR20050010816A (ko) | 2005-01-28 |
| WO2003100650A1 (en) | 2003-12-04 |
| CA2485076A1 (en) | 2003-12-04 |
| US7093023B2 (en) | 2006-08-15 |
| AU2003229337A1 (en) | 2003-12-12 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| CN1656471A (zh) | 使用可重编程硬件高速处理流数据以发现可重编程的模式并对其作出响应的方法、系统和装置 | |
| US20230275835A1 (en) | Apparatus and method of generating lookups and making decisions for packet modifying and forwarding in a software-defined network engine | |
| Mitra et al. | Compiling pcre to fpga for accelerating snort ids | |
| US6678822B1 (en) | Method and apparatus for securely transporting an information container from a trusted environment to an unrestricted environment | |
| Cho et al. | Specialized hardware for deep network packet filtering | |
| US20110113191A1 (en) | Programmable intelligent search memory | |
| US20110153657A1 (en) | Fsa extension architecture for programmable intelligent search memory | |
| Baker et al. | High-throughput linked-pattern matching for intrusion detection systems | |
| Niemiec et al. | A survey on FPGA support for the feasible execution of virtualized network functions | |
| US10769373B2 (en) | Contextual validation of synonyms in otology driven natural language processing | |
| CN1859366A (zh) | 状态堆栈检测防病毒暨防入侵防火墙的方法 | |
| Baker et al. | Automatic synthesis of efficient intrusion detection systems on FPGAs | |
| Wang et al. | A modular NFA architecture for regular expression matching | |
| Fang et al. | SIFO: secure computational infrastructure using FPGA overlays | |
| US20070162972A1 (en) | Apparatus and method for processing of security capabilities through in-field upgrades | |
| Liu et al. | A de-compositional approach to regular expression matching for network security | |
| US8239717B2 (en) | Logic verification apparatus | |
| Klix et al. | Stealing Maggie's Secrets--On the Challenges of IP Theft Through FPGA Reverse Engineering | |
| Cho | Deep content inspection for high speed computer networks | |
| Modi | FPGA-based High Throughput Regular Expression Pattern Matching for Network Intrusion Detection Systems | |
| Shin et al. | The basic building blocks of malware | |
| Baker | Efficient algorithms and architectures for high-speed text processing and data correlation | |
| Lockwood | Network Packet Processing in Reconfigurable Hardware | |
| Latifi et al. | Increasing the efficiency of IDS systems by hardware implementation of packet capturing | |
| Dandalis | Dynamic logic synthesis for reconfigurable hardware |
Legal Events
| Date | Code | Title | Description |
|---|---|---|---|
| C06 | Publication | ||
| PB01 | Publication | ||
| C02 | Deemed withdrawal of patent application after publication (patent law 2001) | ||
| WD01 | Invention patent application deemed withdrawn after publication |