KR20230096811A - Electronic device and mehtod for managing memory - Google Patents

Abstract

Provided are an electronic device and an operating method for managing memory by securing available memory capacity in order to improve responsiveness of an application. An embodiment of the present disclosure identifies whether to swap-out a page of the first process to a first memory or a second memory based on a characteristic of the first process, and determines whether the first memory or the second memory is to be swapped out. 2 Allocates a part of the memory as a swap space, swaps out the pages of the first process, checks whether the swapped out pages are swapped back into the first memory, and An electronic device releasing a swap space of a first memory or a second memory and a method of operating the electronic device are provided.

Description

Memory management method and electronic device using the same {ELECTRONIC DEVICE AND MEHTOD FOR MANAGING MEMORY}

Various embodiments of the present disclosure relate to an electronic device and an operating method of the electronic device for securing available capacity of a memory.

As more and more applications are installed and executed in portable electronic devices such as smart phones, various memory management techniques are used to secure available memory capacity.

OOMK (Out-Of-Memory Killer) is a memory management technique that sequentially forcibly terminates processes of low importance to prevent system shutdown. However, OOMK deteriorates the user experience because it terminates the process that was running without the user's permission.

On the other hand, as another memory management method, the SWAP technique transfers recently unused data from a volatile memory area (eg, RAM) to a volatile memory and a non-volatile memory (eg, NAND flash storage). It is a memory management technique that secures available memory capacity without killing processes by moving them to an area.

However, as the size of the application increases and the user installs more applications and swaps them out, if the memory capacity becomes insufficient, OOMK occurs frequently, deteriorating the user experience.

In particular, an increase in the number of user applications not only deteriorates application response speed, but also accelerates memory competition between applications. In the smartphone environment, application execution speed and application response speed are the top priority requirements of smartphone users. As memory competition between applications increases, the execution speed of the applications rapidly decreases. Therefore, a technique for providing an improved user experience in a mobile environment through a new memory management method is required. That is, a technique for ensuring application responsiveness by delaying the operation of OOMK as much as possible is required.

Various embodiments of the present disclosure disclose a memory management apparatus and method for using a volatile memory area and a non-volatile memory area as a swap area in an electronic device.

Various embodiments of the present disclosure disclose a memory management apparatus and method for improving an OOMK operation to preserve a process state in an electronic device.

In order to solve the above technical problem, an embodiment of the present disclosure provides an electronic device and an operating method thereof for managing memory by securing available memory capacity in order to improve application responsiveness.

According to one aspect of the present disclosure, an electronic device loads a page of a first process related to a first memory, a second memory, and an application stored in the second memory according to the execution of the first memory to the first memory. A processor that executes a process, wherein the processor checks an available capacity for allocating a second process to the first memory, and based on a characteristic of the first process running in the first memory, the second process Identifying whether to swap-out pages of one process to the first memory or the second memory, allocating a part of the first memory or the second memory as a swap space, When a page of the first process is swapped out and the swapped out page is swapped back into the first memory, the swap space may be released.

In one embodiment of the present disclosure, the characteristics of the first process may include at least one of a response time and state preservation degree of the process.

In one embodiment of the present disclosure, the number of times a page of the first process is referenced by a plurality of processes is additionally considered in addition to the characteristics of the first process, and the page of the first process is stored in the first memory or the second memory. You can identify whether to swap-out with .

In one embodiment of the present disclosure, the page of the first process may be a Shared Object (SO) file belonging to a shared library.

In one embodiment of the present disclosure, when the swap space of the first memory is insufficient, the processor selects a first page among pages of the first process based on the number of times the page of the first process is referred from a plurality of processes. may be determined, and the first page may be removed from the first memory.

In one embodiment of the present disclosure, the processor, when the swap space of the second memory is insufficient, the page written to the second memory is written to the second memory based on the time when the page was swapped out to the second memory. A second page among pages may be determined, and the second page may be removed from the second memory.

In one embodiment of the present disclosure, the processor, when the available capacity for allocating a new process to the first memory is insufficient even after the first page is removed from the first memory, the processor stores the running process in the second memory. It is checked whether there is a swap space to swap out a page from, and if the swap space of the second memory is insufficient, the page written to the second memory is stored in the second memory based on the time when the page was swapped out to the second memory. A second page among written pages may be determined, and the second page may be removed from the second memory.

In one embodiment of the present disclosure, the first page and the second page may be SO (Shared Object) files belonging to a shared library.

In one embodiment of the present disclosure, the processor, when the available capacity for allocating a new process to the first memory is insufficient even after removing the second page from the second memory, the time required for driving the process for each of the plurality of processes , determining an order of termination of a plurality of processes running in the first memory based on the calculated time, and terminating at least one process among the plurality of processes running in the first memory, The storage area of the first memory into which the data of the processed process is loaded may be made available to other processes.

In one embodiment of the present disclosure, the time required for driving the process may include at least one of a time required for searching for a shared symbol of a page of the process and a time required for executing an XML-based UI process.

In order to solve the above technical problem, another embodiment of the present disclosure provides a memory management method for improving application responsiveness by securing available memory capacity.

A method according to an aspect of the present disclosure includes executing a first process related to an application stored in a second memory by loading it into the first memory, and checking an available capacity for allocating a second process to the first memory. identifying whether to swap-out pages of the first process to the first memory or the second memory, based on characteristics of the first process running in the first memory; swapping out a page of the first process by allocating a part of the first or second memory as a swap space, and swapping the swapped out page back into the first memory ( swap-in), releasing the swap space.

1 is a diagram illustrating a method of managing a memory according to an exemplary embodiment.
2 is a diagram for explaining the overall system structure according to an embodiment of the present disclosure.
3 is a block diagram illustrating an electronic device for securing available capacity of a memory according to an embodiment of the present disclosure.
4 is a diagram specifically illustrating a method of securing an available capacity of a memory according to an embodiment of the present disclosure.
5 is a diagram for explaining a method of determining a process termination order by calculating a required time for each running process according to an embodiment of the present disclosure.
6 is a flowchart for securing available capacity of a memory according to an embodiment of the present disclosure.
7 is a flowchart illustrating in detail a method for securing an available capacity of a memory according to an embodiment of the present disclosure.
8 is a flowchart specifically illustrating a method of removing a page from a memory according to an exemplary embodiment of the present disclosure.
9 is a flowchart illustrating a method of removing a page from a memory according to an exemplary embodiment of the present disclosure.
10 is a flowchart illustrating a method of terminating a running process according to an embodiment of the present disclosure.
11 is a flowchart more specifically illustrating a method of terminating a running process according to an embodiment of the present disclosure.

Terms used in the present disclosure will be briefly described, and an embodiment of the present disclosure will be described in detail.

The terms used in the present disclosure have been selected from general terms that are currently widely used as much as possible while considering functions in an embodiment of the present disclosure, but they may vary depending on the intention or precedent of a person skilled in the art, the emergence of new technologies, and the like. there is. In addition, in a specific case, there is also a term arbitrarily selected by the applicant, and in this case, the meaning will be described in detail in the description of the corresponding embodiment of the present disclosure. Therefore, terms used in the present disclosure should be defined based on the meaning of the term and the general content of the present disclosure, not simply the name of the term.

When it is said that a certain part "includes" a certain component throughout the specification, it means that it may further include other components without excluding other components unless otherwise stated. Also, the term "unit" used in the specification means a hardware component such as software, FPGA or ASIC, and "unit" performs certain roles. However, "unit" is not meant to be limited to software or hardware. A “unit” may be configured to reside in an addressable storage medium and may be configured to reproduce on one or more processors. Thus, as an example, “unit” can refer to components such as software components, object-oriented software components, class components and task components, processes, functions, properties, procedures, subroutines, segments of program code, drivers, firmware, microcode, circuitry, data, databases, data structures, tables, arrays and variables. Functionality provided within components and "parts" may be combined into fewer components and "parts" or further separated into additional components and "parts".

Hereinafter, with reference to the accompanying drawings, embodiments of the present disclosure will be described in detail so that those skilled in the art can easily carry out the present disclosure. However, an embodiment of the present disclosure may be implemented in many different forms and is not limited to the embodiment described herein. And in order to clearly describe an embodiment of the present disclosure in the drawings, parts irrelevant to the description are omitted, and similar reference numerals are attached to similar parts throughout the present disclosure.

Throughout the specification, when a part is said to be "connected" to another part, this includes not only the case of being "directly connected" but also the case of being "electrically connected" with another element in between. . In addition, when a certain component is said to "include", this means that it may further include other components without excluding other components unless otherwise stated.

In the present disclosure, swap may mean an operation of moving and storing data at least temporarily stored in a main memory device to another area of a main memory device or a secondary memory device. In one embodiment, when a new application cannot be executed due to the capacity occupied by an application already running in the main storage device, the application running in the main storage device or a process that is part thereof may be swapped. For example, the main storage device may be a volatile memory and the secondary storage device may be a non-volatile memory.

In this disclosure, the swap space is When the available capacity of the main memory device for executing a process is insufficient, it may refer to a memory area in which data stored in the main memory device can be moved and stored. In one embodiment, the swap space may be a portion of main storage or a portion of secondary storage.

In the present disclosure, swap-out may refer to an operation of moving data of a main memory device to a swap space. In one embodiment, the usable capacity of the main storage device may be secured by swapping out a process running in the main storage device to the swap space.

In the present disclosure, swap-in may refer to an operation of moving data moved to a swap space back to a main memory device. In one embodiment, a process stored in the swap space may be swapped back into the main storage device and the corresponding process may be executed again in the main storage device.

In the present disclosure, a shared object page (SO page) may mean a shared object file when a shared object file (.so file) of a shared library is loaded into memory.

Hereinafter, the present disclosure will be described in detail with reference to the accompanying drawings.

1 is a diagram illustrating a method of managing a memory according to an exemplary embodiment. Referring to FIG. 1 , an electronic device 100 may include a processor 110, a volatile memory 120, and a non-volatile memory 130.

The processor 110 according to an embodiment may include a memory management unit 111 . When an application is newly executed, the memory management unit 111 may allocate a partial area of the system memory 121 in the volatile memory 120 to the corresponding application.

Also, the memory management unit 111 may dynamically adjust the size of the swap space so that application data is maintained in the swap space for as long as possible. For example, the memory management unit 111 checks the available capacity of the system memory 121 area, and if the available capacity is insufficient, the volatile memory 120 or non-volatile memory ( 130) may be allocated as swap space. For example, the memory management unit 111 may swap out some data of an application running in the system memory 121 to the swap space 140 in units of swap files 420 . The swap space 140 may increase each time the swap file 420 is swapped out. Here, the swap file 420 may mean a unit of a file composed of several pages that can be swapped out and swapped in.

Conversely, when the swap space 140 is not needed, the size of the swap space 140 can be reduced. For example, when all pages of the swap space are swapped in and the swap space is empty, the memory management unit 111 immediately releases the dynamically allocated swap space. Through the dynamic allocation of swap space as above, it is possible to reduce the frequency of forced termination of applications by delaying the occurrence of existing OOMK. Through this, the responsiveness of the application may be improved and the user experience may be improved.

The memory management unit 111 according to an embodiment may secure the storage space by removing the SO page of the volatile memory 120 when the swap space 140 is insufficient even after dynamically allocating the swap space. For example, the memory management unit 111 scans the SO pages stored in the volatile memory 120, and if it finds an SO page that is not shared by multiple applications, it can remove it. Page removal is simpler and less expensive than swap-out because it requires no additional I/O operations.

The memory management unit 111 according to an embodiment may secure the swap space by removing the SO page of the non-volatile memory 130 when the swap space 140 is insufficient even though the swap space is dynamically allocated. For example, the memory manager 111 may remove a file that has not been swapped in for a predetermined period (eg, 7 days or 30 days) among files swapped out of the nonvolatile memory 130 . The file can contain SO pages. In addition, when the size of available swap space falls below a predefined threshold, the swap space can be secured by periodically removing SO pages.

The memory management unit 111 according to an embodiment may terminate a part of an application that is loaded into the system memory 121 and is running when the available capacity of the memory is insufficient even after removing the SO page. For example, the memory management unit 111 may calculate the required driving time for each application and determine the termination order of the applications in the order of applications having a short driving time. Specifically, the time required for starting the application can be calculated by adding the time for searching for a shared object symbol (SO) and the time for converting an XML (eXtensible Markup Language)-User Interface (UI) when the application is first executed.

The SO symbol search time may mean the time required to search for an SO symbol required for running an application in a dynamic shared library. Also, the XML-UI conversion time may mean the time required to convert XML to UI when the application is running.

2 is a diagram for explaining the overall system structure according to an embodiment of the present disclosure.

The system hierarchy can be largely divided into an application layer 210, an application framework layer 220, a kernel layer 230, and a hardware layer 240.

When a specific application is executed in the application layer 210, the application running time measuring unit 221 on the application framework layer 220 may calculate the driving cost of the corresponding application. For example, initialization costs such as SO symbol search, XML-UI conversion, etc. required for running an application may be measured, and the calculated value may be transmitted to the memory management unit 111 of the kernel layer 230.

The kernel layer 230 may connect the application framework layer 220 and the hardware layer 240 . Specifically, the storage space of the volatile memory 120 and the non-volatile memory 130 of the hardware layer 240 is managed through the memory management unit 111 .

3 is a block diagram illustrating an electronic device for securing available capacity of a memory according to an embodiment of the present disclosure.

The electronic device 100 according to an embodiment of the present disclosure is an electronic device that can perform memory management, and may be specifically an electronic device that performs memory management through the program 330 . Referring to FIG. 3 , an electronic device 100 according to an embodiment of the present disclosure may include a processor 110 and a memory 300. Hereinafter, the above components are examined in turn.

The processor 110 may control the overall operation of the electronic device 100 and may control the operation of the electronic device 100 by executing one or more instructions stored in the memory 300 . The processor 110 may read commands received from other components of the electronic device 100 and execute operations or data processing according to the commands. The processor 110 becomes a hardware subject of operations that perform various operations of the electronic device 100 . The processor 110 performs calculation, processing, and control of data so that software is executed. For example, the processor 110 executes an operating system or a kernel of the electronic device 100 and also executes applications on the kernel, so that various processes are performed.

The processor 110 according to an embodiment of the present disclosure checks available capacity for allocating a new process to the volatile memory 120 by executing one or more instructions stored in the memory 300, and executes the instructions in the volatile memory 120. Based on the characteristics of the running process, whether to swap-out pages of the running process to the volatile memory 120 or the non-volatile memory 130 is identified, and the volatile memory 120 or the non-volatile memory Allocate some area of 130 as swap space, swap out pages of the running process, and check if the swapped out pages are swapped back into volatile memory 120 And, the swap space of the volatile memory 120 or the non-volatile memory 130 can be released.

By executing one or more instructions stored in the memory 300, the processor 110 according to an embodiment of the present disclosure further considers the number of times a page of the running process is referred to by a plurality of processes in the characteristics of the running process, It is possible to identify whether a page of a running process is to be swapped out to the volatile memory 120 or the non-volatile memory 130 .

The processor 110 according to an embodiment of the present disclosure, by executing one or more instructions stored in the memory 300, when the swap space of the volatile memory 120 is insufficient, the number of times the page of the running process is referenced by a plurality of processes A first page among pages of a process being executed may be determined based on , and the first page may be removed from the volatile memory 120 .

The processor 110 according to an embodiment of the present disclosure executes one or more instructions stored in the memory 300 so that, when the swap space of the non-volatile memory 130 is insufficient, a page written in the non-volatile memory 130 is changed to a non-volatile memory. A second page among pages written to the nonvolatile memory 130 may be determined based on the swapped out time of the memory 130 , and the second page may be removed from the nonvolatile memory 130 .

The processor 110 according to an embodiment of the present disclosure executes one or more instructions stored in the memory 300, so that when the available capacity for allocating a new process to the volatile memory 120 is insufficient, the volatile memory 120 executes the instructions. Calculate the time required for driving the process for each of the plurality of processes in progress, determine the termination order of the plurality of processes running in the volatile memory 120 based on the calculated time, and among the plurality of processes running in the volatile memory 120 By terminating at least one process, the storage area of the volatile memory 120 loaded with data of the terminated process can be made available to other processes.

The memory 300 may include an internal memory 310 or an external memory 320 .

According to one embodiment, the built-in memory 310 may be a Solid State Drive (SSD). The built-in memory 310 may be a volatile memory 120 or a non-volatile memory 130 . For example, the volatile memory 120 may be dynamic RAM (DRAM), static RAM (SRAM), or synchronous dynamic RAM (SDRAM), and the non-volatile memory 130 may be NAND flash memory, NOR flash memory, or the like.

The external memory 320 is a flash drive, for example, compact flash (CF), secure digital (SD), micro secure digital (Micro-SD), mini secure digital (Mini-SD), extreme digital (xD), etc. can include more. The external memory 320 may be functionally connected to the electronic device 100 through various interfaces. According to an embodiment, the electronic device 100 connected to the external memory 320 may further include a storage device (or storage medium) such as a hard drive.

The memory 300 may store a program 330 for processing and control of the processor 110 . Memory 300 according to an embodiment of the present disclosure may store one or more instructions.

The memory 300 according to an embodiment of the present disclosure may be programmed such as a kernel 230, middleware 340, an application programming interface (API) 330, or an application 210. modules may be included. At least a part of the kernel 230, middleware 340, or application programming interface (API) 330 may be called an Operating System (OS).

Kernel 230 includes system resources (eg, processor 110 or memory 300) used to execute operations or functions implemented in other programming modules (eg, middleware, APIs, or applications) other than the kernel. ) can be controlled or managed. The kernel 230 may provide an interface through which the middleware 340 , API 330 , or application 210 can access, control, or manage individual components of the electronic device 100 . The kernel 230 may include the memory management unit 111 of FIG. 2 for memory management in terms of software.

The middleware 340 may perform an intermediary role so that the API 330 or the application 210 communicates with the kernel 230 to exchange data. Also, the middleware 340 may process one or more task requests received from applications according to priority. Regarding task requests received from applications, the middleware 340 assigns a priority for using system resources of the electronic device 100 to at least one of the applications to control the task requests (eg, scheduling or load balancing).

The API 330 is an interface for controlling functions provided by the kernel 230 or the middleware 340 by the application 210 . For example, the API 330 may include at least one interface or function (eg, command) for file control, window control, image processing, or text control.

The application 210 may be an SMS/MMS application, an email application, a calendar application, an alarm application, a video playback application, a stock and investment related application, a health care application (eg, an application for measuring exercise or blood sugar), or an environment. It may include an information application (eg, an application providing air pressure, humidity, or temperature information) and the like.

However, not all illustrated components are essential components. The electronic device 100 may be implemented with more components than those illustrated, or the electronic device 100 may be implemented with fewer components.

4 is a diagram specifically illustrating a method of securing an available capacity of a memory according to an embodiment of the present disclosure.

According to FIG. 4 , the processor 110 of the electronic device 100 may swap out data stored in the memory to the swap space 140 . The memory may include a volatile memory 120, a non-volatile memory 130, an external memory 320, and the like, but is not limited thereto. The swap space 140 may be, for example, a partial space of the volatile memory 120 or a partial space of the non-volatile memory 130, but is not limited thereto. The data may include data used by a process or application executed by the processor 110 and a dynamic library file, but is not limited thereto. For example, data may be processed in units (eg, pages) of a designated size (eg, 4Kbyte). For convenience of description, a case where the data unit is a page will be described as an example. The page may include, but is not limited to, a heap, a stack, a shared memory, a shared object (SO) page, and the like.

In one embodiment, the processor 110 may swap out processes stored in the volatile memory 120 to the non-volatile memory 130 in units of the swap file 420 . Here, the swap file 420 may mean a unit of a file composed of several pages that can be swapped out and swapped in. The number of swap files 420 may be determined according to the size of the process and the size of the swap space 140, and may be one or more. For example, when the size of a process loaded into RAM and running is 96Mbyte (24,000 pages), the swap file 420 may be divided into three. The swap file 420 may be composed of various numbers of pages. For example, each swap file 420 may consist of 10,000 pages, 10,000 pages, or 4,000 pages.

Information for each swap file 420 may be mapped to an address of the non-volatile memory 130 at the operating system level. For example, the swap file 420 may be stored at a specific address of the non-volatile memory 130 using a mapping table called swap extent 430 .

Start_page determines the first page of the swap file 420, nr_page determines the number of pages constituting the swap file 420, and start_block is the starting position where the swap file 420 is to be stored in the non-volatile memory 130. decide For example, the first swap file 411 starts with page 0 of the pages of the process (start_page 0) and consists of 10,000 pages (nr_pages 10000), and sets 10,000 of the block addresses of the non-volatile memory 130 as the starting position. It is saved as (start_block 10000).

In one embodiment, processor 110 stores a swap file based on the age of non-volatile memory 130 . The non-volatile memory 130 may be configured in block units, and a block may be configured with several cells. For example, one block may consist of 100 cells. Since the lifespan of NAND flash is limited due to the characteristics of semiconductor devices, the processor 110 may store a swap file with a block that is not frequently used as a priority. The swap file 420 is not necessarily stored contiguously in blocks. For example, referring to FIG. 4, the first swap file is stored at block address 10,000 of the non-volatile memory 130 as a starting position, and the second swap file 412 is stored at block address 60,000 as a starting position. and the third swap file 413 is stored with the block address 30,000 as the starting position.

5 is a flowchart for securing available capacity of a memory according to an embodiment of the present disclosure.

In step S510, the electronic device 100 checks the available capacity of the first memory.

In one embodiment, the electronic device 100 may check the free space of the first memory in order to load the first process stored in the second memory into the first memory. In one embodiment, the first memory may be a volatile memory. In one embodiment, the second memory may be a non-volatile memory.

In step S520, the electronic device 100 may identify whether to swap out the process to the first memory or the second memory based on the first process characteristic.

In one embodiment, the characteristics of the first process may be determined according to the characteristics of an application including the corresponding process. For example, the characteristics of the first process may include, but are not limited to, at least one of a response time and state preservation degree of the process.

In one embodiment, since swapping out the first process loading into the first memory to the swap space of the first memory is faster than swapping it out to the swap space of the second memory, the execution In the case of a time-critical type of application (eg, a messenger application), user experience can be improved by allocating swap space to the first memory.

In step S530, the electronic device 100 may allocate the swap space 140 to the first memory or the second memory.

In one embodiment, the electronic device 100 may allocate a required size of the swap space 140 to memory. If a part of the first memory is physically divided into fixed partitions and used as the swap space 140, the storage space of the memory may be wasted when the swap space is not used. In addition, if only the storage space fixed in the memory is used as the swap space 140, the process is forcibly terminated by the OOMK operation when the swap space 140 is insufficient, which deteriorates the user experience.

On the other hand, according to an embodiment, the electronic device 100 may dynamically secure a swap space in memory as much as the size of a process or page to be swapped out (eg, in a file or page unit). For example, since there is no fixed partition, swap space can be additionally allocated in memory to store data whenever necessary. In this way, OOMK tasks that forcefully terminate running processes can be delayed as much as possible.

In step S540, the electronic device 100 may swap out the page of the first process to the first memory or the second memory. In one embodiment, all or some pages of a process may be swapped out. In one embodiment, SO pages may be swapped out before normal pages. Considering that the SO page is a page that is highly likely to be called by other applications, it is dynamically swapped out to the swap space before a normal page to prevent the process including the SO page from being forcibly terminated by OOMK. can

In step S550, the electronic device 100 determines whether a page of the swap space 140 is swapped in. In one embodiment, when a user intends to re-execute an application that has been executed once, pages swapped-out in the swap space 140 may be swapped-in again to volatile memory.

In step S560, the electronic device 100 releases the swap space of the first memory or the second memory. In the case of allocating a fixed swap space, even when a process is swapped in and the swap space is empty, a part of the memory space is held as a swap space, which wastes storage space. In one embodiment, if a part of the swap space of the memory is emptied through swap-in, the electronic device 100 immediately releases the swap space of the memory so that it can be used as a general storage space.

6 is a flowchart illustrating a method of managing a memory according to an application type according to an embodiment of the present disclosure.

In step S610, the electronic device 100 may classify applications according to the type of applications being executed in the first memory. The type of application may be classified according to at least one of process response time and state preservation degree, but is not limited thereto.

In one embodiment, the type of application may be classified according to a predetermined classification criterion or may be classified according to the frequency or usage pattern of the user of the electronic device 100 . For example, application types in which response time is important may include messenger applications and SNS applications. For example, application types in which state preservation is important may include stocks, video playback, and Internet applications, but are not limited thereto. In addition, classification of application types may be different according to users.

In step S620, if the response time is an important application type, the electronic device 100 allocates a swap space in the first memory to swap out the corresponding application or some processes of the application. For example, when a swap space is allocated to the first memory in which an application is loaded, it is possible to swap-in and swap-out faster than allocating a swap space to another memory, thereby increasing process re-execution speed. For example, if the swap space is allocated to the volatile memory 120 rather than the swap space allocated to the non-volatile memory 130, swap-in and swap-out can be performed more quickly, thereby increasing the re-execution speed of the process. Therefore, the first memory may be the volatile memory 120 .

In step S630, when the type of application is not classified, the electronic device 100 forcibly terminates the corresponding application or some processes of the application to secure storage space. For example, in the case of an application that does not belong to a classification standard set in the electronic device 100, since there is no need to swap out, an OOMK operation is executed and the corresponding application is forcibly terminated.

In step S640, the electronic device 100 allocates a swap space in the second memory to swap out the corresponding application or some processes or some pages of the application if the state preservation is an important application type.

7 is a flowchart illustrating a method of managing a memory according to an application type according to an embodiment of the present disclosure in more detail.

In step S710, the electronic device 100 may classify applications according to the type of applications being executed in the first memory. The type of application may be classified according to at least one of process response time and state preservation degree, but is not limited thereto.

In step S720, if the response time is an important application type, the electronic device 100 allocates a swap space in the first memory to swap out the corresponding application or some processes or some pages of the application. For example, when the first memory is the volatile memory 120, it is possible to swap-in and swap-out faster than allocating swap space to the non-volatile memory 130, thereby increasing the process re-execution speed. .

In step S730, if the type of application is not classified, the corresponding application or some processes of the application are forcibly terminated to secure storage space. For example, in the case of an application that does not belong to a classification criterion set in the electronic device 100, since there is no need to swap out, OOMK is executed and the corresponding application is forcibly terminated.

In step S740, if the state preservation is an important application type, the electronic device 100 checks whether the number of references of the SO page of the application from other applications is equal to or greater than a preset threshold. If the value is equal to or greater than the preset threshold, a swap space is allocated to the first memory in order to swap out the corresponding application or some processes or some pages of the application. For example, the more other applications refer to the SO page of the corresponding application, the faster swap-in and swap occurs when swap space is allocated to the first memory where the application is loaded than when swap space is allocated to other memories. -It can be out, so it can increase the re-execution speed of the application.

In step S750, the electronic device 100, when the number of references of the SO page of the application from other applications is not equal to or greater than a preset threshold, stores the corresponding application or some processes or some pages of the application in the second memory to swap out. Allocate swap space.

8 is a flowchart specifically illustrating a method of removing a page from a memory according to an exemplary embodiment of the present disclosure. FIG. 8 is a step showing step S530 of FIG. 5 in more detail.

In step S810, the electronic device 100 may check whether the swap space of the first memory is sufficient. In one embodiment, the electronic device 100 allocates a partial area of the first memory as a swap space, the swap space of the first memory (eg, volatile memory 120, RAM) Check if the space that can be dynamically secured has reached the physical limit. Specifically, the electronic device 100 tries to additionally allocate the swap space of the first memory as shown in FIG. 5 , but checks whether no more swap space can be secured because the first memory space reaches a physical limit.

In step S820, the electronic device 100 may check the number of times the page of the first process is referred to by another process.

In step S830, the electronic device 100 may determine a first page whose number of references from a plurality of processes is equal to or less than a preset threshold among pages written in the first memory. In one embodiment, the preset threshold may be increased n times whenever memory space is insufficient. For example, a page whose number of references by a process is 1 may be initially determined as the first page. Even after that, if the memory space is insufficient, a page having a reference count of 2 may be determined as the first page.

In step S840, the electronic device 100 may remove the first page from the first memory. In one embodiment, the first page may include an SO page or a specific page. Instead of destroying the entire process, we can preserve the state of the process by destroying some pages of the process. For example, when the SO page of a process is removed, the execution speed is faster when reloaded later than when the entire process is removed, so process response speed can be improved.

After step S840, step S540 or step S910 may be performed. In one embodiment, a swap space of the first memory may be secured by removing the first page from the first memory. Thereafter, a process running in the first memory or a page of the process may be swapped out to the swap space of the first memory.

9 is a flowchart illustrating a method of removing a page from a memory according to an exemplary embodiment of the present disclosure. 9 may be a step showing step S530 of FIG. 5 in more detail, and may be performed after step S840 of FIG. 8 is performed.

In step S910, the electronic device 100 may check whether the swap space of the second memory is sufficient. In one embodiment, when the electronic device 100 allocates a partial area of the second memory as a swap space, a space capable of dynamically securing the swap space of the second memory (eg, volatile memory, RAM) is required. Check if you have reached your physical limit. Specifically, the electronic device 100 attempts to additionally allocate the swap space of the second memory as shown in FIG. 5 , but checks whether no more swap space can be secured because the second memory space has reached its physical limit.

In one embodiment, when the available capacity for allocating a new process to the first memory is insufficient even after removing the first page from the first memory according to FIG. It may be checked whether the swap space of the second memory is sufficient to swap out the page of the process.

In step S920, the electronic device 100 may sort the order of the pages based on the swapped-out time of the pages of the second process to the second memory. For example, the order of pages can be determined in ascending order by calculating the time from swap-out for each page to the current point in time. Pages that have not been swapped-in for a long time among swapped-out pages are unlikely to be swapped-in again, and thus may be subject to removal.

In step S930, the electronic device 100 may determine a page that has been swapped out for a long time as the second page. In one embodiment, when the pages are sorted in step S920, a page that has been swapped out for the longest time may be determined as the second page. If there is still insufficient memory space thereafter, an SO page that has been swapped out for the next longest time may be determined as the second page.

In step S940, the electronic device 100 may remove the second page from the second memory. In one embodiment, the second page may include an SO page or a specific page. Instead of destroying the entire process, we can preserve the state of the process by destroying some pages of the process. For example, when the SO page of a process is removed, the execution speed is faster when reloaded later than when the entire process is removed, so process response speed can be improved.

Step S540 may be performed after step S940. In one embodiment, the swap space of the second memory may be secured by removing the second page from the second memory. Thereafter, a process or a page of a process running in the first memory may be swapped out to a swap space of the second memory.

10 is a flowchart illustrating a method of terminating a running process according to an embodiment of the present disclosure. 10 may be performed after step S840 of FIG. 8 or after step S940 of FIG. 9 is performed.

In step S1010, the electronic device 100 may execute a user application.

In step S1020, the electronic device 100 may check whether the available memory capacity is insufficient. In one embodiment, the electronic device 100 forcibly terminates at least one process running in the memory when available capacity of memory for allocating a new process is insufficient despite dynamic allocation of swap space and removal of pages of a process. can make it

In step S1030, the electronic device 100 may calculate the required time for running the application. In one embodiment, the electronic device 100 may calculate the required time of the operation that takes the longest time when driving the corresponding application. For example, the electronic device 100 may calculate SO symbol search time or XML-UI conversion time.

In step S1040, the electronic device 100 may determine the process termination order based on the calculated time. For example, the process termination sequence may be determined in the order of shorter times calculated for each process. Specifically, if a specific process needs a relatively longer running time, the shutdown sequence can be delayed so that it is stored in memory for as long as possible.

In step S1050, the electronic device 100 may end the highest-ranking process. In one embodiment, the electronic device 100 may end a process having a higher priority if the available memory capacity is still insufficient.

11 is a flowchart more specifically illustrating a method of terminating a running process according to an embodiment of the present disclosure.

In step S1110, the electronic device 100 may execute a user application.

In step S1120, the electronic device 100 may check whether the available memory capacity is insufficient. In one embodiment, the electronic device 100 forcibly terminates at least one process running in the memory when available capacity of memory for allocating a new process is insufficient despite dynamic allocation of swap space and removal of pages of a process. can make it

In step S1130, the electronic device 100 may calculate the required time for running the application. In one embodiment, the electronic device 100 may calculate the required time of the operation that takes the longest time when driving the corresponding application. Specifically, the SO symbol search time and XML-UI conversion time can be calculated.

In one embodiment, the electronic device 100 may calculate the time required to find an SO symbol required by a corresponding application in a dynamic shared library. For example, the time taken to link the source code of an application to a dynamic shared library can be measured during application compilation time. The elapsed time can be measured by the equation below.

Ts is the symbol search time in the dynamic shared library, Tr is the time taken to reallocate the memory address of the required symbol, and Tl is the loading time of the SO file. T is the time required to search for SO symbols required for each application.

In one embodiment, the electronic device 100 may calculate the time required to execute an XML-based UI process. Specifically, the electronic device 100 may calculate the time required to convert XML into UI. As the UI of the application becomes more complex, XML processing cost increases, so it may take a long time to convert XML-UI when running the application.

By calculating SO symbol search time, XML-UI conversion time, and at least one, it is possible to improve user experience by determining the termination sequence of processes that take a long time at startup.

In step S1140, the electronic device 100 may determine a process termination sequence based on the calculated time. For example, the process termination sequence may be determined in the order of shorter times calculated for each process. Specifically, if a specific process needs a relatively longer running time, the shutdown sequence can be delayed so that it is stored in memory for as long as possible.

In step S1150, the electronic device 100 may terminate a process having the highest order of termination. In one embodiment, if the available memory capacity is insufficient even after that, the next higher priority process may be terminated.

Claims (20)

In electronic devices,
a first memory;
a second memory; and
a processor executing the first process by loading a page of the first process related to the application into the first memory according to the execution of the application stored in the second memory;
the processor,
Checking available capacity for allocating a second process to the first memory;
identify whether to swap-out pages of the first process to the first memory or the second memory based on characteristics of the first process running in the first memory;
Allocating a part of the first memory or the second memory as a swap space;
Swap-out a page of the first process;
Checking whether the swapped-out page is swapped-in to the first memory again;
releasing the swap space of the first memory or the second memory;
electronic device. According to claim 1,
The electronic device of claim 1, wherein the characteristic of the first process includes at least one of a response time and a state preservation degree of the process.
According to claim 2,
In addition to the characteristics of the first process, the number of times the page of the first process is referenced by a plurality of processes is considered,
The electronic device that identifies whether to swap-out a page of the first process to the first memory or the second memory.
According to claim 1,
The electronic device of claim 1 , wherein the page of the first process includes a Shared Object (SO) file belonging to a shared library.
According to claim 1,
the processor,
When the swap space of the first memory is insufficient,
determining a first page among pages of the first process based on the number of times the page of the first process is referred to by a plurality of processes;
removing the first page from a first memory;
electronic device.
According to claim 1,
the processor,
When the swap space of the second memory is insufficient,
determining a second page among pages written to the second memory based on a time at which the page written to the second memory was swapped out to the second memory;
removing the second page from a second memory;
electronic device.
According to claim 5,
the processor,
If the available capacity for allocating a new process to the first memory is insufficient even after the first page is removed from the first memory,
Checking whether there is a swap space in the second memory for swapping out a page of a process running in the first memory;
When the swap space of the second memory is insufficient,
determining a second page among pages written to the second memory based on a time at which the page written to the second memory was swapped out to the second memory;
removing the second page from a second memory;
electronic device.
According to claim 7,
The first page and the second page include a Shared Object (SO) file belonging to a shared library.
electronics.
According to claim 7,
the processor,
If the available capacity for allocating a new process to the first memory is insufficient even after the second page is removed from the second memory,
Calculate the time required for process driving for each of the plurality of processes running in the first memory, and based on the calculated time,
determining an order of termination of a plurality of processes running in the first memory;
By terminating at least one process among a plurality of processes running in the first memory,
Making the storage area of the first memory loaded with the data of the terminated process available to other processes,
electronics.
According to claim 9,
The time required for driving the process includes at least one of the time required for searching for the SO symbol of the page of the process and the time required for executing an XML-based UI process,
electronics.
In the memory management method of an electronic device,
executing a first process related to an application stored in a second memory by loading it into the first memory;
checking available capacity for allocating a second process to the first memory;
identifying whether to swap-out pages of the first process to the first memory or the second memory based on a characteristic of the first process running in the first memory;
allocating a partial area of the first memory or the second memory as a swap space;
swapping out a page of the first process;
checking whether the swapped-out page is swapped back into the first memory; and
releasing the swap space of the first memory or the second memory;
Memory management method of an electronic device comprising a.
According to claim 11,
The method of claim 1, wherein the characteristic of the first process includes at least one of a process response time and a degree of state preservation.
According to claim 12,
Identifying whether to swap-out a page of the first process to the first memory or the second memory,
and identifying whether to swap-out to the first memory or the second memory based on the number of times a page of the first process is referenced from a plurality of processes.
According to claim 11,
The method of claim 1 , wherein the page of the first process includes a Shared Object (SO) file belonging to a shared library.
According to claim 11,
The step of allocating a part of the first memory or the second memory as a swap space,
When the swap space of the first memory is insufficient,
determining a first page among pages of the first process based on the number of times the page of the first process is referenced from a plurality of processes; and
and removing the first page from a first memory.
According to claim 11,
The step of allocating a part of the first memory or the second memory as a swap space,
When the swap space of the second memory is insufficient,
determining a second page among pages written to the second memory based on a time at which the page written to the second memory was swapped out to the second memory; and
and removing the second page from a second memory.
According to claim 15,
If the available capacity for allocating a new process to the first memory is insufficient even after the first page is removed from the first memory,
checking whether there is a swap space in the second memory for swapping out a page of a process running in the first memory;
When the swap space of the second memory is insufficient,
determining a second page among pages written to the second memory based on a time at which the page written to the second memory was swapped out to the second memory; and
and removing the second page from a second memory.
According to claim 17,
The first page and the second page include a Shared Object (SO) file belonging to a shared library.
method.
According to claim 17,
If the available capacity for allocating a new process to the first memory is insufficient even after the second page is removed from the second memory,
calculating a required process driving time for each of a plurality of processes running in the first memory;
determining an order of termination of a plurality of processes running in the first memory based on the calculated time; and
and terminating at least one process among a plurality of processes running in the first memory.
According to claim 19,
The time required for driving the process includes at least one of a time required for searching for an SO symbol of a page of the process and a time required for executing an XML-based UI process.

Images