CN114816792A - Remote function calling method based on special channel - Google Patents
Remote function calling method based on special channel Download PDFInfo
- Publication number
- CN114816792A CN114816792A CN202210419234.4A CN202210419234A CN114816792A CN 114816792 A CN114816792 A CN 114816792A CN 202210419234 A CN202210419234 A CN 202210419234A CN 114816792 A CN114816792 A CN 114816792A
- Authority
- CN
- China
- Prior art keywords
- function
- remote
- data
- protocol
- server
- 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.)
- Granted
Links
- 238000000034 method Methods 0.000 title claims abstract description 66
- 238000004891 communication Methods 0.000 claims abstract description 52
- 230000005540 biological transmission Effects 0.000 claims abstract description 6
- 238000013500 data storage Methods 0.000 claims abstract description 4
- 230000006870 function Effects 0.000 claims description 221
- 238000012545 processing Methods 0.000 claims description 25
- 238000013461 design Methods 0.000 claims description 22
- 238000013507 mapping Methods 0.000 claims description 9
- 238000002360 preparation method Methods 0.000 claims description 9
- 238000012544 monitoring process Methods 0.000 claims description 6
- 230000001360 synchronised effect Effects 0.000 claims description 3
- 238000005516 engineering process Methods 0.000 claims 1
- 238000011161 development Methods 0.000 abstract description 7
- 238000004883 computer application Methods 0.000 abstract description 3
- 238000010586 diagram Methods 0.000 description 4
- 238000012986 modification Methods 0.000 description 2
- 230000004048 modification Effects 0.000 description 2
- 230000000694 effects Effects 0.000 description 1
Images
Classifications
-
- 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/46—Multiprogramming arrangements
- G06F9/54—Interprogram communication
- G06F9/546—Message passing systems or structures, e.g. queues
-
- 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/46—Multiprogramming arrangements
- G06F9/54—Interprogram communication
- G06F9/547—Remote procedure calls [RPC]; Web services
Landscapes
- Engineering & Computer Science (AREA)
- Software Systems (AREA)
- Theoretical Computer Science (AREA)
- Physics & Mathematics (AREA)
- General Engineering & Computer Science (AREA)
- General Physics & Mathematics (AREA)
- Computer And Data Communications (AREA)
Abstract
The invention relates to a remote function calling method based on a special channel, and belongs to the technical field of data storage. The method forms an independent remote function call dynamic library, and rapidly indexes a remote service set, distributes data and collects return function execution results through a hash table by remote call initiated by a thread pool high-performance scheduling application program, receives and transmits data by using different communication protocols through a stub function, and can add a new communication protocol, thereby providing complete function call, service registration and protocol replacement interfaces. The invention innovatively realizes the remote function calling method supporting multiple communication protocols, provides a standard program calling method while ensuring the data transmission efficiency, and simplifies the development process of multi-computer application programs.
Description
Technical Field
The invention belongs to the technical field of data storage, and particularly relates to a remote function calling method based on a special channel.
Background
Remote function calls are widely applied in multi-machine application program development, particularly in many large-scale cluster systems, and the remote function calls are usually realized through a communication module of an underlying standard. Many open-source remote function call frameworks exist, but most of the communication interfaces thereof use TCP/IP protocol or HTTP protocol of an application layer, and do not support customized protocol on a special channel. On a dedicated channel, in order to fit channel characteristics and obtain optimal performance, a user usually implements a specific communication protocol, which does not support a general SOCKET programming function on a TCP/IP protocol, so that a mainstream open-source remote function call framework cannot be used. The remote function call can not only improve the communication performance of the system, but also simplify the development process and shorten the development period, and is a common middleware in the cluster system programming. Therefore, the method for designing and researching a set of remote function calling method based on the special channel has great significance for developing a special system.
Disclosure of Invention
Technical problem to be solved
The technical problem to be solved by the invention is as follows: how to provide an underlying remote function call method for a dedicated channel that cannot be programmed using the general TCP/IP protocol and SOCKET.
(II) technical scheme
In order to solve the technical problem, the invention provides a remote function calling method based on a special channel, which comprises the following steps:
designing a remote function call dynamic library which can be used at a server and a client simultaneously, providing a function call interface and a callback function interface of the client, providing a registration service interface of the server, and providing a communication interface supporting different network protocols; the remote function call dynamic library is internally divided into an application layer, a processing layer and a communication layer, wherein the application layer is responsible for interacting with an external interface and forwarding data to the processing layer and receiving the data of the processing layer; the processing layer is responsible for data encoding, decoding and distribution, and decouples the work of the communication layer; the communication layer receives and transmits data according to the provided interface protocol;
second, a thread pool design method is provided
Firstly, initializing a flow, wherein a client establishes connection with a server through a specific protocol, the client establishes a corresponding number of threads according to the system hardware performance to form a thread pool, and waits for a function task to be awakened and executed, each thread holds one connection with the server, and each connection comprises handles of various protocols;
after the initialization of the thread pool is completed, the application program can initiate the call of a remote function, wherein the application program is allowed to be called in an asynchronous mode, the application program can return only by inputting function names, parameters and callback function information, the client side can pack and place the data into a function queue to be executed, all threads in the thread pool poll the function queue to be executed, and idle threads can take out and send the data to a server side;
finally, the thread sending the data can block the waiting server from returning, analyze the received data, call the corresponding callback function, and complete the remote function call;
thirdly, providing a Hash index service design method
The user registers the function service for the remote application program to call, i.e. writes the corresponding function processing code, and stores the function name in the remote service set;
after receiving a service registration request of a user, the server performs hash processing on a function name and parameter information, establishes a mapping relation between a hash value and a corresponding function call address, stores the mapping relation into a hash table, analyzes data if the server receives a remote call from a client to obtain the function name and the parameter information, finds a corresponding function to be executed by searching the hash table, and executes the corresponding function, obtains a return value and returns the return value to the client if the server obtains the function call address by searching the table; if the corresponding function is not found, returning error information which does not exist in remote calling;
the fourth step is to provide a design method of multiple communication protocols
Firstly, a user binds a function which completes a list, accept, connect, read and write function in a communication protocol with a stub function provided by a communication layer of a remote function call dynamic library, and then only a specified protocol library structural body is provided when the function is called, and the stub function can establish connection and transmit data by using a corresponding protocol; when the thread pool is initialized, connection information of multiple protocols can be provided, so that each thread has multiple connections, and the specified protocol method can be normally executed during function call;
step five, executing a server preparation process based on the step one, the step three and the step four;
a sixth step of executing a client preparation process based on the second step;
and seventhly, executing a remote function call flow based on the first step: after the client and the server finish the preparation process, the application program performs remote function call for any number of times on the basis, and executes the user task.
Preferably, the fifth step is specifically: firstly, a protocol library structure body is newly established according to a multi-communication protocol design method, mapping of all pile functions is completed, relevant data are stored in a communication layer of a remote function call dynamic library, codes of the step are provided by a user, the protocol library structure body records function addresses actually required to be called by each pile function, and then the real communication function can be called according to the introduced protocol library structure body to carry out data transmission when the pile function is called; then, starting a monitoring thread of the server, calling a list pile function by the thread, and monitoring a communication port according to a specified protocol; after a request of a client is monitored, calling an accept stub function to establish connection, and establishing a new thread to process reading and writing on the connection; finally, the user registers all externally provided function services in an application layer of the remote function call dynamic library, hash is carried out on the function name and the parameter provided by the user according to a hash index service design method, the function name and the parameter are bound with the function address of the finally provided service and stored in a hash table, and therefore the work of the service end is completed, a new protocol can be added through creating a new protocol library structure body subsequently, and a remote service set can be perfected through continuously registering new function services.
Preferably, the sixth step is specifically: when a network node provides remote function call service, other nodes in the same network can start a client program to access the service on the remote node; the client also creates a protocol library structure body so as to receive and transmit data according to the specified protocol, initializes the thread pool according to the thread pool design method, transmits the structure information of various protocols at the moment, and establishes connection with the server through various protocols.
Preferably, the flow of the single remote function call in the seventh step is as follows:
the client interacts with an application layer of the remote function call dynamic library, transmits a function name, parameters and a protocol library structure body into a communication layer of the remote function call dynamic library by using an rpc _ call function, and blocks the function from returning; or asynchronously calling a remote function through a sync _ rpc _ call function, and additionally transmitting a callback function during asynchronous calling so that the remote function calling dynamic library is executed after the remote calling is completed; the information of the application program is transmitted into an application layer of a remote function call dynamic library and then a task is transferred to a processing layer, namely, data is stored into a function queue to be executed, and an idle thread in a thread pool is waited to be taken out and is transmitted to a server through a connection channel special for the thread; after receiving the data, the server analyzes the subsequent function parameter data with indefinite length according to the parameter length; after receiving and analyzing all data at the server, searching a function to be executed by a remote node through a hash table, transmitting corresponding parameters and acquiring a function execution result; and finally, returning the execution result of the function through the connection channel established by the client, calling a callback function if the client is in an asynchronous mode, and returning the execution result of the server if the client is in a synchronous mode.
Preferably, the multi-communication protocol design method proposed in the fourth step realizes support for the dedicated channel and the dedicated protocol thereof, is compatible with the common TCP/IP protocol, and can add a new protocol, and the multi-protocol works simultaneously.
Preferably, it is characterized in that system performance can be optimized at the client by using a thread pool.
Preferably, the data distribution process can be accelerated by using the hash table at the server.
Preferably, in the seventh step, the data delivered to the server is encapsulated in a specific structure.
Preferably, the specific structure is a structure including: the RPC version, the domain name, the function name, the parameter length and the function parameter data.
The invention also provides an application of the method in the technical field of data storage.
(III) advantageous effects
The method forms an independent remote function call dynamic library, and rapidly indexes a remote service set, distributes data and collects return function execution results through a hash table by remote call initiated by a thread pool high-performance scheduling application program, receives and transmits data by using different communication protocols through a stub function, and can add a new communication protocol, thereby providing complete function call, service registration and protocol replacement interfaces. The invention innovatively realizes the remote function calling method supporting multiple communication protocols, provides a standard program calling method while ensuring the data transmission efficiency, and simplifies the development process of multi-computer application programs.
Drawings
FIG. 1 is a diagram of a remote function call dynamic library architecture in the present invention;
FIG. 2 is a diagram of the data structure and processing flow associated with a thread pool in the present invention;
FIG. 3 is a diagram of multiple communication protocol calls in the present invention;
fig. 4 is a diagram illustrating a packet format according to the present invention.
Detailed Description
In order to make the objects, contents, and advantages of the present invention clearer, the following detailed description of the embodiments of the present invention will be made in conjunction with the accompanying drawings and examples.
In order to simplify the development process of a special system, improve the development efficiency of an upper layer cluster system and improve the data read-write performance, the invention designs a set of remote function calling method based on a special channel. The method aims to provide a bottom-layer remote function calling method for a special channel which cannot be programmed by using a general TCP/IP protocol and SOCKET. According to the method, an independent remote function call dynamic library is formed, remote call initiated by a thread pool high-performance scheduling application program is used, a hash table is used for quickly indexing a remote service set, distributing data and collecting a return function execution result, different communication protocols are used for receiving and sending data through a stub function, a new communication protocol can be added, and therefore complete function call, service registration and protocol replacement interfaces are provided for the outside. The invention innovatively realizes the remote function calling method supporting multiple communication protocols, provides a standard program calling method while ensuring the data transmission efficiency, and simplifies the development process of multi-computer application programs.
As shown in fig. 1, the remote function call method based on dedicated channel proposed by the present invention includes the following steps:
designing a remote function call dynamic library which can be used at a server and a client simultaneously, providing a function call interface and a callback function interface of the client, providing a registration service interface of the server simultaneously, and providing a communication interface supporting different network protocols as the most important point; the interior of the whole remote function call dynamic library is divided into an application layer, a processing layer and a communication layer, wherein the application layer is responsible for interacting with an external interface and forwarding data to the processing layer and receiving the data of the processing layer; the processing layer is responsible for high-performance data encoding, decoding and distribution, and the work of the communication layer is decoupled; the communication layer receives and transmits data according to the provided interface protocol.
Second, a high-performance thread pool design method is provided
The invention optimizes the system performance at the client by mainly using the thread pool, and FIG. 2 depicts the data structure and processing flow related to the thread pool, which is mainly divided into three parts of initialization, function execution and return value processing.
Specifically, the high-performance thread pool design method comprises the following steps:
firstly, initializing a flow, establishing connection between a client and a server through a specific protocol, establishing a corresponding number of threads by the client according to system hardware performance (information such as a CPU core, a memory and the like) to form a thread pool, waiting for awakening and executing a function task, wherein each thread holds a connection with the server, and each connection comprises handles of various protocols;
after the initialization of the thread pool is completed, the application program can initiate the call of the remote function, wherein the invention allows the application program to adopt an asynchronous mode for calling, the application program can return only by introducing function names, parameters and callback function information, the client side can pack and place the data into the function queue to be executed, all threads in the thread pool poll the function queue to be executed, and the idle thread can take out and send the data to the server side.
And finally, the thread sending the data blocks the waiting server to return, analyzes the received data, and calls a corresponding callback function to complete the remote function call.
Thirdly, providing a Hash index service design method
The invention accelerates the data distribution process at the server side mainly by using the hash table, thereby improving the data processing performance. A user firstly needs to register a function service for a remote application program to call, namely, a corresponding function processing code is compiled, and a function name is stored in a remote service set;
after receiving a service registration request of a user, the server performs hash processing on a function name and parameter information, establishes a mapping relation between a hash value and a corresponding function call address, stores the mapping relation into a hash table, analyzes data if the server receives a remote call from a client to obtain the function name and the parameter information, finds a corresponding function to be executed by searching the hash table, and executes the corresponding function, obtains a return value and returns the return value to the client if the server obtains the function call address by searching the table; and if the corresponding function is not found, returning error information which does not exist in the remote call.
The fourth step is to provide a design method of multiple communication protocols
The invention realizes the support of the special channel and the special protocol thereof, is compatible with the common TCP/IP protocol, can add a new protocol, and can simultaneously work a plurality of protocols.
As shown in fig. 3, firstly, a user needs to bind a function that completes a list, accept, connect, read, and write function in a communication protocol with a stub function provided by a communication layer of a remote function call dynamic library, and then only needs to provide a specified protocol library structure body when calling, and the stub function will establish connection and transmit data by using a corresponding protocol; when the thread pool is initialized, connection information of multiple protocols can be provided, so that each thread holds multiple connections, and the specified protocol method can be normally executed during function call.
Step five, executing the preparation process of the server based on the first step, the third step and the fourth step
Firstly, a protocol library structure is newly established according to a multi-communication protocol design method, mapping of all stub functions is completed, and relevant data are stored in a communication layer of a remote function call dynamic library. The main code of the step is provided by a user, and the protocol library structure body records the function address which is actually required to be called by each stub function. And then when the stub function is called, the real communication function can be called according to the introduced protocol library structure body for data transmission. And then, starting a monitoring thread of the server, calling a list stub function by the thread, and monitoring the communication port according to a specified protocol. After the request of the client is monitored, an accept stub function is called to establish connection, and a new thread is established to process reading and writing on the connection. Finally, the user needs to register all externally provided function services in the application layer of the remote function call dynamic library. The operation hashes the function name and the parameter provided by the user according to a hash index service design method, and binds the function name and the parameter with the function address of the final service provided and stores the function address into a hash table. The work of the server is completed, and a new protocol can be added by creating a new protocol library structure body subsequently, or a remote service set can be perfected by continuously registering new function services.
A sixth step of executing a client preparation process based on the second step
When a node provides remote function call services, other nodes in the same network may initiate client programs to access the services on the remote node. The client also needs to create a new protocol library structure for receiving and transmitting data according to the specified protocol. And then the client initializes the thread pool according to a high-performance thread pool design method, and at the moment, the structure information of various protocols can be transmitted, so that the connection with the server is established through various protocols. If a connection for a particular protocol is not established at this stage, then remote function calls cannot be subsequently made using the relevant protocol.
A seventh step of executing a remote function call flow based on the first step
After the client and the server complete the preparation process, the application program can perform remote function call for any number of times on the basis, and execute user tasks. The single remote function call flow is as follows:
the client only needs to interact with an application layer of the remote function call dynamic library, function names, parameters and a protocol library structural body are transmitted into a communication layer of the remote function call dynamic library by using an rpc _ call function, and the function return waiting is blocked; remote functions can also be asynchronously called through the sync _ rpc _ call function, and the asynchronous call requires an additional incoming callback function so that the remote function calls the dynamic library to execute after the remote call is completed. And after the information of the application program is transmitted into an application layer of a remote function call dynamic library, the task is transferred to a processing layer, namely, data is stored into a function queue to be executed, and an idle thread in a waiting thread pool is taken out and is transmitted to a server through a connection channel special for the thread. The transferred data is encapsulated by the structure shown in fig. 4, and the server can analyze the subsequent function parameter data with indefinite length according to the parameter length after receiving the data. After the server receives and analyzes all the data, the function which needs to be executed by the remote node is found through the hash table, corresponding parameters are transmitted, and a function execution result is obtained. And finally, returning the execution result of the function through the connection channel established by the client, calling a callback function if the client is in an asynchronous mode, and returning the execution result of the server if the client is in a synchronous mode.
The above description is only a preferred embodiment of the present invention, and it should be noted that, for those skilled in the art, several modifications and variations can be made without departing from the technical principle of the present invention, and these modifications and variations should also be regarded as the protection scope of the present invention.
Claims (10)
1. A remote function calling method based on a dedicated channel is characterized by comprising the following steps:
designing a remote function call dynamic library which can be used at a server and a client simultaneously, providing a function call interface and a callback function interface of the client, providing a registration service interface of the server, and providing a communication interface supporting different network protocols; the remote function call dynamic library is internally divided into an application layer, a processing layer and a communication layer, wherein the application layer is responsible for interacting with an external interface and forwarding data to the processing layer and receiving the data of the processing layer; the processing layer is responsible for data encoding, decoding and distribution, and decouples the work of the communication layer; the communication layer receives and transmits data according to the provided interface protocol;
second, a thread pool design method is provided
Firstly, initializing a flow, establishing connection between a client and a server through a specific protocol, establishing a corresponding number of threads by the client according to the system hardware performance, forming a thread pool, waiting for awakening and executing a function task, wherein each thread holds a connection with the server, and each connection comprises handles of various protocols;
after the initialization of the thread pool is completed, the application program can initiate the call of a remote function, wherein the application program is allowed to be called in an asynchronous mode, the application program can return only by inputting function names, parameters and callback function information, the client side can pack and place the data into a function queue to be executed, all threads in the thread pool poll the function queue to be executed, and idle threads can take out and send the data to a server side;
finally, the thread sending the data can block the waiting server from returning, analyze the received data, call the corresponding callback function, and complete the remote function call;
thirdly, providing a Hash index service design method
The user registers the function service for the remote application program to call, i.e. writes the corresponding function processing code, and stores the function name in the remote service set;
after receiving a service registration request of a user, the server performs hash processing on a function name and parameter information, establishes a mapping relation between a hash value and a corresponding function call address, stores the mapping relation into a hash table, analyzes data if the server receives a remote call from a client to obtain the function name and the parameter information, finds a corresponding function to be executed by searching the hash table, and executes the corresponding function, obtains a return value and returns the return value to the client if the server obtains the function call address by searching the table; if the corresponding function is not found, returning error information which does not exist in remote calling;
the fourth step is to provide a design method of multiple communication protocols
Firstly, a user binds a function which completes a list, accept, connect, read and write function in a communication protocol with a stub function provided by a communication layer of a remote function call dynamic library, and then only a specified protocol library structural body is provided when the function is called, and the stub function can establish connection and transmit data by using a corresponding protocol; when the thread pool is initialized, connection information of multiple protocols can be provided, so that each thread has multiple connections, and the specified protocol method can be normally executed during function call;
step five, executing a server preparation process based on the step one, the step three and the step four;
a sixth step of executing a client preparation process based on the second step;
and seventhly, executing a remote function call flow based on the first step: after the client and the server finish the preparation process, the application program performs remote function call for any number of times on the basis, and executes the user task.
2. The method of claim 1, wherein the fifth step is specifically: firstly, a protocol library structure body is newly established according to a multi-communication protocol design method, mapping of all pile functions is completed, relevant data are stored in a communication layer of a remote function call dynamic library, codes of the step are provided by a user, the protocol library structure body records function addresses actually required to be called by each pile function, and then the real communication function can be called according to the introduced protocol library structure body to carry out data transmission when the pile function is called; then, starting a monitoring thread of the server, calling a list pile function by the thread, and monitoring a communication port according to a specified protocol; after a request of a client is monitored, calling an accept stub function to establish connection, and establishing a new thread to process reading and writing on the connection; finally, the user registers all externally provided function services in an application layer of the remote function call dynamic library, hash is carried out on the function name and the parameter provided by the user according to a hash index service design method, the function name and the parameter are bound with the function address of the finally provided service and stored in a hash table, and therefore the work of the service end is completed, a new protocol can be added through creating a new protocol library structure body subsequently, and a remote service set can be perfected through continuously registering new function services.
3. The method according to claim 2, characterized in that the sixth step is in particular: when a network node provides remote function call service, other nodes in the same network can start a client program to access the service on the remote node; the client also creates a protocol library structure body for receiving and sending data according to the specified protocol, initializes the thread pool according to the thread pool design method, and transmits the structure information of various protocols, so as to establish connection with the server through various protocols.
4. The method of claim 3, wherein the flow of the single remote function call in the seventh step is as follows:
the client interacts with an application layer of the remote function call dynamic library, transmits a function name, parameters and a protocol library structure body into a communication layer of the remote function call dynamic library by using an rpc _ call function, and blocks the function from returning; or asynchronously calling a remote function through a sync _ rpc _ call function, and additionally transmitting a callback function during asynchronous calling so that the remote function calling dynamic library is executed after the remote calling is completed; the information of the application program is transmitted into an application layer of a remote function call dynamic library and then a task is transferred to a processing layer, namely, data is stored into a function queue to be executed, and an idle thread in a thread pool is waited to be taken out and is transmitted to a server through a connection channel special for the thread; after receiving the data, the server analyzes the subsequent function parameter data with indefinite length according to the parameter length; after receiving and analyzing all data at the server, searching a function to be executed by a remote node through a hash table, transmitting corresponding parameters and acquiring a function execution result; and finally, returning the execution result of the function through the connection channel established by the client, calling a callback function if the client is in an asynchronous mode, and returning the execution result of the server if the client is in a synchronous mode.
5. The method according to any of claims 1 to 4, wherein the multi-communication protocol design method proposed in the fourth step implements support for the dedicated channel and its dedicated protocol, and is compatible with the common TCP/IP protocol, and a new protocol can be added, and the multi-protocols work simultaneously.
6. The method of any of claims 1 to 4, wherein system performance can be optimized at the client by using a thread pool.
7. The method according to any one of claims 1 to 4, wherein the data distribution flow can be accelerated at the server by using a hash table.
8. The method as claimed in claim 4, wherein in the seventh step, the data delivered to the server is encapsulated in a specific structure.
9. The method of claim 8, wherein the particular structure is a structure comprising: RPC version, domain name, function name, parameter length, and function parameter data.
10. Use of the method according to any one of claims 1 to 9 in the field of data storage technology.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202210419234.4A CN114816792B (en) | 2022-04-20 | 2022-04-20 | Remote function calling method based on special channel |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202210419234.4A CN114816792B (en) | 2022-04-20 | 2022-04-20 | Remote function calling method based on special channel |
Publications (2)
| Publication Number | Publication Date |
|---|---|
| CN114816792A true CN114816792A (en) | 2022-07-29 |
| CN114816792B CN114816792B (en) | 2024-04-09 |
Family
ID=82506108
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202210419234.4A Active CN114816792B (en) | 2022-04-20 | 2022-04-20 | Remote function calling method based on special channel |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN114816792B (en) |
Cited By (1)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN116506523A (en) * | 2023-06-21 | 2023-07-28 | 之江实验室 | Unified communication method suitable for multiple protocols |
Citations (5)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| WO2003036464A2 (en) * | 2001-10-22 | 2003-05-01 | Sun Microsystems, Inc. | Inter-process communication using different programming languages |
| US6721941B1 (en) * | 1996-08-27 | 2004-04-13 | Compuware Corporation | Collection of timing and coverage data through a debugging interface |
| CN105721473A (en) * | 2016-02-24 | 2016-06-29 | 锐达互动科技股份有限公司 | WEB side remote invoking optimizing method and system |
| CN108804238A (en) * | 2018-03-29 | 2018-11-13 | 中国工程物理研究院计算机应用研究所 | A kind of flexible bus communication means based on remote procedure call |
| CN111597061A (en) * | 2020-05-25 | 2020-08-28 | 瑞斯康达科技发展股份有限公司 | Method and device for remote procedure call of client or server |
-
2022
- 2022-04-20 CN CN202210419234.4A patent/CN114816792B/en active Active
Patent Citations (5)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US6721941B1 (en) * | 1996-08-27 | 2004-04-13 | Compuware Corporation | Collection of timing and coverage data through a debugging interface |
| WO2003036464A2 (en) * | 2001-10-22 | 2003-05-01 | Sun Microsystems, Inc. | Inter-process communication using different programming languages |
| CN105721473A (en) * | 2016-02-24 | 2016-06-29 | 锐达互动科技股份有限公司 | WEB side remote invoking optimizing method and system |
| CN108804238A (en) * | 2018-03-29 | 2018-11-13 | 中国工程物理研究院计算机应用研究所 | A kind of flexible bus communication means based on remote procedure call |
| CN111597061A (en) * | 2020-05-25 | 2020-08-28 | 瑞斯康达科技发展股份有限公司 | Method and device for remote procedure call of client or server |
Non-Patent Citations (2)
| Title |
|---|
| 吕回;: "基于函数截获的、面向图形应用的远程交互分布式设备框架", 计算机应用与软件, no. 09, 15 September 2010 (2010-09-15) * |
| 吴清寿;: "基于Proxy模式的远程处理框架研究", 长江大学学报(自科版), no. 19, 5 July 2013 (2013-07-05) * |
Cited By (2)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN116506523A (en) * | 2023-06-21 | 2023-07-28 | 之江实验室 | Unified communication method suitable for multiple protocols |
| CN116506523B (en) * | 2023-06-21 | 2023-09-19 | 之江实验室 | Unified communication method suitable for multiple protocols |
Also Published As
| Publication number | Publication date |
|---|---|
| CN114816792B (en) | 2024-04-09 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| Neira‐Ayuso et al. | Communicating between the kernel and user‐space in Linux using Netlink sockets | |
| US20050193056A1 (en) | Message transfer using multiplexed connections in an open system interconnection transaction processing environment | |
| US5848234A (en) | Object procedure messaging facility | |
| US8589885B2 (en) | Debugger launch and attach on compute clusters | |
| US20040068479A1 (en) | Exploiting asynchronous access to database operations | |
| CN103116520B (en) | Method based on the remote procedure call of TCP/ UDP | |
| US20030028515A1 (en) | Proxy processing method | |
| CN110134534B (en) | System and method for optimizing message processing for big data distributed system based on NIO | |
| JP2000500940A (en) | Registry communication middleware | |
| EP0414624A2 (en) | System for calling procedures on a remote network node | |
| CN102523225A (en) | Decoupling method in distributed loosely-coupled framework and distributed loosely-coupled framework platform | |
| CN102591726A (en) | Multiprocess communication method | |
| US20070130574A1 (en) | Method and system for event-based remote procedure call implementation in a distributed computing system | |
| JP2004530194A (en) | Method and bridge for combining servers and clients of different object types | |
| US20130046900A1 (en) | Dynamic transaction protocol upgrades | |
| CN106412009A (en) | Interface calling method and device | |
| WO2001093038A2 (en) | Scalable java servers for network server applications | |
| CN114816792A (en) | Remote function calling method based on special channel | |
| EP1246059B1 (en) | Dynamic interface aggregation on demand | |
| US7010609B1 (en) | System and method for adding transport protocols in distributed middleware applications | |
| CN112887356A (en) | System for sharing memory data distribution service and operation method thereof | |
| CA2248634C (en) | Common connector framework | |
| US6839732B1 (en) | Efficient use of domain socket pairs in communication for tightly coupled transactions | |
| CN108365976B (en) | Network service optimization method and device | |
| US20030202522A1 (en) | System for concurrent distributed processing in multiple finite state machines |
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 |