CN105843735A - Terminal memory consumption method and apparatus - Google Patents

Abstract

A method for consuming terminal memory, comprising: creating n processes, wherein the i+1th process among the n processes is created by the i-th process, n is a positive integer not less than 2, and i is a positive integer smaller than n; The terminal is in a low-memory state by using the n processes to jointly consume the memory of the terminal. Corresponding devices are also provided. The technical solution can make the terminal quickly reach the low memory state and be stably in the low memory state.

Description

Method and device for consuming terminal memory

technical field

The present invention relates to the technical field of terminals, in particular to a terminal memory consumption method and device.

Background technique

At present, the development of mobile phones is very fast. As the memory of mobile phones becomes larger and larger, the performance of mobile phones is also getting better and better. In order to ensure the performance of the mobile phone, it is usually necessary to perform various tests on the mobile phone. Among them, sometimes, it is necessary to make the mobile phone in a low-memory state, so as to do related low-memory tests.

At present, it is usual to install and run a large amount of app (application, application program) in the mobile phone, such as installing and running a large amount of apk (Android Package, Android installation package) in a mobile phone using the Android (Android) platform, to consume the memory of the Android platform , put the phone in a low memory state.

Practice has found that this method is cumbersome, time-consuming, and unstable.

Contents of the invention

Embodiments of the present invention provide a terminal memory consumption method and device, so that the terminal quickly reaches a low memory state and remains in a low memory state stably.

In order to solve the above-mentioned technical problems and achieve the above-mentioned beneficial effects, the present invention provides a terminal memory consumption method, including: creating n processes, the i+1th process in the n processes is created by the i-th process, and n is not A positive integer less than 2, i is a positive integer less than n; using the n processes to jointly consume the memory of the terminal, so that the terminal is in a low memory state.

The present invention also provides a device, including: a process creation module, used to create n processes, the i+1th process among the n processes is created by the i-th process, n is a positive integer not less than 2, and i is A positive integer smaller than n; a memory management module, configured to use the n processes to jointly consume the memory of the terminal, so that the terminal is in a low-memory state.

The present invention also provides a memory for storing one or more programs which, when executed by a terminal comprising one or more processors, cause the terminal to perform the terminal memory consumption described above. method.

The present invention also provides a terminal, including: one or more processors; a memory; a transceiver; the processor is connected to the memory through a bus, and when the terminal is running, the processor executes the program stored in the memory , so that the terminal executes the method for consuming terminal memory as described above.

Compared with the prior art, in some feasible implementations of the present invention, the terminal can create n processes, and the i+1th process among the n processes is created by the i-th process, that is, the n processes are created by the first The second one, the second one creates the third one, until the nth one, that is to say, these n processes are chained parent-child processes, so that, on the one hand, the terminal can quickly reach a low memory state, and the solution is simple to implement ; On the other hand, it can greatly reduce the risk of some processes being killed by the low memory killer (low memory cleanup) of the terminal Android platform, and can keep the terminal in a low memory state stably.

Description of drawings

In order to more clearly illustrate the technical solutions of the embodiments of the present invention, the following will briefly introduce the accompanying drawings that need to be used in the description of the prior art. Obviously, the accompanying drawings in the following description are only some embodiments of the present invention. For Those of ordinary skill in the art can also obtain other drawings based on these drawings without making creative efforts.

FIG. 1 is a schematic flowchart of a terminal memory consumption method provided by an embodiment of the present invention;

Fig. 2 is the specific flowchart of terminal creation process in the embodiment of the present invention;

Fig. 3 is a test effect figure of the embodiment of the present invention;

FIG. 4 is a schematic structural diagram of a terminal memory consumption device provided by an embodiment of the present invention;

FIG. 5 is a schematic structural diagram of a terminal provided by an embodiment of the present invention.

detailed description

In order to enable those skilled in the art to better understand the solutions of the present invention, the following will clearly and completely describe the technical solutions in the embodiments of the present invention in conjunction with the drawings in the embodiments of the present invention. Obviously, the described embodiments are only It is an embodiment of a part of the present invention, but not all embodiments. Based on the embodiments of the present invention, all other embodiments obtained by persons of ordinary skill in the art without making creative efforts shall fall within the protection scope of the present invention.

As described in the background technology section, at present, a large number of apps are usually installed and run in a mobile phone, for example, a large number of apks are installed and run in a mobile phone using the Android platform to consume the memory of the Android platform and make the mobile phone in a low-memory state.

However, Android has a set of memory management mechanisms. When the available memory of the mobile phone is lower than a certain threshold, it will trigger the low memory killer (low memory cleaning) mechanism to clean up some processes with lower priority to release memory. Specifically, Android is a multitasking system, which means it can run multiple programs at the same time; generally speaking, starting and running a program has a certain time overhead, so in order to speed up the operation, when exiting a program, Android It will not kill it immediately, so that the next time you run the program, it can be started quickly; as more and more programs are reserved in the system, there will definitely be insufficient memory. Low memory killer is when the system memory is lower than When a certain threshold is reached, related programs are cleared to ensure that the system maintains a certain amount of free memory.

Low memory killer decides the process to release based on two principles, the importance of the process and the amount of free memory that can be obtained by releasing the process. Each program will have an oom_adj value, the smaller the value, the more important the program and the lower the possibility of being killed. In addition, under the same oom_adj, processes with large memory are killed first.

Therefore, when a large number of apks are installed and run on the Android platform using existing technologies, when a large amount of memory is consumed, it is inevitable that some of the apk processes will be killed, and the memory of these apks will be released, which leads to running a large number of apks When the apk keeps the phone in a low-memory state, there will be repeated problems of processes being killed and then re-run. The process is cumbersome, and it takes a long time to reach the low-memory state. Once a process is killed, it may exit the low-memory state. memory state, resulting in an unstable low memory state.

In order to solve the above problems, an embodiment of the present invention provides a terminal memory consumption method and a corresponding device, so that the terminal quickly reaches a low memory state and remains in a low memory state stably.

In the following, specific examples will be used to describe in detail respectively.

Embodiment one,

Please refer to FIG. 1 , an embodiment of the present invention provides a method for consuming terminal memory, which is especially suitable for a terminal using an Android platform, such as a mobile phone or a tablet computer. The method may include:

110. Create n processes, the i+1th process among the n processes is created by the i-th process, n is a positive integer not less than 2, and i is a positive integer smaller than n;

120. Use the n processes to jointly consume memory of the terminal, so that the terminal is in a low memory state.

Wherein, the process is used to consume memory, and may also be referred to as a memory consumption process.

Optionally, in some embodiments, the n processes are processes of a native program; in some other embodiments, the n processes may also be processes of other programs.

Optionally, the execution paths of the n native programs may be in a directory with shell authority, such as the /data/local/tmp directory of a terminal using the Android platform, which is a directory with shell authority.

Each directory of Android has corresponding permissions, such as root (root, highest) permissions, system (system) permissions, shell (shell) permissions, and so on. The permissions of the /data/local/tmp directory in the example above are shell permissions, and the shell permissions are very low. Usually, any data can be put in, including push (push) with adb (AndroidDebug Bridge, Android Debug Bridge), so choose shell permissions The directory, conventional mobile phones and other terminals can be realized.

Of course, the execution paths of the n native programs can also be placed in other directories. If the terminal has been rooted and obtained a higher root authority, then the execution path of the native program can also be in a directory with root authority, such as the system/bin directory.

Alternatively, the execution path of the native program can also be in a directory with system permissions.

Optionally, each of the n processes can be used to occupy pM memory in the terminal memory. The smaller the value of p, the smaller the risk of the process being killed by the low memory killer, but in order to improve efficiency, p The value of p cannot be too small. Preferably, p=30 can be used, that is, 30M memory is allocated for each process, or a value near 30 such as 20 or 25 can also be used.

Optionally, when the terminal is in a low-memory state, low-memory-related tests can be performed.

As can be seen from the above, in the method of the embodiment of the present invention, the technical means adopted mainly include:

(1) The process may be a process of a native program, that is, the execution entity is a native program.

The implementation of the Android system can be divided into multiple layers, including: Java application program, Java framework layer, native (local framework) layer, kernel layer, namely Linux kernel space, etc. Some local services and some link libraries are common in the native layer. A feature of native is that it is generally implemented in C and C++ languages. For example, to perform a complex operation, if it is implemented through java code, the efficiency will be very low. At this time, you can choose to implement it through C or C++ code, and then communicate with the upper-level Java code. Another example is that if the terminal needs to run, it must interact with the underlying hardware driver and pass through the native layer.

Since the native program is between the kernel and the java program, the native program has the characteristics of controllability, independence and stability, which is helpful for fast and stable memory consumption. Of course, the program type of the process is not limited herein, and other types of program processes may also be used in specific implementation.

(2) The execution path of the native program can be in the /data/local/tmp directory, which has shell permissions, so it can be used in the Android user (user) version.

Android is divided into at least two versions: user (user) and eng (engineering). Ordinary users generally use the Android user version. Because the execution path of the native program is generally in the /data/local/tmp directory, and this directory has shell permissions. Shell is commonly known as the shell, which is used to distinguish it from the core, and refers to software (command parser) that "provides a user interface". Due to the shell authority, the solution of the embodiment of the present invention to consume memory by the process of the native program can be used in the Android user version, so as to facilitate low-memory detection on common Android terminals.

(3) Multiple processes jointly exhaust the specified memory and share the risk of being killed by the low memory killer.

In the embodiment of the present invention, multiple processes are used to jointly consume memory, and the risk of being killed by the low memory killer can be shared.

(4) The memory consumption process is a chained parent-child process, reducing the risk of being killed by the low memory killer.

In the embodiment of the present invention, among the n processes used to consume memory, the first process generates the second process, the second process generates the third process, ...the i-th process generates the i+1-th process..., or, process A generates Process B, process B generates process C, process C generates process D, and so on, all n processes are chained parent-child processes, interrelated with each other, and the importance is basically the same. The oom_adj value of each process is basically the same, and there is no oom_adj value Especially low memory processes, thus, can greatly reduce the risk of being killed by the low memory killer. It should be noted that each Android program will have an oom_adj value, the smaller the value, the more important the program and the lower the possibility of being killed.

(5) Each memory consumption process occupies the terminal memory by allocating pM memory, preferably p=30.

In the preferred solution of the embodiment of the present invention, the memory consumed by each process can be basically equal, for example, allocate 30M memory for each process, or in other words, each process occupies 30M memory in the terminal memory. It takes up a lot and is easy to be killed. Multiple processes can share the risk of being killed by the lowmemory killer.

Please refer to FIG. 2, in some embodiments of the present invention, the specific flow chart of the terminal creating n processes, including:

S1. Obtain a preset threshold desired_size (required size); desired_size represents the final required memory size, that is, the size of free memory after running n processes.

Optionally, the threshold defaults to the threshold of the low memory killer. In different terminals, the threshold of lowmemory killer may be different.

S2, judging whether the current free memory is greater than the threshold, if so, then enter step S3, otherwise end;

In this step, determine whether the current free memory (Free_RAMSize) is greater than the threshold desired_size, that is, determine whether Free_RAMSize>desired_size is true, if true, it means that the free memory is too large and has not yet reached the low memory state, and you need to enter step S3 to create a memory consumption process .

Conversely, if it is judged that the current free memory is not greater than the threshold, it means that the free memory is small and has reached a low memory state, and there is no need to consume memory, so there is no need to continue to create a memory consumption process, and the process ends here.

S3. Create a process, including: when there is no process currently, create a first process; when there is an i-th process, use the current i-th process to create an i+1-th process.

In this step, memory is created, which is easy to understand. When there is no current process, the terminal creates the first process; when there is already a process and the current process is the i-th process, the current i-th process is used to create the i+1-th process , to realize the creation of chained parent-child processes. Wherein, after each process is created, for example, after the 1st process or the i+1th process is created, the 1st process or the i+1th process can apply for a certain amount of memory, such as 30M memory, to the Android system through, for example, a malloc function.

After the creation of a process is completed in this step, return to step S2, judge whether it is already in a low memory state by judging the current free memory, and continue the process according to the judgment result. The whole process is a while () loop process, and finally judge that the terminal is in a low memory state state, end the process. Then, you can start various low memory related tests.

It should be noted that when the above threshold is too small, if the memory of the process that continues to be created is too large, the remaining memory of the entire mobile phone may become 0, causing the mobile phone to crash or freeze. In order to avoid this situation, optionally, a minimum value such as 100M can be set in the embodiment of the present invention. When it is judged in step S2 that the current free memory is greater than the threshold, it is further judged whether the current free memory is greater than 100M. , enter step S3, otherwise end. That is to say, the following two relations must be satisfied at the same time:

Free_RAMSize>desired_size;

Free_RAMSize>100M;

Then enter step S3, create a memory consumption process.

This can prevent the memory of the entire mobile phone from being completely consumed and cause the system to crash or freeze.

It should be noted that the above-mentioned minimum value of 100M is only an example, and in practical applications, it can also be changed to other values such as 150M or 120M.

In this paper, the verification results of the technical solutions of the embodiments of the present invention are also shown:

Please refer to the test effect diagram shown in Figure 3. In an application example, assuming that mvg_app is the name of the memory-consuming process, the final effect is shown in Figure 3. In Figure 3: the first dotted box is the process id of the memory consuming process; the second dotted box is the parent process id of the memory consuming process; the third dotted box is the size of memory occupied by each memory consuming process, approximately 30M. It can be seen that the mobile phone can be easily reached and stabilized in a low memory state.

It can be understood that the above solutions of the embodiments of the present invention can be specifically implemented in terminal devices such as mobile phones, for example.

To sum up, compared with the prior art, in some feasible implementations of the present invention, the terminal creates n processes, and the i+1th process among the n processes is created by the ith process, that is, the n processes are created by the 1st One creates the second one, the second one creates the third one, until the nth one, that is to say, these n processes are chained parent-child processes, so that, on the one hand, the terminal can quickly reach the low memory state, and the scheme The implementation is simple; on the other hand, it can greatly reduce the probability of some processes being killed by the low memory killer of the terminal Android platform, and can make the terminal stably in a low memory state; on the other hand, the process can be a process of a native program, This whole scheme can be applied to the Android user version.

In order to better implement the above solutions of the embodiments of the present invention, related devices for coordinating the implementation of the above solutions are also provided below.

Embodiment two,

Please refer to FIG. 4, an embodiment of the present invention provides a device for consuming terminal memory, which may include:

A process creation module 410, configured to create n processes, the i+1th process in the n processes is created by the i-th process, n is a positive integer not less than 2, and i is a positive integer smaller than n;

The memory management module 420 is configured to use the n processes to jointly consume the memory of the terminal, so that the terminal is in a low memory state.

In some embodiments of the present invention, the n processes are native program processes.

In some embodiments of the present invention, the execution path of the native program is in a directory with shell authority.

In some embodiments of the present invention, the process creation module 410 includes:

an acquisition unit, configured to acquire a preset threshold;

A judgment unit, configured to judge whether the current free memory is greater than the threshold, if so, instruct the creation unit to create a process, otherwise end;

The creating unit is used to create a process when the judging unit judges yes, including: creating a first process when there is no process currently; creating an i-th process using the current i-th process when there is an i-th process currently +1 for the process.

In some embodiments of the present invention, the judging unit is specifically used to judge whether the current free memory is greater than the threshold, if so, then further judge whether the current free memory is greater than 100M, if so, instruct the creation unit to create a process, otherwise end, wherein the threshold is the threshold of the low memory killer.

The device for consuming terminal memory in this embodiment of the present invention may be, for example, a terminal device such as a mobile phone, or may be a functional entity running on the terminal device.

It can be understood that the functions of each functional module of the device for consuming terminal memory in the embodiment of the present invention can be specifically implemented according to the method in the above method embodiment, and the specific implementation process can refer to the relevant description in the above method embodiment, and will not be repeated here. repeat.

It can be seen from the above that in some feasible implementation manners of the present invention, the terminal creates n processes, and the i+1th process among the n processes is created by the i-th process, that is, the n processes are created by the first The second one, the second one creates the third one, until the nth one, that is to say, these n processes are chained parent-child processes, so that, on the one hand, the terminal can quickly reach a low memory state, and the solution is simple to implement ; On the other hand, it can greatly reduce the probability that some processes are killed by the low memory killer of the terminal Android platform, and can make the terminal stably in a low memory state; on the other hand, the process can be a process of a native program, so that the entire The scheme can be applied to the Android user version.

Embodiment three,

An embodiment of the present invention also provides a memory for storing one or more programs, the one or more programs include instructions for executing the terminal memory consumption described in the above embodiments, when the one or more programs are included When the terminals of one or more processors are executed, the terminals are executed to consume terminal memory as described in the above embodiments.

Embodiment four,

Please refer to FIG. 5 , the embodiment of the present invention also provides a terminal 500, which may include:

One or more processors 501; memory 502; bus 504; transceiver 505; and one or more programs 503, wherein the one or more programs are stored in the memory 502 and configured to be used by the one or a plurality of processors 501, and the one or more programs 503 include a method for consuming terminal memory as described in the method embodiment above. Wherein, the processor 501 and the memory 502 may be connected through a bus 504 . When the terminal 500 is running, the processor 501 executes the program 503 stored in the memory 502, so that the terminal 500 executes the method for consuming terminal memory as described in the method embodiment above.

In the foregoing embodiments, the descriptions of each embodiment have their own emphases, and for parts not described in detail in a certain embodiment, reference may be made to relevant descriptions of other embodiments.

It should be noted that for the foregoing method embodiments, for the sake of simple description, they are expressed as a series of action combinations, but those skilled in the art should know that the present invention is not limited by the described action sequence, because Certain steps may be performed in other orders or simultaneously in accordance with the present invention. Secondly, those skilled in the art should also know that the embodiments described in the specification belong to preferred embodiments, and the actions and modules involved are not necessarily required by the present invention.

Those of ordinary skill in the art can understand that all or part of the steps in the various methods of the above-mentioned embodiments can be completed by instructing related hardware through a program, and the program can be stored in a computer-readable storage medium, and the storage medium can include: ROM, RAM, disk or CD, etc.

The method and device for consuming terminal memory provided by the embodiments of the present invention are described above in detail. In this paper, specific examples are used to illustrate the principle and implementation of the present invention. The descriptions of the above embodiments are only used to help understand the present invention. method and its core idea; at the same time, for those of ordinary skill in the art, according to the idea of the present invention, there will be changes in the specific implementation and scope of application. In summary, the content of this specification should not be understood as Limitations on the Invention.

Claims (10)

1. the consumption method of a tag memory, it is characterised in that including:

Creating n process, the i+1 process in described n process is by the i-th process creation, and n is not less than 2 Positive integer, i is the positive integer less than n；

Utilize described n process jointly to consume the internal memory of terminal, make described terminal be in low internal storage state.

Method the most according to claim 1, it is characterised in that

Described n process is the process of native program.

Method the most according to claim 2, it is characterised in that

The execution route of described native program is in the catalogue with shell authority.

Method the most according to claim 1, it is characterised in that described terminal creates n process, described I+1 process in n process is included by the i-th process creation:

S1, obtain threshold value set in advance；

S2, judge that current free memory whether more than described threshold value, the most then enters step S3, otherwise Terminate；

S3, establishment process, including: when currently without process, create the 1st process；I-th is had current During process, utilize the i-th current process creation i+1 process；

Return step S2.

Method the most according to claim 4, it is characterised in that described step S2 specifically includes:

Judge that current free memory whether more than described threshold value, the most then determines whether the current free time Whether internal memory more than 100M, the most then enters step S3, otherwise terminates；

Wherein, described threshold value is the threshold value of low internal memory cleaning low memory killer.

6. the consumer of a tag memory, it is characterised in that including:

Process creation module, is used for creating n process, and the i+1 process in described n process is by the i-th process Creating, n is the positive integer not less than 2, and i is the positive integer less than n；

Memory management module, for utilizing described n process jointly to consume the internal memory of terminal, makes described end In low internal storage state.

Device the most according to claim 6, it is characterised in that

Described n process is the process of native program.

Device the most according to claim 7, it is characterised in that

The execution route of described native program is in the catalogue with shell authority.

Device the most according to claim 6, it is characterised in that described process creation module includes:

Acquiring unit, is used for obtaining threshold value set in advance；

Judging unit, for judging whether current free memory is more than described threshold value, if, it indicates that wound Build unit and create process, otherwise terminate；

Described creating unit, for creating process when described judging unit is judged as YES, including: currently When there is no process, create the 1st process；Current have the i-th process time, utilize the i-th current process creation the I+1 process.

Device the most according to claim 9, it is characterised in that

Described judging unit, specifically for judging whether current free memory is more than described threshold value, if so, Then determine whether whether current free memory is more than 100M, if, it indicates that creating unit creates process, Otherwise terminating, wherein, described threshold value is the threshold value of low internal memory cleaning low memory killer.