CN117215803A - Process communication method and device, electronic equipment and readable storage medium - Google Patents

Abstract

The application provides a process communication method, a device, an electronic device and a readable storage medium, wherein the method comprises the following steps: the method comprises the steps that a first process writes first data into a first memory space, and a second process reads the first data in the first memory space; and/or the second process writes second data into a second memory space, and the first process reads the second data in the second memory space; the first process is in a kernel mode, the second process is in a user mode, and the first memory space and the second memory space are memory spaces shared by the first process and the second process. The application can improve the communication efficiency.

Description

A process communication method, device, electronic equipment and readable storage medium

Technical field

The present application relates to the field of communication technology, and in particular, to a process communication method, device, electronic equipment and readable storage medium.

Background technique

In the operating system, due to the limitations of the central processing unit (Central Processing Unit, CPU) permissions, data interaction and communication between the kernel state and the user state are mainly through the device control interface function (input/output control, ioctl) in the device driver. way to achieve data communication between kernel mode and user mode. However, ioctl is mainly used to transmit information from user mode to kernel mode. It is one-way and can only be initiated actively in user mode. When the user state needs to obtain the message transmission actively initiated by the kernel state, it can only query through polling, resulting in low communication efficiency.

Contents of the invention

This application provides a process communication method, device, electronic equipment and readable storage medium to solve the problem.

In a first aspect, embodiments of the present application provide a process communication method, which is characterized by including:

The first process writes the first data into the first memory space, and the second process reads the first data in the first memory space; and/or,

The second process writes the second data into the second memory space, and the first process reads the second data in the second memory space;

Wherein, the first process is in the kernel state, the second process is in the user state, and the first memory space and the second memory space are memory spaces shared by the first process and the second process.

In a second aspect, the embodiment of the present application also provides a process communication device, which is characterized in that it includes:

The first communication module is used for the first process to write the first data into the first memory space, and the second process to read the first data in the first memory space; and/or,

The second communication module is used for the second process to write the second data into the second memory space, and the first process to read the second data in the second memory space;

Wherein, the first process is in the kernel state, the second process is in the user state, and the first memory space and the second memory space are memory spaces shared by the first process and the second process.

In a third aspect, embodiments of the present application further provide an electronic device, including: a transceiver, a memory, a processor, and a program stored on the memory and executable on the processor; the processor is configured to Reading the program in the memory implements the steps in the method described in the first aspect of the embodiment of this application.

In a fourth aspect, embodiments of the present application further provide a readable storage medium. A program is stored on the readable storage medium. When the program is executed by a processor, the steps in the method described in the first aspect of the embodiment of the present application are implemented. .

In this embodiment of the present application, the first process writes the first data into the first memory space, and the second process reads the first data in the first memory space; and/or the second process writes the second data into the first memory space. Write to the second memory space, and the first process reads the second data in the second memory space. That is, the kernel state can send data to the user state through the first memory space, and the user state can send data to the kernel state through the second memory space, thereby improving communication efficiency.

Description of drawings

In order to explain the technical solution of the present application more clearly, the drawings required to be used in the embodiments or description of the prior art will be briefly introduced below. Obviously, the drawings in the following description are only some embodiments of the present application. , for those of ordinary skill in the art, other drawings can also be obtained based on these drawings without exerting creative labor.

Figure 1 is a schematic flow chart of process communication provided by an embodiment of the present application;

Figure 2 is a schematic diagram of kernel state initialization provided by an embodiment of the present application;

Figure 3 is a schematic diagram of a shared memory space provided by an embodiment of the present application;

Figure 4 is a schematic diagram of user mode initialization provided by an embodiment of the present application;

Figure 5 is a schematic diagram of a kernel state sending data to a user state provided by an embodiment of the present application;

Figure 6 is a schematic diagram of a user mode receiving data sent by a kernel mode according to an embodiment of the present application;

Figure 7 is a schematic diagram of a user state sending data to the kernel state provided by an embodiment of the present application;

Figure 8 is a schematic diagram of a kernel state receiving data sent by a user state provided by an embodiment of the present application;

Figure 9 is a schematic structural diagram of a process communication device provided by an embodiment of the present application;

Figure 10 is a schematic structural diagram of an electronic device provided by an embodiment of the present application.

Detailed ways

The technical solutions in the embodiments of the present application will be clearly and completely described below with reference to the accompanying drawings in the embodiments of the present application. Obviously, the described embodiments are part of the embodiments of the present application, rather than all of the embodiments. Based on the embodiments in this application, all other embodiments obtained by those of ordinary skill in the art without creative efforts fall within the scope of protection of this application.

The terms "first", "second", etc. in the embodiments of this application are used to distinguish similar objects and are not necessarily used to describe a specific order or sequence. In addition, the terms "including" and "having" and any variations thereof are intended to cover non-exclusive inclusions, e.g., a process, method, system, product, or apparatus that encompasses a series of steps or units and need not be limited to those explicitly listed. Those steps or elements may instead include other steps or elements not expressly listed or inherent to the process, method, product or apparatus. In addition, the use of "and/or" in this application indicates at least one of the connected objects, such as A and/or B and/or C, indicating that A alone, B alone, C alone, and both A and B exist, There are 7 situations in which both B and C exist, both A and C exist, and A, B, and C all exist.

Please refer to Figure 1. Figure 1 is a schematic flow chart of a process communication method provided by an embodiment of the present application. As shown in Figure 1, it includes the following steps:

Step 101. The first process writes the first data into the first memory space, and the second process reads the first data in the first memory space; and/or,

The second process writes the second data into the second memory space, and the first process reads the second data in the second memory space;

Wherein, the first process is in the kernel state, the second process is in the user state, and the first memory space and the second memory space are memory spaces shared by the first process and the second process.

It can be understood that the above-mentioned first memory space and the above-mentioned second memory space are two independent memory spaces. The above-mentioned first memory space is used for writing data in the kernel mode and reading data in the user mode, and the above-mentioned second memory space is used for user mode. Write data and read data in kernel mode.

Wherein, the process in which the above-mentioned first data is written into the above-mentioned first memory space by the first process and read by the above-mentioned second process is the process of transmitting data from kernel mode to user mode; the above-mentioned second data is written by the second process The process of reading the above-mentioned second memory space by the above-mentioned first process is the process of transmitting data from the user state to the kernel state. The above two processes can be executed in parallel, that is, while the first process writes the first data into the first memory space, the second process can write the second data into the second memory space, or the first process can also write the second data from the above-mentioned second memory space. Read data from the memory space; while the second process reads the first data from the first memory space, the second process can write the second data into the second memory space, or the first process can also read the second data from the second memory space. Read data from space. That is, when communicating between the kernel state and the user state, data can be sent or received in parallel through the first memory space and the second memory space respectively.

In this way, by assigning the data writing permission of the first memory space to the first process in the kernel state, and assigning the data writing permission of the second memory space to the second process in the user state, the first process and the second process Data will not be written to the same memory space, which ensures the reliability of communication data between kernel mode and user mode.

In this embodiment of the present application, the first process writes the first data into the first memory space, and the second process reads the first data in the first memory space; and/or the second process writes the second data into the first memory space. Write to the second memory space, and the first process reads the second data in the second memory space. That is, the kernel state can send data to the user state through the first memory space, and the user state can send data to the kernel state through the second memory space, thereby improving communication efficiency.

Moreover, the data transmission from the kernel state to the user state is implemented based on the first memory space, and the data transmission from the user state to the kernel state is implemented based on the second memory space. That is, the process of sending data from the kernel state to the user state is different from the process of sending data from the user state to the user state. The process of sending data in the kernel state can be executed in parallel without affecting each other and has high reliability. In this way, the communication process between the kernel state and the user state does not require atomic protection operations such as locks or semaphores to prevent data from being tampered with, and can avoid the impact of atomic protection operations on communication efficiency.

Optionally, the method also includes:

The first process creates the first memory space and the second memory space;

The first process maps the first memory space and the second memory space to the second process, so that the first process and the second process share the first memory space and the second memory space. Second memory space.

Before the kernel mode communicates with the user mode, the first storage space and the second memory space can be created by the first process, and the above-mentioned first memory space and the above-mentioned second memory space can be mapped to the second process, so that the first process Share the above-mentioned first memory space and the above-mentioned second memory space with the second process.

Specifically, in the Linux system, the above mapping can be achieved by creating and initializing the first virtual device (/dev/mem device). The /dev/mem device is used for user mode mapping of the first memory space and the second memory created by the kernel mode. space.

In this embodiment, through the first memory space and the second memory space shared by the first process and the second process, the first process and the second process can achieve parallel communication, thereby improving the kernel state and Communication efficiency between user states.

Optionally, the first memory space includes M storage units, where M is a positive integer;

The first process writes the first data into the first memory space, and the second process reads the first data in the first memory space, including:

The first process obtains the first data;

When there is a free first storage unit among the M storage units, the first process writes the first data into the first storage unit;

The first process updates the status information of the first storage unit;

The second process reads the first data in the first storage unit when it monitors changes in the status information of the first storage unit.

For the first memory space, the capacity of the first memory space and the capacity of each storage unit can be determined according to system resources and actual business requirements, and the data structure of each storage unit can include multiple domain segments, for example, using Field segments used to represent the current usage status of the storage unit, field segments used to represent the effective data length that can be used to transmit data in the storage unit, field segments used to store data, etc.

It should be noted that the usage status of the storage unit can be divided into idle and full. An idle storage unit means that the storage unit can write data, and a full storage unit means that the storage unit cannot write data.

Wherein, the above-mentioned first storage unit is any storage unit whose use status is idle among the M storage units, and data can be written in the first storage unit. If the above-mentioned M storage units are all in full use, you can wait until there are free storage units before rewriting data.

The status information of the first storage unit may be used to inform the second process that there is newly written data in the first storage unit. The status information of the first storage unit may include the usage status of the first storage unit and the first storage unit. The data length in , specifically, can be represented by the information of different field segments in the above-mentioned storage unit. For example, the length of the field segment used to represent the usage status of the storage unit can be 1 bit (bit): the value is "0 " means that the usage status of the storage unit is idle, and a value of "1" means that the usage status of the storage unit is full; or a value of "0" means that the usage status of the storage unit is full, and the value is " "1" indicates that the storage unit is idle. The length of the field segment used to represent the data length in the storage unit can be set according to the length of data that can be stored in the storage unit, and this application does not limit this.

Specifically, in the Linux system, the above-mentioned second process can monitor the status information of the above-mentioned first storage unit through a monitoring function (such as the epoll function, select function), etc., when monitoring changes in the status information of the first storage unit, Notify the second process to read the written first data from the first storage unit.

In this implementation, the first process obtains the first data; when there is a free first storage unit among the M storage units, the first process writes the first data into the In a storage unit; the first process updates the status information of the first storage unit; the second process reads the first storage when monitoring changes in the status information of the first storage unit. the first data in the unit. That is, the first process writes the first data in the free first storage unit and updates the status information of the first storage unit, and the second process can monitor the status information results of the first storage unit. Reading the first data written in the first storage unit enables the kernel state to send the first data to the user state, thereby improving the real-time nature of communication between the kernel state and the user state.

In addition, through the first memory space, if the kernel state needs to send data to multiple user states, this can be achieved by expanding the M storage units. The process of sending data from the kernel state to each user state is as described above.

Optionally, the first process updates the status information of the first storage unit, including:

After the first data is written into the first storage unit, the first process updates the status information of the first storage unit if at least one of the following conditions is met:

The data length of the first storage unit is greater than or equal to the first preset threshold;

The first timer has expired.

The above-mentioned first preset threshold and the above-mentioned first timer can be set in advance according to actual needs or experience values. For example, for data with high timeliness, a smaller first preset threshold or a smaller first timer can be set. The timeout time of the timer is used to send the data from the kernel state to the user state as soon as possible. For another example, in order to save transmission resources, a larger first preset threshold or a larger timeout period of the first timer can be set to avoid frequent updates of the status information of the first storage unit, thereby preventing the second process from being updated in the first Frequent data reads occur in the storage unit. Moreover, during the communication process between the kernel state and the user state, the state update frequency of the first storage unit can be considered from the data length through the first preset threshold, and the first storage unit can be considered from the time through the first timer. frequency of status updates.

It can be understood that the above-mentioned first preset threshold needs to be smaller than the length of data that can be stored in the above-mentioned first storage unit.

It should be noted that in this embodiment of the present application, the status information of the above-mentioned first storage unit can be updated according to the newly written data length or according to a certain time interval. Specifically, the first process can write the first The status information of the first storage unit is updated after the data length of the data in the storage unit is greater than or equal to the above-mentioned first preset threshold. For example, when the data length of the first data is greater than or equal to the first preset threshold, the status information of the first storage unit can be updated; when the data length of the first data is less than the first preset threshold, In this case, if the data length of all data written by the first process after the last update of the status information of the first storage unit is greater than or equal to the above-mentioned first preset threshold, the status information of the above-mentioned first storage unit may also be updated; If the data length of all data written by the first process after the last update of the status information of the first storage unit is still less than the above-mentioned first preset threshold, then it is necessary to wait for the first process to continue writing to the first storage unit. The data until the data length written in the first storage unit is greater than or equal to the above-mentioned first preset threshold.

In this implementation, after the first data is written into the first storage unit, the first process updates the status information of the first storage unit if at least one of the following conditions is met: The data length is greater than or equal to the first preset threshold; the first timer times out. That is, the update frequency of the status information of the first storage unit can be controlled from the data length and time, while ensuring the real-time nature of data transmission, avoiding frequent updates of the status information of the first storage unit, thereby reducing the need for data transmission. resource.

Optionally, the first memory space includes N storage units, where N is a positive integer;

The second process writes the second data into the second memory space, and the first process reads the second data in the second memory space, including:

The second process obtains the second data;

When there is a free second storage unit among the N storage units, the second process writes the second data into the second storage unit;

The second process updates the status information of the second storage unit;

The first process reads the second data in the second storage unit when monitoring changes in the status information of the second storage unit.

It should be noted that the above-mentioned second process writes the second data into the second memory space, and the first process reads the second data in the second memory space. The process of writing the second data into the second memory space by the above-mentioned first process can be referred to. The process of writing a piece of data into the first memory space and the second process reading the first data in the first memory space will not be described again here.

Among them, the data writing permission of the above-mentioned second memory space is obtained by the second process, and the data writing permission of the above-mentioned first memory space is obtained by the first process, and the above-mentioned first process and the above-mentioned second process both enjoy the above-mentioned first process. Data reading permissions for the memory space and the above-mentioned second memory space.

Specifically, in the Linux system, the above-mentioned first process can monitor the status information of the above-mentioned second storage unit by creating a second virtual device (notification device). The notification device can be used to notify the kernel state whether the status information of the above-mentioned second storage unit is changes occur. The first process reading the second data in the second storage unit can be implemented by creating a work queue (workqueue). The work item content of the workqueue is to read the data sent by the user mode from the second storage unit. For example, after writing data in the second storage unit, the above-mentioned notification device can monitor the increase in the data stored in the second storage unit, so that the first process can read the newly written data in the second storage unit through the workqueue based on the monitoring result. The data.

In this implementation, the second process obtains the second data; when there is a free second storage unit among the N storage units, the second process writes the second data into the Nth storage unit. Among the two storage units; the second process updates the status information of the second storage unit; the first process reads the second storage when monitoring changes in the status information of the second storage unit. the second data in the unit. That is, the second process writes the second data in the free second storage unit and updates the status information of the second storage unit. The first process can monitor the status information results of the second storage unit. Reading the second data written in the second storage unit enables the user state to send the second data to the kernel state, thereby improving the real-time performance of communication between the kernel state and the user state.

Optionally, the second process updates the status information of the second storage unit, including:

After the second data is written into the second storage unit, the second process updates the status information of the second storage unit if at least one of the following conditions is met:

The data length of the second storage unit is greater than or equal to the second preset threshold;

The second timer times out.

It should be noted that the process of updating the status information of the second storage unit by the second process may refer to the process of updating the status information of the first storage unit by the above-mentioned first process, which will not be described again here.

In this implementation, after the second data is written into the second storage unit, the second process updates the status information of the second storage unit if at least one of the following conditions is met: The data length is greater than or equal to the second preset threshold; the second timer times out. That is, the update frequency of the status information of the second storage unit can be controlled from the data length and time, while ensuring the real-time nature of data transmission, avoiding frequent updates of the status information of the second storage unit, thereby reducing the need for data transmission. resource.

Optionally, after the first process writes the first data into the first memory space and the second process reads the first data in the first memory space, the method further includes:

The second process updates the status information and the first pointer of the first memory space. The first pointer points to a first address. The first address is the latest address of the second process in the first memory space. Read data address;

and / or,

The second process writes the second data into the second memory space, and after the first process reads the second data in the second memory space, the method further includes:

The first process updates the status information and the second pointer of the second memory space. The second pointer points to a second address. The second address is the latest address of the first process in the second memory space. The data address to be read.

In the process of the second process reading the data in the first memory space, the status information of the first memory space can be used to

The status information of the first memory space may also be used to inform the first process that the data written in the first memory space has been read by the second process.

Among them, the status information of the second memory space can be used to inform the first process that there is newly written data in the second memory space waiting to be read, or to inform the second process that the data written in the second memory space has been Read by the first process.

In this implementation, through the status information of the first memory space and the first pointer, the second process can determine whether it is necessary to read the data in the first memory space and the data in the first memory space. The latest read data address in the first memory space allows the second process to completely read the data written by the first process into the first memory space; through the status information of the second memory space and the second Pointer, the first process can determine whether it needs to read the data in the second memory space and the latest data address read in the second memory space, so that the first process can completely read all the data. The second process writes the data into the second memory space, thereby improving the reliability and real-time performance of the communication between the kernel state and the user state.

For better understanding, the specific implementation modes of the present application are further described in detail below in conjunction with the accompanying drawings:

Step S1: Initialize the kernel state and user state respectively;

Among them, the kernel state initialization process, as shown in Figure 2, specifically includes the following processes:

During the kernel driver loading phase of the Linux system, two memory spaces are applied for. The memory space used for kernel mode sending and user mode receiving is marked as M _K , and the memory space used for user mode sending and kernel state receiving is marked as M _U ;

Among them, memory space M _K and memory space M _U can use the same space layout and data structure. The capacity of each shared memory space and the capacity of the storage unit can be flexibly adjusted according to system resources and actual business needs. The spatial layout of the memory space As shown in Figure 3, each memory space can be divided into multiple storage units.

Initialize the memory space M _K and the memory space M _U according to the storage unit data structure shown in Table 1. The capacity of each shared memory space and the capacity of the storage unit can be flexibly adjusted according to system resources and actual business needs;

Taking the example of setting the space capacity of memory space M _K (or memory space M _U ) to 4MB and the storage unit capacity to 4KB, set each domain segment in the storage unit:

Table 1

Create a workqueue. The content of the work item is to read the data sent from the user state from the memory space M _U. It should be noted that the content of the work item can be combined with the actual business to add corresponding operations;

Create and initialize the first virtual device (/dev/mem device), which is used to map the memory space M _K and _MU created by the user state to the memory state;

Create a second virtual device (notification device), which is used to notify the kernel state and user state that the current /dev/mem device has changed and data can be received;

This completes the kernel state initialization process.

Among them, the user mode initialization process, as shown in Figure 4, specifically includes the following processes:

After the system kernel initialization is completed, run the user mode application. At this time, the kernel mode has completed the relevant initialization process;

Open the /dev/mem device and map the memory space M _K and M _U ;

Create a listening function (epoll function or select function) to monitor the status changes of the /dev/mem device. The execution entity corresponding to the monitoring status changes is used to read the data sent from the kernel state from the memory space M _K ; similarly, This part can add corresponding operations based on actual business.

This completes the user mode initialization process.

Step S2: The kernel state sends data to the user state, as shown in Figure 5, which specifically includes the following processes:

The kernel state obtains the data information D _K that needs to be sent to the user state;

Determine whether there are any free storage units in memory space M _K ;

At this time, if there is no free storage unit in the memory space M _K , record the error message, wait and try to retransmit;

At this time, if there is a free storage unit in the memory space M _K , fill the data information D _K into the free storage unit in the memory space M _K. At the same time, update the storage unit usage status and data length;

Determine whether the data length in the storage unit reaches the storage threshold;

If the data length corresponding to the currently filled storage unit does not reach the preset threshold, determine whether a sending timer has been created;

If a send timer is not currently created, create a send timer. The timeout time is defined according to the actual scenario. The timeout task is to refresh the notification device to notify user mode/dev/mem device status changes;

When the sending timer has been created, determine whether the sending timer has timed out;

If the sending timer has not expired, return to the previous step to continue judging;

If the sending timer times out, execute the timeout task and refresh the notification device to notify the user mode /dev/mem device status change;

If the data length corresponding to the currently filled storage unit reaches the preset threshold, delete the existing sending timer;

Refresh notification device notifies user mode/dev/mem device status changes;

At this point, the process of sending data from kernel mode to user mode is completed.

Step S3: The user mode receives the data sent by the kernel mode, as shown in Figure 6, which specifically includes the following processes:

The user mode monitors the status change of the /dev/mem device through epoll or select;

Execute the task entity when listening to the /dev/mem device change notification;

Read the filled data D _K from the memory space M _K until the reading is completed;

Update the memory unit status corresponding to the read data D _K to the idle state, and refresh the user mode unit pointer at the same time;

At this point, the process of receiving data from the user mode and sending data from the kernel mode is completed.

Step S4: The user state sends data to the kernel state, as shown in Figure 7, which specifically includes the following processes:

The user state obtains the data information _DU that needs to be sent to the kernel state;

Determine whether there are any free storage units in the memory space M _U ;

At this time, if there is no free storage unit in the memory space M _U , record the error message, wait and try to retransmit;

At this time, if there is a free storage unit in the memory space M _U , fill the data information D _U into the free storage unit in the memory space M _U. At the same time, update the storage unit usage status and data length;

Determine whether the data length in the storage unit reaches the storage threshold;

If the data length corresponding to the currently filled storage unit does not reach the preset threshold, determine whether a sending timer has been created;

If a send timer is not currently created, create a send timer. The timeout time is defined according to the actual scenario. The timeout task is to refresh the notification device to notify user mode/dev/mem device status changes;

When the sending timer has been created, determine whether the sending timer has timed out;

If the sending timer has not expired, return to the previous step to continue judging;

If the sending timer times out, execute the timeout task and refresh the notification device to notify the user mode /dev/mem device status change;

If the data length corresponding to the currently filled storage unit reaches the preset threshold, delete the existing sending timer;

Refresh notification device notifies kernel state/dev/mem device status changes;

At this point, the process of sending data from user mode to kernel mode is completed.

Step S5: The kernel state receives the data sent by the user state, as shown in Figure 8, which specifically includes the following processes:

When the /dev/mem device changes, the device status update function is called;

Update the workqueue created during the initialization phase and execute the work queue entity;

Read the filled data D _U from the memory space M _U until the reading is completed;

Update the memory unit status corresponding to the read data D _U to the idle state, and refresh the kernel state unit pointer at the same time;

At this point, the process of receiving and sending data in the kernel mode is completed.

It should be noted that the above step S1 may be executed when the kernel mode and the user mode communicate for the first time, and subsequent communication processes may not be executed. Moreover, since the embodiment of the present application performs different functions through two memory spaces, the above steps S2 to S3 and steps S4 to S5 can be executed in parallel without affecting each other.

In the embodiment of this application, the user state and the kernel state use two independent memory spaces to interact, which do not affect each other and have high reliability. Since the two memories have different functions and there is no interaction, there is no need for interaction between the user state and the kernel state. Atomic protection in the form of locks or semaphores, and only one copy is needed to complete the communication, which greatly improves communication efficiency.

In addition, when there are multiple senders and multiple receivers, that is, the kernel state needs to interact with multiple user states, or the user state needs to interact with multiple kernel states, the memory can be directly expanded, the interaction method remains unchanged, and the scalability is strong.

Referring to Figure 9, Figure 9 is a schematic structural diagram of a process communication device provided by an embodiment of the present application. As shown in Figure 9, the process communication device 900 includes:

The first communication module 901 is used for the first process to write the first data into the first memory space, and the second process to read the first data in the first memory space; and/or,

The second communication module 902 is used for the second process to write the second data into the second memory space, and the first process to read the second data in the second memory space;

Wherein, the first process is in the kernel state, the second process is in the user state, and the first memory space and the second memory space are memory spaces shared by the first process and the second process.

Optionally, the first memory space includes M storage units, where M is a positive integer;

The first communication module 901 includes:

A first acquisition unit, used for the first process to acquire the first data;

A first writing unit, configured for the first process to write the first data into the first storage unit when there is a free first storage unit among the M storage units;

A first update unit, used by the first process to update the status information of the first storage unit;

The first reading unit is used for the second process to read the first data in the first storage unit when the second process detects changes in the status information of the first storage unit.

Optionally, the first update unit includes:

The first update subunit is used to update the status information of the first storage unit by the first process when at least one of the following is satisfied after the first data is written into the first storage unit:

The data length of the first storage unit is greater than or equal to the first preset threshold;

The first timer has expired.

Optionally, the process communication device 900 also includes:

The first update module is used by the second process to update the status information and the first pointer of the first memory space. The first pointer points to a first address, and the first address is where the second process is located. The latest read data address in the first memory space;

and / or,

The second update module is used by the first process to update the status information and the second pointer of the second memory space. The second pointer points to a second address. The second address is where the first process is located. The latest read data address in the second memory space.

Optionally, the first memory space includes N storage units, where N is a positive integer;

The second communication module 902 includes:

a second acquisition module, used by the second process to acquire the second data;

A second writing unit, configured for the second process to write the second data into the second storage unit when there is a free second storage unit among the N storage units;

a second update unit, used by the second process to update the status information of the second storage unit;

The second reading unit is used for the first process to read the second data in the second storage unit when the first process detects changes in the status information of the second storage unit.

Optionally, the second update unit includes:

The second sub-update unit is used to update the status information of the second storage unit by the second process when at least one of the following is satisfied after the second data is written into the second storage unit:

The data length of the second storage unit is greater than or equal to the second preset threshold;

The second timer times out.

Optionally, the process communication device 900 also includes:

A creation module, used by the first process to create the first memory space and the second memory space;

A mapping module configured for the first process to map the first memory space and the second memory space to the second process, so that the first process and the second process share the first memory space and the second memory space.

The process communication device 900 can implement each process of the method embodiment in Figure 1 in the embodiment of the present application, and achieve the same beneficial effects. To avoid duplication, the details will not be described here.

An embodiment of the present application also provides an electronic device. Since the problem-solving principle of the electronic device is similar to the process communication method shown in Figure 1 in the embodiment of the present application, the implementation of the electronic device can be referred to the implementation of the method, and repeated details will not be repeated.

As shown in Figure 10, the electronic device according to the embodiment of the present application includes a memory 1020, a transceiver 1010, and a processor 1000;

Memory 1020 is used to store computer programs; transceiver 1010 is used to send and receive data under the control of the processor 1000; processor 1000 is used to read the computer program in the memory 1020 and perform the following operations:

The first process writes the first data into the first memory space, and the second process reads the first data in the first memory space; and/or,

The second process writes the second data into the second memory space, and the first process reads the second data in the second memory space;

Wherein, the first process is in the kernel state, the second process is in the user state, and the first memory space and the second memory space are memory spaces shared by the first process and the second process.

In FIG. 10 , the bus architecture may include any number of interconnected buses and bridges, specifically one or more processors represented by processor 1000 and various circuits of the memory represented by memory 1020 are linked together. The bus architecture can also link together various other circuits such as peripherals, voltage regulators, and power management circuits, which are all well known in the art and therefore will not be described further herein. The bus interface provides the interface. Transceiver 1010 may be a plurality of elements, including a transmitter and a transceiver, providing a unit for communicating with various other devices over a transmission medium. The processor 1000 is responsible for managing the bus architecture and general processing, and the memory 1020 can store data used by the processor 1000 when performing operations.

The processor 1000 may be a central processing unit (Central Processing Unit, CPU), an application specific integrated circuit (Application Specific Integrated Circuit, ASIC), a field programmable gate array (Field-Programmable Gate Array, FPGA) or a complex programmable logic device (Complex Programmable LogicDevice (CPLD), the processor can also adopt a multi-core architecture.

Optionally, the first memory space includes M storage units, where M is a positive integer;

The first process writes the first data into the first memory space, and the second process reads the first data in the first memory space, including:

The first process obtains the first data;

When there is a free first storage unit among the M storage units, the first process writes the first data into the first storage unit;

The first process updates the status information of the first storage unit;

The second process reads the first data in the first storage unit when it monitors changes in the status information of the first storage unit.

Optionally, the first process updates the status information of the first storage unit, including:

After the first data is written into the first storage unit, the first process updates the status information of the first storage unit if at least one of the following conditions is met:

The data length of the first storage unit is greater than or equal to the first preset threshold;

The first timer has expired.

Optionally, the processor 1000 is also used to read the computer program in the memory 1020 and perform the following operations:

The second process updates the status information and the first pointer of the first memory space. The first pointer points to a first address. The first address is the latest address of the second process in the first memory space. Read data address;

and / or,

The first process updates the status information and the second pointer of the second memory space. The second pointer points to a second address. The second address is the latest address of the first process in the second memory space. The data address to be read.

Optionally, the first memory space includes N storage units, where N is a positive integer;

The second process writes the second data into the second memory space, and the first process reads the second data in the second memory space, including:

The second process obtains the second data;

When there is a free second storage unit among the N storage units, the second process writes the second data into the second storage unit;

The second process updates the status information of the second storage unit;

The first process reads the second data in the second storage unit when monitoring changes in the status information of the second storage unit.

Optionally, the second process updates the status information of the second storage unit, including:

After the second data is written into the second storage unit, the second process updates the status information of the second storage unit if at least one of the following conditions is met:

The data length of the second storage unit is greater than or equal to the second preset threshold;

The second timer times out.

Optionally, the processor 1000 is also used to read the computer program in the memory 1020 and perform the following operations:

The first process creates the first memory space and the second memory space;

The first process maps the first memory space and the second memory space to the second process, so that the first process and the second process share the first memory space and the second memory space. Second memory space.

The electronic device provided by the embodiment of the present application can execute the above-mentioned method embodiment shown in Figure 1. Its implementation principles and technical effects are similar and will not be described again in this embodiment.

Embodiments of the present application also provide a readable storage medium. Programs or instructions are stored on the readable storage medium. When the program or instructions are executed by a processor, each process of the method embodiment described in Figure 1 is implemented, and can To achieve the same technical effect, to avoid repetition, we will not repeat them here.

Wherein, the processor is the processor in the electronic device described in the above embodiment. The readable storage medium includes computer readable storage media, such as computer read-only memory (Read-Only Memory, ROM), random access memory (Random Access Memory, RAM), magnetic disk or optical disk, etc.

An embodiment of the present application further provides a chip. The chip includes a processor and a communication interface. The communication interface is coupled to the processor. The processor is used to run programs or instructions to implement the method described in Figure 1. Each process in the example can achieve the same technical effect. To avoid repetition, we will not repeat it here.

It should be understood that the chips mentioned in the embodiments of this application may also be called system-on-chip, system-on-a-chip, system-on-a-chip or system-on-chip, etc.

It should be noted that, in this document, the terms "comprising", "comprises" or any other variations thereof are intended to cover a non-exclusive inclusion, such that a process, method, article or device that includes a series of elements not only includes those elements, It also includes other elements not expressly listed or inherent in the process, method, article or apparatus. Without further limitation, an element defined by the statement "comprises a..." does not exclude the presence of additional identical elements in a process, method, article or apparatus that includes that element. In addition, it should be pointed out that the scope of the methods and devices in the embodiments of the present application is not limited to performing functions in the order shown or discussed, but may also include performing functions in a substantially simultaneous manner or in reverse order according to the functions involved. Functions may be performed, for example, the methods described may be performed in an order different from that described, and various steps may be added, omitted, or combined. Additionally, features described with reference to certain examples may be combined in other examples.

Through the above description of the embodiments, those skilled in the art can clearly understand that the methods of the above embodiments can be implemented by means of software plus the necessary general hardware platform. Of course, it can also be implemented by hardware, but in many cases the former is better. implementation. Based on this understanding, the technical solution of the present application can be embodied in the form of a computer software product that is essentially or contributes to the existing technology. The computer software product is stored in a storage medium (such as ROM/RAM, disk , optical disk), including several instructions to cause a terminal (which can be a mobile phone, computer, server, or network device, etc.) to execute the methods described in various embodiments of this application.

The embodiments of the present application have been described above in conjunction with the accompanying drawings. However, the present application is not limited to the above-mentioned specific implementations. The above-mentioned specific implementations are only illustrative and not restrictive. Those of ordinary skill in the art will Inspired by this application, many forms can be made without departing from the purpose of this application and the scope protected by the claims, all of which fall within the protection of this application.

Claims (10)

1. A process communication method, comprising:

the method comprises the steps that a first process writes first data into a first memory space, and a second process reads the first data in the first memory space; and/or the number of the groups of groups,

the second process writes second data into a second memory space, and the first process reads the second data in the second memory space;

the first process is in a kernel mode, the second process is in a user mode, and the first memory space and the second memory space are memory spaces shared by the first process and the second process.

2. The method of claim 1, wherein the first memory space comprises M memory cells, M being a positive integer;

the first process writes first data into a first memory space, and the second process reads the first data in the first memory space, including:

the first process acquires the first data;

in the case that there is a free first storage unit in the M storage units, the first process writes the first data into the first storage unit;

the first process updates state information of the first storage unit;

The second process reads the first data in the first memory cell while monitoring a change in state information of the first memory cell.

3. The method of claim 2, wherein the first process updating the state information of the first memory cell comprises:

after the first data is written into the first storage unit, the first process updates the state information of the first storage unit if at least one of the following is satisfied:

the data length of the first storage unit is larger than or equal to a first preset threshold value;

the first timer times out.

4. The method of claim 1, wherein the first process writes first data to a first memory space, and wherein after the second process reads the first data in the first memory space, the method further comprises:

the second process updates state information of the first memory space and a first pointer, wherein the first pointer points to a first address, and the first address is a data address which is read by the second process in the first memory space;

and/or the number of the groups of groups,

the second process writes second data into a second memory space, and after the first process reads the second data in the second memory space, the method further comprises:

The first process updates the state information of the second memory space and a second pointer, wherein the second pointer points to a second address, and the second address is the data address which is read by the first process in the second memory space.

5. The method of claim 1, wherein the first memory space comprises N memory cells, N being a positive integer;

the second process writes second data into a second memory space, and the first process reads the second data in the second memory space, including:

the second process obtains the second data;

in the case that there is a free second storage unit in the N storage units, the second process writes the second data into the second storage unit;

the second process updates the state information of the second storage unit;

the first process reads the second data in the second storage unit while monitoring a change in state information of the second storage unit.

6. The method of claim 5, wherein the second process updating the state information of the second memory cell comprises:

after the second data is written into the second storage unit, the second process updates the state information of the second storage unit if at least one of the following is satisfied:

The data length of the second storage unit is larger than or equal to a second preset threshold value;

the second timer times out.

7. The method of any one of claims 1 to 6, wherein the method further comprises:

the first process creates the first memory space and the second memory space;

the first process maps the first memory space and the second memory space to the second process such that the first process and the second process share the first memory space and the second memory space.

8. A process communication apparatus, comprising:

the first communication module is used for writing first data into a first memory space by a first process and reading the first data in the first memory space by a second process; and/or the number of the groups of groups,

the second communication module is used for writing second data into a second memory space by a second process, and the first process reads the second data in the second memory space;

the first process is in a kernel mode, the second process is in a user mode, and the first memory space and the second memory space are memory spaces shared by the first process and the second process.

9. An electronic device, comprising: a transceiver, a memory, a processor, and a computer program stored on the memory and executable on the processor; it is characterized in that the method comprises the steps of,

the processor being configured to read a program in a memory to implement the steps in the method according to any one of claims 1 to 7.

10. A readable storage medium, characterized in that it stores thereon a program or instructions which, when executed by a processor, implement the steps of the process communication method according to any of claims 1 to 7.