throbber
UNITED STATES PATENT AND TRADEMARK OFFICE
`________________
`
`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
`
`

This document is available on Docket Alarm but you must sign up to view it.


Or .

Accessing this document will incur an additional charge of $.

After purchase, you can access this document again without charge.

Accept $ Charge
throbber

Still Working On It

This document is taking longer than usual to download. This can happen if we need to contact the court directly to obtain the document and their servers are running slowly.

Give it another minute or two to complete, and then try the refresh button.

throbber

A few More Minutes ... Still Working

It can take up to 5 minutes for us to download a document if the court servers are running slowly.

Thank you for your continued patience.

This document could not be displayed.

We could not find this document within its docket. Please go back to the docket page and check the link. If that does not work, go back to the docket and refresh it to pull the newest information.

Your account does not support viewing this document.

You need a Paid Account to view this document. Click here to change your account type.

Your account does not support viewing this document.

Set your membership status to view this document.

With a Docket Alarm membership, you'll get a whole lot more, including:

  • Up-to-date information for this case.
  • Email alerts whenever there is an update.
  • Full text search for other cases.
  • Get email alerts whenever a new case matches your search.

Become a Member

One Moment Please

The filing “” is large (MB) and is being downloaded.

Please refresh this page in a few minutes to see if the filing has been downloaded. The filing will also be emailed to you when the download completes.

Your document is on its way!

If you do not receive the document in five minutes, contact support at support@docketalarm.com.

Sealed Document

We are unable to display this document, it may be under a court ordered seal.

If you have proper credentials to access the file, you may proceed directly to the court's system using your government issued username and password.


Access Government Site

We are redirecting you
to a mobile optimized page.





Document Unreadable or Corrupt

Refresh this Document
Go to the Docket

We are unable to display this document.

Refresh this Document
Go to the Docket