CN114721814A - Task allocation method and device based on shared stack and computer equipment - Google Patents
Task allocation method and device based on shared stack and computer equipment Download PDFInfo
- Publication number
- CN114721814A CN114721814A CN202210135509.1A CN202210135509A CN114721814A CN 114721814 A CN114721814 A CN 114721814A CN 202210135509 A CN202210135509 A CN 202210135509A CN 114721814 A CN114721814 A CN 114721814A
- Authority
- CN
- China
- Prior art keywords
- stack
- task
- shared
- memory
- controlling
- 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 29
- 230000015654 memory Effects 0.000 claims abstract description 100
- 238000004590 computer program Methods 0.000 claims description 10
- 230000004048 modification Effects 0.000 claims description 4
- 238000012986 modification Methods 0.000 claims description 4
- 239000002699 waste material Substances 0.000 abstract description 8
- 238000010586 diagram Methods 0.000 description 7
- 238000012545 processing Methods 0.000 description 7
- 238000004891 communication Methods 0.000 description 4
- 230000008569 process Effects 0.000 description 4
- 238000005516 engineering process Methods 0.000 description 2
- 238000012360 testing method Methods 0.000 description 2
- 238000004458 analytical method Methods 0.000 description 1
- 238000004364 calculation method Methods 0.000 description 1
- 230000001413 cellular effect Effects 0.000 description 1
- 230000000694 effects Effects 0.000 description 1
- 230000006870 function Effects 0.000 description 1
- 239000004973 liquid crystal related substance Substances 0.000 description 1
- 230000003287 optical effect Effects 0.000 description 1
- 230000004044 response Effects 0.000 description 1
- 230000003068 static effect Effects 0.000 description 1
Images
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F9/00—Arrangements for program control, e.g. control units
- G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
- G06F9/46—Multiprogramming arrangements
- G06F9/50—Allocation of resources, e.g. of the central processing unit [CPU]
- G06F9/5005—Allocation of resources, e.g. of the central processing unit [CPU] to service a request
- G06F9/5011—Allocation of resources, e.g. of the central processing unit [CPU] to service a request the resources being hardware resources other than CPUs, Servers and Terminals
- G06F9/5016—Allocation of resources, e.g. of the central processing unit [CPU] to service a request the resources being hardware resources other than CPUs, Servers and Terminals the resource being the memory
Landscapes
- Engineering & Computer Science (AREA)
- Software Systems (AREA)
- Theoretical Computer Science (AREA)
- Physics & Mathematics (AREA)
- General Engineering & Computer Science (AREA)
- General Physics & Mathematics (AREA)
- Information Retrieval, Db Structures And Fs Structures Therefor (AREA)
Abstract
The invention provides a task allocation method of a shared stack, which comprises the following steps: establishing a shared stack and generating a first task; controlling the first task to run on the shared stack; acquiring preset first stack memory information; backing up the stack data of the first task to a first stack memory corresponding to first stack memory information; restoring stack data of a second task to the shared stack, and controlling the second task to run on the shared stack; by setting the mode of sharing the stack, the waste degree of the thread stack can be reduced, the unused part of the thread stack can be used as a normal heap memory, the on-chip memory of a chip is compressed, the chip cost is reduced, the memory overhead is reduced, and the space waste of the thread stack is reduced to the maximum extent.
Description
Technical Field
The present invention relates to the field of communications technologies, and in particular, to a method and an apparatus for task allocation based on a shared stack, a computer device, and a storage medium.
Background
Currently, embedded operating systems, such as FreeRTOS, RT-Thread, etc., in the market allocate a stack space for each Thread when creating the Thread, so as to save live and temporary variables when the Thread runs. As shown in FIG. 1, when a different thread runs, the SP pointer is modified to point to the location of the present thread stack.
In the existing thread running mode, the unused part of the thread stack can not be reused. When the operating system runs the task c which is not identified in fig. 1, the stacks of the task a and the task b are in the state shown in fig. 1, and a free part of the two thread stacks is not used by the thread yet, but other threads cannot use the part of the memory, which causes memory waste. Secondly, the size of the thread stack is difficult to set, if the memory is saved as much as possible, the maximum stack space used by the thread is required to be guaranteed to just reach the allocated stack space after the thread runs, but even though the thread is fully tested, the maximum stack space obtained by the test is not guaranteed to be a value obtained by the test, a certain margin is required to be reserved, and moreover, the use amount of the stack space is possibly changed by randomly increasing some operation codes or function calls, so that the stack space is allocated with a value as small as possible, which is very difficult.
Disclosure of Invention
Therefore, it is necessary to provide a method, an apparatus, a computer device, and a storage medium for allocating tasks of a shared stack, which reduce the waste of a thread stack, reduce the chip cost by using the unused part of the thread stack as a normal heap memory, and compress the on-chip memory of the chip.
A task allocation method of a shared stack comprises the following steps:
establishing a shared stack and generating a first task;
controlling the first task to run on the shared stack;
acquiring preset first stack memory information;
backing up the stack data of the first task to a first stack memory corresponding to first stack memory information;
and restoring the stack data of the second task to the shared stack, and controlling the second task to run on the shared stack.
A task allocation apparatus of a shared stack, comprising:
the establishing and generating module is used for establishing a shared stack and generating a first task;
the first task control module is used for controlling the first task to run on the shared stack;
the heap memory information acquisition module is used for acquiring preset first heap memory information;
the backup module is used for backing up the stack data of the first task to a first stack memory corresponding to first stack memory information;
and the second task control module is used for restoring the stack data of the second task to the shared stack and controlling the second task to run on the shared stack.
Preferably, the module connected to the heap memory information obtaining module includes:
and the modification module is used for modifying the stack description information of the task control component TCB in the first task.
Preferably, the second task control module includes:
and the second task control sub-module is used for restoring the stack data of the second task to the shared stack, releasing the backup data of the second task, modifying stack description information of the TCB in the second task, and controlling the second task to run on the shared stack.
A computer device, comprising:
at least one processor; and the number of the first and second groups,
a memory communicatively coupled to the at least one processor; wherein,
the memory stores instructions executable by the at least one processor to enable the at least one processor to perform the steps of the above-described shared stack task allocation method.
A computer-readable storage medium, storing a computer program which, when executed by a processor, implements the steps of the above-described method for task allocation of a shared stack.
According to the task allocation method and device for the shared stack, the computer equipment and the storage medium, the waste degree of the thread stack can be reduced by setting the shared stack, the unused part of the thread stack can be used as a normal heap memory, the on-chip memory of a chip is compressed, the chip cost is reduced, the memory overhead is reduced, and the space waste of the thread stack is reduced to the maximum extent.
Drawings
FIG. 1 is a schematic diagram of the operation of a thread in the present invention;
FIG. 2 is a flowchart illustrating a task allocation method of a shared stack according to the present invention;
FIG. 3 is a schematic diagram of the operation of a thread in the present invention;
FIG. 4 is a schematic diagram of the operation of a thread in the present invention;
FIG. 5 is a schematic diagram of the operation of a thread in the present invention;
FIG. 6 is a block diagram of a task allocation apparatus for a shared stack according to the present invention;
fig. 7 is an internal structural view of a computer device in the present invention.
Detailed Description
In order to make the objects, technical solutions and advantages of the present application more apparent, the present application is described in further detail below with reference to the accompanying drawings and embodiments. It should be understood that the specific embodiments described herein are merely illustrative of the present application and are not intended to limit the present application.
In one embodiment, as shown in fig. 2, a flowchart of a task allocation method for a shared stack is provided, which includes the following steps:
in this embodiment, the method for allocating tasks of a shared stack may be applied to a Central Processing Unit (CPU), where the CPU is connected to a memory, and the memory may include multiple memories such as a random access memory, which is not limited in this invention; further, the central processing unit may establish a shared stack in the random access memory, and on the other hand, the central processing unit may establish a first task, namely, a task a, for the certain operation in response to the upper application.
actually applied to this embodiment, the central processing unit may control the first task to run on the shared stack, that is, the task a is run on the shared stack; specifically, the first task includes initial stack information, the initial stack information of the first task is firstly copied to a shared stack, then a heap memory storing the initial stack information of the first task is released, and the task A can run on the shared stack; further, the TCB of the first task may be controlled to record the stack pointing of the first task; in addition, the central processor may control the SP pointer to point to the location of the stack on the running thread.
during the operation process of switching to the second task, the central processing unit may further obtain preset first bank memory (heap) information, that is, during the task switching process, it is necessary to first obtain an empty first bank memory information and allocate the non-operating memory.
further, the stack data of the first task may be backed up to the first heap memory corresponding to the first heap memory information, that is, the stack data of the task a is transferred to the heap area.
Specifically, during thread switching, according to stack description information in a TCB (Task Control Block) of a first Task, a central processing unit obtains first stack memory information corresponding to a first stack memory of a specified size; and backing up stack data from the shared stack to a first stack memory with a specified size according to the stack memory information.
Specifically, applying to this embodiment, after backing up the stack data of the first task to the first stack memory corresponding to the first stack memory information, the backing up includes: the stack description information of the TCB in the first task is modified to indicate that the stack data of the first task has been transferred into the heap area.
And 105, restoring the stack data of the second task to the shared stack, and controlling the second task to run on the shared stack.
After the first stack data is backed up to the heap memory, stack data of a second task of the heap memory originally located at other positions is sent to the shared stack, and the central controller controls the second task to run on the shared stack.
Specifically, the restoring stack data of the second task to the shared stack and controlling the second task to run on the shared stack include: and restoring the stack data of the second task to the shared stack, releasing the backup data of the second task, modifying stack description information of the TCB in the second task, and controlling the second task to run on the shared stack.
The stack data of a second task (task B) is restored to the shared stack, the backup data of the task B in the stack memory is released, the stack description information of the TCB in the second task is modified and points to the top of the stack, the TCB of the second task is controlled to record the stack direction of the second task, and the second task is controlled to run on the shared stack.
In the invention, the waste degree of the thread stack can be reduced by setting the stack sharing mode, the unused part of the thread stack can be used as a normal heap memory, the on-chip memory of a chip is compressed, the chip cost is reduced, the memory overhead is reduced, and the space waste of the thread stack is reduced to the maximum extent.
In one embodiment, the following is illustrated by a specific example in order that those skilled in the art may better understand the present invention:
1. shared stack schema overview
If the chips running the embedded operating system are all single cores or each core of a multi-core chip runs respectively, the concept of coroutine does not exist, in such a project, many threads may exist, but at the same time, the CPU can only run one thread, and other threads are not in a running state, as shown in fig. 3, task a and task b run on respective Stack stacks, in this case, theoretically, all other threads and unused parts of the stacks are wasted parts, and can be moved to other uses.
Therefore, the final goal to be achieved is that, except for the running thread which needs a large enough stack space, the stack space of all the other non-running threads only needs to reserve the used part, so as to minimize the memory occupation.
2. How to release unused stack memory
When the thread runs, a memory with continuous block addresses is needed to be used as a stack, and the effect of releasing unused stack space is achieved by releasing the original memory after backup.
From the bottom of the stack to the location pointed to by the current stack pointer, this section of memory is the stack space that is already in use by the current thread. As shown in fig. 4 (1), when the thread runs normally, only a part of the space of the thread stack is occupied, in order to release the unused stack space, a block of memory is applied again, the size is the size of the used stack, then the original data of the used stack is copied to the newly applied memory, as shown in fig. 4 (2), the backup of the stack that has been completed is performed, and finally as shown in fig. 4 (3), the original stack memory is released, so that the purpose of reducing the memory occupation is achieved.
3. Specific scheme of shared stack
Specifically, all threads share one thread stack, when a certain thread needs to run, the thread occupies the shared stack to run, and other threads which cannot be run temporarily can backup the stack used by the thread to the memory in which the dynamic memory is applied.
As shown in fig. 5, the task a and the task b are two threads using a shared stack, and starting from a certain point of time, the task a starts to run, and then switches to the task b to run.
Firstly, the TaskA occupies a shared stack, the TCB of the TaskA is responsible for recording stack pointing of the TaskA, and then the TaskA is switched to the TaskB.
Therefore, stack space occupation of all the threads which are not operated is not a fixed value any more, but how much memory is occupied by the stacks when the stacks are used is avoided, and how much space needs to be allocated to each thread stack is not considered, because the space is dynamically allocated. The stack space of the running thread is a fixed size, that is, the size of the shared stack, and the size of the shared stack depends on the thread with the largest stack overhead among all threads, for example, if the stack spaces of 1K, 2K and 4K are required for TaskA, TaskB and TaskC, respectively, the shared stack needs to be opened to 4K.
It should be understood that, although the steps in the flowchart of fig. 1 are shown in order as indicated by the arrows, the steps are not necessarily performed in order as indicated by the arrows. The steps are not performed in the exact order shown and described, and may be performed in other orders, unless explicitly stated otherwise. Moreover, at least a part of the steps in fig. 1 may include multiple steps or multiple stages, which are not necessarily performed at the same time, but may be performed at different times, and the order of performing the steps or stages is not necessarily performed in sequence, but may be performed alternately or alternately with other steps or at least a part of the steps or stages in other steps.
In one embodiment, as shown in fig. 6, a block diagram of a task allocation apparatus for sharing a stack is provided, including:
the establishing and generating module 301 is configured to establish a shared stack and generate a first task;
a first task control module 302, configured to control the first task to run on the shared stack;
a heap memory information obtaining module 303, configured to obtain preset first heap memory information;
a backup module 304, configured to backup the stack data of the first task to a first stack memory corresponding to the first stack memory information;
and a second task control module 305, configured to restore stack data of a second task to the shared stack, and control the second task to run on the shared stack.
Preferably, the first task includes initial stack information, and the first task control module includes:
and the control sub-module is used for copying the initial stack information of the first task to the shared stack, releasing the heap memory corresponding to the initial stack information and controlling the first task to run on the shared stack.
Preferably, the heap memory information obtaining module includes:
the acquisition submodule is used for acquiring first stack memory information corresponding to a first stack memory with a specified size according to stack description information in a task control component TCB of a first task when the thread is switched;
the backup submodule is used for backing up stack data from the shared stack to a first stack memory with a specified size according to the stack memory information;
and the modification sub-module is used for modifying the stack description information of the TCB in the first task.
Preferably, the second task control module includes:
and the second task control sub-module is used for restoring the stack data of the second task to the shared stack, releasing the backup data of the second task, modifying stack description information of the TCB in the second task, and controlling the second task to run on the shared stack.
Preferably, the apparatus further comprises:
the first stack pointing control module is used for controlling the TCB of the first task to record the stack pointing of the first task;
and the second stack pointing control module is used for controlling the TCB of the second task to record the stack pointing of the second task.
Preferably, the apparatus further comprises:
and the pointer control module is used for controlling the SP pointer to enable the SP pointer to point to the position of the stack on the running thread.
For specific limitations of the task allocation apparatus of the shared stack, reference may be made to the above limitations of the task allocation method of the shared stack, and details are not described herein again. The various modules in the task allocation apparatus of the shared stack described above may be implemented in whole or in part by software, hardware, and combinations thereof. The modules can be embedded in a hardware form or independent from a processor in the computer device, and can also be stored in a memory in the computer device in a software form, so that the processor can call and execute operations corresponding to the modules.
In one embodiment, a computer device is provided, the internal structure of which may be as shown in FIG. 7. The computer device includes a processor, a memory, a communication interface, a display screen, and an input device connected by a system bus. Wherein the processor of the computer device is adapted to provide the calculation and control capabilities, the processor may comprise a central processing unit, performing the steps of the method. The memory of the computer device comprises a nonvolatile storage medium and an internal memory. The non-volatile storage medium stores an operating system and a computer program. The internal memory provides an environment for the operation of an operating system and computer programs in the non-volatile storage medium. The communication interface of the computer device is used for communicating with an external terminal in a wired or wireless manner, and the wireless manner can be realized through WIFI, a mobile cellular network, NFC (near field communication) or other technologies. The computer program is executed by a processor to implement a method of task allocation for a shared stack. The display screen of the computer equipment can be a liquid crystal display screen or an electronic ink display screen, and the input device of the computer equipment can be a touch layer covered on the display screen, a key, a track ball or a touch pad arranged on the shell of the computer equipment, an external keyboard, a touch pad or a mouse and the like.
Those skilled in the art will appreciate that the architecture shown in fig. 7 is merely a block diagram of some of the structures associated with the disclosed aspects and is not intended to limit the computing devices to which the disclosed aspects apply, as particular computing devices may include more or less components than those shown, or may combine certain components, or have a different arrangement of components.
In one embodiment, a computer device is provided comprising a memory having a computer program stored therein and a processor implementing the steps of fig. 1 when executing the computer program.
In one embodiment, a computer-readable storage medium is provided, on which a computer program is stored, which, when executed by a processor, implements the steps of fig. 1.
It should be noted that, the user information (including but not limited to user device information, user personal information, etc.) and data (including but not limited to data for analysis, stored data, presented data, etc.) referred to in the present application are information and data authorized by the user or sufficiently authorized by each party.
It will be understood by those skilled in the art that all or part of the processes of the methods of the embodiments described above can be implemented by hardware instructions of a computer program, which can be stored in a non-volatile computer-readable storage medium, and when executed, can include the processes of the embodiments of the methods described above. Any reference to memory, storage, database or other medium used in the embodiments provided herein can include at least one of non-volatile and volatile memory. Non-volatile Memory may include Read-Only Memory (ROM), magnetic tape, floppy disk, flash Memory, optical storage, or the like. Volatile Memory can include Random Access Memory (RAM) or external cache Memory. By way of illustration and not limitation, RAM can take many forms, such as Static Random Access Memory (SRAM) or Dynamic Random Access Memory (DRAM), among others.
The technical features of the above embodiments can be arbitrarily combined, and for the sake of brevity, all possible combinations of the technical features in the above embodiments are not described, but should be considered as the scope of the present specification as long as there is no contradiction between the combinations of the technical features.
The above-mentioned embodiments only express several embodiments of the present application, and the description thereof is more specific and detailed, but not construed as limiting the scope of the invention. It should be noted that, for a person skilled in the art, several variations and modifications can be made without departing from the concept of the present application, which falls within the scope of protection of the present application. Therefore, the protection scope of the present patent application shall be subject to the appended claims.
Claims (10)
1. A task allocation method of a shared stack is characterized by comprising the following steps:
establishing a shared stack and generating a first task;
controlling the first task to run on the shared stack;
acquiring preset first stack memory information;
backing up the stack data of the first task to a first stack memory corresponding to first stack memory information;
and restoring the stack data of the second task to the shared stack, and controlling the second task to run on the shared stack.
2. The method of task allocation for a shared stack of claim 1, wherein the first task includes initial stack information, and wherein said controlling the first task to run on the shared stack comprises:
copying the initial stack information of the first task to a shared stack, releasing a heap memory corresponding to the initial stack information, and controlling the first task to run on the shared stack.
3. The method for allocating tasks of a shared stack according to claim 1, wherein backing up the stack data of the first task to the first heap memory corresponding to the first heap memory information comprises:
when the thread is switched, acquiring first stack memory information corresponding to a first stack memory with a specified size according to stack description information in a task control unit (TCB) of a first task;
backing up stack data from the shared stack to a first stack memory with a specified size according to the stack memory information;
stack description information of the TCB in the first task is modified.
4. The method for allocating tasks on a shared stack according to claim 1, wherein the restoring stack data of a second task to the shared stack and controlling the second task to run on the shared stack comprises:
and restoring the stack data of the second task to the shared stack, releasing the backup data of the second task, modifying stack description information of the TCB in the second task, and controlling the second task to run on the shared stack.
5. The method for task allocation of a shared stack according to claim 1, further comprising:
controlling a TCB of the first task to record stack direction of the first task;
and/or the TCB controlling the second task records the stack orientation of the second task.
6. The method for task allocation of a shared stack according to claim 1, further comprising:
and controlling the SP pointer to point to the position of the stack on the running thread.
7. A task allocation apparatus for a shared stack, comprising:
the establishing and generating module is used for establishing a shared stack and generating a first task;
the first task control module is used for controlling the first task to run on the shared stack;
the heap memory information acquisition module is used for acquiring preset first heap memory information;
the backup module is used for backing up the stack data of the first task to a first stack memory corresponding to first stack memory information;
and the second task control module is used for restoring the stack data of the second task to the shared stack and controlling the second task to run on the shared stack.
8. The stack-sharing task allocation device according to claim 1, wherein the module connected to the heap memory information obtaining module includes:
and the modification module is used for modifying the stack description information of the task control component TCB in the first task.
9. A computer device, comprising:
at least one processor; and the number of the first and second groups,
a memory communicatively coupled to the at least one processor; wherein,
the memory stores instructions executable by the at least one processor to enable the at least one processor to perform the steps of the method of task allocation of a shared stack as claimed in any one of claims 1 to 5.
10. A computer-readable storage medium storing a computer program, wherein the computer program, when executed by a processor, implements the steps of the method for allocating tasks of a shared stack according to any one of claims 1 to 5.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202210135509.1A CN114721814A (en) | 2022-02-14 | 2022-02-14 | Task allocation method and device based on shared stack and computer equipment |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202210135509.1A CN114721814A (en) | 2022-02-14 | 2022-02-14 | Task allocation method and device based on shared stack and computer equipment |
Publications (1)
| Publication Number | Publication Date |
|---|---|
| CN114721814A true CN114721814A (en) | 2022-07-08 |
Family
ID=82235366
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202210135509.1A Pending CN114721814A (en) | 2022-02-14 | 2022-02-14 | Task allocation method and device based on shared stack and computer equipment |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN114721814A (en) |
Cited By (1)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN116737366A (en) * | 2023-05-15 | 2023-09-12 | 广州汽车集团股份有限公司 | Processing method and device of shared stack, electronic equipment and storage medium |
-
2022
- 2022-02-14 CN CN202210135509.1A patent/CN114721814A/en active Pending
Cited By (2)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN116737366A (en) * | 2023-05-15 | 2023-09-12 | 广州汽车集团股份有限公司 | Processing method and device of shared stack, electronic equipment and storage medium |
| CN116737366B (en) * | 2023-05-15 | 2024-05-10 | 广州汽车集团股份有限公司 | Processing method and device of shared stack, electronic equipment and storage medium |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| CN110704161B (en) | Virtual machine creation method and device and computer equipment | |
| CN111104208B (en) | Process scheduling management method, device, computer equipment and storage medium | |
| US7028140B2 (en) | Storage system and method for acquisition and utilization of snapshots | |
| KR20080094938A (en) | Reducing power consumption by disabling refresh of unused portions of dram during periods of device inactivity | |
| CN111338779B (en) | Resource allocation method, device, computer equipment and storage medium | |
| CN110069336A (en) | Memory source distribution method, distributor, chip and storage device | |
| CN116185623A (en) | Task allocation method and device, electronic equipment and storage medium | |
| CN114721814A (en) | Task allocation method and device based on shared stack and computer equipment | |
| CN113419672B (en) | Storage capacity management method, system and storage medium | |
| CN115357389A (en) | Memory management method and device and electronic equipment | |
| KR102116984B1 (en) | Method for controlling memory swap operation and data processing system adopting the same | |
| CN112799832A (en) | Memory allocation control method, device, equipment and storage medium | |
| CN105677481A (en) | Method and system for processing data and electronic equipment | |
| US20050144389A1 (en) | Method, system, and apparatus for explicit control over a disk cache memory | |
| CN109783145B (en) | Method for creating multi-image-based multifunctional embedded system | |
| CN101714120A (en) | Data storage system and method | |
| CN111444117A (en) | Method and device for realizing fragmentation of storage space, storage medium and electronic equipment | |
| CN115686782A (en) | Resource scheduling method and device based on solid state disk, electronic equipment and storage medium | |
| CN105512091A (en) | Memory allocation method and device | |
| CN115470155A (en) | L2P table caching method and device supporting solid state disk multi-scene multiplexing | |
| KR20070014724A (en) | Memory controlling method for mobile communicationn terminal | |
| KR20150136811A (en) | Apparatus and Method for managing memory in an embedded system | |
| CN114327868B (en) | Memory dynamic regulation and control method, device, equipment and medium | |
| CN110362510B (en) | Dynamic stack allocation method, device, computer equipment and storage medium | |
| CN114710441B (en) | Link aggregation method, system, computer equipment and storage medium |
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 |