CN115203251A - Local database query method based on shared memory - Google Patents
Local database query method based on shared memory Download PDFInfo
- Publication number
- CN115203251A CN115203251A CN202210614921.1A CN202210614921A CN115203251A CN 115203251 A CN115203251 A CN 115203251A CN 202210614921 A CN202210614921 A CN 202210614921A CN 115203251 A CN115203251 A CN 115203251A
- Authority
- CN
- China
- Prior art keywords
- shared memory
- memory
- database
- client
- space
- 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.)
- Pending
Links
- 238000000034 method Methods 0.000 title claims abstract description 122
- 230000008569 process Effects 0.000 claims abstract description 80
- 230000007246 mechanism Effects 0.000 claims abstract description 16
- 238000004891 communication Methods 0.000 claims abstract description 14
- 230000006870 function Effects 0.000 claims description 30
- 238000004590 computer program Methods 0.000 claims description 9
- 238000013507 mapping Methods 0.000 claims description 6
- 238000005516 engineering process Methods 0.000 claims description 5
- 238000010586 diagram Methods 0.000 description 2
- 238000004458 analytical method Methods 0.000 description 1
- 238000007405 data analysis Methods 0.000 description 1
- 238000012986 modification Methods 0.000 description 1
- 230000004048 modification Effects 0.000 description 1
- 230000003287 optical effect Effects 0.000 description 1
- 238000012545 processing Methods 0.000 description 1
- 238000012827 research and development Methods 0.000 description 1
- 239000007787 solid Substances 0.000 description 1
- 238000006467 substitution reaction Methods 0.000 description 1
Images
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F16/00—Information retrieval; Database structures therefor; File system structures therefor
- G06F16/20—Information retrieval; Database structures therefor; File system structures therefor of structured data, e.g. relational data
- G06F16/24—Querying
- G06F16/245—Query processing
- G06F16/2455—Query execution
- G06F16/24553—Query execution of query operations
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F16/00—Information retrieval; Database structures therefor; File system structures therefor
- G06F16/20—Information retrieval; Database structures therefor; File system structures therefor of structured data, e.g. relational data
- G06F16/24—Querying
- G06F16/245—Query processing
- G06F16/2455—Query execution
- G06F16/24552—Database cache management
-
- 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/544—Buffers; Shared memory; Pipes
Landscapes
- Engineering & Computer Science (AREA)
- Theoretical Computer Science (AREA)
- Databases & Information Systems (AREA)
- Physics & Mathematics (AREA)
- General Engineering & Computer Science (AREA)
- General Physics & Mathematics (AREA)
- Computational Linguistics (AREA)
- Data Mining & Analysis (AREA)
- Software Systems (AREA)
- Information Retrieval, Db Structures And Fs Structures Therefor (AREA)
Abstract
The invention discloses a local database query method based on a shared memory, which belongs to the technical field of databases and aims to solve the technical problems of removing pain points of the shared memory, reducing the data access times and data copy times in the memory and improving the query efficiency, and the technical scheme is as follows: the method is based on an interprocess communication mechanism of a shared memory, and an inquiry iterator object established in a local database process is shared to a client process for use, so that the client can inquire data in a database.
Description
Technical Field
The invention relates to the technical field of databases, in particular to a local database query method based on a shared memory.
Background
The database system operates as an independent process, and the client is another process. For a scenario where the client and the database system operate on the same server, the communication between them is inter-process communication. The client accesses the database by adopting a Socket-based communication mechanism.
Interprocess communication is the propagation or exchange of information between different processes. The user spaces of the processes are independent of each other and are generally inaccessible to each other, with the only exception being a shared memory area. In addition, the system space is a "public place" that is accessible to processes, so the kernel can also provide such conditions. Common methods of interprocess communication (IPC) are: signals, pipes, sockets, semaphores, shared memory, and message queues.
Shared memory is a memory mapped to be accessed by other processes, and the shared memory is created by one process but can be accessed by a plurality of processes. Shared memory is the fastest IPC method, and is specially designed for the low operating efficiency of other interprocess communication methods.
The disadvantages of shared memory communication are as follows:
(1) predefining a data format in the shared memory among the processes;
(2) the process of data analysis is complicated, and data indexes may need to be created again;
(3) the area of shared memory must be contiguous.
Therefore, how to remove pain points of the shared memory, reduce the number of data access times and the number of data copy times in the memory, and improve the query efficiency is a technical problem to be solved urgently at present.
Disclosure of Invention
The technical task of the invention is to provide a local database query method based on a shared memory, so as to solve the problems of how to remove pain points of the shared memory, reduce the data access times and data copy times in the memory and improve the query efficiency.
The technical task of the invention is realized in the following way, a local database query method based on shared memory, the method is based on the inter-process communication mechanism of the shared memory, the query iterator object created in the local database process is shared to the client process for use, and then the client performs data query to the database; the method comprises the following specific steps:
s1, when a client side inquires data in any time period, calling an API (application program interface) inquiry interface of a database SDK (software development kit);
s2, a database SDK in the client calls a query function of a database process through a gPRC mechanism;
s3, the database process applies for the space required by the iterator object to the shared memory management module, and creates a shared memory iterator on the applied shared memory space;
s4, searching a corresponding memory block object according to the queried time range, and adding one to the reference technology of the memory block object;
s5, storing the memory block object pointer in a ref array of the iterator, and finding the position of the inquired first piece of data through a positioning algorithm;
s6, returning the pointer of the iterator to a database SDK of the client through a gRPC mechanism;
s7, after the database SDK of the client receives the pointer address, converting the space pointed by the pointer into an iterator object in the client process through a forced forwarding instruction;
s8, the client accesses data in the database SDK by using the iterator object; calling a value function to obtain a numerical value of the current record, calling a next function to position the position of the next record, and judging whether the query is finished or not through the valid function;
s9, after the query of the client is finished, calling an end interface, and calling a function for ending the query of the database process by the database SDK of the client through a gPRC mechanism;
s10, the database process subtracts one from the reference count of the objects in the ref array of the iterator, and then deletes the iterator objects;
and S11, returning to success.
Preferably, before the client queries the database, the following is executed:
creating an inter-process shared memory: the shared memory in a plurality of processes is set to be the same initial address by allocating a large shared memory space, so that pointers in the shared memory can be directly used among the processes, and a foundation is created for sharing objects among the processes;
the database process manages the shared memory: the database process is used for managing and maintaining data in the whole shared memory, and the client process is used for reading the memory data; a shared memory management module is arranged in a database process and used for providing functions of an application space and a release space.
Preferably, the creating of the inter-process shared memory specifically includes:
when a database process and a client process are started, a loading shared memory is created, and the same initial address of the shared memory is set;
configuring the initial address of the shared memory mapping area of the client process and the initial address of the shared memory mapping area of the database process into the same initial address;
after the setting is completed, a pointer pointing to any variable stored in the shared memory is created in the shared memory, and the pointer can be correctly analyzed in different processes and the variable pointed by the pointer can be read.
Preferably, the shared memory management module is further configured to manage a whole continuous space allocated by the shared memory, and provide an interface for applying and releasing a space of any size of the memory in the continuous area of the shared memory.
Preferably, the memory management mode of the shared memory management module adopts simple and convenient fixed-length memory management with the highest performance.
Preferably, the shared memory management module further has the following functions:
(1) initializing the shared memory management module: the shared memory management module divides the whole shared memory space into memory blocks with fixed sizes according to the size of 8K, and places the initial addresses of the memory blocks into a usable queue;
(2) applying for a space to the shared memory management module: the shared memory management module provides a memory application allocation interface Allocate8K, calls the interface Allocate8K, and takes out the first address of the memory block at the head of the usable queue and returns the first address;
(3) releasing the space applied by the shared memory management module: the shared memory management module provides a memory Release interface Release, and places the incoming memory block head address into the end of the usable queue.
Preferably, the shared memory space is used for sharing data and sharing objects;
the database process stores the data and the objects required by the query in a shared memory space, and the shared memory space creates the related class objects and the array space for storing the data according to the use mode of a normal memory.
Preferably, the iterator internally includes a list of all memory chunk objects (ZMetricVector objects) that overlap with the query time range, and an iterator current location pointer.
An electronic device, comprising: a memory and at least one processor;
wherein the memory has stored thereon a computer program;
the at least one processor executes the computer program stored by the memory, causing the at least one processor to perform the shared memory-based local database query method as described above.
A computer-readable storage medium having stored thereon a computer program executable by a processor to implement a shared memory-based local database query method as described above.
The local database query method based on the shared memory has the following advantages:
the invention aims at the problem of low query performance caused by the fact that data needs to be copied in a memory for many times when a local database is queried, uses a shared memory-based technology, and data stored in the database does not need to be copied at all, thereby greatly improving the performance and having the following advantages:
(1) the data to be queried does not have to be copied;
(2) the shared object technology is used, the memory data format is shielded, and the research and development work is simplified;
(3) by using an iterator mechanism, the client acquires data one by one according to needs without occupying memory space;
aiming at pain points of shared memory communication, based on an inter-process communication mechanism of a shared memory, the query iterator object established in the process of the local database is used, the query iterator object can be shared in the process of the client, the data format of the shared memory is shielded, the client does not need to establish a new iterator object, the query efficiency is improved, and the analysis process of the client on the shared memory data is simplified;
the shared memory is set to be the same initial address in a plurality of processes by allocating a large shared memory space, so that pointers in the shared memory can be directly used among the processes, and a foundation is created for sharing objects among the processes;
and fourthly, by sharing the iterator object used for query, the method reduces the data access times and the data copying times in the memory, thereby improving the performance during query. Meanwhile, logic for analyzing the storage format of the data to be queried is hidden.
Drawings
The invention is further described below with reference to the accompanying drawings.
FIG. 1 is a diagram illustrating creation of an interprocess shared memory;
FIG. 2 is a diagram of a database process managing shared memory.
Detailed Description
The method for querying a local database based on a shared memory according to the present invention is described in detail below with reference to the drawings and the embodiments.
Example 1:
the invention relates to a local database query method based on a shared memory, which is based on an interprocess communication mechanism of the shared memory, and shares a query iterator object established in a local database process to a client process for use, thereby realizing that the client queries data from a database; the method comprises the following specific steps:
s1, calling an API (application programming interface) query interface of the database SDK when a client queries data in any time period;
s2, a database SDK in the client calls a query function of a database process through a gPRC mechanism;
s3, the database process applies for the space required by the iterator object to the shared memory management module, and creates a shared memory iterator on the applied shared memory space;
s4, searching a corresponding memory block object according to the inquired time range, and adding one to the reference technology of the memory block object;
s5, storing the memory block object pointer in a ref array of the iterator, and finding the position of the inquired first piece of data through a positioning algorithm;
s6, returning the pointer of the iterator to a database SDK of the client through a gPRC mechanism;
s7, after the database SDK of the client receives the pointer address, converting the space pointed by the pointer into an iterator object in the client process through a forced forwarding instruction;
s8, the client accesses data in the database SDK by using the iterator object; calling a value function to obtain a numerical value of the current record, calling a next function to position the position of the next record, and judging whether the query is finished or not through the valid function;
s9, after the query of the client is finished, calling an end interface, and calling a function for ending the query of the database process by the database SDK of the client through a gPRC mechanism;
s10, the database process subtracts one from the reference count of the objects in the ref array of the iterator, and then deletes the iterator objects;
and S11, returning to success.
Before the client in this embodiment performs data query on the database, the following is executed:
creating an inter-process shared memory: the shared memory in a plurality of processes is set to be the same initial address by allocating a large shared memory space, so that pointers in the shared memory can be directly used among the processes, and a foundation is created for sharing objects among the processes;
(II) managing the shared memory by the database process: the database process is used for managing and maintaining data in the whole shared memory, and the client process is used for reading the memory data; a shared memory management module is arranged in a database process and used for providing functions of an application space and a release space.
As shown in fig. 1, the creating of the inter-process shared memory in this embodiment is specifically as follows:
(1) When the database process and the client process are started, establishing and loading a shared memory, and setting the same initial address of the shared memory; the process shares a larger memory space, and the memory space can be configured as a parameter, such as 2G.
(2) Configuring the initial address of the shared memory mapping area of the client process and the initial address of the shared memory mapping area of the database process into the same initial address;
(3) After the setting is finished, a pointer pointing to any variable stored in the shared memory is established in the shared memory, and the pointer can be correctly analyzed in different processes and can read out the variable pointed by the pointer.
The shared memory management module in this embodiment is further configured to manage a whole continuous space allocated by the shared memory, and provide an interface for applying and releasing a space of any size of the memory in the continuous area of the shared memory. The memory management mode of the shared memory management module adopts simple and convenient fixed-length memory management with the highest performance. The shared memory management module also has the following functions:
(1) initializing a shared memory management module: the shared memory management module divides the whole shared memory space into memory blocks with fixed size according to the size of 8K, and places the initial addresses of the memory blocks into usable queues;
(2) applying for a space to the shared memory management module: the shared memory management module provides a memory application allocation interface Allocate8K, calls the interface Allocate8K, and takes out the first address of the memory block at the head of the usable queue and returns the first address;
(3) releasing the space applied by the shared memory management module: the shared memory management module provides a memory Release interface Release, and places the incoming memory block head address into the end of the usable queue.
The shared memory space in this embodiment is used for sharing data and shared objects;
the database process stores the data and the objects required by the query in a shared memory space, and the shared memory space creates the mutually associated class objects and the array space for storing the data according to the use mode of a normal memory.
As shown in fig. 2, data is divided into many fixed-size (1000 pieces by default) data blocks in zmetricvectors. Each ZMetricVector object internally maintains a memory block head address list applied from the shared memory management module for storing data. When the storage space reserved by the ZMetricVector object is insufficient, the space for storing the records with fixed size (100 records by default) is applied to the shared memory. When the amount of data stored in a ZMetricVector object reaches 1000, the object cannot insert data, and new data needs to be inserted into the newly created ZMetricVector object.
As data is continually inserted into the database, the database maintains a list of all ZMetricVector objects.
The MectricIterator refers to an iterator object that is returned when querying data for a certain time range. The entire iterator internally includes a list of all memory chunk objects (ZMetricVector objects) that overlap the query time range, as well as the iterator current location pointer. And when the initialization of the MectricItator is completed, the default position is the recording position corresponding to the minimum time of the query time range. The Next function moves the location pointer to the Next record location in the sequence. The Valid function is used to determine whether the current record is Valid. The Value function is used to return the Value of this record.
Example 2:
the present embodiment further provides an electronic device, including: a memory and a processor;
wherein the memory stores computer execution instructions;
the processor executes the computer executable instructions stored in the memory, so that the processor executes the local database query method based on the shared memory in any embodiment of the invention.
The processor may be a Central Processing Unit (CPU), but may also be other general purpose processors, digital Signal Processors (DSPs), application Specific Integrated Circuits (ASICs), array of off-the-shelf programmable gates (FPGAs) or other programmable logic devices, discrete gate or transistor logic devices, discrete hardware components, and the like. The processor may be a microprocessor or the processor may be any conventional processor or the like.
The memory may be used to store computer programs and/or modules, and the processor may implement various functions of the electronic device by executing or executing the computer programs and/or modules stored in the memory and invoking data stored in the memory. The memory may mainly include a storage program area and a storage data area, wherein the storage program area may store an operating system, an application program required for at least one function, and the like; the storage data area may store data created according to the use of the terminal, and the like. The memory may also include high speed random access memory, and may also include non-volatile memory, such as a hard disk, a memory, a plug-in hard disk, a memory only card (SMC), a Secure Digital (SD) card, a flash memory card, at least one disk storage period, a flash memory device, or other volatile solid state memory device.
Example 3:
the present embodiment also provides a computer-readable storage medium, in which a plurality of instructions are stored, and the instructions are loaded by a processor, so that the processor executes the method for querying a local database based on a shared memory according to any embodiment of the present invention. Specifically, a system or an apparatus equipped with a storage medium on which software program codes that realize the functions of any of the above-described embodiments are stored may be provided, and a computer (or a CPU or MPU) of the system or the apparatus is caused to read out and execute the program codes stored in the storage medium.
In this case, the program code itself read from the storage medium can realize the functions of any of the above-described embodiments, and thus the program code and the storage medium storing the program code constitute a part of the present invention.
Examples of the storage medium for supplying the program code include a floppy disk, a hard disk, a magneto-optical disk, an optical disk (e.g., CD-ROM, CD-R, CD-RW, DVD-ROM, DVD-RYM, DVD-RW, DVD + RW), a magnetic tape, a nonvolatile memory card, and a ROM. Alternatively, the program code may be downloaded from a server computer via a communications network.
Further, it should be clear that the functions of any one of the above-described embodiments may be implemented not only by executing the program code read out by the computer, but also by causing an operating system or the like operating on the computer to perform a part or all of the actual operations based on instructions of the program code.
Further, it is to be understood that the program code read out from the storage medium is written to a memory provided in an expansion board inserted into the computer or to a memory provided in an expansion unit connected to the computer, and then causes a CPU or the like mounted on the expansion board or the expansion unit to perform part or all of the actual operations based on instructions of the program code, thereby realizing the functions of any of the above-described embodiments.
Finally, it should be noted that: the above embodiments are only used to illustrate the technical solution of the present invention, and not to limit the same; while the invention has been described in detail and with reference to the foregoing embodiments, it will be understood by those skilled in the art that: the technical solutions described in the foregoing embodiments may still be modified, or some or all of the technical features may be equivalently replaced; and the modifications or the substitutions do not make the essence of the corresponding technical solutions depart from the scope of the technical solutions of the embodiments of the present invention.
Claims (10)
1. A local database query method based on shared memory is characterized in that the method is based on an interprocess communication mechanism of the shared memory, and a query iterator object created in a local database process is shared to a client process for use, so that the client can query the database for data; the method comprises the following specific steps:
s1, calling an API (application programming interface) query interface of the database SDK when a client queries data in any time period;
s2, a database SDK in the client calls a query function of a database process through a gPRC mechanism;
s3, the database process applies for the space required by the iterator object to the shared memory management module, and creates a shared memory iterator on the applied shared memory space;
s4, searching a corresponding memory block object according to the queried time range, and adding one to the reference technology of the memory block object;
s5, storing the memory block object pointer in a ref array of the iterator, and finding the position of the inquired first piece of data through a positioning algorithm;
s6, returning the pointer of the iterator to a database SDK of the client through a gRPC mechanism;
s7, after the database SDK of the client receives the pointer address, converting the space pointed by the pointer into an iterator object in the client process through a forced forwarding instruction;
s8, the client accesses data in the database SDK by using the iterator object; calling a value function to obtain a numerical value of the current record, calling a next function to position the position of the next record, and judging whether the query is finished or not through the valid function;
s9, after the query of the client is finished, calling an end interface, and calling a function for ending the query of the database process by the database SDK of the client through a gPRC mechanism;
s10, the database process subtracts one from the object reference count in the ref array of the iterator, and then deletes the iterator object;
and S11, returning to success.
2. The local database query method based on shared memory according to claim 1, wherein the following is executed before the client queries the database:
creating an inter-process shared memory: the shared memory in a plurality of processes is set to be the same initial address by allocating the shared memory space, so that pointers in the shared memory can be directly used among the processes, and a foundation is created for sharing objects among the processes;
the database process manages the shared memory: the database process is used for managing and maintaining data in the whole shared memory, and the client process is used for reading memory data; a shared memory management module is arranged in a database process and used for providing functions of an application space and a release space.
3. The local database query method based on shared memory according to claim 2, wherein the creating of the inter-process shared memory is specifically as follows:
when a database process and a client process are started, a loading shared memory is created, and the same initial address of the shared memory is set;
configuring the initial address of the shared memory mapping area of the client process and the initial address of the shared memory mapping area of the database process into the same initial address;
after the setting is completed, a pointer pointing to any variable stored in the shared memory is created in the shared memory, and the pointer can be correctly analyzed in different processes and the variable pointed by the pointer can be read.
4. The method according to claim 1 or 2, wherein the shared memory management module is further configured to manage a whole continuous space allocated by the shared memory, and provide an interface for applying and releasing a space of any size in the continuous area of the shared memory.
5. The local database query method based on shared memory according to claim 4, wherein the memory management mode of the shared memory management module adopts fixed-length memory management.
6. The method according to claim 5, wherein the shared memory management module further has the following functions:
(1) initializing a shared memory management module: the shared memory management module divides the whole shared memory space into memory blocks with fixed sizes according to the sizes, and places the initial addresses of the memory blocks into a usable queue;
(2) applying for a space to the shared memory management module: the shared memory management module provides a memory application allocation interface Allocate8K, calls the interface Allocate8K, and takes out the first address of the memory block at the head of the usable queue and returns the first address;
(3) releasing the space applied by the shared memory management module: the shared memory management module provides a memory Release interface Release, and places the incoming memory block head address into the end of the usable queue.
7. The local database query method based on shared memory according to claim 6, wherein the shared memory space is used for sharing data and shared objects;
the database process stores the data and the objects required by the query in a shared memory space, and the shared memory space creates the related class objects and the array space for storing the data according to the use mode of a normal memory.
8. The method according to claim 7, wherein the iterator internally comprises a list of all memory block objects overlapping with the query time range and an iterator current location pointer.
9. An electronic device, comprising: a memory and at least one processor;
wherein the memory has stored thereon a computer program;
the at least one processor executing the memory-stored computer program causes the at least one processor to perform the shared memory-based local database query method of any of claims 1-8.
10. A computer-readable storage medium, in which a computer program is stored, the computer program being executable by a processor to implement the shared-memory-based local database query method according to any one of claims 1 to 8.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202210614921.1A CN115203251A (en) | 2022-06-01 | 2022-06-01 | Local database query method based on shared memory |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202210614921.1A CN115203251A (en) | 2022-06-01 | 2022-06-01 | Local database query method based on shared memory |
Publications (1)
| Publication Number | Publication Date |
|---|---|
| CN115203251A true CN115203251A (en) | 2022-10-18 |
Family
ID=83577017
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202210614921.1A Pending CN115203251A (en) | 2022-06-01 | 2022-06-01 | Local database query method based on shared memory |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN115203251A (en) |
Cited By (1)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN116069530A (en) * | 2023-04-03 | 2023-05-05 | 中国人民解放军国防科技大学 | Simulation engine data sharing blackboard system based on memory pool |
-
2022
- 2022-06-01 CN CN202210614921.1A patent/CN115203251A/en active Pending
Cited By (1)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN116069530A (en) * | 2023-04-03 | 2023-05-05 | 中国人民解放军国防科技大学 | Simulation engine data sharing blackboard system based on memory pool |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| JP3830886B2 (en) | Method for storing data in nonvolatile memory | |
| CN110046133B (en) | Metadata management method, device and system for storage file system | |
| US7707337B2 (en) | Object-based storage device with low process load and control method thereof | |
| US20100106935A1 (en) | Pretranslating Input/Output Buffers In Environments With Multiple Page Sizes | |
| US9086920B2 (en) | Device for managing data buffers in a memory space divided into a plurality of memory elements | |
| US10565131B2 (en) | Main memory including hardware accelerator and method of operating the same | |
| US6665747B1 (en) | Method and apparatus for interfacing with a secondary storage system | |
| JPH10254756A (en) | Use of three-state reference for managing referred object | |
| EP4174677A1 (en) | Data reading and writing method and device | |
| US11500828B1 (en) | Method and device for constructing database model with ID-based data indexing-enabled data accessing | |
| CN115203251A (en) | Local database query method based on shared memory | |
| CN114327642A (en) | Data read-write control method and electronic equipment | |
| CN110928803B (en) | Memory management method and device | |
| US9021492B2 (en) | Dual mode reader writer lock | |
| US11921683B2 (en) | Use of time to live value during database compaction | |
| CN107203387B (en) | Target database access method and system | |
| US20180107619A1 (en) | Method for shared distributed memory management in multi-core solid state drive | |
| CN110334034B (en) | Mapping table dynamic loading method and device, computer equipment and storage medium | |
| CN114327769B (en) | Operating system event recording method and device and computer system | |
| US7681009B2 (en) | Dynamically updateable and moveable memory zones | |
| US9659041B2 (en) | Model for capturing audit trail data with reduced probability of loss of critical data | |
| US20020099919A1 (en) | Method of memory management | |
| CN110209343B (en) | Data storage method, device, server and storage medium | |
| US20200334175A1 (en) | Controlling operation of multiple computational engines | |
| CN115563075B (en) | Virtual file system implementation method based on microkernel |
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 |