JP2003114805A - Information processing unit and method - Google Patents

Abstract

PROBLEM TO BE SOLVED: To implement a remote procedure call (RPC) mechanism capable of operating in a constrained memory size in response to procedure methods of blocking call and non-blocking call. SOLUTION: Each RPC client stub corresponding to a function call procedure of each of blocking call or non-blocking call is provided. An RPC client task commonly used for a plurality of RPCs is provided at a client side of the RPC, and a RPC server task commonly used for a plurality of RPCs in the same manner as above is proved at a server side of the RPC. In non-blocking call, the RPC client task calls for call back function based on the result of RPC's performance. In blocking call, it returns the performance result to the RPC client stub.

Description

Detailed Description of the Invention

[0001]

TECHNICAL FIELD The present invention relates to a plurality of CPUs (processing units).
The process executed by the first CPU is composed of
The present invention relates to an information report processing device and method having a function of calling a process executed in 1.

[0002]

2. Description of the Related Art Processing for realizing a certain function is performed by multiple CPUs.
There are many examples of execution in (processing unit). These are mainly distributed processing (DCE: Distributed Computing Env.
It is used in the field of ironment) and its purpose is to distribute the processing load to multiple CPUs, or to use a CPU that specially performs high-speed specific processing from other CPUs connected via a network. is there. RPC (Remote Procedure Call) is a central means for realizing this distributed processing, and is a mechanism for calling a function executed by another CPU (Remote) between different CPUs. IETF (Internet E
ngineering Task Force) document RFC 1831 (RPC:
Remote Procedure Call Protocol Specification Versi
on 2. R.). The data related to RPC transmitted between CPUs has a common format called XDR so that functions can be called across CPUs even when the instruction set differs depending on the CPUs. XDR is RFC1832 (XDR: External Data Representation
Default).

[0003]

The conventional RPC has been used between CPUs operating the same type of OS. Therefore, the procedure for calling a function was the same between CPUs. However, when the type of OS is different, the usage of the function may be different, and it is difficult to apply RPC between different OSs. In particular, there are types of blocking call and non-blocking call, which will be described later in the embodiments, as the method for calling a function. In the past, the main application destinations of distributed processing were workstations and servers, and an environment in which resources such as memory could be abundantly used. On the other hand, the memory capacity that can be used is limited in the embedded OS installed in small information processing devices such as mobile phones. Traditional RPC
Then, one server task was sequentially generated and processed for one function procedure. However, in embedded devices, it is generally common to dynamically allocate memory as needed to generate a process. I want to avoid it.

As described above, the conventional RPC mechanism cannot handle the difference between the blocking call and the non-blocking call, and it is difficult to operate with a limited memory capacity. The object of the present invention is to solve these problems. is there.

[0005]

The above-mentioned problems can be solved by providing the following means. Provide each RPC client stub corresponding to each function calling procedure method of blocking call and non-blocking call. The RPC requesting task calls the RPC client stub of the function to be processed by RPC. One RPC client task that is commonly used for multiple RPCs is provided on the client side of RPC. The RPC client task is R
The request message (argument parameter) from the PC client stub is queued and processed sequentially. The RPC client task transmits a request message (argument parameter) to the RPC server task operating on another CPU.
The RPC server task executes a function based on the request message to the C
Execute on PU and return the execution result to RPC client task. In the case of a non-blocking call, the RPC client task calls a callback function based on the execution result. In the case of a blocking call, the execution result is returned to the RPC client stub.

[0006]

BEST MODE FOR CARRYING OUT THE INVENTION An embodiment in which the present invention is applied to a mobile phone will be described below. (System Configuration) FIG. 1 is a diagram for explaining a mobile phone having two CPUs. In FIG. 1, 1 is a mobile phone, 10a
Is CPU-A that mainly controls the protocol of the telephone, 10b is CPU-B that mainly performs the processing of applications, 11 is the telephone line section that performs processing such as sending and receiving telephone calls, 12 is an antenna, 13
a and 13b are display units, 14 is an input unit, 15a and 15b are storage units for storing data, 16a and 16b are speakers, 17 is a microphone, and 18a and 1a.
8b is an RPC (Remo
te Procedure Call) section, 19 is an I / F section between CPUs that physically connects two CPUs.

The CPU-A (10a) mainly performs processing relating to wireless communication in the mobile phone 1. The CPU-B (10b) mainly performs processing related to mobile phone applications (Web browser, mailer, chat client, still image, moving image pickup or reproduction). Display 13a on the CPU-A (10a) side
Is a small liquid crystal display device provided on the back surface of the mobile phone, and displays the time, the telephone number of the sender of the incoming call, the mail address, and the like. The display unit 13b on the CPU-B (10b) side is a large-sized color liquid crystal display device and displays a page screen of a Web browser, a moving image, a reproduction screen of a still image, and the like. further,
When the mobile phone 1 is on standby, CPU-B is used to reduce power consumption.
Stop the operation of (10b) and press C when receiving a call or operating a mobile phone.
Start up PU-B (19b) and perform necessary processing. CPU-A (10a) and C
PU-B (10b) is different in CPU type and instruction set is not compatible. For reference, one conventional CPU (20)
FIG. 2 shows the system configuration of the mobile phone configured as described above. twenty one
Is a telephone line section for performing processing such as transmission / reception of a telephone, 22 is an antenna, 23 is a display section, 24 is an input section, 25 is a storage section for storing data, 26 is a speaker, and 27 is a microphone.

(Application of RPC) Mobile phone 1 in this embodiment
Is characterized by including two CPUs 18a and 18b, and an inter-CPU I / F unit 19 and RPC units 18a and 18b in order to perform communication between the CPUs. The inter-CPU I / F unit 19 is a storage device such as a memory. The RPC parts 18a and 18b are parts for enabling procedural function calls between different CPUs. CP
Transferring data between CPUs by allowing U to call functions that execute on other CPUs,
Event notification, processing request, etc. can be performed.

(General Description of Blocking Type Function and Non-blocking Type Function) Generally, functions can be classified into two types: blocking type functions and non-blocking type functions. When you use a blocking function, the process that called the function stops and blocks until the function returns an execution result. On the other hand, the non-blocking function returns the call result of the function immediately, and the execution result itself of the function is later notified to the calling process.
Therefore, the calling process can continue the processing between the calling time and the execution result notification time, and the function processing and the process execution can be performed asynchronously.
In the case of a non-blocking type function, the processing result of the function is generally returned using a callback function. A callback function is a function provided by the calling process when the processing of the called function is completed by passing the address of the second function as a parameter when the function is called.
You can call two functions. A function executed from the called function at this time is called a callback function.

(RPC Processing Method) Hereinafter, with respect to the RPC units 18a and 18b, a method of calling a blocking type function and a non-blocking type function between different CPUs will be described.

(Processing of Non-blocking Function) A method of calling a non-blocking function will be described with reference to FIGS.

(Processing configuration of non-blocking type function)
3 is the application 104 running on the CPU-A 10a, C
It is a block diagram explaining the method of calling the non-blocking function 105 which operates in PU-B 10b across CPUs.
In FIG. 3, description of each block to which the same numbers as in FIG. 1 are added will be omitted. 101 and 103 are modules for performing inter-CPU communication called client stub and server stub, 102 is a callback function for making a callback, and 104 is a non-blocking type function work_nb
() An application program (function) that calls (105), and 105 is a non-blocking type function work_nb (). Also, the communication between the CPUs is bidirectional, and the RPC units 18a and 18b are
The side that issues the request is the client (the side that calls the function), and the side that receives the request is the server (the side that processes the function). In order to realize this, the RPC units 18a and 18b are composed of RPC clients 181a and 181b and RPC servers 182a and 182b. 1811
Reference characters a and 1811b are transmission monitoring units included in the RPC clients 181a and 181b and perform error control and the like. 1821a, 1821b
Is a Dispatcher included in the RPC server, analyzes requests from the RPC clients 182a and 182b, and calls the target server stub 103. 1011 is a data conversion unit that converts data to a common format (XDR: External Data Representation) to make data compatible between different CPUs, and 1021 is a data recovery unit that restores the data converted by the previous data conversion unit 1011. is there.

The modules 104, 105, 181, and 182 are tasks that operate on the real-time multitasking OS. Communication between each task is message communication between tasks supported by the real-time OS. Furthermore, CPU-A (10a)
And CPU-B (10b), the type of real-time OS is different. Message client stub 101 is application 104
Function that is called from the task of, callback 102
Is a function process called from the RPC client 181, and the server stub 103 is a function process called from the RPC server 182.

(Non-blocking Function Processing Sequence) FIG. 4 shows an application 10 operating on the CPU-A 10a.
4 is a non-blocking function work_n that runs on CPU-B 10b
It is a sequence diagram explaining the method of calling b () remotely. Application 104 uses the non-blocking function work_nb () on the other CPU-B (10b) side for the same CPU-A (10a)
Call with the same normal procedure as the function on the side (S10 in Fig. 4
1). The client stub 101 is the application 104
Converts the argument set in work_nb () into the XDR format (S102 in FIG. 4) and uses the API function rpcMsgSendNB () provided by the RPC client 181a to execute the RPC client 181.
to a (S103 in FIG. 4). The API function rpcMsgSendNB ()
The process is to send the argument data converted in S102 to the RPC client 181a, and then retur to the client stub 101.
n (S104 in FIG. 4), and then return to the application 104.
(S105 in FIG. 4). Upon receiving the argument data, the RPC client 181a adds a header shown in FIG. 5 described later to the argument data and creates a message to be sent to the CPU-B (10).

In this embodiment, there are only 104 applications for the sake of simplicity, but there are usually a plurality of applications. If the processing request message (function argument) of the function in the CPU-B (10b) is sent to the RPC client 181a from multiple applications in S103, the processing request message (function) is sent to the queue provided by the RPC client 181a. ) Is queued. The RPC client 181a sequentially processes the queued requests. If a message with priority designation is received, the message with priority designation is given priority and processed. Further, in the priority designation, it is possible to postpone the processing request message requested earlier in time, and to discard it, which is described in the message.
This is used when there is a request for urgent processing such as error processing in a mobile phone, which is to postpone or discard the processing request message requested earlier in time.

The RPC client 181a sends a message (request
Send RPC header + argument data) 300 to CPU I / F section 19
(S106 in FIG. 4). After transmitting the message, the RPC client 181a performs transmission monitoring (S107 in FIG. 4) and performs error processing at the time of transmission failure and timeout processing such as return value not returning. The error notification at this time uses the callback function callback () provided by the application 104 (S122a in FIG. 4). Callback function callback ().
Returns an error notification as a return value to the application 104 that called work_nb () (S123a in FIG. 4).

The inter-CPU I / F unit 19 receives the message (request RPC header + argument data) 300, and then the message (request RPC header
The RPC server 182b is notified that the header + argument data) has been received (S108 in FIG. 4). The RPC server 182b that received the notification
Acquires a message (request RPC header + argument data) stored in a predetermined area (S109 in FIG. 4). RPC server 1
The 82b refers to the request RPC header from the acquired message (request RPC header + argument data) and identifies the server stub 103 corresponding to the function to be executed from the procedure code of the request RPC header (see FIG. 4). S110), server
The argument data is transmitted to the stub 103 (S111 in FIG. 4). Upon receiving the argument data, the server stub 103 restores the XDR format data into a format executable by the CPU-B (19b) (see FIG. 4).
S112) Create an argument for the function work_nb () 105 (S11 in FIG. 4
3). The server stub 103 uses the created argument as the function wor.
It is set as an argument of k_nb () 105, and the function work_nb () 105 is called (S114 in FIG. 4). The function work_nb () 105 executes a predetermined process (S115 in FIG. 4), and then returns the execution result to the server stub 103 (S116 in FIG. 4). Server stub 103
Converts the received execution result into the XDR data format (S117 in FIG. 4) and sends it to the RPC server 182b (S11 in FIG. 4).
8).

Upon receiving the execution result data, the RPC server 182b adds a header to the execution result data and creates a message to be sent to the CPU-A 10a, as described later with reference to FIG. Then, the RPC server 182b sends the message (response RP
(C header + execution result data) 320 is transmitted to the inter-CPU I / F unit 19 (S119 in FIG. 4). The I / F unit 19 between the CPUs displays the message (response RPC
After receiving (header + execution result data) 320, message
Receiving (response RPC header + execution result data) 320
Notify the RPC client 181a (S120 in FIG. 4). Upon receiving the notification, the RPC client 181a receives the message (response RPC header + execution result data) stored in a predetermined area.
Is acquired (S121 in FIG. 4). And the RPC client 181a
Cuts the response RPC header from the message (response RPC header + execution result data). Here, after performing a predetermined error check process, the callback function callback () provided by the application 104 is called (see FIG. 4).
S122b). The callback function callback () restores the execution result data in XDR format to a format that can be executed by the CPU-A (10a) (S124 in FIG. 4), and for the application 104 that called the function work_nb (), The restored execution result is returned as a return value (S123b in FIG. 4). In the above explanation, CPU-A
Although it has been described that the function execution request is issued from (10a) to the CPU-B (10b), the same procedure can be performed in the opposite way.

(Data structure of RPC message) CPU described above
The data structure of the request message 300 and the response message 320 transmitted / received by the inter-interface unit 19 will be described. 5 different
It is a figure explaining the request message (request RPC header + argument data) 300 which RPC exchanges between CPUs. In FIG. 5, 30 is a request RPC header composed of control information, and 31 is S10.
This is a parameter cell that stores the data received in 3 (mainly the argument to the function to be executed). In this embodiment,
The request RPC header 30 is composed of five pieces of control information. 301 is XI
An ID for identifying a message called D, which is used to specify the request message 300 and a response message 320 described later, 302 is a control code indicating whether the message is a request or a response, and 303 is a remotely called function. It is a procedure code that is an arbitrary number given to each and identifies the function to be executed. 304 is the byte length of the parameter cell storing the argument data, and 305 is a spare.

FIG. 6 is a diagram for explaining a response message (response RPC header + argument data) 320 exchanged by RPCs between different CPUs. In FIG. 6, 32 is a response RPC header composed of control information, and 33 is a return cell for storing the data received by the RPC server 182b in S118 of FIG. 4 (mainly the execution result of the executed function). In this embodiment, the response RPC header 32 is composed of five pieces of control information. 321 is an ID for identifying a message called XID, which is used to specify the request message 300 corresponding to the response message 320. 322 is a control code indicating whether the message is a request or a response, 323 is a procedure code which is an arbitrary number given to each remotely called function, 324 is the byte length of the return cell storing the execution result of the function, and 325 is RPC This is an RPC error code that stores error information related to execution of.

(Processing of Blocking Function) A method of calling a blocking function will be described with reference to FIGS. 7 and 8.

(Processing Configuration of Blocking Function) FIG. 7
Is an application running on CPU-A 10a
FIG. 9 is a block diagram illustrating a method of remotely calling a blocking function that operates in 10b. In FIG. 7, description of the blocks to which the same numbers as in FIG. 3 are added will be omitted. 106 is an application program (function) that calls the blocking type function work_b (), and 107 is a blocking type function work_b ().

(Processing Sequence of Blocking Function)
Figure 4 shows the application 106 running on the CPU-A 10a.
6 is a sequence diagram illustrating a method of remotely calling a blocking function work_b () that operates on the CPU-B 10b. FIG. The application 106 calls the blocking type function work_b () with a normal procedure (S201 in FIG. 8). client·
The stub 101 converts the argument set in work_b () into the XDR data format (S202 in FIG. 8), and the RPC client 18
The API function rpcMsgSend () provided by 1a is used to send to the RPC client 181a (S203 in FIG. 8). The API function rpcMsg
After sending the argument data converted in S202 to the RPC client 181a in Send (), work_b running on CPU-B (10b)
Until the execution result from () is returned,
The processing of the stub 101 is blocked. That is, the processing of the application 106 is stopped. RPC client 18
When 1a receives the argument data, it adds a header to the argument data as shown in FIG. 5 and creates a message to be sent to the CPU-B 10b. FIG. 5 is as described above.

In this embodiment, there are only 104 applications for simplification of description, but there are usually a plurality of applications. If the processing request message (function argument) of the function in the CPU-B (10b) is sent to the RPC client 181a from multiple applications in S203, the processing request message (function) is sent to the queue provided by the RPC client 181a. ) Is queued. The RPC client 181a sequentially processes the queued requests. Also, if a priority-specified message is received, the priority-specified message is processed with priority. The RPC client 181a sends a message (request
Send RPC header + argument data) 300 to CPU I / F section 19
(S204 in FIG. 8). After transmitting the message, the RPC client 181a performs transmission monitoring (S205 in FIG. 8) and performs error processing at the time of transmission failure and timeout processing such as return value not returning. The error notification at this time is sent to the client stub 101 as the return value of work_b ().
220a), the client stub 101 is an application
It is transmitted to 106 (S221a in FIG. 8).

The inter-CPU I / F unit 19 receives the message (request RPC header + argument data) 300, and then the message (request RPC header
The RPC server 182b is notified that the header + argument data) has been received (S206 in FIG. 8). The RPC server 182b that received the notification
Acquires the message (request RPC header + argument data) 300 stored in a predetermined area (S207 in FIG. 8). The RPC server 182b refers to the request RPC header from the acquired message (request RPC header + argument data) 300, identifies the server stub 103 from the procedure code of the request RPC header (S208 in FIG. 8), The argument data is transmitted to the stub 103 (S209 in FIG. 8). When the server stub 103 receives the argument data, the server stub 103 restores the XDR format data into a format executable by the CPU-B (19b) (S210 in FIG. 8), and the function work_b () 107
The argument of is specified (S211 in FIG. 8). The server stub 103 is
Set the argument confirmed above to the function work_b () 107 and
Call ork_b () 107 (S212 in FIG. 8). Function work_b () 107
After executing the predetermined process (S213 in FIG. 8), returns the execution result to the server stub 103 (S214 in FIG. 8). The server stub 103 converts the received execution result into the XDR data format (S215 in FIG. 8) and sends it to the RPC server 182b (S216 in FIG. 8).

Upon receiving the execution result data, the RPC server 182b adds a header to the execution result data and creates a message 320 for transmission to the CPU-A 10a, as shown in FIG. The description of FIG. 6 is as described above.
Then, the RPC server 182b transmits a message (response RPC header + execution result data) 320 to the inter-CPU I / F unit 19 (see FIG. 8).
S217).

After receiving the message (response RPC header + execution result data) 320, the inter-CPU I / F unit 19 notifies the RPC client 181a that the message (response RPC header + execution result data) has been received ( (S218 in FIG. 8). Upon receiving the notification, the RPC client 181a goes to obtain the message (response RPC header + execution result data) stored in a predetermined area (S219 in FIG. 8). The RPC client 181a trims the response RPC header from the acquired message (response RPC header + execution result data) 320. Here, after performing a predetermined error check process, the execution result data is transmitted to the client stub 101 (S220b in FIG. 8). The client stub 101 restores the execution result data to a format that can be executed by the CPU-A (10b) (S222 in FIG. 8), and returns the restored execution result to the application 106 that called the function work_b (). Return as a return value (S221b in FIG. 8).

(Embodiment of priority processing RPC task) In the above-mentioned embodiment, a processing request message is used as a method for urgently processing by delaying or discarding a processing request message requested earlier in time such as error processing. Although priority processing is performed, an embodiment in which an RPC mechanism (RPC client task 181 and RPC server task 182) for priority processing is separately provided is also conceivable. Further, when providing a plurality of priorities, an embodiment in which a plurality of RPC client tasks 181 and RPC server tasks 182 having different task execution priorities on the multitask real-time OS are provided for each priority is also conceivable.

(Embodiment of plural OSs on the same CPU) In the above-mentioned embodiment, the RPC between the two CPUs CPU-A (10a) and CPU-B (10b) is shown, but these RPCs are the same. CP
It may be between multiple OSs running on U.

[0030]

According to the present invention, each RPC client stub corresponding to each function calling procedure method of blocking call and non-blocking call is provided, and the RPC client task commonly used for a plurality of RPCs is provided on the RPC client side. , RPC server tasks that are also commonly used for multiple RPCs are provided on the RPC server side, and in the case of a blocking call, the execution result of the RPC is returned to the stub,
In the case of the non-blocking call, by calling the callback function based on the execution result, both the blocking call and the non-blocking call can be handled, and the operation with the limited memory capacity is facilitated.

[Brief description of drawings]

FIG. 1 is a block diagram illustrating a mobile phone using the present invention.

FIG. 2 is a block diagram illustrating a conventional mobile phone.

FIG. 3 is a block diagram illustrating a method of calling a non-blocking function using the present invention.

FIG. 4 is a sequence diagram illustrating a method of calling a non-blocking function using the present invention.

FIG. 5 is a diagram illustrating an example of a request RPC message according to the present invention.

FIG. 6 is a diagram illustrating an example of a response RPC message according to the present invention.

FIG. 7 is a block diagram illustrating a method of calling a blocking function using the present invention.

FIG. 8 is a sequence diagram illustrating a method of calling a blocking function using the present invention.

[Explanation of symbols]

1: Mobile phone according to the present invention, 2: Conventional mobile phone, 10
a: CPU-A, 10b: CPU-B, 11: Telephone line section, 12: Antenna, 13a, 13b: Display section, 14: Input section, 15a, 15b: Storage section, 16a, 16b: Speaker, 17: Microphone 18a, 18b: RPC (R
emote Procedure Call) section, 19: I / F section between CPUs, 21: Telephone line section, 22: Antenna, 23: Display section, 24: Input section, 25:
Storage unit, 26: speaker, 27: microphone, 30: request RPC header, 31: parameter cell, 32: response RPC header, 33: return cell, 101: client stub, 102: callback function, 103: server stub , 104: Application program (function) that calls the non-blocking function work_nb (), 105: Non-blocking function work_nb
(), 106: Application program (function) that calls blocking type function work_b (), 107: Blocking type function work_b (), 181a, 181b: RPC client, 18
2a, 182b: RPC server, 300: Request message, 301: XI
D, 302: Control code indicating whether the message is a request or a response,
303: Procedure code, 304: Parameter cell byte length, 305: Reserved, 320: Response message, 321: XID, 32
2: Control code indicating whether the message is a request or response, 323:
Procedure code, 324: Return cell byte length, 3
25: RPC error code, 1011: data conversion unit, 1021: data restoration unit, 1811a, 1811b: transmission monitoring unit, 1821a, 1821
b: Dispatcher, 1011: data conversion unit, S101 to S124: sequence of calling non-blocking function, S201 to S222: sequence of calling blocking function.

   ─────────────────────────────────────────────────── ─── Continued front page    (72) Inventor Hideki Kuwamoto             292 Yoshida-cho, Totsuka-ku, Yokohama-shi, Kanagawa             Ceremony Hitachi Digital Media Development Book             Department (72) Inventor Katsuya Miyata             292 Yoshida-cho, Totsuka-ku, Yokohama-shi, Kanagawa             Ceremony Hitachi Digital Media Development Book             Department (72) Inventor Norihiro Sakayama             180 Totsuka-cho, Totsuka-ku, Yokohama-shi, Kanagawa             Standing Communication System Co., Ltd. (72) Inventor Naoki Mori             1410 Inada Stock Company, Hitachinaka City, Ibaraki Prefecture             Hitachi, Ltd. Digital Media Products Division             Within F term (reference) 5B089 GA25 GB09 JA11 JB10 KA06                       KE02 KE03                 5B098 AA10 GA02 GA04 GC16

Claims (16)

[Claims] 1. An information processing device in which a plurality of OSs (Operating Systems) run, or an OS running in another information processing device
RPC with a non-blocking call function call procedure in an information processing device running an OS that can communicate with
A (Remote Procedure Call) client stub and an RPC client stub having a function call procedure for a blocking call are provided, a message including an argument of the function is received from the client stub, and a message including the argument is sent to the RPC server. Transmit to task and R
Receives a message containing the execution result of the function from the PC server task, calls a callback function based on the execution result in the case of a non-blocking call, and returns a message containing the execution result in the client stub in the case of a blocking call. An information processing device characterized by having an RPC client task. 2. The RPC client task according to claim 1, wherein messages from a plurality of client stubs are RPC'ed.
An information processing device characterized by transmitting to a server task. 3. The information processing apparatus according to claim 1, wherein the RPC client task transmits messages from a plurality of client stubs to the same RPC server task. 4. The information processing apparatus according to claim 1, wherein the RPC client task queues messages from the client stub and sequentially processes the messages. 5. The message according to claim 1, wherein the message includes data indicating a processing priority, and the RPC client task is
An information processing apparatus, characterized in that a message from a client stub is queued and sequentially processed in order from the highest priority. 6. The information processing apparatus according to claim 1, wherein the RPC client task checks whether or not the transmission of the message to the RPC server task is successful. 7. The information processing apparatus according to claim 1, wherein an RPC client task is provided for each priority of processing a function. 8. An information processing device running a plurality of OSs (Operating Systems) or an OS running on another information processing device
And an RPC client stub having both a non-blocking call function calling procedure and a blocking call function calling procedure. 9. An information processing device running a plurality of OSs (Operating Systems), or an OS running on another information processing device
In an information processing method of an information processing device in which an OS capable of communicating with an OS operates, an RPC (Remote Procedure Call) client stub having a non-blocking call function calling procedure and an RPC client stub having a blocking call function calling procedure are provided. A message including the argument of the function is received from the client stub, the message including the argument is transmitted to the RPC server task, and the message including the execution result of the function is received from the RPC server task. An information processing method comprising: providing a RPC client task for calling a callback function based on the execution result in the case of a non-blocking call, and returning a message including the execution result in a client stub in the case of a blocking call. 10. The RPC client task according to claim 9, wherein messages from a plurality of client stubs are received.
An information processing method characterized by transmitting to an RPC server task. 11. The information processing method according to claim 9, wherein the RPC client task transmits messages from a plurality of client stubs to the same RPC server task. 12. The information processing method according to claim 9, wherein the RPC client task queues messages from the client stub and sequentially processes them. 13. The message according to claim 9, wherein the message includes data indicating a processing priority, and the RPC client task queues the message from the client stub and sequentially processes the messages in descending order of priority. Information processing method. 14. The information processing method according to claim 9, wherein the RPC client task checks whether or not the transmission of the message to the RPC server task is successful. 15. The information processing method according to claim 9, wherein an RPC client task is provided for each priority of the function processing. 16. An information processing device running a plurality of OSs (Operating Systems) or running on another information processing device
An information processing method, wherein an information processing device running an OS capable of communicating with an OS is provided with an RPC client stub having both a non-blocking call function calling procedure and a blocking call function calling procedure.