`________________
`
`BEFORE THE PATENT TRIAL AND APPEAL BOARD
`________________
`
` INTEL CORP. and
`CAVIUM, INC.,
`
`Petitioners,
`
`v.
`
`ALACRITECH INC.,
`
`Patent Owner.
`________________
`
`Case IPR2017-013911
`U.S. Patent 7,237,036
`________________
`
`CORRECTED PATENT OWNER’S EXHIBIT 2026
`
`DECLARATION OF KEVIN ALMEROTH, PH.D.
`
`1 Cavium, who filed a Petition in Case IPR2017-01718, has been joined as a
`
`petitioner in this proceeding.
`
`Alacritech Exhibit 2026
`
`Petitioner Riot Games – Ex. 1056,
`Riot Games, Inc. v. PalTalk Holdings, Inc., IPR2018-00129, -130, -131, -132, Cover
`
`
`
`(https://nmap.org/book/tcpip-ref.html, Ex. 2042.) I personally obtained this figure
`
`from the link above. This figure accurately depicts an IP header as of October
`
`1997.
`
`62.
`
`The Transmission Control Protocol, referred to as “TCP,” is one of
`
`the main protocols used to send and receive information over the Internet. TCP is
`
`well known in the computer networking industry—one early TCP rule set was
`
`published as a Request for Comment (or “RFC”) by the Internet Engineering Task
`
`Force (“IETF”) in September 1981 (RFC 793). That rule set was based on an even
`
`earlier rule set published in December 1974 as RFC 675. TCP is an example of a
`
`Alacritech Exhibit 2026, Page 23
`
`Petitioner Riot Games – Ex. 1056,
`Riot Games, Inc. v. PalTalk Holdings, Inc., IPR2018-00129, -130, -131, -132, p. 23
`
`
`
`transport (layer 4) protocol in the OSI model. TCP is responsible for adding
`
`reliability and ordering to the stream of network information—for example, the
`
`packets of information sent using IP as the network-layer protocol may not arrive
`
`at the destination in the same order intended by the sender of the message. TCP
`
`sets rules for breaking up and transmitting the message so that the recipient is able
`
`to reliably receive and reassemble the message. Another common analogy from
`
`the physical world is the example of sending a multi-page letter through the mail
`
`by separately numbering each page and mailing it in its own envelope. IP, like the
`
`postal service, will route the envelope-like packets to the destination, but TCP (like
`
`the numbering of the individual pages) sets the rules to allow the recipient to verify
`
`that all of the pages have been received and to reassemble the pages in the right
`
`order.
`
`63.
`
`TCP describes, for example, how two devices on the Internet may
`
`establish a connection over which TCP data packets may be communicated
`
`between them. By way of a negotiation process known as a three-way handshake,
`
`such a connection can be established between two nodes, and once that connection
`
`establishment phase completes, data transfer can begin. Typically, a TCP
`
`connection is managed by a device operating system so that applications such as a
`
`web browser or a web server like a CDN caching server can pass data to the
`
`operating system’s TCP protocol “stack,” and the operating system will manage
`
`Alacritech Exhibit 2026, Page 24
`
`Petitioner Riot Games – Ex. 1056,
`Riot Games, Inc. v. PalTalk Holdings, Inc., IPR2018-00129, -130, -131, -132, p. 24
`
`
`
`resulting in another combined data packet. The data resulting from combining the
`
`payload data, application layer header, and presentation layer header is then passed
`
`to the session layer, which performs required operations including attaching a
`
`session layer header to the data and presenting the resulting combination of data to
`
`the transport layer. This process continues as the information moves to lower
`
`layers, with a transport layer header, network layer header, and data link layer
`
`header and trailer attached to the data at each of those layers, with each step
`
`typically including data moving and copying, before sending the data as bit packets
`
`over the network to the second host. (Id. at 4:28-33.)
`
`68.
`
`This process of adding a layer header to the data from the preceding
`
`layer is sometimes referred to as “encapsulation” because the data and layer header
`
`is treated as the data for the immediately following layer, which, in turn, adds its
`
`own layer header to the data from the preceding layer. Each layer is generally not
`
`aware of which portion of the data from the preceding layer constitutes the layer
`
`header or the user data; as such, each layer treats the data it receives from the
`
`preceding layer as some generic payload.
`
`Alacritech Exhibit 2026, Page 28
`
`Petitioner Riot Games – Ex. 1056,
`Riot Games, Inc. v. PalTalk Holdings, Inc., IPR2018-00129, -130, -131, -132, p. 28
`
`
`
`(Ex. 1008, Stevens at 1008.034, Figure 1.4 (adapted from Petition at 18).)
`
`69. On the receiving side, the receiving host generally performs the
`
`reverse of the sending process, beginning with receiving the bits from the network.
`
`Headers are removed, one at a time, and the received data is processed, in order,
`
`from the lowest (physical) layer to the highest (application) layer before
`
`transmission to a destination within the receiving host (e.g., to the operating system
`
`space where the received data may be used by an application running on the
`
`receiving host). (Ex. 1001 at 4:34-39.) Each layer of the receiving host recognizes
`
`and manipulates only the headers associated with that layer, since to that layer the
`
`higher layer header data is included with and indistinguishable from the payload
`
`data. “Multiple interrupts, valuable central processing unit (CPU) processing time
`
`Alacritech Exhibit 2026, Page 29
`
`Petitioner Riot Games – Ex. 1056,
`Riot Games, Inc. v. PalTalk Holdings, Inc., IPR2018-00129, -130, -131, -132, p. 29
`
`
`
`and repeated data copies may also be necessary for the receiving host to place the
`
`data in an appropriate form at its intended destination.” (Id. at 4:43-46.)
`
`70. Because the processing of each layer typically involves a copy and
`
`data manipulation operation (for example a checksum generation or validation
`
`operation), the host CPU must be “interrupted” at least one time per layer in order
`
`to process the data and construct (transmit side) or deconstruct (receive side) the
`
`packet. An interrupt is a signal to the processor emitted by hardware or software
`
`indicating an event that needs immediate attention. An interrupt alerts the
`
`processor to a high-priority condition requiring the interruption of the current code
`
`the processor is executing. (Id.) This process associated with traditional network
`
`interface cards results in “repeated copying and interrupts to the CPU” of the host
`
`computer. (Ex. 1001 at 5:39-40.) When the host CPU is interrupted, it generally
`
`must stop all other tasks it is currently working on, including tasks completely
`
`unrelated to the network processing. Frequent interrupts to the host CPU can be
`
`very disruptive to the host system generally and cause system instability and
`
`degraded system performance.
`
`71.
`
`The invention of the ’036 Patent includes a “fast-path” where the host
`
`CPU is relieved of certain TCP/IP processing, which is instead performed by the
`
`INIC. In other words, the invention “allow[s] data from the message to be
`
`processed via a fast-path which accesses message data directly at its source or
`
`Alacritech Exhibit 2026, Page 30
`
`Petitioner Riot Games – Ex. 1056,
`Riot Games, Inc. v. PalTalk Holdings, Inc., IPR2018-00129, -130, -131, -132, p. 30
`
`
`
`I hereby declare under penalty of perjury that all statements made herein of
`
`my own knowledge are true and that all statements made on the information and
`
`belief are believed to be true; and further that these statements were made with the
`
`knowledge that willful false statements and the like so made are punishable by fine
`
`or imprisonment, or both, under Section 1001 of Title 18 of the United States
`
`Code.
`
`Executed: February 24, 2018
`
`Kevin C. Almeroth, Ph.D.
`
`Alacritech Exhibit 2026, Page 62
`
`Petitioner Riot Games – Ex. 1056,
`Riot Games, Inc. v. PalTalk Holdings, Inc., IPR2018-00129, -130, -131, -132, p. 62
`
`