CN113342554B - IO multiplexing method, medium, device and operating system - Google Patents
IO multiplexing method, medium, device and operating system Download PDFInfo
- Publication number
- CN113342554B CN113342554B CN202110879896.5A CN202110879896A CN113342554B CN 113342554 B CN113342554 B CN 113342554B CN 202110879896 A CN202110879896 A CN 202110879896A CN 113342554 B CN113342554 B CN 113342554B
- Authority
- CN
- China
- Prior art keywords
- event
- kernel
- kernel object
- thread
- target
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Active
Links
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/541—Interprogram communication via adapters, e.g. between incompatible applications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F11/00—Error detection; Error correction; Monitoring
- G06F11/30—Monitoring
- G06F11/3003—Monitoring arrangements specially adapted to the computing system or computing system component being monitored
- G06F11/302—Monitoring arrangements specially adapted to the computing system or computing system component being monitored where the computing system component is a software system
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F11/00—Error detection; Error correction; Monitoring
- G06F11/30—Monitoring
- G06F11/3003—Monitoring arrangements specially adapted to the computing system or computing system component being monitored
- G06F11/3041—Monitoring arrangements specially adapted to the computing system or computing system component being monitored where the computing system component is an input/output interface
Abstract
The embodiment of the invention provides an IO multiplexing method, medium, device and operating system.A monitoring thread in a kernel state receives a call request of an application process, wherein the call request comprises identifiers of a plurality of kernel objects. The monitoring thread creates agent information corresponding to the plurality of kernel objects respectively, and correspondingly binds the agent information to the plurality of kernel objects, the agent information corresponding to each kernel object comprises an event kernel object, and the monitoring thread is blocked by the created event kernel object. And after the event triggering thread triggers the event corresponding to the triggered event identifier to the target kernel object, awakening the monitoring thread through the event kernel object bound by the target kernel object. And the monitoring thread acquires the triggered event identifier of the target kernel object and sends the identifier of the target kernel object and the triggered event identifier to the application process. By the scheme, IO multiplexing of a plurality of kernel objects in the operating system can be realized.
Description
Technical Field
The present invention relates to the field of operating system technologies, and in particular, to an IO multiplexing method, medium, device, and operating system.
Background
The IO multiplexing is a synchronous IO model, and it is implemented that one thread can monitor multiple File descriptors (File handles), and once a certain File descriptor is ready (generally, read ready or write ready), it can notify an application process to perform corresponding read/write operations. The traditional IO multiplexing mechanism is realized by using functions such as select, poll, epoll and the like.
In some operating systems, all underlying layers are shielded by a Virtual File System (VFS) mechanism, a user can implement operations on different files through a uniform interface, each File needs a reference to indicate, and at this time, a File descriptor is generated by application. The file descriptor, being a non-negative integer in form, is actually an index value, pointing to a file. When an application process opens an existing file or creates a new file, the kernel returns a file descriptor to the application process. Most operations on files are operated on by this descriptor, such as read (read), write (write), etc.
The IO multiplexing mechanism implemented by using functions such as select, poll, epoll, and the like belongs to the traditional IO multiplexing mechanism, is only suitable for socket connection and application scenarios adopting a VFS mechanism (such as a block device and a character device accessed to the VFS), and has application limitations.
Disclosure of Invention
The embodiment of the invention provides an IO multiplexing method, medium, equipment and an operating system, which are used for breaking through the limitation that the traditional IO multiplexing mechanism can only effectively connect socket and equipment based on VFS drive, providing an IO multiplexing technology at the level of kernel images and realizing the IO multiplexing mechanism of kernel components.
In a first aspect, an embodiment of the present invention provides an IO multiplexing method, which is applied to a listening thread in a kernel mode, and the method includes:
receiving a calling request of an application process, wherein the calling request comprises identifiers of a plurality of kernel objects;
creating proxy information corresponding to the plurality of kernel objects respectively, wherein the proxy information corresponding to each kernel object comprises an event kernel object;
correspondingly binding the proxy information respectively corresponding to the plurality of kernel objects;
blocking the listening thread by the created event kernel object;
responding to awakening of the monitoring thread by an event trigger thread, and acquiring an event identifier triggered by a target kernel object, wherein after the event trigger thread triggers an event corresponding to the triggered event identifier for the target kernel object, the monitoring thread is awakened by the event kernel object bound by the target kernel object, and the target kernel object is any one of the plurality of kernel objects;
and sending the identification of the target kernel object and the triggered event identification to the application process.
In a second aspect, an embodiment of the present invention provides an IO multiplexing apparatus, corresponding to a listening thread in a kernel mode, including:
the system comprises a receiving module, a processing module and a processing module, wherein the receiving module is used for receiving a calling request of an application process, and the calling request comprises identifiers of a plurality of kernel objects;
the processing module is used for creating proxy information corresponding to the plurality of kernel objects respectively and correspondingly binding the proxy information corresponding to the plurality of kernel objects, wherein the proxy information corresponding to each kernel object comprises an event kernel object; and blocking the listening thread by the created event kernel object;
an obtaining module, configured to obtain an event identifier triggered by a target kernel object in response to an event triggering thread waking the monitoring thread, where after the event triggering thread triggers an event corresponding to the triggered event identifier for the target kernel object, the monitoring thread is woken up by the event kernel object bound by the target kernel object, and the target kernel object is any one of the multiple kernel objects;
and the sending module is used for sending the identifier of the target kernel object and the triggered event identifier to the application process.
In a third aspect, an embodiment of the present invention provides an IO multiplexing method, which is applied to an event-triggered thread in a kernel state, where the method includes:
triggering an event corresponding to the triggered event identification for the target kernel object; wherein the target kernel object is any one of a plurality of kernel objects snooped by a snoop thread; the monitoring thread responds to a call request of an application process, wherein the call request contains the identifiers of the kernel objects, the agent information corresponding to the kernel objects is created, and the agent information corresponding to the kernel objects is correspondingly bound to the kernel objects, wherein the agent information corresponding to each kernel object comprises an event kernel object, and the monitoring thread is in a blocking state through the created event kernel object;
and awakening the monitoring thread through the event kernel object bound by the target kernel object so that the monitoring thread acquires the triggered event identifier of the target kernel object and sends the triggered event identifier and the identifier of the target kernel object to the application process.
In a fourth aspect, an embodiment of the present invention provides an IO multiplexing apparatus, corresponding to an event-triggered thread in a kernel state, where the apparatus includes:
the triggering module is used for triggering an event corresponding to the triggered event identifier for the target kernel object; wherein the target kernel object is any one of the plurality of kernel objects snooped by a snoop thread; the monitoring thread responds to a call request of an application process, wherein the call request contains the identifiers of the kernel objects, the agent information corresponding to the kernel objects is created, and the agent information corresponding to the kernel objects is correspondingly bound to the kernel objects, wherein the agent information corresponding to each kernel object comprises an event kernel object, and the monitoring thread is in a blocking state through the created event kernel object;
and the awakening module is used for awakening the monitoring thread through the event kernel object bound by the target kernel object so that the monitoring thread acquires the triggered event identifier of the target kernel object and sends the triggered event identifier and the identifier of the target kernel object to the application process.
In a fifth aspect, an embodiment of the present invention provides an electronic device, including a processor, a memory, and an operating system, where the memory stores executable code thereon, and when the executable code is executed by the processor, the processor may implement at least the IO multiplexing method in the first aspect or the third aspect.
In a sixth aspect, an embodiment of the present invention provides a non-transitory machine-readable storage medium having stored thereon executable code, which when executed by a processor of an electronic device, causes the processor to implement at least the IO multiplexing method in the first aspect or the third aspect.
In a seventh aspect, an embodiment of the present invention provides an operating system, including:
the system comprises an application process running in a user mode, a monitoring thread and an event triggering thread running in a kernel mode, and a plurality of kernel objects;
the application process is used for sending a call request to the monitoring thread, wherein the call request comprises the identifiers of the kernel objects;
the monitoring thread is used for creating agent information corresponding to the plurality of kernel objects respectively, and correspondingly binding the agent information corresponding to the plurality of kernel objects, wherein the agent information corresponding to each kernel object comprises an event kernel object; blocking the listening thread by the created event kernel object; responding to the awakening of the monitoring thread by the event triggering thread, acquiring an event identifier triggered by a target kernel object, and sending the identifier of the target kernel object and the triggered event identifier to the application process, wherein the target kernel object is any one of the plurality of kernel objects;
and the event triggering thread is used for awakening the monitoring thread through the event kernel object bound by the target kernel object after triggering the event corresponding to the triggered event identifier for the target kernel object.
In the embodiment of the invention, the kernel object is used as a general framework of the kernel component, and an IO multiplexing technology is provided at the level of the kernel object, so as to realize an IO multiplexing mechanism of the kernel component. Specifically, when an application process in the user mode needs to pay attention to a state change (such as a state change into a readable and writable state) of a plurality of kernel objects, a call request is triggered to a listening thread in the kernel mode through a system call, and the call request includes the identifiers of the plurality of kernel objects. The monitoring thread creates proxy information containing event kernel objects (event objects) based on the call request, and binds the proxy information to each kernel object, so that each kernel object is bound with an event kernel object, and event transmission of the kernel objects is carried out through the event kernel objects. After the binding of the agent information is completed, the listening thread may be in a blocking state by calling a setting interface of the event kernel object, and wait for some event of the kernel object to occur. When some event triggering thread in the kernel state calls some kernel object (called target kernel object) and triggers an event corresponding to some event identifier for the target kernel object, the event triggering thread wakes up the listening thread through the event kernel object bound on the target kernel object. The monitoring thread is awakened to indicate that a certain event is triggered by the kernel object, at the moment, the monitoring thread acquires an event identifier triggered by the target kernel object, and feeds back the identifier of the target kernel object and the event identifier triggered by the target kernel object to the application process, so that the application process can process the event corresponding to the event identifier.
In the above scheme, by adding an event proxy mechanism in the kernel objects, when multiplexing monitoring is performed, a piece of temporary proxy information is set in each monitored kernel object, and when any kernel object is triggered by an event, a blocked monitoring thread can be awakened, and an event trigger condition is accurately returned to an application process, so that IO multiplexing of a plurality of kernel objects in the operating system is realized.
Drawings
In order to more clearly illustrate the technical solutions in the embodiments of the present invention, the drawings needed to be used in the description of the embodiments are briefly introduced below, and it is obvious that the drawings in the following description are some embodiments of the present invention, and it is obvious for those skilled in the art to obtain other drawings based on the drawings without creative efforts.
FIG. 1 is a diagram illustrating an operating system architecture according to an embodiment of the present invention;
fig. 2 is an interaction flowchart of an IO multiplexing method according to an embodiment of the present invention;
fig. 3a is an interaction flowchart of an IO multiplexing method according to another embodiment of the present invention;
fig. 3b is a schematic application diagram of an IO multiplexing method according to an embodiment of the present invention;
fig. 4 is an interaction flowchart of an IO multiplexing method according to another embodiment of the present invention;
fig. 5 is a schematic application diagram of an IO multiplexing method according to another embodiment of the present invention;
fig. 6 is a schematic structural diagram of an IO multiplexing apparatus according to an embodiment of the present invention;
fig. 7 is a schematic structural diagram of an IO multiplexing apparatus according to an embodiment of the present invention;
fig. 8 is a schematic structural diagram of an electronic device according to an embodiment of the present invention.
Detailed Description
In order to make the objects, technical solutions and advantages of the embodiments of the present invention clearer, the technical solutions in the embodiments of the present invention will be clearly and completely described below with reference to the drawings in the embodiments of the present invention, and it is obvious that the described embodiments are some, but not all, embodiments of the present invention. All other embodiments, which can be derived by a person skilled in the art from the embodiments given herein without making any creative effort, shall fall within the protection scope of the present invention.
The IO multiplexing method provided by the embodiment of the present invention is used to implement IO multiplexing of kernel components, where the kernel components include interrupts, message queues, shared memories, and the like. In order to realize IO multiplexing of the kernel component, the kernel object is adopted as a general framework of the kernel component, and an IO multiplexing technology is provided on the level of the kernel object, so that an IO multiplexing mechanism of the kernel component can be realized.
The kernel object is a mechanism for encapsulating and abstracting kernel components in the operating system in an objectification mode and managing the kernel components. In short, when the kernel component is managed in an objectification manner, the kernel component may be referred to as a kernel object.
In the scheme, the same base class (kernel object base class) is provided for all kernel objects, the functions realized by the kernel object base class are available for all kernel objects, and in brief, different kernel objects are realized by adding own unique attributes on the basis of inheriting the kernel object base class. The kernel object base classes include, for example: a management mechanism for namespaces, a management mechanism for resource creation, consumption, etc.
In the embodiment of the present invention, not only can each kernel component be implemented based on the design of the same kernel object base class, but also each file included in the operating system can be implemented by adopting the design based on the same kernel object base class, so that each kernel component and file in the operating system inherit the same kernel object base class, and then the IO multiplexing scheme provided by the embodiment of the present invention can be applied to each kernel component and file in the operating system, and at this time, each kernel component and file can be regarded as a kernel object.
Certainly, assuming that an IO multiplexing technology based on a VFS mechanism is already adopted in an operating system, the IO multiplexing scheme provided in the embodiment of the present invention may be applied to the operating system as a complementary scheme to compensate for a situation that the traditional IO multiplexing mechanism cannot cover the kernel component, so that IO multiplexing of the kernel component cannot be implemented.
The following is an exemplary description of an implementation process of the IO multiplexing scheme provided in the embodiment of the present invention.
Fig. 1 is a schematic diagram of an operating system architecture according to an embodiment of the present invention, as shown in fig. 1, the operating system includes: the system comprises an application process running in a user mode, a monitoring thread and an event triggering thread running in a kernel mode, and a plurality of kernel objects.
In fig. 1, it is assumed that an application process is a process that is running an application program, and the application program may need to pay attention to whether a plurality of kernel objects have a read-write event during the running process, and the plurality of kernel objects are kernel objects 1 to kernel object N illustrated in the drawing. The application process will be trapped in kernel state by user state through system call (system call), so that a thread running a monitoring function (called a monitoring thread) is started in kernel state to realize event monitoring to the plurality of kernel objects.
As shown in fig. 1, in practice, the plurality of kernel objects may be currently running in one or more event-triggered threads, for example, it is assumed that kernel object 1 and kernel object 2 are running in event-triggered thread a, and kernel objects 3 to N are running in event-triggered thread b.
Whether the multiple kernel objects run in the same event trigger thread or the multiple event trigger threads, the event trigger condition of the kernel objects run by the event trigger threads is monitored by the same monitoring thread, which is the nature of IO multiplexing of the kernel objects.
In the above operating system, the working process of the application process, the monitoring thread, and the event triggering thread in the process of implementing IO multiplexing of the kernel object may be summarized as follows:
and the application process is used for sending a calling request to the monitoring thread, wherein the calling request comprises the identifiers of the plurality of kernel objects.
The monitoring thread is used for creating proxy information corresponding to the plurality of kernel objects respectively and correspondingly binding the proxy information corresponding to the plurality of kernel objects, wherein the proxy information corresponding to each kernel object comprises an event kernel object; blocking the monitoring thread through the created event kernel object; and responding to the awakening of the monitoring thread by the event triggering thread, acquiring the triggered event identifier of the target kernel object, and sending the identifier of the target kernel object and the triggered event identifier to the application process, wherein the target kernel object is any one of the plurality of kernel objects.
And the event triggering thread is used for awakening the monitoring thread through the event kernel object bound by the target kernel object after the event corresponding to the triggered event identifier is triggered by the target kernel object.
For the sake of understanding, the working process of the application process, the listening thread, and the event triggering thread in the operating system in the process of implementing IO multiplexing of the kernel object is exemplarily described below with reference to fig. 2. In fig. 2, it is assumed that the kernel objects concerned by the application process include a kernel object 1 and a kernel object 2, and the two kernel objects run in the same event trigger thread. As shown in fig. 2, the IO multiplexing method at this time may include the steps of:
201. and the application process sends a call request to the listening thread, wherein the call request comprises the identifiers of the kernel object 1 and the kernel object 2.
202. The listening thread creates proxy information containing the event object.
203. The listening thread binds the agent information to kernel object 1 and kernel object 2.
The agent information is an event agent, and may be a data structure, where the data structure includes an event object. It is understood that the same event object is contained in the proxy information bound to the respective kernel objects.
204. The listening thread is in a blocked state through the event object.
The blocking state may also be referred to as a sleep state. The event object may be provided with a blocking interface function that is set by the listening thread to trap to a blocking state by executing the blocking interface function. The monitoring thread is in a blocking state, and occupation of the CPU can be released.
205. The event triggering thread triggers an event corresponding to a certain event identifier for the kernel object 1.
206. The event-triggered thread wakes up the listening thread based on the event object bound by kernel object 1.
The event object may be provided with a set wake interface function that the event-triggered thread wakes up the listening thread by executing.
As shown in steps 205 and 206, the listening thread may be awakened as long as any one of the kernel objects that the application process needs to listen to is triggered, i.e., a certain event occurs. This also illustrates the nature of the same snoop thread being multiplexed by multiple kernel objects.
207. And the monitoring thread sends the identifier of the kernel object 1 and the triggered event identifier thereof to the application process.
The listening thread is awakened, which indicates that at least one kernel object which it listens to is triggered by an event, so that the listening thread can traverse each kernel object to obtain the identifier of the kernel object which is triggered by the event and the identifier of the event which is triggered.
In the embodiment of the present invention, the event identifier is used to characterize an event type, such as a read event and a write event, but not limited thereto.
The monitoring thread only feeds back the identifier of the kernel object 1 and the triggered event identifier to the application process, so that the application process knows which kernel object is triggered by which type of event currently, and can perform corresponding processing. For example, when a read event occurs in kernel object 1, the application process reads the data generated in kernel object 1 by calling the read function.
The IO multiplexing scheme is designed based on a kernel object base class, so that all kernel objects (such as message queues, shared contents, interrupts, and the like) are naturally supported. By adding an event agent mechanism in the kernel objects, when multiplexing monitoring is carried out, temporary agent information is set in each monitored kernel object, when any kernel object is triggered to have an event, a blocked monitoring thread can be awakened, and meanwhile, the event triggering condition is accurately returned to an application process, so that IO multiplexing of a plurality of kernel objects in an operating system is realized.
In the following, it is still assumed that the kernel objects concerned by the application process include kernel object 1 and kernel object 2, and these two kernel objects run in the same event-triggered thread. Another implementation of the IO multiplexing method is illustrated in conjunction with fig. 3 a.
Fig. 3a is an interaction flowchart of an IO multiplexing method according to another embodiment of the present invention, and as shown in fig. 3a, the method may include the following steps:
301. and the application process sends a call request to the listening thread, wherein the call request comprises the identifiers of the kernel object 1 and the kernel object 2 and the identifiers of the events concerned by the kernel object 1 and the kernel object 2 respectively.
The concerned event identifier of the kernel object refers to an event identifier that a certain kernel object concerned by the application process can be triggered. In fact, a kernel object may be triggered by multiple types of events, but the application process may only care about one or a few of the types of events, and thus the application process will inform the listening thread which types of events are for each kernel object that the listening thread is interested in.
302. The listening thread creates proxy information 1 corresponding to the kernel object 1 and proxy information 2 corresponding to the kernel object 2.
The agent information 1 and the agent information 2 both include pointers of event objects and event lists, the agent information 1 further includes event identifiers of the kernel object 1 which is concerned, and the agent information 2 further includes event identifiers of the kernel object 2 which is concerned.
Wherein, as described above, the role of the same event object created is: blocking the listening thread and waking up the listening thread.
The pointer of the event list, which may also be referred to as a storage address of the event list, is a temporarily created storage space for storing the event identifier triggered by the kernel object.
303. The listening thread binds the agent information 1 to the kernel object 1 and binds the agent information 2 to the kernel object 2.
304. The listening thread is in a blocked state through the event object.
305. The event triggering thread triggers an event corresponding to a certain event identifier for the kernel object 1.
306. And the event triggering thread determines that the concerned event identifier of the kernel object 1 contains the triggered event identifier, and writes the triggered event identifier and the identifier of the kernel object 1 into an event list.
307. The event trigger thread writes the triggered event identification into kernel object 1.
It should be noted that, in practical applications, the agent setting process in step 301-. Because if the event triggering process occurs before the agent setting process, the event that has occurred before is not sensed after the agent setting process is completed, which may result in the loss of the occurred event.
Optionally, when triggering some kind of event of the kernel object 1, the event triggering thread may also write the triggered event identifier into the proxy information bound to the kernel object 1. In this way, after the listening thread is woken up, the listening thread can also traverse the proxy information bound on each kernel object to know which type of event on which kernel object is triggered.
308. The event triggering thread wakes up the monitoring thread through the event object bound by the kernel object 1.
309. The monitoring thread unbinds the agent information corresponding to the kernel object 1 from the kernel object 1, and unbinds the agent information corresponding to the kernel object 2 from the kernel object 2.
310. And deleting the agent information 1 and the agent information 2 corresponding to the kernel object 1 and the kernel object 2 respectively by the monitoring thread.
The monitoring thread responds to a call request of the application process, and executes creation and binding processing of the proxy information once, wherein the life cycle of the proxy information created this time is until the monitoring thread is awakened because the event triggering thread triggers an event to a certain kernel object. Therefore, the event triggering thread stores the called kernel object 1 and the triggered event identifier into the event list based on the pointer of the event list contained in the agent information, and wakes up the monitoring thread through the event object in the agent information, and the role of the agent information is completed, so that after the monitoring thread is woken up, the agent information corresponding to each kernel object created in the calling process can be unbound from the corresponding kernel object, and each created agent information is deleted.
The application process can call the monitoring thread regularly, so that when the monitoring thread receives the call request of the application process next time, the subsequent processing procedures of agent information creation, binding and the like of the next round can be executed.
311. And the listening thread inquires the event list to acquire the identifier of the kernel object 1 and the triggered event identifier thereof.
When the monitoring thread is awakened by the event triggering thread, the monitoring thread traverses the event list to inquire the identifier of the kernel object with the event and the triggered event identifier thereof in the calling process.
312. And the monitoring thread sends the identifier of the kernel object 1 and the triggered event identifier thereof to the application process.
Based on the scheme, the event agent mechanism is added in the kernel objects, a temporary agent is arranged in each monitored kernel object during multiplex monitoring, event transmission of the kernel objects is carried out through the event agent, the storage cost of the event state is saved, when an event occurs in a certain kernel object, the occurred event identification can be written into the agent, the monitoring thread only needs to feed back the event occurrence result inquired from the agent to the application process of the user state, and the application process can obtain an accurate result without traversing the occurrence event like the traditional IO multiplex mechanism realized based on the select function.
To facilitate understanding of the IO multiplexing method provided by the embodiment shown in fig. 3a, the implementation process of fig. 3a is simplified and schematically illustrated in conjunction with fig. 3 b.
Fig. 4 is a flowchart of an IO multiplexing method according to another embodiment of the present invention, and as shown in fig. 4, the method may include the following steps:
401. and the application process sends a call request to the listening thread, wherein the call request comprises the identifiers of the kernel object 1 and the kernel object 2 and the identifiers of the events concerned by the kernel object 1 and the kernel object 2 respectively.
402. The listening thread queries whether there is an event identification triggered in kernel object 1 and kernel object 2.
403. And the monitoring thread inquires that the triggered event identifier exists in the kernel object 2, and then the identifier of the kernel object 2 and the triggered event identifier are sent to the application process.
404. And the application process sends a call request to the listening thread, wherein the call request comprises the identifiers of the kernel object 1 and the kernel object 2 and the identifiers of the events concerned by the kernel object 1 and the kernel object 2 respectively.
405. The listening thread queries whether there is an event identification triggered in kernel object 1 and kernel object 2.
406. And the monitoring thread inquires that the triggered event identifier does not exist in the kernel object 1 and the kernel object 2, and then the agent information 1 corresponding to the kernel object 1 and the agent information 2 corresponding to the kernel object 2 are created.
The agent information 1 and the agent information 2 both include pointers of event objects and event lists, the agent information 1 further includes event identifiers of the kernel object 1 which is concerned, and the agent information 2 further includes event identifiers of the kernel object 2 which is concerned.
407. The listening thread binds the agent information 1 to the kernel object 1 and binds the agent information 2 to the kernel object 2.
408. The listening thread is in a blocked state through the event object.
409. The event triggering thread triggers an event corresponding to a certain event identifier for the kernel object 1.
410. And the event triggering thread determines that the concerned event identifier of the kernel object 1 contains the triggered event identifier, and writes the triggered event identifier and the identifier of the kernel object 1 into an event list.
411. The event trigger thread writes the triggered event identification into kernel object 1.
412. The event triggering thread wakes up the monitoring thread through the event object bound by the kernel object 1.
413. The monitoring thread unbinds the agent information corresponding to the kernel object 1 from the kernel object 1, and unbinds the agent information corresponding to the kernel object 2 from the kernel object 2.
414. And deleting the proxy information corresponding to the kernel object 1 and the kernel object 2 respectively by the monitoring thread.
415. And the listening thread inquires the event list to acquire the identifier of the kernel object 1 and the triggered event identifier thereof.
416. And the monitoring thread sends the identifier of the kernel object 1 and the triggered event identifier thereof to the application process.
According to the scheme provided by this embodiment, when the event triggering thread writes the triggered event identifier of a certain kernel object into the kernel object, after the monitoring thread receives a call request sent by the application process each time, it is first queried whether the triggered event identifier exists in each monitored kernel object, and if so, the identifier of the corresponding kernel object and the triggered event identifier are directly fed back to the application process, so that the application process performs corresponding event processing, and the call process is completed.
In fact, the triggered event identifier stored in the kernel object may be associated with a state identifier, which is used to characterize whether the corresponding event identifier has been notified to the application process. Before the application process is not notified, the state is set to be a non-notification state; when the application process has been notified, the state is set to the notified state. In this way, the listening thread does not repeatedly send to the application process the event identification that has been previously notified to the application process. Or, optionally, after the application process completes the corresponding event processing, the notified state or the completed state may be set.
When the monitoring thread receives the call request sent by the application process again next time, the monitoring thread also executes the process of inquiring whether the triggered event identifier exists in each monitored kernel object, and if the inquiry result shows that the triggered event identifier does not exist in each kernel object (namely the event identifier in the non-notification state), the subsequent steps of agent information creation, binding and the like are executed.
Through the scheme, even the event occurring before the proxy information is created can be accurately notified to the application process, and the loss of the event can not be generated.
The IO multiplexing scheme provided by the embodiment of the invention can realize IO multiplexing of the kernel object. For example, under the micro-kernel architecture, multiplexing of the user-mode interrupt to the same listening thread may be implemented, that is, the IO multiplexing scheme provided by the embodiment of the present invention may be used in a user-mode interrupt scenario.
In this scenario, the user-mode driver will be used as the application process, the interrupt handler in the kernel will be used as the event-triggered thread, and the kernel objects to be snooped will be the interrupts in the kernel, as shown in fig. 5. At this time, as shown in fig. 5, the execution process of the IO multiplexing scheme may be implemented as:
the monitoring thread generates agent information corresponding to each interrupt based on the calling of the user-state driver, and the agent information is bound to the corresponding interrupt, wherein the agent information comprises an event object. The listening thread then falls into a blocked state through the event object. When some interrupt occurs, an interrupt handler in the kernel triggers the corresponding interrupt, and awakens the monitoring thread through the event object bound by the interrupt. And after the monitoring thread is awakened, acquiring triggered interrupt information, and feeding the interrupt information back to the user-mode driver, wherein the user-mode driver processes corresponding interrupt.
The IO multiplexing device according to one or more embodiments of the present invention will be described in detail below. Those skilled in the art will appreciate that these IO multiplexing devices can each be constructed using commercially available hardware components configured through the steps taught in this scheme.
Fig. 6 is a schematic structural diagram of an IO multiplexing apparatus according to an embodiment of the present invention, and as shown in fig. 6, the IO multiplexing apparatus corresponds to a listening thread in a kernel mode, and includes: the device comprises a receiving module 11, a processing module 12, an obtaining module 13 and a sending module 14.
The receiving module 11 is configured to receive a call request of an application process, where the call request includes identifiers of multiple kernel objects.
A processing module 12, configured to create proxy information corresponding to each of the plurality of kernel objects, and correspondingly bind the proxy information corresponding to each of the plurality of kernel objects to the plurality of kernel objects, where the proxy information corresponding to each kernel object includes an event kernel object; and blocking the listening thread through the created event kernel object.
An obtaining module 13, configured to obtain an event identifier triggered by a target kernel object in response to an event triggering thread waking the listening thread, where after the event triggering thread triggers an event corresponding to the triggered event identifier for the target kernel object, the listening thread is woken up by the event kernel object bound by the target kernel object, and the target kernel object is any one of the multiple kernel objects.
A sending module 14, configured to send, to the application process, the identifier of the target kernel object and the identifier of the triggered event.
Optionally, the call request further includes an event identifier to which each of the plurality of kernel objects is concerned; the proxy information corresponding to each kernel object further includes: event identification of the concerned corresponding kernel object; the concerned event identification of the target kernel object is used for: after the event triggering thread triggers the event corresponding to the triggered event identifier for the target kernel object, if the event identifier concerned by the target kernel object contains the triggered event identifier according to the proxy information bound by the target kernel object, the monitoring thread is awakened through the event kernel object bound by the target kernel object.
Optionally, the proxy information corresponding to each kernel object further includes: pointers to event lists. Based on this, the obtaining module 13 is specifically configured to: and inquiring the event list according to the pointer of the event list so as to acquire the triggered event identifier of the target kernel object from the event list. After the event triggering thread triggers the event corresponding to the triggered event identifier to the target kernel object, writing the triggered event identifier and the identifier of the target kernel object into the event list according to the proxy information bound to the target kernel object.
Optionally, after the event triggering thread triggers an event corresponding to the triggered event identifier for the target kernel object, writing the triggered event identifier into the target kernel object. Based on this, the processing module 12 is specifically configured to: if the plurality of kernel objects are inquired that the triggered event identifications do not exist, establishing proxy information corresponding to the plurality of kernel objects respectively; and if the triggered event identifications exist in the plurality of kernel objects, directly sending the triggered event identifications and the identifications of the corresponding kernel objects to the application process.
Optionally, the apparatus further comprises: the deleting module is used for unbinding the agent information respectively corresponding to the plurality of kernel objects from the plurality of kernel objects; and deleting the proxy information corresponding to the plurality of kernel objects respectively.
The IO multiplexing apparatus shown in fig. 6 may perform the steps performed by the listening thread in the foregoing embodiment, and for parts not described in detail in this embodiment, reference may be made to the related description of the foregoing embodiment, which is not described herein again.
Fig. 7 is a schematic structural diagram of an IO multiplexing apparatus according to an embodiment of the present invention, and as shown in fig. 7, the IO multiplexing apparatus corresponds to an event triggered thread in a kernel state, and includes: a trigger module 21 and a wake-up module 22.
The triggering module 21 is configured to trigger an event corresponding to the triggered event identifier for the target kernel object; wherein the target kernel object is any one of a plurality of kernel objects snooped by a snoop thread; the monitoring thread responds to a call request of an application process, wherein the call request contains the identifiers of the kernel objects, the agent information corresponding to the kernel objects is created, and the agent information corresponding to the kernel objects is correspondingly bound to the kernel objects, wherein the agent information corresponding to each kernel object comprises an event kernel object, and the monitoring thread is in a blocking state through the created event kernel object.
A waking module 22, configured to wake up the listening thread through the event kernel object bound by the target kernel object, so that the listening thread obtains an event identifier triggered by the target kernel object, and sends the triggered event identifier and the identifier of the target kernel object to the application process.
Optionally, the call request further includes an event identifier to which each of the plurality of kernel objects is concerned; the proxy information corresponding to each kernel object further includes: event identification of the concerned corresponding kernel object; the wake-up module 22 is specifically configured to: and if the concerned event identifier of the target kernel object contains the triggered event identifier according to the proxy information bound by the target kernel object, awakening the monitoring thread through the event kernel object bound by the target kernel object.
Optionally, the proxy information corresponding to each kernel object further includes: pointers to event lists. The device further comprises: and the writing module is used for writing the triggered event identifier and the identifier of the target kernel object into the event list according to the proxy information bound by the target kernel object, so that the monitoring thread acquires the identifier of the target kernel object and the triggered event identifier from the event list.
The IO multiplexing apparatus shown in fig. 7 may perform the steps of the event-triggered thread execution in the foregoing embodiment, and reference may be made to the related description of the foregoing embodiment for parts not described in detail in this embodiment, which is not described herein again.
In one possible design, the structure of the IO multiplexing device shown in fig. 6 or fig. 7 may be implemented as an electronic device. As shown in fig. 8, the electronic device may include: processor 31, memory 32, operating system 33. Wherein the memory 32 has stored thereon executable code which, when executed by the processor 31, at least makes the processor 31 capable of implementing the IO multiplexing method as provided in the previous embodiments.
The electronic device may also include interfaces such as I/O interfaces, communication interfaces, and the like in its structure.
The operating system 33 includes a user-mode application process, a kernel-mode listening thread and an event-triggered thread. The operating system 23 also includes a plurality of kernel objects.
In addition, an embodiment of the present invention provides a non-transitory machine-readable storage medium having stored thereon executable code, which, when executed by a processor of an electronic device, causes the processor to execute the IO multiplexing method provided in the foregoing embodiment.
The above-described apparatus embodiments are merely illustrative, wherein the various modules illustrated as separate components may or may not be physically separate. Some or all of the modules may be selected according to actual needs to achieve the purpose of the solution of the present embodiment. One of ordinary skill in the art can understand and implement it without inventive effort.
Through the above description of the embodiments, those skilled in the art will clearly understand that each embodiment can be implemented by adding a necessary general hardware platform, and of course, can also be implemented by a combination of hardware and software. With this understanding in mind, the above-described aspects and portions of the present technology which contribute substantially or in part to the prior art may be embodied in the form of a computer program product, which may be embodied on one or more computer-usable storage media having computer-usable program code embodied therein, including without limitation disk storage, CD-ROM, optical storage, and the like.
Finally, it should be noted that: the above examples are only intended to illustrate the technical solution of the present invention, but not to limit it; although the present invention has been described in detail with reference to the foregoing embodiments, it will be understood by those of ordinary skill in the art that: the technical solutions described in the foregoing embodiments may still be modified, or some technical features may be equivalently replaced; and such modifications or substitutions do not depart from the spirit and scope of the corresponding technical solutions of the embodiments of the present invention.
Claims (12)
1. An IO multiplexing method applied to a snoop thread in a kernel mode, the method comprising:
receiving a calling request of an application process, wherein the calling request comprises identifiers of a plurality of kernel objects; the plurality of kernel objects are a plurality of kernel components realized by the same kernel object base class, and the kernel object base class is set based on the common functions used by different kernel components;
creating proxy information corresponding to the plurality of kernel objects respectively, wherein the proxy information corresponding to each kernel object comprises an event kernel object;
correspondingly binding the proxy information respectively corresponding to the plurality of kernel objects;
blocking the listening thread by the created event kernel object;
responding to awakening of the monitoring thread by an event trigger thread, and acquiring an event identifier triggered by a target kernel object, wherein after the event trigger thread triggers an event corresponding to the triggered event identifier for the target kernel object, the monitoring thread is awakened by the event kernel object bound by the target kernel object, and the target kernel object is any one of the plurality of kernel objects;
and sending the identification of the target kernel object and the triggered event identification to the application process.
2. The method according to claim 1, wherein the call request further includes an event identifier of each concerned kernel object; the proxy information corresponding to each kernel object further includes: event identification of the concerned corresponding kernel object;
the concerned event identification of the target kernel object is used for: after the event triggering thread triggers the event corresponding to the triggered event identifier for the target kernel object, if the event identifier concerned by the target kernel object contains the triggered event identifier according to the proxy information bound by the target kernel object, the monitoring thread is awakened through the event kernel object bound by the target kernel object.
3. The method of claim 1, wherein the proxy information corresponding to each kernel object further comprises: a pointer to an event list;
the acquiring the event identifier triggered by the target kernel object includes:
inquiring the event list according to the pointer of the event list so as to acquire the triggered event identifier of the target kernel object from the event list;
after the event triggering thread triggers the event corresponding to the triggered event identifier to the target kernel object, writing the triggered event identifier and the identifier of the target kernel object into the event list according to the proxy information bound to the target kernel object.
4. The method according to claim 1, wherein after the event triggering thread triggers the event corresponding to the triggered event identifier for the target kernel object, writing the triggered event identifier into the target kernel object;
the creating of the proxy information corresponding to the plurality of kernel objects respectively includes:
if the plurality of kernel objects are inquired that the triggered event identifications do not exist, the agent information corresponding to the plurality of kernel objects is created.
5. The method of claim 4, further comprising:
and if the triggered event identifications exist in the plurality of kernel objects, directly sending the triggered event identifications and the identifications of the corresponding kernel objects to the application process.
6. The method of claim 1, further comprising:
unbinding the agent information corresponding to the plurality of kernel objects from the plurality of kernel objects respectively;
and deleting the proxy information corresponding to the plurality of kernel objects respectively.
7. An IO multiplexing method applied to an event-triggered thread in a kernel state, the method comprising:
triggering an event corresponding to the triggered event identification for the target kernel object; wherein the target kernel object is any one of a plurality of kernel objects snooped by a snoop thread; the monitoring thread responds to a call request of an application process, wherein the call request contains the identifiers of the kernel objects, the agent information corresponding to the kernel objects is created, and the agent information corresponding to the kernel objects is correspondingly bound to the kernel objects, wherein the agent information corresponding to each kernel object comprises an event kernel object, and the monitoring thread is in a blocking state through the created event kernel object; the plurality of kernel objects are a plurality of kernel components realized by the same kernel object base class, and the kernel object base class is set based on the common functions used by different kernel components;
and awakening the monitoring thread through the event kernel object bound by the target kernel object so that the monitoring thread acquires the triggered event identifier of the target kernel object and sends the triggered event identifier and the identifier of the target kernel object to the application process.
8. The method according to claim 7, wherein the call request further includes an event identifier of each concerned event of the plurality of kernel objects; the proxy information corresponding to each kernel object further includes: event identification of the concerned corresponding kernel object;
the waking up the monitoring thread by the event kernel object bound by the target kernel object includes:
and if the concerned event identifier of the target kernel object contains the triggered event identifier according to the proxy information bound by the target kernel object, awakening the monitoring thread through the event kernel object bound by the target kernel object.
9. The method of claim 7, wherein the proxy information corresponding to each kernel object further comprises: a pointer to an event list;
the method further comprises the following steps:
and writing the triggered event identifier and the identifier of the target kernel object into the event list according to the proxy information bound by the target kernel object, so that the monitoring thread acquires the identifier of the target kernel object and the triggered event identifier from the event list.
10. A non-transitory machine-readable storage medium having stored thereon executable code, which when executed by a processor of an electronic device, causes the processor to perform the IO multiplexing method of any one of claims 1 to 6, or the IO multiplexing method of any one of claims 7 to 9.
11. An electronic device, comprising: a memory, a processor, an operating system; wherein the memory has stored thereon executable code which, when executed by the processor, causes the processor to perform the IO multiplexing method of any one of claims 1 to 6, or the IO multiplexing method of any one of claims 7 to 9.
12. An operating system, comprising:
the system comprises an application process running in a user mode, a monitoring thread and an event triggering thread running in a kernel mode, and a plurality of kernel objects;
the application process is used for sending a call request to the monitoring thread, wherein the call request comprises the identifiers of the kernel objects; the plurality of kernel objects are a plurality of kernel components realized by the same kernel object base class, and the kernel object base class is set based on the common functions used by different kernel components;
the monitoring thread is used for creating agent information corresponding to the plurality of kernel objects respectively, and correspondingly binding the agent information corresponding to the plurality of kernel objects, wherein the agent information corresponding to each kernel object comprises an event kernel object; blocking the listening thread by the created event kernel object; responding to the awakening of the monitoring thread by the event triggering thread, acquiring an event identifier triggered by a target kernel object, and sending the identifier of the target kernel object and the triggered event identifier to the application process, wherein the target kernel object is any one of the plurality of kernel objects;
and the event triggering thread is used for awakening the monitoring thread through the event kernel object bound by the target kernel object after triggering the event corresponding to the triggered event identifier for the target kernel object.
Priority Applications (2)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202110879896.5A CN113342554B (en) | 2021-08-02 | 2021-08-02 | IO multiplexing method, medium, device and operating system |
| PCT/CN2022/107885 WO2023011249A1 (en) | 2021-08-02 | 2022-07-26 | I/o multiplexing method, medium, device and operation system |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202110879896.5A CN113342554B (en) | 2021-08-02 | 2021-08-02 | IO multiplexing method, medium, device and operating system |
Publications (2)
| Publication Number | Publication Date |
|---|---|
| CN113342554A CN113342554A (en) | 2021-09-03 |
| CN113342554B true CN113342554B (en) | 2022-01-04 |
Family
ID=77480659
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202110879896.5A Active CN113342554B (en) | 2021-08-02 | 2021-08-02 | IO multiplexing method, medium, device and operating system |
Country Status (2)
| Country | Link |
|---|---|
| CN (1) | CN113342554B (en) |
| WO (1) | WO2023011249A1 (en) |
Families Citing this family (2)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN113342554B (en) * | 2021-08-02 | 2022-01-04 | 阿里云计算有限公司 | IO multiplexing method, medium, device and operating system |
| CN117632533A (en) * | 2022-08-19 | 2024-03-01 | 华为技术有限公司 | Interrupt message processing method and device |
Citations (13)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US20110173630A1 (en) * | 2008-02-01 | 2011-07-14 | Arimilli Ravi K | Central Repository for Wake-and-Go Mechanism |
| US20150089011A1 (en) * | 2013-09-25 | 2015-03-26 | International Business Machines Corporation | Event Driven Remote Direct Memory Access Snapshots |
| US20160011997A1 (en) * | 2009-10-09 | 2016-01-14 | Avago Technologies General Ip (Singapore) Pte. | Enhanced I/O Performance in a Multi-Processor System Via Interrupt Affinity Schemes |
| CN106970821A (en) * | 2016-01-12 | 2017-07-21 | 阿里巴巴集团控股有限公司 | A kind of method and apparatus that I/O requests are handled under KVM virtualization |
| US20180217915A1 (en) * | 2015-09-25 | 2018-08-02 | Huawei Technologies Co.,Ltd. | Debugging method, multi-core processor, and debugging device |
| US20180295052A1 (en) * | 2017-04-06 | 2018-10-11 | Gvbb Holdings S.A.R.L. | System and method for timely and uniform distribution for real-time packet transmission |
| CN109918054A (en) * | 2019-01-24 | 2019-06-21 | 华东师范大学 | A kind of service bus micro-kernel frame design method based on Formal Specification |
| CN110096340A (en) * | 2018-01-29 | 2019-08-06 | 北京世纪好未来教育科技有限公司 | Timed task processing method and processing device |
| CN112631744A (en) * | 2019-09-24 | 2021-04-09 | 阿里巴巴集团控股有限公司 | Process processing method and device, electronic equipment and computer readable storage medium |
| CN112685148A (en) * | 2020-12-07 | 2021-04-20 | 南方电网数字电网研究院有限公司 | Asynchronous communication method and device of mass terminals, computer equipment and storage medium |
| CN112698963A (en) * | 2020-12-22 | 2021-04-23 | 新华三技术有限公司成都分公司 | Event notification method and device |
| CN112749023A (en) * | 2019-10-30 | 2021-05-04 | 阿里巴巴集团控股有限公司 | Information processing method, device, equipment and system |
| CN112968965A (en) * | 2021-02-25 | 2021-06-15 | 网宿科技股份有限公司 | Metadata service method, server and storage medium for NFV network node |
Family Cites Families (5)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| WO2011096307A1 (en) * | 2010-02-03 | 2011-08-11 | 日本電気株式会社 | Proxy device and operation method thereof |
| CN107436838A (en) * | 2017-07-12 | 2017-12-05 | 北京潘达互娱科技有限公司 | A kind of kernel data statistical method and device |
| CN109947581B (en) * | 2019-03-29 | 2021-08-27 | 浪潮云信息技术股份公司 | High concurrency data transfer method and data transfer method for switch |
| CN111158937A (en) * | 2019-12-31 | 2020-05-15 | 奇安信科技集团股份有限公司 | Software core file endogenous protection method and device based on kernel drive |
| CN113342554B (en) * | 2021-08-02 | 2022-01-04 | 阿里云计算有限公司 | IO multiplexing method, medium, device and operating system |
-
2021
- 2021-08-02 CN CN202110879896.5A patent/CN113342554B/en active Active
-
2022
- 2022-07-26 WO PCT/CN2022/107885 patent/WO2023011249A1/en unknown
Patent Citations (13)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US20110173630A1 (en) * | 2008-02-01 | 2011-07-14 | Arimilli Ravi K | Central Repository for Wake-and-Go Mechanism |
| US20160011997A1 (en) * | 2009-10-09 | 2016-01-14 | Avago Technologies General Ip (Singapore) Pte. | Enhanced I/O Performance in a Multi-Processor System Via Interrupt Affinity Schemes |
| US20150089011A1 (en) * | 2013-09-25 | 2015-03-26 | International Business Machines Corporation | Event Driven Remote Direct Memory Access Snapshots |
| US20180217915A1 (en) * | 2015-09-25 | 2018-08-02 | Huawei Technologies Co.,Ltd. | Debugging method, multi-core processor, and debugging device |
| CN106970821A (en) * | 2016-01-12 | 2017-07-21 | 阿里巴巴集团控股有限公司 | A kind of method and apparatus that I/O requests are handled under KVM virtualization |
| US20180295052A1 (en) * | 2017-04-06 | 2018-10-11 | Gvbb Holdings S.A.R.L. | System and method for timely and uniform distribution for real-time packet transmission |
| CN110096340A (en) * | 2018-01-29 | 2019-08-06 | 北京世纪好未来教育科技有限公司 | Timed task processing method and processing device |
| CN109918054A (en) * | 2019-01-24 | 2019-06-21 | 华东师范大学 | A kind of service bus micro-kernel frame design method based on Formal Specification |
| CN112631744A (en) * | 2019-09-24 | 2021-04-09 | 阿里巴巴集团控股有限公司 | Process processing method and device, electronic equipment and computer readable storage medium |
| CN112749023A (en) * | 2019-10-30 | 2021-05-04 | 阿里巴巴集团控股有限公司 | Information processing method, device, equipment and system |
| CN112685148A (en) * | 2020-12-07 | 2021-04-20 | 南方电网数字电网研究院有限公司 | Asynchronous communication method and device of mass terminals, computer equipment and storage medium |
| CN112698963A (en) * | 2020-12-22 | 2021-04-23 | 新华三技术有限公司成都分公司 | Event notification method and device |
| CN112968965A (en) * | 2021-02-25 | 2021-06-15 | 网宿科技股份有限公司 | Metadata service method, server and storage medium for NFV network node |
Non-Patent Citations (2)
| Title |
|---|
| The design and implementation of microdrivers;Vinod Ganapathy 等;《ACM》;20080331;全文 * |
| 自适应网络I/O模型的研究与实现;黄欣;《中国优秀博硕士学位论文全文数据库（硕士）信息科技辑》;20130215;全文 * |
Also Published As
| Publication number | Publication date |
|---|---|
| WO2023011249A1 (en) | 2023-02-09 |
| CN113342554A (en) | 2021-09-03 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| US10198343B2 (en) | Method for debugging a computer program | |
| CN107729139B (en) | Method and device for concurrently acquiring resources | |
| CN110941481A (en) | Resource scheduling method, device and system | |
| US8006246B2 (en) | Apparatus for forcibly terminating thread blocked on input/output operation and method for the same | |
| CN113342554B (en) | IO multiplexing method, medium, device and operating system | |
| JP5705871B2 (en) | Resolving locks on distributed persistent instances | |
| EP2893444A1 (en) | Quota-based resource management | |
| CN102541661B (en) | Realize the method and apparatus of wait on address synchronization interface | |
| JPH05197568A (en) | Computer system and method of event management | |
| US11327816B2 (en) | Monitoring components in a service framework | |
| US11386014B2 (en) | Method and system for low latency data management | |
| EP3489815B1 (en) | Method and system for low latency data management | |
| CN111857993B (en) | Method for calling user mode function in kernel mode | |
| CN109359092B (en) | File management method, desktop display method, device, terminal and medium | |
| CN111897666A (en) | Method, device and system for communication among multiple processes | |
| US20190227918A1 (en) | Method for allocating memory resources, chip and non-transitory readable medium | |
| CN113010265A (en) | Pod scheduling method, scheduler, memory plug-in and system | |
| CN112214388A (en) | Memory monitoring method, device, equipment and computer readable storage medium | |
| CN113515317A (en) | Data recovery method and device | |
| CN113157426A (en) | Task scheduling method, system, equipment and storage medium | |
| US20040025007A1 (en) | Restricting access to a method in a component | |
| JP2006031203A (en) | On-vehicle information terminal | |
| CN110879747B (en) | Resource management method and device | |
| EP4354284A1 (en) | Scheduling method, apparatus and system, and computing device | |
| JP2016173746A (en) | Information processing device, control method thereof and program |
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 |