CN113810370B - TCP acceleration method based on Socket docking TOE drive - Google Patents
TCP acceleration method based on Socket docking TOE drive Download PDFInfo
- Publication number
- CN113810370B CN113810370B CN202110891464.6A CN202110891464A CN113810370B CN 113810370 B CN113810370 B CN 113810370B CN 202110891464 A CN202110891464 A CN 202110891464A CN 113810370 B CN113810370 B CN 113810370B
- Authority
- CN
- China
- Prior art keywords
- tcp
- socket
- data
- layer
- port
- 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.)
- Active
Links
- 238000000034 method Methods 0.000 title claims abstract description 51
- 230000001133 acceleration Effects 0.000 title claims abstract description 24
- 238000003032 molecular docking Methods 0.000 title claims abstract description 20
- 230000005540 biological transmission Effects 0.000 claims description 12
- 238000012545 processing Methods 0.000 claims description 11
- 238000012544 monitoring process Methods 0.000 claims description 3
- 238000004806 packaging method and process Methods 0.000 abstract 1
- 239000008186 active pharmaceutical agent Substances 0.000 description 10
- 238000004891 communication Methods 0.000 description 5
- 230000000694 effects Effects 0.000 description 3
- 238000004364 calculation method Methods 0.000 description 2
- 238000010586 diagram Methods 0.000 description 2
- 238000005538 encapsulation Methods 0.000 description 2
- 238000012986 modification Methods 0.000 description 2
- 230000004048 modification Effects 0.000 description 2
- 230000009286 beneficial effect Effects 0.000 description 1
- 238000011161 development Methods 0.000 description 1
- 238000005516 engineering process Methods 0.000 description 1
- 210000001503 joint Anatomy 0.000 description 1
- 238000012858 packaging process Methods 0.000 description 1
- 238000006467 substitution reaction Methods 0.000 description 1
- 238000012795 verification Methods 0.000 description 1
Images
Classifications
-
- H—ELECTRICITY
- H04—ELECTRIC COMMUNICATION TECHNIQUE
- H04L—TRANSMISSION OF DIGITAL INFORMATION, e.g. TELEGRAPHIC COMMUNICATION
- H04L69/00—Network arrangements, protocols or services independent of the application payload and not provided for in the other groups of this subclass
- H04L69/16—Implementation or adaptation of Internet protocol [IP], of transmission control protocol [TCP] or of user datagram protocol [UDP]
- H04L69/161—Implementation details of TCP/IP or UDP/IP stack architecture; Specification of modified or new header fields
- H04L69/162—Implementation details of TCP/IP or UDP/IP stack architecture; Specification of modified or new header fields involving adaptations of sockets based mechanisms
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F9/00—Arrangements for program control, e.g. control units
- G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
- G06F9/44—Arrangements for executing specific programs
- G06F9/448—Execution paradigms, e.g. implementations of programming paradigms
- G06F9/4482—Procedural
-
- H—ELECTRICITY
- H04—ELECTRIC COMMUNICATION TECHNIQUE
- H04L—TRANSMISSION OF DIGITAL INFORMATION, e.g. TELEGRAPHIC COMMUNICATION
- H04L67/00—Network arrangements or protocols for supporting network services or applications
- H04L67/14—Session management
- H04L67/141—Setup of application sessions
-
- H—ELECTRICITY
- H04—ELECTRIC COMMUNICATION TECHNIQUE
- H04L—TRANSMISSION OF DIGITAL INFORMATION, e.g. TELEGRAPHIC COMMUNICATION
- H04L67/00—Network arrangements or protocols for supporting network services or applications
- H04L67/14—Session management
- H04L67/143—Termination or inactivation of sessions, e.g. event-controlled end of session
-
- H—ELECTRICITY
- H04—ELECTRIC COMMUNICATION TECHNIQUE
- H04L—TRANSMISSION OF DIGITAL INFORMATION, e.g. TELEGRAPHIC COMMUNICATION
- H04L69/00—Network arrangements, protocols or services independent of the application payload and not provided for in the other groups of this subclass
- H04L69/16—Implementation or adaptation of Internet protocol [IP], of transmission control protocol [TCP] or of user datagram protocol [UDP]
- H04L69/163—In-band adaptation of TCP data exchange; In-band control procedures
-
- Y—GENERAL TAGGING OF NEW TECHNOLOGICAL DEVELOPMENTS; GENERAL TAGGING OF CROSS-SECTIONAL TECHNOLOGIES SPANNING OVER SEVERAL SECTIONS OF THE IPC; TECHNICAL SUBJECTS COVERED BY FORMER USPC CROSS-REFERENCE ART COLLECTIONS [XRACs] AND DIGESTS
- Y02—TECHNOLOGIES OR APPLICATIONS FOR MITIGATION OR ADAPTATION AGAINST CLIMATE CHANGE
- Y02D—CLIMATE CHANGE MITIGATION TECHNOLOGIES IN INFORMATION AND COMMUNICATION TECHNOLOGIES [ICT], I.E. INFORMATION AND COMMUNICATION TECHNOLOGIES AIMING AT THE REDUCTION OF THEIR OWN ENERGY USE
- Y02D30/00—Reducing energy consumption in communication networks
- Y02D30/50—Reducing energy consumption in communication networks in wire-line communication networks, e.g. low power modes or reduced link rate
Abstract
The invention provides a TCP acceleration method based on Socket docking TOE driving, which is applied to a TCP acceleration network card based on Socket docking TOE driving; according to the method, a Socket skips a linux kernel protocol stack to directly butt-joint TOE drive through dynamic replacement of a Socket module, and operations such as packaging, checking, unpacking and the like of a transport layer, a network layer and a data link layer are realized through FGPA. The method for dynamically replacing the Socket module does not need to modify kernel source codes, and is convenient to use and relatively small in workload.
Description
Technical Field
The invention relates to the technical field of Internet, in particular to a TCP acceleration method based on Socket docking TOE driving.
Background
With the high-speed development of network information, the transmission quantity of network data has an exponentially increasing trend, and the traditional TCP communication calculation quantity is too large, so that the network throughput is limited by CPU performance, and a TCP acceleration technology TCP/IP Offload Engine appears on the market, which directly transplants a TCP/IP communication module to FGPA and carries out calculation acceleration through hardware. In the linux kernel, since the Socket module directly interfaces with the TCP/IP module (network protocol stack), in order to ensure consistency of habit of a user, the Socket module needs to be modified to directly interface with the TOE network card driver.
The linux kernel network protocol stack contains a plurality of protocols such as TCP, UDP, IP, ICMP, IGMP.
Application layer: is responsible for handling specific application layer details, and is used for transmission and control by analyzing an application layer protocol.
Transport layer: the TCP protocol is responsible for providing highly reliable end-to-end data communications.
Network layer: processing the activity of the packet in the internet, such as routing of the packet.
Data link layer: details of the physical interface with the cable or any other transmission medium are handled, responsible for the communication protocol implementing the physical link.
Whether it is the transport layer or the network layer or even the data link layer, the host processor needs to expend a lot of resources to perform packet encapsulation and verification. This will result in network bandwidth being limited by CPU performance in a high-speed ethernet environment.
And modifying the Socket module to skip the kernel protocol stack and directly butt-joint the TOE driver.
Scheme one: and directly modifying a Socket module in the linux kernel source code. Disadvantages: the workload is large, the difficulty is high, the time period is long, the kernel source code needs to be recompiled, and the use is inconvenient.
Scheme II: and dynamically replacing the Socket module. The advantages are that: the kernel source code does not need to be modified, the use is convenient, and the workload is relatively small.
Disclosure of Invention
The invention aims to provide a TCP acceleration method based on Socket docking TOE driving, which aims to solve the problems in the technical background.
In order to achieve the above purpose, the present invention adopts the following technical scheme:
the invention provides a TCP acceleration method based on Socket docking TOE driving, which dynamically replaces a Socket module to enable the Socket to skip a linux kernel protocol stack and directly dock the TOE driving; the method comprises the following steps:
s1: adding an add_port interface, and storing a toe port into a toe list port;
s2: in the init process, dynamically replacing tcp_port with field_tcp_port through a hook function, and replacing inet_stream_ops structure with field_inet_stream_ops;
s3: comparing the current port with the toe port list in the fitoe_tcp_port and the fitoe_inet_stream_ops, judging whether the current port belongs to the toe port or not, and if so, turning to S4; otherwise, calling the original tcp_port and inet_stream_ops;
s4: the Driver transmits the data to the FPGA, and the FPGA processes the data packet of the multi-layer network protocol;
s5: the replaced tcp_port and inet_stream_ops structures are restored in the process of exit.
Preferably, the linux kernel protocol includes a TCP protocol and an IP protocol.
Preferably, the Socket upper layer is an operating system API, and the Socket lower layer is directly opposite to the transport layer.
Preferably, the data flow of the TCP data transmission is as follows:
a1: the application layer adds the user data into the user header to generate application data, and sends the application data to the transport layer through the Socket layer tcp_sndmsg;
a2: the transport layer adds a TCP header of 20 bytes in the application data to generate a TCP segment, stores a 16bit port number, namely an identifier of the application program, in the TCP header, and then gives the data to the network layer;
a3: a network layer, which adds an IP header in the TCP segment to generate an IP datagram, wherein the IP header has a length of 20byte and comprises an 8bit protocol domain for identifying which layer the data belongs to, and the network layer transmits the data to a data link layer;
a4: and the data link layer adds an Ethernet header of 14 bytes and an Ethernet tail of 4 bytes in the IP datagram to generate an Ethernet frame, and finally the Ethernet frame is sent to a network by the FPGA through network card equipment.
Preferably, the data flow of the TCP data reception is as follows:
b1: the data link layer unpacks the Ethernet frame to obtain an IP datagram, and the IP datagram is delivered to the network layer;
b2: a network layer unpacking the IP datagram and transmitting the datagram to a transport layer through a protocol domain in an IP header;
b3: the transport layer unpacks the TCP segment and reports the data message to the application layer through a port number in a TCP header;
b4: and the application layer unpacks the user header to complete the control transmission of the data.
Preferably, the Socket processing procedure of the TCP is as follows:
c1: creating a socket;
c2: binding ip;
and C3: monitoring ports;
and C4: waiting for a client to connect;
c5: the client creates a socket;
c6: the client establishes a link with the server;
c7: the client sends data;
and C8: the data is transmitted to the server and received by the server;
c9: the server processes the received data;
c10: the server side sends data to the client side;
c11: the client breaks the link;
and C12: the broken link information is transmitted to a server;
c13: the service end breaks the chain.
Preferably, in the Socket processing of the TCP, the corresponding relations between Operating System API and Socket TCP APIs are respectively: listen () corresponds to inet_Listen (), accept () corresponds to inet_ csk _accept (), connect () corresponds to itcp_v4_connect (), write () corresponds to tcp_sendmsg (), read () corresponds to tcp_recvmsg (), close () corresponds to tcp_close_bylock ().
Preferably, the transport layer function network protocol stack function includes: constructing a TCP header; calculating a checksum and a sequence number; transmitting an ack packet; sliding window.
Preferably, the network layer function network protocol stack function includes: routing, namely selecting the next hop; adding an IP header; calculating IP header checksum, which is used for detecting whether the ip message is in error in the transmission process; performing IP slicing; and acquiring the MAC address of the next hop, and transferring to link layer processing.
The invention also provides a TCP acceleration network card based on Socket docking TOE driving, which is applied to any one of the TCP acceleration methods based on Socket docking TOE driving.
Compared with the prior art, the technical scheme of the invention has the following beneficial effects:
the method for dynamically replacing the Socket module does not need to modify kernel source codes, and is convenient to use and relatively small in workload.
Drawings
The accompanying drawings, which are included to provide a further understanding of the application, illustrate and explain the application and are not to be construed as limiting the application. In the drawings:
FIG. 1 is a system schematic block diagram of a preferred embodiment of the present invention;
FIG. 2 is an encapsulation process when data enters the protocol stack according to the preferred embodiment of the present invention;
FIG. 3 is a tcp socket process in accordance with a preferred embodiment of the present invention.
Fig. 4 is an optimized Socket TCP API call procedure in accordance with a preferred embodiment of the present invention.
Detailed Description
The invention provides a TCP acceleration method based on Socket docking TOE driving, which is used for making the purposes, the technical scheme and the effects of the invention clearer and more definite, and the invention is further described in detail below by referring to the accompanying drawings and examples. It should be understood that the specific embodiments described herein are for purposes of illustration only and are not intended to limit the scope of the invention.
It is noted that the terms "first," "second," and the like in the description and claims of the present invention and in the foregoing figures are used for distinguishing between similar objects and not necessarily for describing a particular sequential or chronological order, and it is to be understood that the data so used may be interchanged where appropriate. Furthermore, the terms "comprises," "comprising," and "having," and any variations thereof, are intended to cover a non-exclusive inclusion, such that a process, method, system, article, or apparatus that comprises a list of steps or elements is not necessarily limited to those steps or elements expressly listed but may include other steps or elements not expressly listed or inherent to such process, method, article, or apparatus.
Examples:
the invention provides a TCP acceleration method based on Socket docking TOE driving, and a schematic block diagram of the TCP acceleration method is shown in figure 1.
Fig. 2 is a packaging process when data enters a protocol stack, and the specific process is as follows:
application layer: the method is responsible for processing specific application layer details, and transmission and control are carried out between applications by analyzing an application layer protocol;
transport layer: the TCP protocol is responsible for providing highly reliable end-to-end data communications;
network layer: processing the activity of the packet in the internet, such as routing of the packet.
The data flow of the TCP data transmission is as follows:
the application layer adds the user data into the user header to generate application data, and sends the application data to the transport layer through the Socket layer tcp_sndmsg;
the transport layer adds a TCP header of 20 bytes in the application data to generate a TCP segment, stores a 16bit port number, namely an identifier of the application program, in the TCP header, and then gives the data to the network layer;
a network layer, which adds an IP header in the TCP segment to generate an IP datagram, wherein the IP header has a length of 20byte and comprises an 8bit protocol domain for identifying which layer the data belongs to, and the network layer transmits the data to a data link layer;
and the data link layer adds an Ethernet header of 14 bytes and an Ethernet tail of 4 bytes in the IP datagram to generate an Ethernet frame, and finally the Ethernet frame is sent to a network by the FPGA through the network card equipment.
The data stream of the TCP data reception is as follows:
the data link layer unpacks the Ethernet frame to obtain an IP datagram, and the IP datagram is delivered to the network layer;
a network layer unpacking the IP datagram and transmitting the datagram to a transport layer through a protocol domain in an IP header;
the transport layer unpacks the TCP segment and reports the data message to the application layer through a port number in a TCP header;
and the application layer unpacks the user header to complete the control transmission of the data.
The TCP Socket processing procedure is shown in fig. 3, and specifically includes the following steps:
step 1: creating a socket;
step 2: binding ip;
step 3: monitoring ports;
step 4: waiting for a client to connect;
step 5: the client creates a socket;
step 6: the client establishes a link with the server;
step 7: the client sends data;
step 8: the data is transmitted to the server and received by the server;
step 9: the server processes the received data;
step 10: the server side sends data to the client side;
step 11: the client breaks the link;
step 12: the broken link information is transmitted to a server;
step 13: the service end breaks the chain.
The optimized Socket TCP API calling process is shown in fig. 4, and the specific steps are as follows:
the replacing module dynamically replaces tcp_port into fitoe_tcp_port through a hook function in the init process, and replaces inet_stream_ops structure into fitoe_inet_stream_ops.
The replacement module restores the replaced tcp_port and inet_stream_ops structures in the process of exit.
When the operating system calls an API such as listen, accept, connet, write, read, close, the replaced Socket TCP APIs, namely the fitoe_tcp_prot and the fitoe_inet_stream_ops, are called. Because the replacement of the Socket TCP API is global, other network cards can be ensured to work normally after the replacement, and the current Socket needs to be judged in the fitoe_tcp_port and the fitoe_inet_stream_ops. If the Socket belongs to the TOE, continuing to call, and if the Socket does not belong to the TOE, calling the TCP API of the original system Socket.
Regarding whether a Socket belongs to a TOE, add_port interfaces are added, and TOE ports are saved into a TOE list port. When the Socket TCP API is called, whether the port belongs to the TOE is judged.
If the original tcp_prot and the original inet_stream_ops of the system are not in the toe port, the original tcp_prot and the original inet_stream_ops of the system are directly called.
If the data belongs to the toe port, the data is directly transmitted to the FPGA through the Driver, and the FPGA performs data packet processing work of a multi-layer network protocol.
bypass is a special channel reserved for the protocol of the arp etc. The channel is in butt joint with a linux kernel network protocol stack, and FGPA directly carries out transparent transmission on the data of the channel.
In summary, the Socket-docking TOE-driven TCP acceleration method adopts a dynamic Socket module replacement method without modifying kernel source codes, so that the method is convenient to use and has relatively small workload.
The above description of the specific embodiments of the present invention has been given by way of example only, and the present invention is not limited to the above described specific embodiments. Any equivalent modifications and substitutions for the present invention will occur to those skilled in the art, and are also within the scope of the present invention. Accordingly, equivalent changes and modifications are intended to be included within the scope of the present invention without departing from the spirit and scope thereof.
Claims (9)
1. A TCP acceleration method based on Socket docking TOE driving is characterized in that a Socket module is dynamically replaced to enable the Socket to skip a linux kernel protocol stack and directly dock the TOE driving; the method comprises the following steps:
s1: adding an add_port interface, and storing a toe port into a toe list port;
s2: in the init process, dynamically replacing tcp_port with field_tcp_port through a hook function, and replacing inet_stream_ops structure with field_inet_stream_ops;
s3: comparing the current port with the toe port list in the fitoe_tcp_port and the fitoe_inet_stream_ops, judging whether the current port belongs to the toe port or not, and if so, turning to S4; otherwise, calling the original tcp_port and inet_stream_ops;
s4: the Driver transmits the data to the FPGA, and the FPGA processes the data packet of the multi-layer network protocol;
s5: the replaced tcp_port and inet_stream_ops structures are restored in the process of exit.
2. The TCP acceleration method of claim 1, wherein said linux kernel protocol comprises a TCP protocol and an IP protocol.
3. The TCP acceleration method based on Socket docking TOE driving of claim 1, wherein the Socket upper layer is an operating system API, and the Socket lower layer is directly opposite to the transport layer.
4. The TCP acceleration method based on Socket docking TOE driving according to claim 1, wherein the data stream sent by the TCP is as follows:
a1: the application layer adds the user data into the user header to generate application data, and sends the application data to the transport layer through the Socket layer tcp_sndmsg;
a2: the transport layer adds a TCP header of 20 bytes in the application data to generate a TCP segment, stores a 16bit port number, namely an identifier of the application program, in the TCP header, and then gives the data to the network layer;
a3: a network layer, which adds an IP header in the TCP segment to generate an IP datagram, wherein the IP header has a length of 20byte and comprises an 8bit protocol domain for identifying which layer the data belongs to, and the network layer transmits the data to a data link layer;
a4: and the data link layer adds an Ethernet header of 14 bytes and an Ethernet tail of 4 bytes in the IP datagram to generate an Ethernet frame, and finally the Ethernet frame is sent to a network by the FPGA through network card equipment.
5. The TCP acceleration method based on Socket docking TOE driving according to claim 1, wherein the data stream received by the TCP is as follows:
b1: the data link layer unpacks the Ethernet frame to obtain an IP datagram, and the IP datagram is delivered to the network layer;
b2: a network layer unpacking the IP datagram and transmitting the datagram to a transport layer through a protocol domain in an IP header;
b3: the transport layer unpacks the TCP segment and reports the data message to the application layer through a port number in a TCP header;
b4: and the application layer unpacks the user header to complete the control transmission of the data.
6. The TCP acceleration method based on Socket docking TOE driving according to claim 1, wherein the Socket processing procedure of the TCP is as follows:
c1: creating a socket;
c2: binding ip;
and C3: monitoring ports;
and C4: waiting for a client to connect;
c5: the client creates a socket;
c6: the client establishes a link with the server;
c7: the client sends data;
and C8: the data is transmitted to the server and received by the server;
c9: the server processes the received data;
c10: the server side sends data to the client side;
c11: the client breaks the link;
and C12: the broken link information is transmitted to a server;
c13: the service end breaks the chain.
7. The TCP acceleration method based on Socket docking TOE driving of claim 6, wherein the corresponding relations between Operating System API and Socket TCP API in the Socket processing of TCP are respectively: listen () corresponds to inet_Listen (), accept () corresponds to inet_ csk _accept (), connect () corresponds to itcp_v4_connect (), write () corresponds to tcp_sendmsg (), read () corresponds to tcp_recvmsg (), close () corresponds to tcp_close_bylock ().
8. The TCP acceleration method based on Socket docking TOE driving according to claim 3, 4 or 5, wherein the transport layer function network protocol stack function comprises: constructing a TCP header; calculating a checksum and a sequence number; transmitting an ack packet; sliding window.
9. The TCP acceleration method based on Socket docking TOE driving according to claim 4 or 5, wherein the network layer function network protocol stack function includes: routing, namely selecting the next hop; adding an IP header; calculating IP header checksum, which is used for detecting whether the ip message is in error in the transmission process; performing IP slicing; and acquiring the MAC address of the next hop, and transferring to link layer processing.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202110891464.6A CN113810370B (en) | 2021-08-04 | 2021-08-04 | TCP acceleration method based on Socket docking TOE drive |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202110891464.6A CN113810370B (en) | 2021-08-04 | 2021-08-04 | TCP acceleration method based on Socket docking TOE drive |
Publications (2)
| Publication Number | Publication Date |
|---|---|
| CN113810370A CN113810370A (en) | 2021-12-17 |
| CN113810370B true CN113810370B (en) | 2023-06-16 |
Family
ID=78893273
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202110891464.6A Active CN113810370B (en) | 2021-08-04 | 2021-08-04 | TCP acceleration method based on Socket docking TOE drive |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN113810370B (en) |
Families Citing this family (1)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN114285747B (en) * | 2021-12-24 | 2024-05-03 | 盛立安元科技(杭州)股份有限公司 | TCP data receiving method, device, equipment and storage medium |
Citations (1)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| TWI239734B (en) * | 2004-03-02 | 2005-09-11 | Ind Tech Res Inst | Full hardware based TCP/IP traffic offload engine (TOE) device and method thereof |
Family Cites Families (3)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| JP4875126B2 (en) * | 2002-06-06 | 2012-02-15 | エヌヴィディア コーポレイション | Gigabit Ethernet adapter supporting ISCSI and IPSEC protocols |
| CN108156172B (en) * | 2018-01-09 | 2020-03-17 | 四川九洲电器集团有限责任公司 | Method for receiving TCP data at high speed |
| US11537541B2 (en) * | 2018-09-28 | 2022-12-27 | Xilinx, Inc. | Network interface device and host processing device |
-
2021
- 2021-08-04 CN CN202110891464.6A patent/CN113810370B/en active Active
Patent Citations (1)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| TWI239734B (en) * | 2004-03-02 | 2005-09-11 | Ind Tech Res Inst | Full hardware based TCP/IP traffic offload engine (TOE) device and method thereof |
Also Published As
| Publication number | Publication date |
|---|---|
| CN113810370A (en) | 2021-12-17 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| US8009672B2 (en) | Apparatus and method of splitting a data stream over multiple transport control protocol/internet protocol (TCP/IP) connections | |
| US7685287B2 (en) | Method and system for layering an infinite request/reply data stream on finite, unidirectional, time-limited transports | |
| US8544025B2 (en) | Efficient data transfer on local network connections using a pseudo socket layer | |
| EP1892929A1 (en) | A method, an apparatus and a system for message transmission | |
| US9015822B2 (en) | Automatic invocation of DTN bundle protocol | |
| KR20010052198A (en) | Reduced racket header in wireless communications network | |
| US9197556B2 (en) | Communications over multiple protocol interfaces in a computing environment | |
| KR20020024962A (en) | Device for processing multi-layer packet | |
| US20090232137A1 (en) | System and Method for Enhancing TCP Large Send and Large Receive Offload Performance | |
| KR20040091731A (en) | Method of and system for multi-path communication | |
| US20040083288A1 (en) | Apparatus and method for receive transport protocol termination | |
| CN113810370B (en) | TCP acceleration method based on Socket docking TOE drive | |
| CN107508828B (en) | A kind of very-long-range data interaction system and method | |
| US8572245B1 (en) | Using the TCP window size for identifying packets and debugging | |
| Natarajan et al. | SCTP: What, why, and how | |
| CN102315918B (en) | Method and device for intercommunicating TCP (Transmission Control Protocol) connection with SCTP (Stream Control Transmission Protocol) connection | |
| EP1562115A2 (en) | Socket connections over a serial link | |
| JP4938134B2 (en) | Method and apparatus for communicating between multiple connection interfaces | |
| US20080056263A1 (en) | Efficient transport layer processing of incoming packets | |
| CN112667359B (en) | Data transparent transmission method, electronic equipment and storage medium | |
| CN111212088B (en) | RTP message forwarding method and device for accelerating speed increase of server | |
| CN113765799A (en) | Method for transmitting and receiving container message, storage medium and container communication system | |
| CN1293726C (en) | Method for implementing quick transmission of bridge data on network link | |
| US20190199833A1 (en) | Transmission device, method, program, and recording medium | |
| US20070055788A1 (en) | Method for forwarding network file system requests and responses between network segments |
Legal Events
| Date | Code | Title | Description |
|---|---|---|---|
| PB01 | Publication | ||
| PB01 | Publication | ||
| SE01 | Entry into force of request for substantive examination | ||
| SE01 | Entry into force of request for substantive examination | ||
| GR01 | Patent grant | ||
| GR01 | Patent grant | ||
| PE01 | Entry into force of the registration of the contract for pledge of patent right |
Denomination of invention: A TCP Acceleration Method Based on Socket Docking TOE Driver Effective date of registration: 20231013 Granted publication date: 20230616 Pledgee: Shanghai Rural Commercial Bank Co.,Ltd. Yangpu Sub branch Pledgor: FANGYI INFORMATION TECHNOLOGY (SHANGHAI) CO.,LTD. Registration number: Y2023310000642 |
|
| PE01 | Entry into force of the registration of the contract for pledge of patent right |