CN1520112A

CN1520112A - 网络协议卸载引擎

Info

Publication number: CN1520112A
Application number: CNA2003101240610A
Authority: CN
Inventors: Sr; S·R·范加尔; Y·霍斯科特; V·K·埃拉冈特拉; J·许
Original assignee: Intel Corp
Current assignee: Intel Corp
Priority date: 2002-12-31
Filing date: 2003-12-31
Publication date: 2004-08-11
Anticipated expiration: 2023-12-31
Also published as: CN1520112B; US7324540B2; US20040125751A1

Abstract

本公开文本描述了用于协调多个网络协议卸载引擎(例如，传输控制协议(TCP)卸载引擎)的操作的技术。

Description

网络协议卸载引擎

引用的相关申请

本申请涉及以下共同待决的申请：2002年9月3号提交的、美国序号为10/234,392的“网络协议引擎”；2002年9月3号提交的、美国序号为10/234,489的“基于分组的时钟信号”；以及2002年9月3号提交的、美国序号为10/234,493的“跟踪无序分组”。

引用的附录

本申请包括微代码指令的附录，附录A。作者保留该材料的可申请版权权利。

背景技术

网络使得计算机以及其它电子设备可以交换诸如电子邮件消息、web页面、音频数据、视频数据等等之类的数据。在通过网络传输以前，数据典型地分布在分组集合上。接收机可以在接收到这些分组以后把数据重新装配回其最初的形式。

除了被发送的数据(“有效载荷”)之外，分组中还包含“报头”信息。网络协议可以定义存储在报头中的信息、分组的结构以及各过程应当如何处理分组。

不同网络协议处理网络通信的不同方面。许多网络通信模型把这些协议组织到协议栈的不同分层中。例如，像传输控制协议/网际协议(TCP/IP)模型和开放软件协会(OSI)模型这样的模型定义的协议栈包括：“物理层”，处理在物理媒体上的信号传输；“链路层”，处理在物理连接上提供可靠的数据通信的低级细节；“网络层”，例如网际协议等，它可以处理涉及到在包含源端和目的端的网络中寻找路径的任务；以及“传输层”，协调端点到端点的通信的同时使“应用层”的程序与网络通信的复杂性隔离开。

在ATM网络中使用了不同的网络通信模型，异步传输模型(ATM)。ATM模型同样定义了物理层，但是定义了ATM层和ATM适配层(AAL)来替代TCP/IP和OSI模型中的网络层、传输层以及应用层。

通常，为了在网络上发送数据，对于不同的协议栈分层会产生不同的报头。例如在TCP/IP中，传输层处理通过增加一个传输层报头给由应用提供的数据集来生成传输层分组(有时也称为“分段”)；然后，网络层处理通过为传输层分组添加网络层报头来生成网络层分组(例如IP分组)；然后，链路层处理通过添加链路层报头到网络分组来生成链路层分组(也称为“帧”)；等等。依此类推，该过程类似于把一系列的信封一个接一个地塞起来。

在分组通过网络传播后，接收机以与上面相反的次序处理(例如，“撕开”信封。)。例如，接收机的链路层处理可以验证接收到的帧并把内封的网络层分组传送给协议栈的网络层。网络层可以利用网络报头来验证分组的正确传送，并把内封的传输段传送给协议栈的传输层。最后，传输层处理根据传输报头来处理传输分组并把结果数据传送给应用。

如上所述，为了处理网络通信，发送机和接收机都有相当多的处理要做。此外，网络连接的速度不断地快速增高。例如，能够每秒传输10G比特以及更快的网络连接很快就会普及。网络连接速度的增长对提供这种连接的设备强加了重要的设计问题。也就是说，在这样的速度上，一个设计不适当的设备将会被洪水般的网络业务量淹没。

附图说明

图1是说明卸载引擎(off-load engine)集合的图。

图2是说明卸载引擎和控制器之间通信的图。

图3是说明引擎控制器的分层结构的图。

图4是把分组分配给卸载引擎的处理流程图。

图5是卸载引擎的框图。

图6是用于生成和当前的卸载引擎使用情况相对应的信号的逻辑图。

图7是卸载引擎处理器的示意图。

图8是用于对网络协议的操作编程的指令集的图表。

图9是TCP(传输控制协议)状态机的图。

图10-14说明了用于跟踪无序分组的方案的操作。

图15是跟踪无序分组的处理流程图。

图16-17是用于跟踪无序的系统的示意图，它包括内容可寻址的存储器(content-addressable memory)。

图18是用于提供时钟信号的原理图。

图19是包括卸载引擎的集合在内的网络设备的框图。

具体实施方式

许多计算机系统和其它的主机设备使处理器(例如，通用中央处理单元(CPU))具有可以处理多种任务的特性。通常这些处理器还具有处理网络业务量的附加责任。网络业务量和连接速度的增加对于主机处理器资源提出了不断增长的要求。为了至少部分地减少网络通信的负担，网络协议“卸载”引擎可以执行一个或者多个主机的网络协议操作。一个引擎可以执行多种协议的操作。例如，引擎可以被配置来执行传输层协议(例如TCP，用户数据报协议(UDP)，和实时传输协议(RTP))、网络层协议(例如，IPv4和IPv6)和/或应用层协议(例如套接字编程)的操作。相似地，在异步传输模型(ATM)网络中，引擎100可以被配置以便为ATM分组(也称为“信元”)提供ATM层或者ATM适配层(AAL)的层操作。

除了通过处理协议操作来保存主机处理器资源以外，引擎还潜在地可以提供“线速度”处理，即便是对于非常快速的连接，诸如10G比特每秒和40G比特每秒的连接(例如，以太网连接、OC-192连接或OC-768连接)也如此。换言之，引擎通常可以在下一个分组到达之前完成一个分组的处理。通过和高速连接同步，引擎100可以潜在地避免或者减少与大量积压分组排队相关的花费和复杂性。

尽管网络卸载引擎可以减轻主机系统上处理网络操作的负担，但是一个引擎只能支持有限数目的连接(例如，传输层连接或者ATM连接)。例如，尽管引擎具有可以支持128个连接的资源，但是给定的主机系统却可能期望同时支持成百甚至成千的连接。

图1图解说明了一种聚集多个卸载引擎100a-100n的方案。因而，n个聚集的引擎100a-100n可以支持n×C条连接，而不是象单个引擎那样只支持C条连接。在所示的方案中，控制器102把处理不同网络连接的责任分布到不同的引擎100上。例如，控制器102可以把连接的分配集中到最小数目的引擎上。这样可以通过减少待用引擎100a-100n的活动而减少系统的功耗和发热量。

更加详细地，引擎100a-100n包含一个接口来接收数据线106上的分组。这些数据线106可以携带例如以太网媒体访问控制器(MAC)或者同步光纤网(SONET)成帧器的输出。如图所示，引擎100a-100n通过接口把由引擎执行的网络操作的结果输出到通向例如主机系统的总线104上。

控制器102协调引擎100的操作。例如，当一个标识先前未曾看到的连接的分组到达时，控制器102可以分配一个引擎100来处理新连接的分组。除了分配连接以外，控制器102可以把对共享总线104的访问限制在为正被处理的分组的连接分配的引擎100上。除了这些任务以外，控制器102还可以选择性地在下述不同环境中使能或者禁止不同的引擎100。同样，这可以潜在地节省功率并且减少由引擎100的集合所产生的热量。

图1所示的方案可以以各种不同的方式实施。例如，控制器102可以维护标识为不同的连接分配了哪个引擎100的数据。然而，代替集中式方法，控制器102和引擎100可以改为通过引擎/控制器通信而协调引擎100的使用。例如，图2示出了通过引擎100和控制器102的接口通信的实例。

在图2所示的实例中，引擎100存储标识分配给引擎100的连接的数据。在分组到达期间，激活的引擎100(被分配到至少一个工作连接上的引擎)从控制器102接收“许可”116信号。“许可”116信号使引擎100可以在其连接数据中查找分组的连接。如果引擎100的查找成功，则引擎100发送信号“命中”114到控制器102。响应对“命中”信号114的接收，控制器102通过在引擎100处理分组期间暂时解除断言(de-assert)其它当前激活的引擎100上的“许可”116信号，而同意把输出总线106的控制给予被分配的引擎100。这种解除断言不仅确保总线104由被分配的引擎100控制，而且可以节省否则会被其它引擎消耗的功率。在引擎100完成它的分组处理操作之后，控制器102重新断言许可信号116给至少为一个工作连接服务的引擎，以便为下一个分组做好准备。

潜在地，如果分组发信号通知新连接的开始，不会有引擎100为该分组发“命中”信号。因而，控制器102把该连接分配到引擎100之一。控制器102可以根据当前引擎100的使用情况实施分配方案。为了给控制器102提供关于引擎100当前使用情况的信息，引擎100可以当引擎100不能处理额外的连接时输出“满”信号110进行标识。响应“满”信号110，当有新的连接需要被分配时控制器102可以选择不同的引擎。

如图所示，当引擎100当前没有处理激活的连接时，引擎100也可以输出“空”112信号。例如，随着连接的结束，连接被相应地从相应引擎中释放。最终，引擎也许不再为任何工作连接服务并且可以断言该“空”112信号。作为响应，控制器可解除断言许可信号直到该引擎被再次暂时征用。

图2中所示的信号只是用于示例，不同实施方式可以不同地通信。例如，代替“空”112和“满”110信号，引擎100可以报告当前处理的连接数目、所用容量的百分比或者其它的容量度量。

图1示出了一个管理n个卸载引擎100的控制器102。被管理引擎100的数目(例如8)会被限制，例如以便简化控制器102和引擎100之间的仲裁。为了增加引擎100的数目和系统处理的连接的数目，图3示出了图1所示方案的分层的集合。也就是说，一个分层的控制器122管理其它控制器102，而不是控制卸载引擎100的集合。因而，该方案可以支持(g组引擎×n个引擎/组×C个连接/引擎)，而不是提供(n个引擎×C个连接/引擎)。

组120和控制器122之间的交互和图2中所示的十分相同。例如，组120可以识别该组引擎集合什么时候“满”或者“空”以及组120中的引擎是否被分配用来处理当前分组的连接。相似地，该分层控制器122可以把新的连接分配给特定组120，同意把输出总线104的控制给予特定组120，等等。例如，当组120中的引擎识别出对于分组连接的“命中”时(例如，该连接已被分配给该引擎)，该引擎可以用信号通知“命中”给该组的控制器102，后者进而又用信号通知“命中”到分层控制器122。作为响应，分层控制器122发送许可信号给该组的控制器102，后者进而又发送许可信号给报告该命中的特定引擎。

图3所示的方案可以升级，并且可以被用于集中数目非常大的引擎。另外，虽然图3示出了“两层”的分层结构，但是，控制器的层次可以以许多不同的等级循环重复。也就是说，分层控制器可以协调一组在层次上更低的分层控制器，并依此类推。再次，分层控制器之间的通信可以使用图2中所示的方案(例如，通过传送“命中”、“满”、“空”和/或“许可”信号)。

图4示出了给不同卸载引擎分配连接的处理流程图。如图所示，在接收140分组后该处理确定142分组是新连接的一部分还是已经被分配给引擎的连接的一部分。例如，连接可以被定义为分组的网际协议(IP)源地址和目的地址、传输层协议源端口和目的端口的组合。引擎可以在标识被分配给引擎的连接的数据中查找分组的连接数据。如果一个引擎报告“命中”，引擎152就可以处理该分组(例如，执行TCP操作)。否则，控制器可以为新连接分配一个引擎。

可以用多种方式完成分配(例如，循环负载均衡)。然而，如图所示，可以执行分配以便集中引擎中的连接分配。这使得控制器能够将更多“空”引擎断电。因而，如图所示，该处理可以确定144当前分配给工作连接的引擎是否有容量去处理额外的连接。如果是，该连接可以被分配148到该引擎以便处理152。也就是说，被分配的该引擎可以处理该连接中当前和将来的分段。

潜在地，当前分配给连接的引擎也许不能支持额外的连接(例如，如“满”信号110所标识的)。因而，处理可以激活146额外的引擎并且把新连接分配148给最近激活的引擎以便处理152。

和图4所示的处理相象的处理也可以被分层控制器(例如图3中的122)使用，尽管该分层控制器是和组(图3中的120)或者该组的控制器102交互而不是和单独的引擎交互。例如，分层控制器122可以根据该组所断言的信号，而断言或者解除断言该组控制器上的“许可”信号。

可以有多种方式来实施控制器和引擎。例如，引擎和控制器可以被实施为专用集成电路(ASIC)、可编程门阵列(PGA)或者其它数字逻辑。

有多种引擎体系结构可被使用。例如，引擎可以由被编程的网络处理器实施，例如具有多个精简指令集计算(RISC)处理器(例如Intel的因特网交换处理器(IXP))的处理器。另一方面，图5示出了引擎100的实例，它包括指令的处理器170(例如微控制器、算术逻辑单元(ALU)或者微处理器)和存储设备172(例如ROM(只读存储器)或者RAM(随机存取存储器))，该指令可以被处理器170执行以便完成网络协议操作。这种基于指令的引擎100提供了高度的灵活性。例如，由于网络协议正在改变或者被替换，可以通过更换指令而不是更换引擎100自身来更新引擎100。

作为引擎100的操作的概况，引擎100在存储器166中存储用于不同连接的环境数据。例如，对于TCP协议，该数据被称为TCB(传输控制块)数据。对于给定分组，引擎100在存储器166中查找相应的连接环境并且使该数据对于处理器170是可用的，在本例中这通过工作寄存器168实现。利用这种环境数据，处理器170执行适当的协议实施指令集172。潜在地由处理器170修改的环境数据然后被返回到环境存储器166。

更详细地，所示的引擎100包括输入序列发生器/缓冲器162，它对接收到的分组报头(例如，TCP/IP分组的TCP和IP报头)进行语法分析并且暂时缓冲该分析过的数据。输入序列发生器/缓冲器162也可以在主机可访问存储器中启动分组有效载荷的存储(例如，通过直接存储器存取(DMA))。

如上所述，引擎100为不同网络连接存储环境数据166。为了从存储器166中对于给定分组快速检索环境数据，所示的引擎100包括内容可寻址的存储器164(CAM)，它为分组的IP源地址和目的地址以及源端口和目的端口的组合所标识的不同连接存储不同的连接标识符(例如索引号码)。和数据库根据关键词检索记录相似，CAM可以根据内容值快速检索存储的数据。因而，根据由输入序列发生器162解析的分组数据，CAM164可以快速检索连接标识符并且把该标识符发送到环境数据存储器166。接下来，相应于该标识符的连接环境数据被从存储器166传输到工作寄存器168以便被处理器170使用。

当控制器为引擎分配了新的连接时，当前的分组可以表示新连接的开始。因而，引擎100可以为该连接初始化工作寄存器168(例如设置成TCP中的“侦听”状态)并且分配CAM164和环境数据166的条目，例如使用LRU(最近最少使用)算法或者其它分配方案。

可以选择连接引擎100不同部分的数据线的数目以便允许在单个时钟周期内在被连接的部分之间进行数据传输。例如，如果连接的环境数据包括x比特的数据，则引擎100可以这样设计以使得连接数据存储器166可以提供x行的数据给工作寄存器168。

所示的示例实施方式可以最多使用3个处理周期把连接数据载入到工作寄存器168：一个周期用于查询CAM164；一个周期用于访问连接数据166；以及一个周期用于载入工作寄存器168。这种设计既能节省处理时间又可以节约访问存储器164，166的功率消耗。

在检索了分组的连接数据之后，引擎100的处理器170可以执行存储在存储器172中的协议实施指令。在接收到“唤醒”信号(例如当连接环境被检索到或者正被检索时，来自输入序列发生器162)后，处理器170可以确定当前连接的状态并且识别用于处理这一状态的指令的起始地址。处理器170然后执行在该起始地址开始的指令。根据该指令，处理器170可以改变环境数据(例如通过改变工作寄存器168)，在发送缓冲器174中装配消息(例如TCP ACK)以便于随后的网络传输，和/或通过总线104使被处理的分组数据对主机是可用的。同样，潜在地被处理器170修改的环境数据被返回到环境数据存储器166。

如图所示，引擎100从控制器接收许可116信号。许可116信号可被用来控制处理器170的操作。例如，为了节省功率，从控制器接收的许可116信号被馈送到一个与门，后者中也馈入了处理器时钟。因而，当许可116信号未被断言时，处理器不会接收时钟信号。

如图所示，除了从控制器接收许可116信号之外，当引擎100已被分配用于当前分组的连接时(例如当在CAM164中找到该连接时)，引擎100还产生“命中”114信号。引擎100还可以根据CAM164和/或连接存储器166可用的容量产生“满”110和“空”112信号。

可以用多种方式产生以上所述信号。例如，图6示出了产生“满”110和“空”112信号的逻辑的实例。该逻辑在由CAM164维护的寄存器180上操作。尽管寄存器180显示为具有8位，但是，典型地寄存器180具有更多位(例如128位)。“1”位(例如寄存器位180b)标识已使用的CAM164条目，而“0”位标识未使用的CAM164条目。所示逻辑包括与门的网络184，它在所有寄存器位都被置为“1”时产生“满”110信号。所示逻辑还包括一个或门网络182，它产生“空”信号112。同样，所示的信号和逻辑仅用于示例。例如，取代所示的逻辑门，寄存器180可以馈送到一个编码器中，该编码器把寄存器180的位值翻译成标识使用情况的值。

在图5所示聚集了示例引擎的集合的系统中，引擎100的CAM最初为“空”并且引擎都不会接收“许可”信号。在接收到组成连接一部分的分组后，控制器102选择一个引擎100用于该连接的分配并且断言许可信号116给所选择的引擎100。所选择的引擎100处理输入的分段并且更新它的CAM164和TCB166的内容。许可116还使得引擎100能够在该分段期间驱动总线104上的数据。

控制器102可以给引擎100分配更多的连接，直到引擎100用信号通知“满”110。该“满”信号110使得控制器102把新连接分配到不同的引擎上(尽管潜在地是已经活动的引擎)。

新到达的分段或者是被分配到活动的引擎之一上的现有连接或者是未被分配(例如新)的连接。为了确定引擎100是否已经被分配给该分组的连接，控制器102断言许可信号给当前服务于至少一个工作连接的引擎100。这些引擎100并行地执行连接(例如CAM164)查找。对于新的连接(例如，没有引擎报告CAM164命中)，控制器102把该连接分配到最近被激活的引擎100上，只要它还没有用信号通知“满”110。然而，如果引擎100断言了“满”信号110，那么控制器例如通过访问一个标识最近才被分配了它们的第一个连接的引擎的队列，来选择下一个最近被激活的引擎。继续这一过程直到识别出一个还没有断言“满”信号110的活动引擎100。如果没有识别出这样的活动的引擎100，则控制器102可以激活其它引擎100并且给它分配该连接。

分配给当前连接的引擎100在该分段期间完成TCP处理，而其它活动的引擎暂时空闲，意味着它们的许可116暂时被解除断言。在被分配的引擎对于该分组完成它的网络协议操作后，现有许可116被重新断言。如果引擎100不再被分配给一个活动的连接，则控制器可以解除断言许可信号直到引擎100被再次激活。

图7-18更详细地描述了图5所示的卸载引擎100的特征。同样地，其它卸载引擎可以提供或者不提供这些特征或者以不同的实施方式为特征。

图7更详细地示出了引擎100的处理器170。如图所示，处理器170可以包括一个ALU(算术逻辑单元)202，后者对载入到指令寄存器204中的微代码指令进行译码并且执行这些微代码。除了转移指令和起始地址初始化之外，指令172被从存储器172按顺序连续载入206到指令寄存器204。指令172可以指定对存储解析分组数据的接收缓冲器162、工作寄存器168、发送缓冲器174和/或主机存储器(未示出)的访问(例如读或者写访问)。指令也可以指定对暂时存储器、其它寄存器(例如复制R0，cond以及状态良好(statusok)寄存器)、移位寄存器等等(未示出)的访问。为了编程方便可以对发送缓冲器174和工作寄存器168中的不同区域赋予不同的标号以便在指令中使用。此外，可以为不同连接状态定义各种常数。例如，“LOAD TCB[state]，LISTEN”指示处理器把工作寄存器168中的连接环境状态的状态改变为“LISTEN(侦听)”状态。

图8示出了可以被用来对处理器编程以便执行协议操作的微代码指令集的实例。如图所示，该指令集包括在系统中的各种操作：移动数据(例如LOAD和MOV)、执行算术和布尔操作(例如AND、OR、NOT、ADD、SUB)、比较数据(例如CMP和EQUAL)，操作数据(例如SHL(向左移位))以及在程序中提供分支转移(例如BREQZ(条件转移，如果前一操作的结果等于0)、BRNEQZ(条件转移，如果前一操作的结果不等于0)以及JMP(无条件跳转))。

指令集还包括为了对引擎100的资源执行协议操作而专门定制的操作。这些指令包括用于清除CAM164中连接的项目(例如CAM1CLR)以及用于保存环境数据到环境数据存储设备166(例如TCBWR)的操作。其它实施方式还可以包括读和写连接数据到CAM164(例如CAM1READ key-->data以及CAM1WRITE key-->data)的指令以及读环境数据166的指令(例如TCBRD index-->destination)。可替换地，这些指令可被实施为硬连线逻辑。

尽管潜在地缺少常规通用CPU所提供的许多指令(例如处理器170也许不具有用于浮点操作的指令)，但是该指令集为开发人员提供了对于引擎100资源的方便的访问，而该资源是为网络协议实施定制的。程序员可以使用微代码指令直接对协议操作编程。可替换地，程序员可以使用各种代码开发工具(例如编译器或者汇编器)。

如上所述，引擎100的指令可以为各种网络协议实施操作。例如，引擎可以为诸如TCP之类的传输层协议实施操作。可以在RFC(请求注解)793、1122以及1323中找到TCP的完整规范及可选扩展。

简要来说，TCP为应用提供了面向连接的服务。也就是说，就像拿起电话机并假设电话公司会完成所有的中间工作一样，TCP为应用提供了简单的原语以便建立连接(例如CONNECT和CLOSE)和传输数据(例如SEND和RECEIVE)。TCP透明地处理通信问题，诸如数据重传、拥塞以及流量控制。

为了给应用程序提供这些服务，TCP对被称为分段的分组操作。TCP分段包括随后跟着一个或者多个数据字节的TCP报头。接收机可以重新装配来自接收分段的数据。就所有数据来说，分段也许不能以它们的正确顺序到达其目的地。例如不同的分段可以通过不同的路径穿过网络。因而，TCP为每个被发送的数据赋予一个序号。由于所有字节都被排序，因此每个字节都可以被应答以确认成功传输。应答机制是累积的，因此特定序号的应答指示了直到该序号的字节都已被成功传送。

这种排序方案为TCP提供了强大的工具以便管理连接。例如，使用被称为“滑动窗”的技术，TCP可以确定什么时候发送机应该重发分段。在“滑动窗”方案中，发送机在发送一个分段后开启一个定时器。接收到后，接收机发回一个应答分段，该应答分段具有和接收机想要接收的下一个序号相同的应答号。如果在被传送的字节的应答到达前，定时器就超过期限，则发送机再次发送该分段。这种排序方案也使得发送机和接收机能够根据网络性能以及发送机和接收机的能力动态地协商窗口大小，该窗口大小可用来调整发送到接收机的数据量。

除了对信息排序以外，TCP报头中还包括标志的集合，使得发送机和接收机可以控制连接。这些标志包括SYN(同步)位、ACK(应答)位、FIN(完成)位、RST(复位)位。包括为“1”的SYN位和为“0”的ACK位的消息(SYN消息)表示请求一个连接。包括为“1”的SYN位和为“1”的ACK位的应答消息(SYN+ACK消息)表示接受该请求。包括为“1”的FIN位的消息指示发送机想要释放该连接。最后，其RST位为“1”的消息标识一个连接因为问题(例如无效分段或者连接请求被拒绝)而需要被复位。

图9描述了表示建立和释放TCP连接的不同阶段的状态图。该图示出了不同状态210-229以及这些状态210-229之间的转移(表示为带箭头的线)。使用相应的事件/动作名称来标记转移，这些名称标识了移动到随后的状态210-229所需的事件和动作。例如，在接收到SYN消息并且响应一个SYN+ACK消息后，连接从侦听(LISTEN)状态212转移到同步接收(SYN RCVD)状态214。

在图9的状态图中，用实线的转移显示发送机(请求连接的TCP实体)的典型路径而用虚线的转移显示接收机的典型路径。为了说明状态机的操作，接收机典型地以关闭(CLOSED)状态210开始，它指示当前没有活动的或者未决的连接。在转移到侦听212状态以便等待连接请求后，接收机将会接收到请求连接的SYN消息，并且使用SYN+ACK消息应答该SYN消息，然后进入同步接收(SYN RCVD)状态214。在接收到应答消息SYN+ACK之后，连接进入建立(ESTABLISHED)状态218，它对应于正常的工作数据传输。该建立状态218可以持续一段时间。最后，假如没有复位消息到达并且没有错误发生，服务器会接收并且应答FIN消息然后进入关闭等待(CLOSE WAIT)状态220。在发布了它自身的FIN并且进入最后的应答(LAST ACK)状态229后，服务器接收到它的FIN的应答并且最后返回到最初的关闭状态。

同样，状态图也管理TCP发送机的状态。发送机和接收机的路径共享上述的许多相同状态。然而，发送机在请求连接之后还会进入到同步发送(SYN SENT)状态216，在请求释放连接后进入完成等待1(FIN WAIT1)状态222，在从接收机接收到对释放连接的同意后进入完成等待2(FIN WAIT2)状态226，发送机和接收机两者同时请求释放时进入关闭(CLOSING)状态224，以及当前一个被发送的连接分段超期后进入定时的等待(TIMED WAIT)状态。

引擎100的协议指令可以实施以上所述的或者RFC中的TCP操作中的大多数，即便不是全部的话。例如，指令可以包括步骤：选择处理、窗口管理、流量控制、拥塞控制、ACK消息生成以及验证、数据分段、特殊标志处理(例如设置和读URGENT和PUSH标志)、校验和计算等等。协议指令还可以包括与TCP相关的其它操作，如安全支持、随机数生成、TCP上的RDMA(远程直接存储器存取)等等。

在被配置用来提供TCP操作的引擎100中，环境数据可以包括每个连接264比特的信息，它包括：每个都是32比特，分别用于PUSH(由微代码标记“TCB[pushseq]”来标识)、FIN(“TCB[finseq]”)、以及URGENT(“TCB[rupseq]”)序号、下一个期望的分段号(“TCB[next]”)、当前广告的窗口的序号(“TCB[cwin]”)、最后的未应答序号的序号(“TCB[suna]”)、以及接下来的下一个分段的序号(“TCB[snext]”)。剩余的位中存储各种TCB状态标志(“TCB[flags]”)、TCP分段码(“TCB[code]”)、状态(“TCB[tcbstate]”)以及错误标志(“TCB[error]”)。

为了说明对被配置用来执行TCP操作的引擎100的编程，附录A公开了用于TCP接收机的源微代码的实例。简要地说，例程TCPRST核对TCP ACK位、初始化发送缓冲器并初始化发送消息ACK号。例程TCPACKIN处理输入的ACK消息并且检查该ACK是否有效或者重复。TCPACKOUT响应输入的消息，根据接收的和期望的序号生成ACK消息。TCPSEQ确定输入数据的第一个和最后一个序号、计算输入数据的大小、并且检查输入数据的序号是否有效以及是否在接收窗口中。TCPINITCB初始化工作寄存器中的TCP区。TCPINITWIN利用窗口信息初始化该工作寄存器。TCPSENDWIN计算窗口长度以便包含在发送消息中。最后，TCBDATAPROC核对输入标志，处理“urgent”、“push”以及“finish”标志、响应于消息来处理标志并且把数据转发给应用或者用户。

引擎100执行的另一个操作是分组的重新排序。例如，和许多网络协议相似，TCP不会假设TCP分组(“分段”)将按顺序到达。为了正确地重新装配分组，接收机可以记住接收到的最后序号并且等待接收被赋予下一序号的字节。不按次序到达的分组被缓冲直到介于其间(intervening)的字节到达。一旦被等待的字节到达，序列中的下一字节可以潜在地从缓冲数据中被快速检索出来。

图10-14说明了可以被引擎100执行的、对无序分组进行跟踪的方案的操作。该方案允许对分组快速地“动态(on-the-fly)”排序，而不用采取传统的排序算法。可以使用另一组内容可寻址的存储器240，242来实施该方案，尽管这并不是必须的。使用本技术的引擎100可以包括两套不同的内容可寻址的存储器-用于检索连接环境数据的内容可寻址的存储器164以及用于跟踪无序分组的内容可寻址的存储器。

为了说明的目的，在实施TCP的环境中讨论图10-14。然而，该方案对于各种分组排序方案，例如对编号的分组(例如，协议数据单元碎片)具有广泛的适用性。因而，尽管以下描述讨论了TCP序号的存储，用于编号分组的实施例也可以替代用来存储分组号。

简要地，当分组到达时，分组跟踪子系统确定接收的分组是否按次序。如果不是，该子系统查询存储器以识别和刚到达的分组相邻的前面接收的无序分组的相邻集合，并且子系统可以修改存储在该存储器中的数据以便把该分组添加到该集合中。当分组按顺序到达时，子系统可以访问该存储器以便快速识别跟着刚接收的分组的、以前接收的分组的相邻链。

更详细地，如图10中所示，协议234(例如TCP)把数据集232分成分组236a-236d的集合以便在网络238上传输。在所示的例子中，原始数据集232的15字节被分布到分组236a-236d。例如，分组236d包括被赋予序号“1”到“3”的字节。

如图所示，引擎100包括内容可寻址的存储器240，242，它们存储和接收的、无序分组有关的信息。存储器240存储一个或者多个无序分组的相邻链的第一序号以及该链的长度。因而，当在已存在链的开始处结束的新分组到达时，该新分组可被添加在已存在的链之上。相似地，存储器242也存储一个或者多个分组的相邻分组链的结束(最后序号+1)以及该链的长度。因而，当在已存在链的结束处开始的新分组到达时，新分组可被添加以组成连续分组的甚至更大的链。为了说明这些操作，图11-14示出了当分组236a-236d到达时，发生的一系列示例操作。

如图11所示，分组236b携带着有序号“8”到“12”的字节到达。假设引擎100当前在等待序号“1”，则分组236b不是按顺序到达的。因而，如图所示，引擎100通过修正存储在内容可寻址的存储器240，242中的数据来跟踪无序分组236b。分组236b不和前面接收的分组链相邻，因为在本例中还没有链。因而，引擎100存储起始序号“8”，以及该分组中的字节数目“4”。引擎还存储该分组终点的标识。在所示的例子中，引擎通过在接收的分组的最后的序号上加1而存储结束的边界(例如，12+1＝13)。除了在内容可寻址的存储器240，242中修改或者增加条目之外，引擎100可以存储该分组或者分组的索引(例如指针)，以反应该分组的相关顺序。这样可以在最后发送到应用时，快速地检索该分组。

如图12所示，引擎100接下来接收分组236a，它携带字节“13”到“15”。同样，引擎100仍然等待序号“1”。因而，分组236b也是无序到达的。引擎100检验存储器240，242以确定接收的分组236a是否和前面存储的分组链相邻。在本例中，新到达的分组236a不是在前一链开始的地方结束，但是却是在前一个链结束的地方开始。换言之，分组236a紧邻分组236b的“底部”。如图所示，引擎100通过增加已存在链的长度并相应修改其第一和最后序号数据，把分组236a并入到内容可寻址的存储器数据中的已存在链中。因而，尽管其长度已经从“4”增加到7，新链的第一序号仍然是“8”，而该链的结束序号也从“13”增加到“16”以反应新接收分组236a的字节。引擎100还存储新分组241a或者到该新分组的索引，以反应该分组的相对排序。

如图13所示，引擎100接下来接收携带字节“4”到“7”的新接收分组236c。由于该分组236c不包括下一个想要的序号“1”，引擎100重复上述处理。也就是说，引擎100确定新接收分组236c适于在跨越分组236b，236a的分组链的顶部。因而，引擎100修改存储在内容可寻址的存储器240，242中的数据，以便包括链的新开始序号“4”，以及链的新长度数据“11”。引擎100同样存储指向分组241c数据的索引，以便反映分组241c的相对排序。

如图14所示，引擎最终接收到分组236d，它包括下一个期望的序号“1”。引擎100可以立刻把这个分组236d传送到应用。引擎100还会检查它的内容可寻址的存储器240以查看其它分组是否也可以被发送到该应用。在此情况中，接收的分组236d与一个已经跨越了分组236a-236c的分组链毗连。因而，引擎100可以立刻把成链的分组的数据按正确的顺序转发给应用。

图11-14所示的示例序列突出了本方案的一些方面。首先，该方案可以防止无序分组被丢掉并被发送机重发。这可以提高整体的吞吐量。该方案使用了很少的内容可寻址的存储器操作来处理无序分组，节省了时间和功率。此外，当分组以正确顺序到达时，单个内容可寻址的存储器操作就可以识别出能够同样被发送到应用的一系列连续分组。

图15示出了处理器250用于实施上述方案的流程图。如图所示，在接收252到分组后，处理器250确定254分组是否按顺序(例如，该分组是否包括下一个想要的序号)。如果不是，处理器250确定262所接收的分组的终点是否毗连已存在分组链的起点。如果是，处理器250可以修正264存储在内容可寻址的存储器中的数据以便反映一个更大的、合并的分组链，它开始于接收的分组并且结束于前面存在的分组链的终点。处理器250还确定266接收分组的起点是否毗连一个存在的分组链的终点。如果是，处理器250修正568存储在内容可寻址的存储器中的数据以反映一个更大的、合并的分组链，它结束于接收的分组。

潜在地，接收的分组也许在两头都毗连已存在的分组链。换言之，新接收的分组正好填充两个不相互重叠的链之间的洞。由于处理器250检测所接收分组的开始262和结束266边界，一个新接收的分组会使得处理器250把两个不同链结合成单个的单链。

如图所示，如果接收的分组没有毗连分组链，则处理器250为新的分组链在内容可寻址的存储器中存储270该数据，该分组链只包含接收分组，至少在最初时这样。

如果接收分组是按顺序的，处理器250可以查询256内容可寻址的存储器以识别跟在该接收分组之后的毗连分组链。如果这样的链存在，处理器250可以把新接收分组和邻接分组链中的其它分组数据一起输出给应用。

如上所述的分组跟踪处理可以使用各种硬件、固件和/或软件实施。例如，图16和17示出了上述方案的硬件实施方式。如在这些图中所示，该实施方式的特点是具有两个内容可寻址的存储器290、292-一个存储器290存储无序分组链的第一序号作为关键词，而另一个存储器292存储该链的最后+1的序号作为关键词。如图所示，两个CAM290，292还存储链的长度。

其它实施方式还使用单个CAM。其它的实施方式还可以使用基于地址的存储器或者其它数据存储设备来代替内容可寻址的存储器。

潜在地，相同的CAM290，292可被用来跟踪许多不同连接的分组。在这种情况下，连接ID会被附加到每个CAM条目上，以作为关键词的一部分来区分用于不同连接的条目。将分组信息合并成CAM290，292中的链允许用更少的CAM290，292来处理更多的连接。

如图16所示，该实施方式包括寄存器，它们存储起始序号280、结束序号282、数据长度284。图5所示引擎100的处理器170可以访问这些寄存器以跟踪分组。例如，可以在发回到发送机的应答消息中请求要包含的下一期望序号。

如图所示，该实施方式操作控制信号以便从CAM290，292中读出(CAMREAD)、写入到CAM290，292(CAMWRITE)、以及清除CAM290，292的条目(CAMCLR)。如图17所示，可以配置硬件以便当将数据装载到寄存器290，292，294时，同时把寄存器值写入到CAM290，292两者中。如图17所示，对于给定的起始或者结束序号的“命中”，电路把“seg1en”寄存器设定为匹配的CAM条目的长度。电路(未示出)还会在成功的CAM290，292读操作之后，设定“seqfirst”280以及“seqlast”282寄存器。电路还提供“CamIndex”信号，标识在CAM290，292中发现的特定条目。

为了实施上述分组跟踪方法，分组子系统会具有其独立的、执行实施该方案的指令的控制器，或者具有硬连线逻辑。可替换地，处理器170(图5)可以包含用于该方案的指令。潜在地，处理器170的指令集(图8)可以被扩展以包括访问CAM290，292的命令。这种指令可以包括写入数据到CAM290，292中的指令(例如，用于CAM290的CAM2FirstWR key<--data和用于CAM292的CAM2LastWR key<--data)；用于从CAM读出数据的指令(例如，CAM2FirstRD key-->data和CAM2LastRD key-->data)；清除CAM条目的指令(例如，CAM2CLRkey)，和/或当查找失败时，用于生成条件值的指令(CAM2EMPTY-->cond)。

潜在地，引擎100的组件可以使用相同速率的时钟。时钟信号本质上决定逻辑网络工作的速度。不幸的是，由于对于一个给定分组需要执行多个指令这一事实，为了以线速度工作，引擎100必须按照远高于连接速率的非常快的速率来提供时钟。以单个很快的时钟运行整个引擎100会消耗大量的功率还会产生很高的温度，这会影响热敏感硅的性能。

反之，可以用不同速率来给引擎100的部分提供时钟。例如，序列发生器可以使用对应于网络连接速度的速率(“1x”)的时钟。由于可以对处理器170编程，来执行许多指令以便对给定分组执行适当的网络协议操作，处理部分的时钟可以具有比序列发生器162更快的速率。例如，处理逻辑中组件的时钟可以是序列发生器162时钟频率的某个倍数“k”倍，其中k足够高以便为处理器170提供充足的时间来完成给定分组的指令执行而不会低于线速度。使用“双时钟”方法的引擎100需要提供被称为“同步器”的装置(未示出)，它允许具有不同时钟的部分进行通信。

作为“双时钟”系统的例子，对于一个输入数据宽度为16位的引擎，为了达到10G比特每秒，序列发生器162的时钟频率应为625MHz(例如，[16比特/循环×[625,000,000循环/秒]＝10,000,000,000比特/秒]。假设最小的分组为64字节(例如，只有IP和TCP报头、帧检测序列以及硬件的源地址和目的地址的分组)，它将需要16位/625MHz的接口108用32个循环来接收该分组比特。潜在地，分组间的空隙可以在下一个分组到来前提供额外的时间。如果多达n个的一组指令被用于处理该分组并且每个循环可以执行一条不同指令，则处理块110的时钟频率为k*(625MHz)，其中k＝n指令/32循环。为了实施方便，k的值被上舍入为一个整数值或者2n的值，尽管这并非严格要求。

由于以较快的时钟运行的组件通常会比以较慢的时钟运行的相同组件消耗更多的功率并且产生更多的热量，因此根据引擎的组件的需要以不同速率给它们提供时钟可以使引擎100节省功率并且保持更低的温度。这样既可以减少引擎100的功率要求又可以避免对于昂贵的制冷系统的需要。

潜在地，功耗和发热量还可以被进一步降低。即，不是使系统106固定地适于处理某些复杂的情况，而是引擎的组件可以具有根据一个或者多个分组特征而动态变化的时钟。例如，引擎100可以使用标识分组大小的数据(例如，IP数据报报头中的长度字段)来缩放处理组件的时钟频率。例如，对于一个比较大的分组，处理器170在下一分组到达之前有更多的时间来处理该分组，因此，可以降低频率而不落后于线速度。相似地，对于一个较小的分组，可以提高频率。对于不同的输入分组，“动态地”、自适应地缩放时钟频率可以通过在处理较大分组时降低工作频率来减少功率。这进而又可以得到一个更冷的工作系统，该系统可以避免硅“热点”的产生和/或昂贵的制冷系统。

因而，缩放逻辑可以接收分组数据并且相应地调整提供给处理逻辑的频率。尽管以上讨论的是根据分组大小进行的操作，各种其它度量也可用于调整该频率，诸如有效载荷大小、服务质量(例如，更高优先级的分组可以接收更高的频率)、协议类型等等。此外，除了使用单个分组的特征之外，还可以使用聚集特征来调整时钟速率(例如，接收分组的平均大小)。为了节省额外的功率，在网络空闲时可以暂时禁用时钟。

可以用各种硬件和/或软件方案来实现缩放逻辑。例如，图18示出一个硬件方案，它使用分频器318a-318c来提供可用的频率范围(例如，32x、16x、8x和4x)。不同的频率信号被馈入到多路转换器320以便基于分组特征进行选择。例如，选择器322可以以一个量值比较器为特征，它将分组大小和预先计算的不同门限进行比较。例如，比较器可以为分组使用不同的频率，例如，大小一直到64字节的分组(32x)，64和88字节之间的分组(16x)，88和126字节之间的分组(8x)，以及126到236字节之间的分组(4x)。尽管图18示例了4个不同的时钟信号，其它实施方式也可以以n个时钟信号为特征。另外，所提供的不同频率之间的关系也不需要象图18所示那样彼此均匀划分。

所得到的时钟信号可以被发送到引擎100中的不同组件。例如，输入序列发生器116可以接收“1x”的时钟信号，而处理器122接收动态确定的“kx”时钟信号。根据其实施方式，连接数据存储器112和CAM114可以接收“1x”或者“kx”时钟信号。

如图所示，时钟信号可以和接收自引擎控制器的许可信号进行与(AND)操作。同样，这可以节省功率并减少不需要引擎时的发热量。把缩放逻辑在物理上放置在频率源附近也可以节省功耗。进而，在全局时钟分配点上调整时钟既能节省功率又可以减少提供时钟分配所需要的逻辑。

图19示出了使用卸载引擎的集合的示例系统330。系统330包括一个或多个物理层设备(PHY)332，它们处理传输媒介(例如，铜线、光纤或者无线)上的信号发送和接受。系统330还可以包括一个或者多个链路层334设备(例如，以太网媒体访问控制(MAC)或者同步光纤网络(SONET)成帧器)。如图所示，系统330包括卸载引擎336的集合，以便代表主机处理器338处理通过PHY层332和链路层334接收的数据。

同样，多种实施方式可以使用一个或多个上述技术。另外，引擎/控制器336可以表现为多种产品。例如组件336可以被设计成单个芯片。潜在地，这种芯片可以被包含在一个芯片组中或者主板上。此外，组件336还可以被集成到诸如存储区网络组件(例如，存储开关)、应用服务器、网络适配器、NIC(网络接口卡)、或者MAC(媒体访问设备)、或微处理器之类的组件中。

此处所述各技术方面可以用多种硬件和/或软件结构实现。例如，该技术可以用计算机程序实现。这种程序被存储在计算机可读媒体上并且包含用于对处理器(例如，控制器或引擎处理器)编程的指令。

其它的实施例被包含在下述权利要求的范围中。

附录A

　　END：     TCBWR index

　　IDLE：    JMP IDLE

　　LBLLISTEN：  SUB rcv[len]，HEADERLEN--＞seglen

　　        AND rcv[code]，RST--＞cond

　　        BRNEQZ IDLE

　　        AND rcv[code]，ACK--＞cond

　　        BRNEQZ TCPRST

　　        AND rcv[code]，SYN--＞cond

　　        B RNEQZ TCPINITWIN

　　        JMP TCPRST

　　LBLLISTEN1：    LOAD wkreg[state]＜--SYNRCVD

　　        JMP END

　　LBLSYNRCVD：    JMP TCPSEQOK

　　LBLSYNRCVD1：   AND rcv[code]，ACK--＞cond

　　        BREQZ IDLE

　　        CMP wkreg[suna]，rcv[ack]--＞cond

　　        BRNEQZ TCPRST

　　        CMP rcv[ack]，wkreg[snext]--＞cond

　　        BRNEQZ TCPRST

　　        ADD wkreg[suna]，1--＞wkreg[suna]

　　        JMP TCPDATAPROC

　　LBLSYNRCVD4：  AND wkreg[flags]，RDONE--＞R0

　　        EQUAL R0，0--＞cond

　　        BRNEQZ LBLSYNRCVD5

　　        LOAD wkreg[state]＜--CLOSEWAIT

　　        JMP END

　　LBLSYNRCVD5：  LOAD wkreg[state]＜--ESTABLISHED

　　        JMP END

　　LBLESTABLISHED：JMP TCPSEQOK

　　LBLESTABLISHED4：CMP wkreg[rbcount]，75RBSIZE--＞cond

　　        BREQZ LBLESTABLISHED5

　　        LOAD wkreg[rbcount]＜--0

　　LBLESTABLISHED5：AND wkreg[flags]，RDONE--＞R0

　　        EQUAL R0，0--＞cond

　　        BRNEQ ZEND

　　        LOAD wkreg[state]＜--CLOSEWAIT

　　        JMP END

　　LBLCLOSEWAIT：  JMP TCPSEQOK

　　LBLLASTACK：  JMP TCPSEQOK

　　LBLLASTACK2：  AND rcv[code]，ACK--＞cond

　　        BREQZ END

　　        CMP wkreg[suna]，rcv[ack]--＞cond

　　        BRNEQZ END

　　        CMP rcv[ack]，wkreg[snext]--＞cond

　　        BRNEQZ END

　　        JMP TCBDEALLOCATE

　　TCPRST：    LOAD snd[window]＜--0

　　        AND rcv[code]，SYN--＞cond

　　        BREQZ LBL02

　　        ADD seglen，1--＞seglen

　　LBL02：   AND rcv[code]，FIN--＞cond
				
				<dp n="d21"/>
　　        BREQZ LBL03
　　        ADD seglen，1--＞seglen

　　 LBL03：    AND rcv[code]，ACK--＞cond

　　        BRNEQZ LBL00

　　        LOAD snd[seq]＜--0

　　        LOAD snd[code]＜--RST|ACK

　　        JMP LBL01

　　 LBL00：    MOV rcv[ack]--＞snd[seq]

　　        LOAD snd[code]＜--RST

　　 LBL01：    ADD rcv[seq]，seglen--＞snd[ack]

　　        EQUAL wkreg[state]，LISTEN--＞cond

　　        BRNEQZ IDLE

　　        EQUAL wkreg[state]，SYNRCVD--＞cond

　　        BREQZ TCBDEALLOCATE

　　        AND rcv[code]，SYN--＞cond

　　        BRNEQZ TCBDEALLOCATE

　　        JMP IDLE

　　TCBDEALLOCATE：  CAMICLR index

　　        JMP IDLE

　　TCPINITWIN：    LOAD wkreg[code]＜--SYN
　　        MOV rcv[window]--＞wkreg[swindow]

　　        MOV rcv[seq]--＞wkreg[lwseq]

　　        MOV rcv[seq]--＞wkreg[rnext]

　　        ADD rcv[seq]，RBSIZE--＞wkreg[cwin]

　　        JMP TCPDATAPROC

　　TCPSENDWIN：    CMP wkreg[lwseq]，rcv[seq]--＞cond

　　        BRNEQZ LBL11

　　        EQUAL rcv[seq]，wkreg[lwseq]--＞cond

　　        BREQZ LBL10

　　        CMP wkreg[lwack]，rcv[ack]--＞cond

　　        BRNEQZ LBL11

　　LBL10：    MOV rcv[window]--＞wkreg[swindow]

　　        MOV rcv[seq]--＞wkreg[lwseq]

　　        MOV rcv[ack]--＞wkreg[lwack]

　　LBL11：    EQUAL wkreg[state]，ESTABLISHED--＞cond

　　        BRNEQZ LBLESTABLISHED4

　　        OR wkreg[flags]，SNDFIN--＞wkreg[flags]

　　        JMP TCPACK

　　TCPSEQOK：    LOAD statusok＜--0

　　        SUB rcv[len]，HEADERLEN--＞seglen

　　        AND rcv[code]，SYN--＞cond

　　        BREQZ LBL20

　　        ADD seglen，1--＞seglen

　　LBL20：    AND rcv[code]，FIN--＞cond

　　        BREQZ LBL21
　　        ADD seglen，1--＞seglen

　　LBL21：    SUB RBSIZE，wkreg[rbcount]--＞rwindow

　　        EQUAL rwindow，0--＞cond

　　        BREQZ LBL22

　　        EQUAL seglen，0--＞cond

　　        BREQZ LBL22

　　        EQUAL wkreg[rnext]，rcv[seq]--＞cond

　　        BREQZ LBL25
　　        LOAD statusok＜--1

　　        JMP LBL25

　　LBL22：    EQUAL rwindow，0--＞cond
				
				<dp n="d22"/>
    　　   BRNEQZ LBL25
　　       ADD wkreg[rnext]，rvindow--＞seqwin
　　       ADD rcv[seq]，seglen--＞seqlast
　　       EQUAL seglen，0--＞cond
　　       BRNEQZ LBL23
　　       CMP seqlast，wkreg[rnext]--＞cond
　　       MOV cond--＞statusok
　　       CMP seqlast，seqwin--＞cond
　　       NOT cond--＞cond
　　       AND cond，statusok--＞statusok
　　LBL23：    CMP wkreg[rnext]，rcv[seq]--＞cond
　　       BRNEQZ LBL25
　　       CMP seqwin，rcv[seq]--＞cond
　　       OR statusok，cond--＞statusok
　　LBL25：    AND rcv[code]，SYN--＞cond
　　       BREQZ LBL26
　　       SUB seglen，1--＞seglen
　　LBL26：    AND rcv[code]，FIN--＞cond
　　       BREQZ LBL27
　　       SUB seglen，1--＞seglen
　　LBL27：    EQUAL statusok，0--＞cond
　　       BRNEQZ TCPACKOUT
　　       AND rcv[code]，RST--＞cond
　　       BRNEQZ TCBDEALLOCATE
　　       AND rcv[code]，SYN--＞cond
　　       BRNEQZ TCPRST
　　       EQUAL wkreg[state]，SYNRCVD--＞cond
　　       BRNEQZ LBLSYNRCVD1
　　       JMP TCPACKIN
　　TCPACKOUT：    CMP seglen，0--＞cond
　　       BRNEQZ LBL30
　　       AND rcv[code]，SYN|FIN--＞cond
　　       BREQZ IDLE
　　LBL30：    LOAD snd[code]＜--ACK
　　       MOV wkreg[snext]--＞snd[seq]
　　       MOV wkreg[rnext]--＞snd[ack]
　　       SUB RBSIZE，wkreg[rbcount]--＞rwindow
　　       CMP wkreg[state]，SYNRCVD--＞cond
　　       BREQZ LBL35
　　       SHL2 rwindow--＞R0
　　       CMP RBSIZE，R0--＞cond
　　       BRNEQZ LBL32
　　       CMP RMSS，rwindow--＞cond
　　       BREQZ LBL33
　　LBL32：    LOAD rwindow＜--0
　　LBL33：    CMP wkreg[cwin]，wkreg[rnext]--＞cond
　　       BREQZ LBL34
　　       SUB wkreg[cwin]，wkreg[rnext]--＞R0
　　       CMP rwindow，R0--＞cond
　　       BRNEQZ LBL34
　　       MOV R0--＞rwindow
　　LBL34：    ADD wkreg[rnext]，rwindow--＞wkreg[cwin]
　　LBL35：    MOV rwindow--＞snd[window]
　　       JMP END
　　TCPACK：    AND wkreg[flags]，SNDFIN--＞R0
　　　　   EQUAL R0，0--＞cond
				
				<dp n="d23"/>
  　       BRN EQZLBL60
    　     OR wkreg[code]，FIN--＞wkreg[code]
　  LBL60：    OR wkreg[code]，ACK--＞snd[code]
　　       AND wkreg[flags]，～NEEDOUT--＞wkreg[flags]
　　       MOV wkreg[snext]--＞snd[seq]
　　       AND wkreg[code]，SYN|FIN--＞cond
　　       BREQZ LBL61
　　       ADD wkreg[snext]，1--＞wkreg[snext]
　　LBL61：    MOV wkreg[rnext]--＞snd[ack]
　　       SUB RBSIZE，wkreg[rbcount]--＞rwindow
　　       CMP wkreg[state]，SYNRCVD--＞cond
　　       BREQZ LBL65
　　       SHL2 rwindow--＞R0
　　       CMP RBSIZE，R0--＞cond
　　       BRNEQZ LBL62
　　       CMP RMSS，rwindow--＞cond
　　       BREQZ LBL63
　　LBL62：    LOAD rwindow＜--0
　　LBL63：    SUB wkreg[cwin]，wkreg[rnext]--＞R0
　　       CMP rwindow，R0--＞cond
　　       BRNEQZ LBL64
　　       MOV R0--＞rwindow
　　LBL64：    ADD wkreg[rnext]，rwindow--＞wkreg[cwin]
　　LBL65：    MOV rwindow--＞snd[window]
　　       AND wkreg[code]，0--＞wkreg[code]
　　       EQUAL wkreg[state]，LISTEN--＞cond
　　　     BRNEQZ LBLLISTEN1
　　       EQUAL wkreg[state]，SYNRCVD--＞cond
　　       BRNEQZ LBLSYNRCVD4
　　       EQUAL wkreg[state]，ESTABLISHED--＞cond
　　       BRNEQZ TCPSENDWIN
　　       EQUAL wkreg[state]，CLOSEWAIT--＞cond
　　       BREQZ END
　　       LOAD wkreg[state]＜--LASTACK
　　       JMP END
　　TCPACKIN：    AND rcv[code]，ACK--＞cond
　　       BREQZ LBL41
　　       CMP rcv[ack]，wkreg[suna]--＞cond
　　       BREQZ IDLE
　　       CMP rcv[ack]，wkreg[snext]--＞cond
　　       BRNEQZ TCPACKOUT
　　       MOV rcv[ack]--＞wkreg[suna]
　　       AND wkreg[code]，SYN--＞cond
　　       BREQZ LBL40
　　       AND wkreg[code]，～SYN--＞wkreg[code]
　　       AND wkreg[flags]，～FIRSTSEND--＞wkreg[flags]
　　LBL40：    AND wkreg[code]，FIN--＞cond
　　       BREQZ LBL41
　　       EQUAL wkreg[snext]，rcv[ack]--＞cond
　　       BREQZ LBL41
　　       AND wkreg[code]，～FIN--＞wkreg[code]
　　       AND wkreg[flags]，～SNDFIN--＞wkreg[flags]
　　LBL41：    EQUAL wkreg[state]，CLOSEWAIT--＞cond
　　       BRNEQZ TCPSENDWIN
　　       EQUAL wkreg[state]，ESTABLISHED--＞cond
　　       BRNEQZ TCPDATAPROC
				
				<dp n="d24"/>
　　       EQUAL wkreg[state]，LASTACK--＞cond
　　       BRNEQZ LBLLASTACK2
　　       JMP END
　　TCPDATAPROC：    MOV rcv[code]--＞statusok
　　       MOV rcv[seq]--＞seqfirst
　　       AND statusok，URG--＞cond
　　       BREQZ LBL51
　　       ADD seqfirst，rcv[urgptr]--＞R0
　　       AND wkreg[flags]，RUPOK--＞rwindow
　　       EQUAL rwindow，0--＞cond
　　       BRNEQZ LBL50
　　       CMP R0，wkreg[rupseq]--＞cond
　　       BREQZ LBL51
　　LBL50：    MOV R0--＞wkreg[rupseq]
　　       OR wkreg[flags]，RUPOK--＞wkreg[flags]
　　LBL51：    AND statusok，SYN--＞cond
　　       BREQZ LBL52
　　       ADD wkreg[rnext]，1--＞wkreg[rnext]
　　       OR wkreg[flags]，NEEDOUT--＞wkreg[flags]
　　       ADD seqfirst，1--＞seqfirst
　　LBL52：    SUB RBSIZE，wkreg[rbcount]--＞rwindow
　　       ADD wkreg[rnext]，rwindow--＞seqwin
　　       ADD seqfirst，seglen--＞seqlast
　　       CMp wkreg[rnext]，seqfirst--＞cond
　　       BREQZ LBL53
　　       SUB wkreg[rnext]，seqfirst--＞R0
　　       SUB seglen，R0--＞seglen
　　       MOV wkreg[rnext]--＞seqfirst
　　LBL53：    CMP seqlast，seqwin--＞cond
　　       BREQZ LBL54
　　       SUB seqlast，seqwin--＞R0
　　       SUB seglen，R0--＞seglen
　　       AND statusok，～FIN--＞statusok
　　LBL54：    EQUAL seqfirst，wkreg[rnext]--＞cond
 　　      BREQZ LBL55
 　　      CMP seglen，0--＞cond
　　       BREQZ LBL56
　　       ADD wkreg[rnext]，seglen--＞wkreg[rnext]
　　       ADD wkreg[rbcount]，seglen--＞wkreg[rbcount]
　　LBL512：    CAM2EMPTY cond
　　       BRNEQZ LBL511
　　       CAM2LLKUP seqlast
　　       BREQZ LBL511
　　       CAM2CLR [cam2_idx]
　　       ADD wkreg[rnext]，seglen--＞wkreg[rnext]
　　       ADD wkreg[rbcount]，seglen--＞wkreg[rbcount]
　　LBL511：    EQUAL wkreg[finseq]，wkreg[rnext]--＞cond
　　       BRNEQZ ALLDONE
　　       CMP wkreg[pushseq]，wkreg[rnext]--＞cond
　　       BRNEQZ NEXT
　　       OR statusok，PSH--＞statusok
　　       LOAD wkreg[pushseq]＜--0
　　       JMPNEXT
　　ALLDONE：    OR statusok，FIN--＞statusok
　　NEXT：     OR wkreg[flags]，NEEDOUT--＞wkreg[flags]
　　LBL56：    AND statusok，FIN--＞cond
				
				<dp n="d25"/>
　　       BREQZ LBL58
　　       OR wkreg[flags]，RDONE|NEEDOUT--＞wkreg[flags]
　　       ADD wkreg[rnext]，1--＞wkreg[rnext]
　　LBL58：    AND statusok，PSH|URG--＞cond
　　       BREQZ NEXTP1
　　       OR wkreg[flags]，PUSH--＞wkreg[flags]
　　       JMP NEXTP1
　　LBL55：    AND statusok，FIN--＞cond
　　       BREQZ LBL59
　　       ADD seqfirst，seglen--＞wkreg[finseq]
　　LBL59：    AND statusok，PSH|URG--＞cond
　　       BREQZ LBL510
　　       ADD seqfirst，seglen--＞wkreg[Pushseq]
　　LBL510：    AND statusok，～(FIN|PSH)--＞statusok
　　       CAM2LLKUP seqlast
　　       BREQZ LBL515
　　       CAM2CLR [cam2_idx]
　　       ADD seqlast，seglen--＞seqlast
　　       SUB seqlast，seqfirst--＞seglen
　　LBL515：    CAM2RLKUP seqfirst
　　       BREQZ LBL516
　　       CAM2CLR [cam2_idx]
　　       SUB seqfirst，seglen--＞seqfirst
　　       SUB seqlast，seqfirst--＞seglen
　　LBL516：    CAM2WR seglen
　　       OR wkreg[flags]，NEEDOUT--＞wkreg[flags]
　　NEXTP1：    AND wkreg[flags]，NEEDOUT--＞R0
　　       EQUAL R0，0--＞cond
　　       BREQZ TCPACK
　　       EQUAL wkreg[state]，LISTEN--＞cond
　　       BRNEQZ LBLLISTEN1
　　       EQUAL wkreg[state]，SYNRCVD--＞cond
　　       BRNEQZ LBLSYNRCVD4
　　       EQUAL wkreg[state]，ESTABLISHED--＞cond
　　       BRNEQZ TCPSENDWIN
　　       JMP END

Claims

1.一种处理接收的分组的方法，该方法包括：

识别该接收的分组的网络连接；以及

把该网络连接分配给一组多个网络协议卸载引擎中的一个。

2.权利要求1的方法，

其中该连接包括传输控制协议(TCP)连接；以及

其中该网络协议卸载引擎中的至少一个包括TCP卸载引擎。

3.权利要求1的方法，其中该连接包括传输层连接。

4.权利要求1的方法，其中该分配包括使当前被分配至少一个连接的网络协议卸载引擎的数目最小。

5.权利要求1的方法，其中该分配包括根据来自至少其中一个引擎的、标识该引擎当前使用情况的至少一个信号来进行分配。

6.权利要求1的方法，其中该分配包括为该连接存储数据。

7.权利要求6的方法，其中该数据包括源地址、目的地址、源端口以及目的端口。

8.权利要求1的方法，其中，该分配包括维护被分配第一连接的引擎的队列。

9.权利要求1的方法，还包括断言一个信号给为接收的分组的连接分配的多个网络协议卸载引擎之一。

10.权利要求9的方法，还包括利用分配给该连接的网络协议卸载引擎对该分组执行网络协议操作。

11.权利要求1的方法，还包括

断言一个信号给被分配到至少一个进行中的连接的网络协议卸载引擎；以及

从该网络协议卸载引擎接收信号，该网络协议卸载引擎接收这样的信号，即它标识哪个网络协议卸载引擎，如果有的话，已被分配给该分组的连接。

12.一种网络协议卸载引擎，该引擎包括：

输入接口，用于接收分组数据；

输出接口，用于输出网络协议操作的结果；

控制器接口，用于和多个网络协议卸载引擎的控制器通信；以及

用于以下操作的逻辑：

对接收的分组数据执行网络协议操作；以及

当该引擎已经被分配来处理接收的分组的连接时，至少通过接收信号来和控制器通信。

13.权利要求12的引擎，其中，网络协议操作包括传输控制协议(TCP)操作。

14.权利要求12的引擎，其中，输出接口包括到由多个网络协议卸载引擎共享的总线的接口。

15.权利要求12的引擎，其中，该引擎包括存储设备和逻辑，用以存储标识被分配给该引擎的连接的数据。

16.权利要求15的引擎，其中，该存储设备包括内容可寻址的存储器(CAM)。

17.权利要求15的引擎，还包括用于断言信号给该控制器的逻辑，该信号指示在该存储设备中查找连接成功。

18.权利要求12的引擎，还包括断言至少一个信号给控制器，以识别网络协议卸载引擎的使用情况。

19.权利要求18的引擎，其中，该至少一个信号包括至少一个以下信号：网络协议卸载引擎满信号和网络协议卸载引擎空信号。

20.权利要求12的引擎，其中，该逻辑包括处理器和存储设备，后者存储用于执行网络协议操作的指令。

21.权利要求12的引擎，其中，该至少一个信号使引擎能够对接收的分组数据执行网络协议操作。

22.一种控制器，该控制器包括：

到一组多个网络协议卸载引擎的至少一个接口；以及

把网络连接分配给一组多个网络协议卸载引擎之一的逻辑。

23.权利要求22的控制器，

其中该连接包括传输控制协议(TCP)连接；以及

其中至少一个网络协议卸载引擎包括TCP卸载引擎。

24.权利要求22的控制器，其中用于分配的逻辑包括用于最小化当前被分配至少一个连接的卸载引擎数目的逻辑。

25.权利要求22的控制器，其中，该分配包括根据从至少其中一个引擎中接收的信号来分配，该信号标识至少一个引擎相应的使用情况。

26.权利要求22的控制器，还包括只是断言信号到为接收的分组的连接分配的引擎的逻辑。

27.权利要求22的控制器，还包括逻辑，用于：

只断言信号给已被分配到至少一个进行中连接的引擎；以及

从该引擎接收信号，该引擎接收这样的信号，即该信号标识哪个引擎，如果有的话，已被分配给分组的连接

28.权利要求22的控制器，

还包括一个接口用来和层次更高的控制器通信。

29.一种系统，包括：

多个网络协议卸载引擎，该引擎对接收的分组数据执行网络协议操作；

耦合到该多个网络协议卸载引擎的至少一个子集的至少一个控制器；

第一总线，用于把接收的分组的数据载送到该多个网络协议卸载引擎；以及

第二总线，用于从该多个网络协议卸载引擎中载送引擎对接收的分组的处理结果。

30.权利要求29的系统，其中该多个网络协议卸载引擎包括至少一个传输控制协议(TCP)卸载引擎。

31.权利要求29的系统，其中该控制器协调对第二总线的访问。

32.权利要求29的系统，其中该控制器包括把网络连接分配给多个网络协议卸载引擎之一的逻辑。

33.权利要求32的系统，其中用于分配的逻辑包括用于把分配给至少一个进行中连接的引擎的数目最小化的逻辑。

34.权利要求29的系统，其中该控制器和该多个网络协议卸载引擎使用至少一个以下信号进行通信：从引擎发送到控制器、标识引擎的使用情况的使用情况信号，由该控制器发送给至少一个引擎的许可信号，以及从一个引擎发送到控制器、指示该引擎已被分配给分组的连接的信号。

35.权利要求29的系统，其中多个网络协议卸载引擎存储标识分配给各个引擎的连接的数据。

36.权利要求29的系统，还包括至少一个分层控制器以协调该至少一个控制器的多个控制器的操作，该至少一个控制器中的个体控制器耦合到该多个网络协议卸载引擎的不同子集上。

37.权利要求36的系统，其中，该分层控制器包括逻辑，用于把连接分配给由该至少一个控制器中的一个控制器所管理的多个网络协议卸载引擎。

38.一种系统，包括：

至少一个物理层组件(PHY)；

耦合到该至少一个PHY的至少一个以太网媒体访问控制器(MAC)；

至少一个主机系统，该主机系统包括：

至少一个主机处理器；以及

该主机处理器可访问的存储器；以及

耦合到该至少一个以太网MAC和至少一个主机系统的传输控制协议(TCP)卸载子系统，TCP卸载子系统包括：

对接收的分组执行TCP操作的多个TCP卸载引擎；以及

至少一个控制器，该至少一个控制器包括逻辑，用来把连接分配给该多个网络协议卸载引擎中的一个网络协议卸载引擎。

39.权利要求38的系统，其中该至少一个控制器和该网络协议卸载引擎的至少一个使用至少一个以下信号通信：从引擎发送到控制器的、标识引擎使用情况的使用情况信号，由控制器发送给至少一个引擎的许可信号，以及从引擎发送到控制器、指示该引擎已被分配给分组的连接的信号。

40.权利要求38的系统，

还包括至少一个分层控制器；以及

其中该至少一个分层控制器和至少一个控制器使用至少一个以下信号通信：从该控制器发送到层次更高的控制器、标识耦合到该控制器的网络协议卸载引擎使用情况的使用情况信号，由层次更高的控制器发送给该控制器的许可信号，以及从该控制器发送到层次更高的控制器、指示耦合到该控制器的网络协议卸载引擎已被分配给分组的连接的信号。