CN116974732A

CN116974732A - Memory processing method, device, terminal equipment and medium

Info

Publication number: CN116974732A
Application number: CN202210425508.0A
Authority: CN
Inventors: 韩立
Original assignee: Beijing Zitiao Network Technology Co Ltd
Current assignee: Beijing Zitiao Network Technology Co Ltd
Priority date: 2022-04-21
Filing date: 2022-04-21
Publication date: 2023-10-31

Abstract

The disclosure discloses a memory processing method, a memory processing device, terminal equipment and a medium. The method comprises the following steps: acquiring the memory size of a memory applied by a target object; applying for a target memory with a set size in the target heap, wherein the set size is smaller than the memory size; applying for a local memory with a memory size in a local heap; storing the target object in a local memory; the set identification information is used for identifying that the applied memory is applied from the local heap. According to the method, the target memory is applied to the target heap, the local memory is applied to the local heap for storing the target object, the memory used by the target object can be changed from the target heap to the local heap, the available memory space of the target object is larger through the local heap, the OOM problem caused by storing the target object in the target heap is avoided, and the application program using effect is improved.

Description

Memory processing method, device, terminal equipment and medium

Technical Field

The embodiment of the disclosure relates to the technical field of computers, in particular to a memory processing method, a memory processing device, terminal equipment and a medium.

Background

Currently, in some android systems, the memory used for the pixel data corresponding to the picture (i.e., bitmap) in the application program is allocated in a Java (i.e., java) heap, i.e., the pixel data of the Bitmap is stored in the Java heap.

However, the size of Java heap is limited, and common Java heap sizes are 64M (megabits), 128M, 256M, 384M, 512M, and the like. For the android system adopting Java heap allocation to store Bitmap pixel data, as functions of application programs are more and more abundant, pictures are more and more used, and Java heap memory occupied by the Bitmap pixel data is more and more occupied. In this process, the problems Of Java heap Memory exhaustion (OOM) and the like are easily caused, so that the application program crashes, and the use effect Of the application program is affected.

Disclosure of Invention

The embodiment of the disclosure provides a memory processing method, a memory processing device, terminal equipment and a medium, which are used for solving the OOM problem caused by distributing and storing Bitmap pixel data by a Java heap and improving the use effect of an application program.

In a first aspect, an embodiment of the present disclosure provides a memory processing method, including:

acquiring the memory size of a memory applied by a target object;

applying for a target memory with a set size in a target heap, wherein the set size is smaller than the memory size;

Applying for the local memory with the memory size in the local heap;

storing the target object in the local memory;

the set identification information is used for identifying that the applied memory is applied from the local heap, and the global reference information is used for identifying the storage position of the array in a global reference table.

In a second aspect, an embodiment of the present disclosure further provides a memory processing apparatus, including:

the acquisition module is used for acquiring the memory size of the memory applied by the target object;

the first application module is used for applying for a target memory with a set size in a target heap, wherein the set size is smaller than the memory size;

the second application module is used for applying for the local memory with the memory size in the local heap;

the storage module is used for storing the target object in the local memory;

In a third aspect, an embodiment of the present disclosure further provides a terminal device, including:

one or more processing devices;

a storage means for storing one or more programs;

the one or more programs are executed by the one or more processing devices, so that the one or more processing devices implement the memory processing method provided by the embodiments of the present disclosure.

In a fourth aspect, the embodiments of the present disclosure further provide a computer readable medium having a computer program stored thereon, where the program when executed by a processing device implements the memory processing method provided by the embodiments of the present disclosure.

The embodiment of the disclosure provides a memory processing method, a memory processing device, terminal equipment and a medium, wherein the memory size of a memory applied by a target object is firstly obtained; secondly, applying for a target memory with a set size in the target heap, wherein the set size is smaller than the memory size; then applying for the local memory with the memory size in the local heap; finally, storing the target object in a local memory; the set identification information is used for identifying that the applied memory is applied from the local heap, and the global reference information is used for identifying the storage position of the array in the global reference table. According to the method, the target memory is applied to the target heap, the local memory is applied to the local heap for storing the target object, the memory used by the target object can be changed from the target heap to the local heap, the available memory space of the target object is larger through the local heap, the OOM problem caused by storing the target object in the target heap is avoided, and the application program using effect is improved.

Drawings

The above and other features, advantages, and aspects of embodiments of the present disclosure will become more apparent by reference to the following detailed description when taken in conjunction with the accompanying drawings. The same or similar reference numbers will be used throughout the drawings to refer to the same or like elements. It should be understood that the figures are schematic and that elements and components are not necessarily drawn to scale.

Fig. 1 is a flow chart of a memory processing method according to a first embodiment of the disclosure;

fig. 2 is a flow chart of a memory processing method according to a second embodiment of the disclosure;

fig. 3 is a schematic structural diagram of a memory processing device according to a third embodiment of the disclosure;

fig. 4 is a schematic structural diagram of a terminal device according to a fourth embodiment of the present disclosure.

Detailed Description

Embodiments of the present disclosure will be described in more detail below with reference to the accompanying drawings. While certain embodiments of the present disclosure have been shown in the accompanying drawings, it is to be understood that the present disclosure may be embodied in various forms and should not be construed as limited to the embodiments set forth herein, but are provided to provide a more thorough and complete understanding of the present disclosure. It should be understood that the drawings and embodiments of the present disclosure are for illustration purposes only and are not intended to limit the scope of the present disclosure.

It should be understood that the various steps recited in the method embodiments of the present disclosure may be performed in a different order and/or performed in parallel. Furthermore, method embodiments may include additional steps and/or omit performing the illustrated steps. The scope of the present disclosure is not limited in this respect.

The term "including" and variations thereof as used herein are intended to be open-ended, i.e., including, but not limited to. The term "based on" is based at least in part on. The term "one embodiment" means "at least one embodiment"; the term "another embodiment" means "at least one additional embodiment"; the term "some embodiments" means "at least some embodiments. Related definitions of other terms will be given in the description below.

It should be noted that the terms "first," "second," and the like in this disclosure are merely used to distinguish between different devices, modules, or units and are not used to define an order or interdependence of functions performed by the devices, modules, or units.

It should be noted that references to "one", "a plurality" and "a plurality" in this disclosure are intended to be illustrative rather than limiting, and those of ordinary skill in the art will appreciate that "one or more" is intended to be understood as "one or more" unless the context clearly indicates otherwise.

The names of messages or information interacted between the various devices in the embodiments of the present disclosure are for illustrative purposes only and are not intended to limit the scope of such messages or information.

In the following embodiments, optional features and examples are provided in each embodiment at the same time, and the features described in the embodiments may be combined to form multiple alternatives, and each numbered embodiment should not be considered as only one technical solution. Furthermore, embodiments of the present disclosure and features of embodiments may be combined with each other without conflict.

In some android systems, the memory used by the pixel data corresponding to the Bitmap in the application program is allocated in the Java heap, i.e. the pixel data of the Bitmap is stored in the Java heap. However, the size of Java heap is limited, and common sizes are 64M, 128M, 256M, 384M, 512M, etc. For the android system for distributing and storing Bitmap pixel data by adopting Java heap, as the functions of application programs are more and more abundant, the pictures are more and more used, and the occupied Java heap memory is more, so that the problem of Java heap OOM is easier to cause, and the application programs crash, thereby influencing the use effect of the application programs.

Because the upper limit of the size of the local heap (i.e., native heap) is relatively large, 32-bit applications can use 3 (Gigabyte, GB) to 4GB of Native heap memory, and 64-bit applications can use more Native heap memory.

For an android system for storing Bitmap pixel data by Java heap allocation, the embodiment of the disclosure provides a memory processing method, which can change the memory used by the Bitmap pixel data from Java heap allocation to Native heap allocation, so that the memory space used by the Bitmap pixel data is larger, and Java OOM problem is not easy to occur for an application program.

The memory processing method provided by the embodiment of the disclosure can provide the application program with the capability of distributing the memory used by Bitmap pixel data from the Native heap. Specifically, for an android system which adopts a Java heap to allocate and store Bitmap pixel data, when an application program allocates memory for the Bitmap pixel data from the Java heap, the operation of allocating memory from the Java heap is replaced by the operation of allocating memory from the Native heap, relevant information such as the size of the Bitmap and the memory on the Native heap is recorded, and then the memory allocated from the Native heap is provided for the application program for use. And releasing the Bitmap memory applied from the Native heap at the original position of the application program for releasing the Bitmap memory. The method can enable the problem that Java OOM is broken down to be less likely to happen to the application program, and therefore the use experience and effect of the application program are improved.

Example 1

Fig. 1 is a flow chart of a memory processing method according to a first embodiment of the present disclosure, where the method may be applicable to a case of processing a memory for storing a target object, and the method may be performed by a memory processing apparatus, where the apparatus may be implemented by software and/or hardware and is generally integrated on a terminal device, and in this embodiment, the terminal device includes but is not limited to: a computer, a notebook computer, a smart phone, a tablet computer, or the like.

As shown in fig. 1, a memory processing method provided in a first embodiment of the present disclosure includes the following steps:

s110, obtaining the memory size of the memory applied by the target object.

In this embodiment, the target object may refer to pixel data corresponding to a video or a picture to be saved in the application program. Since the video is also composed of one frame of picture, the pixel data corresponding to the video may be considered to be composed of one frame of picture, and the target object may be considered to be picture pixel data. The pixel data of the picture may be represented as pixel data of a Bitmap.

Optionally, the target object is pixel data of a picture.

The memory size of the memory applied by the target object can be understood as the memory size required for storing the target object. The size of the memory to which the target object applies is not particularly limited here. For example, the memory size of the application memory required by the target object may be determined according to the pixel size of the target object.

S120, applying for a target memory with a set size in a target heap, wherein the set size is smaller than the memory size.

In this embodiment, the target heap may refer to a Java heap, which may be considered an area in Java for storing data. The set size may be a predetermined size of the memory to be applied from the target heap, and the set size is not particularly limited herein. The memory applied by the target object is converted from the target heap application to the local heap application, so the set size can be smaller than the memory size.

The target memory may refer to a set-sized memory space as applied from the target heap. The set identification information, the global reference information and the address information of the memory applied from the local heap can be stored in the array corresponding to the target memory. The data in the target memory may be stored in the form of bytes, the data may correspond to a plurality of bytes, and the storage of the plurality of bytes may form a corresponding byte array, and the byte array may be regarded as an array corresponding to the target memory.

The set identification information may be used to identify the memory to which the target object applies as being applied from the local heap. The setting identification information is not limited herein, and may be, for example, a custom character string, such as 0x13572468. It can be understood that when the identification information is set through the custom character string, the character string represented by the commonly used Bitmap pixel data can be avoided, so as to avoid misjudgment caused by superposition.

The global reference information may be used to identify storage locations of the array within the global reference table. The global reference table may refer to a table for storing the reference relation of the Java local interface (Java Native Interface, JNI) to the Java virtual machine (Java Virtual Machine, JVM) object which is locally introduced, that is, after the target object is introduced into the Java heap, the reference relation of the Java JNI to the Java virtual machine may be stored in the global reference table, and based on this reference, content information such as parameters in the corresponding array of the target object may be accessed; the Global reference table may be represented as Global Reftable. A local heap may refer to a Native heap, which may be considered an area in the local area for storing data.

The address information of the memory applied from the local heap may be used to identify a location in the local heap where the memory applied from the local heap, such as the first address information of the memory applied from the local heap, as can be understood.

Here, how to apply for the target memory with the set size to the target heap is not limited. For example, a target memory of a set size may be applied for by a function (e.g., newnonmablearray function) for applying for memory from a target heap, and the applied target memory may correspond to an array. Specifically, for the array, firstly, in order for a target object in Java to obtain the real size of the memory required by the target object by using the information of the memory required by the target object in the array, the information of the memory required by the target object in the array can be modified into the memory size of the memory applied by the target object; then, in order to identify that the memory applied by the target object in the array is applied from the local heap, setting identification information can be stored in the array, so that whether the array is the array of the memory applied by the target object applied from the local heap can be judged according to the setting identification information in the subsequent process; finally, in order to facilitate the release of the array corresponding to the target object in the subsequent process, the array may be stored in the global reference table, and after the array is stored in the global reference table, the global reference information is also stored in the array.

S130, applying for the local memory with the memory size in the local heap.

In this embodiment, the local memory may refer to the memory space applied from the local heap.

The local memory is not limited as to how the memory size of the memory applied by the target object is applied in the local heap. For example, the first address of the array may be obtained by a function (such as an addressOf function) for obtaining the first address of the array corresponding to the target memory; on the basis, whether set identification information exists in the array or not can be determined in an array storage space from the beginning of the initial address so as to judge whether the memory applied by the target object in the array is applied from a local heap or not; if the set identification information exists, the set identification information indicates that the memory applied by the target object in the array is applied from the local heap, and at this time, the local memory of the memory size of the memory applied by the target object can be applied from the local heap through a function (such as a calloc function) for memory allocation, and the returned address information representing the head address of the applied local memory is stored in the array.

S140, storing the target object in the local memory.

In this embodiment, after applying for the local memory of the memory size from the local memory, the target object may be stored in the local memory.

The first embodiment of the present disclosure provides a memory processing method, which includes first obtaining a memory size of a memory applied by a target object; secondly, applying for a target memory with a set size in the target heap, wherein the set size is smaller than the memory size; then applying for the local memory with the memory size in the local heap; finally, storing the target object in a local memory; the set identification information is used for identifying that the applied memory is applied from the local heap, and the global reference information is used for identifying the storage position of the array in the global reference table. According to the method, the target memory is applied to the target heap, the local memory is applied to the local heap for storing the target object, the memory used by the target object can be changed from the target heap to the local heap, the available memory space of the target object is larger through the local heap, the OOM problem caused by storing the target object in the target heap is avoided, and the application program using effect is improved.

Optionally, the method is applied to an android system with a target version, wherein the target version is a version in which a memory is allocated for a target object by a target heap, and the target heap is a Java heap.

The target version may be a version of memory allocated by a target heap for a target object, and the target heap may be a Java heap; i.e. the target version may be considered as the version of the memory allocated by the Java heap for the target object. The memory processing method provided by the embodiment can be applied to the android system of the target version.

Example two

Fig. 2 is a flow chart of a memory processing method according to a second embodiment of the disclosure. The second embodiment is a refinement based on the above embodiments. In this embodiment, a process of applying for a target memory with a set size in a target heap, applying for a local memory with a memory size in a local heap, and releasing corresponding arrays of the local memory and the target memory is specifically described. It should be noted that, in this embodiment, reference is made to the first embodiment.

As shown in fig. 2, a memory processing method according to a second embodiment of the present disclosure includes the following steps:

s210, obtaining the memory size of the memory applied by the target object.

In this embodiment, the target object may be pixel data of a picture, i.e., pixel data of a Bitmap. The terminal device may determine, according to the pixel size of the target object, the memory size of the memory required to obtain the target object.

S220, applying for the array with the set size through the application function, wherein the array corresponds to the target memory with the set size on the target heap.

In this embodiment, the application function may refer to a function for applying for memory from the target heap, e.g., the application function may be a newnonmablearray function. The target heap may be a Java heap.

The application function can apply for the array with the set size from the target heap, and the array can correspond to the target memory with the set size on the target heap.

S230, modifying the size information of the array into the memory size.

In this embodiment, the size information of the array may be understood as information stored in the array for characterizing the memory size of the memory applied by the target object. For example, if the obtained memory size of the memory applied by the target object is 1000 bytes, the size information of the array may be expressed as 1000 bytes, so as to record the memory size of the memory applied by the target object.

In order for the target object in the target heap to acquire the real memory size required by the target object by utilizing the size information of the array, the size information of the array can be modified into the memory size of the memory applied by the target object.

S240, storing the set identification information into an array.

In this embodiment, the memory applied by the target object may be applied from the local heap by setting the identification information, so in order to identify that the memory applied by the target object in the array is applied from the local heap, the setting identification information may be stored in the array for use in subsequent auxiliary determination of whether the applied memory is applied from the local heap.

S250, storing the array into a global reference table, and storing global reference information into the array.

In this embodiment, after the setting identification information is stored in the array, in order to ensure the release timing of the array, the array may be stored in the global reference table; and global reference information identifying the storage location of the array within the global reference table may be stored into the array for subsequent release of the array based on its storage location in the global reference table,

s260, determining whether the set identification information exists in the array through the head address acquisition function, and if yes, executing S270.

In this embodiment, the first address obtaining function may refer to a function for obtaining the first address of the array, for example, the first address obtaining function may be an addressOf function. It should be noted that, in the array, the memory space from the first address to the last address of the array may be used to store the setting identification information, the global reference information and the address information of the memory applied from the local heap, which are associated with the target object; in other storage spaces of the array except for the memory space between the first address and the last address of the array, the size information of the array (that is, the real memory size required for recording the target object) and the space of the array (the space of the array is understood to be the space occupied by the basic structure of the array, and is not limited in detail herein) are stored.

The first address of the array can be obtained through the first address obtaining function, on the basis, in the memory space between the first address and the end address of the array, whether the set identification information exists or not can be judged, if yes, it can be indicated that the memory applied by the target object in the array is applied from the local heap, and then S270 can be continuously executed. If the setting identification information does not exist, the original function can be called for returning, the original logic method is executed, and the method for executing the original logic method is not particularly limited.

S270, applying for the local memory with the memory size from the local heap through a memory allocation function.

In this embodiment, the memory allocation function may refer to a function for performing memory allocation on a memory space of the local heap, for example, the memory allocation function may be a calloc function.

Through the memory allocation function, the local memory with the memory size of the memory applied by the target object can be applied from the memory space of the local heap.

S280, storing the head address of the local memory into an array as address information.

In this embodiment, after the local memory of the memory size is applied from the local heap through the memory allocation function, the first address of the local memory may be stored as address information into the array, so that the address information is used as a pointer in the subsequent step, and the corresponding local memory is located in the local heap according to the address information.

S290, releasing the array corresponding to the local memory and the target memory stored in the global reference table by deleting the weak global reference function.

In this embodiment, a local heap is applied for a local memory for storing a target object; correspondingly, in order to realize better memory management, the situation of memory overflow is avoided, and after the target object uses the applied local memory, the corresponding local memory, the array and the like can be released. How the method of releasing the local memory and the array is implemented is not limited herein; as may be the local reference release method, the weak global reference release method, the global reference release method, etc., the specific implementation of the local reference release method, the weak global reference release method, and the global reference release method are not limited herein. The release may be understood as releasing the contained object, for example, releasing the local memory may be understood as releasing the local memory storing the target object in the local heap, where no object is stored in the local memory, and the local memory may be used for storing other objects to be stored later.

For example, it may be first determined whether the set identifier information is included in the array by deleting the weak global reference function, so as to determine whether the target object in the array is the memory applied from the local heap. If the array contains the set identification information, it can indicate that the target object in the array is the memory applied from the local heap, and at this time, global reference information and address information (i.e. address information representing the first address of the local memory) stored in the array can be obtained by deleting the weak global reference function; on the basis, the method can locate the local memory based on the address information representing the head address of the local memory, release the local memory, and locate the array corresponding to the target memory stored in the global reference table based on the global reference information, and release the array. The delete weak global reference function may refer to a function for deleting a reference to a target object to release a local memory and an array corresponding to the target object, for example, the delete weak global reference function may be a DeleteWeakGlobalRef function.

If the array does not contain the set identification information, the array corresponding to the target object can be released from the weak global reference table directly by deleting the weak global reference function.

Optionally, releasing the array corresponding to the local memory and the target memory stored in the global reference table by deleting the weak global reference function includes: determining whether set identification information is stored in the array or not by deleting the weak global reference function; if yes, global reference information and address information are obtained by deleting the weak global reference function; releasing the local memory corresponding to the address information by deleting the weak global reference function; the array within the global reference table is released by deleting the weak global reference function.

The process of releasing the array corresponding to the local memory and the target memory stored in the global reference table by deleting the weak global reference function may be that whether the set identification information is stored in the array is determined by deleting the weak global reference function; if so, global reference information and address information can be obtained by deleting the weak global reference function; on the basis, the local memory corresponding to the address information can be released by deleting the weak global reference function, and the array corresponding to the global reference information in the global reference table can be released by deleting the weak global reference function.

The second embodiment provides a memory processing method, which embodies the processes of applying for a target memory with a set size in a target heap, applying for a local memory with the memory size in the local heap, and releasing corresponding arrays of the local memory and the target memory. Applying for a target memory from a target heap through an application function, and modifying an array corresponding to the target memory to enable the array to contain size information representing the size of the memory, set identification information and global reference information; and applying for a local memory in the local heap through the head address acquisition function and the memory allocation function, wherein the local memory is used for storing the target object, and storing the head address of the local memory as address information into the array to be used as a local memory pointer for subsequent release. In addition, the memory management can be perfected by deleting the weak global reference function to release the local memory and the array stored in the global reference table, so that the problems of memory overflow and the like caused by that the local memory is not released after the target object is used are avoided, and the effectiveness of memory processing is optimized.

The present disclosure is exemplarily described below:

the disclosure provides a method for processing a memory for an android system which adopts Java heap (i.e. target heap) to distribute and store Bitmap pixel data (i.e. target objects), and mainly can realize the capability of an application program for providing the memory for distributing Bitmap pixel data from Native heap for use by the Bitmap on the android system by modifying the creation flow of the Bitmap and the release flow of the Bitmap in the android system. The method comprises the following specific implementation processes:

The creating flow of the Bitmap without using the method of the present disclosure is as follows (the Bitmap pixel data is applied for the memory from the Java heap in the Bitmap creating process):

1. applying for memory from Java heap to Bitmap pixel data by calling newNonMOVIEW array function, applying for a byte array (i.e. array);

2. the first address of the byte array is obtained by calling an address of function, and the memory from the first address to the memory at the end of the byte array is used for storing the pixel data of Bitmap.

The creating flow of the Bitmap when the method is used is as follows (two agents are made in the creating process of the Bitmap when the method is used):

1. the newNonMOVIEArray function called in the Bitmap creation process (the newNonMOVIEArray function called in the Bitmap creation process is a native logic process, and the proxy can be understood as the execution logic for modifying the process; similarly, the definition of the proxy is not repeated in the following embodiments):

a. when applying a Bitmap size (i.e., the memory size of the memory to which the target object applies) for a Bitmap on a Java heap through a newNonMovableArray function (i.e., an application function), only a byte array of size (sizeof (int) + sizeof (jobject) +sizeof (void)) is actually applied through proxy modification (12 bytes on 32-bit applications and 16 bytes on 64-bit applications). Wherein sizeof (int) is used for storing 0x13572468 (i.e. setting identification information), sizeof (jobject) corresponds to GlobalRef (i.e. global reference information), sizeof (void) corresponds to a pointer (i.e. address information of a memory applied from a local heap) stored later;

b. Modifying the size (i.e. the size) of the byte array to bitmapSize (i.e. modifying the size information of the array to the memory size of the memory applied by the target object) so as to obtain the real size of the Bitmap by using the bitmapSize in Java;

c. the first 4 bytes at the beginning of the first address of the byte array hold 0x13572468 as magic number (i.e., set identification information) to determine that this is a modified byte array. The storage location of the magic cube is not limited, and may be the first 4 bytes from the first address of the byte array, or may be a certain storage location after the first address of the byte array;

d. the byte array object is added to the Global Reftable (i.e., global reference table) by creating a Global reference (fake array object) function (i.e., newGlobalRef (fakeArrayObj) function) to ensure that the release timing of the byte array must be after the weak Global reference (i.e., deleteWeakGlobalRef) is deleted and GlobalRef is saved to the byte array for use in subsequent releases.

Table 1 shows a correspondence between the array content of a byte array and the memory space. . As shown in Table 1, a byte array memory layout is created by the agent, which may also be referred to as a fake array (i.e., fakeArray). The bitmapSize and the space before it in the array are the space of the array itself (i.e. the basic structure), the actual space starts from 0x13572468, including GlobalRef; in addition, the last memory space (i.e., 9-12 bytes) in the array may wait for subsequent use to store address information.

Table 1 correspondence between array contents of byte array and memory space

2. The addressOf function (i.e., the head address acquisition function) called in the proxy Bitmap creation process:

a. in the proxy function of address of, whether the input array is a modified array or not can be judged according to whether the data of the first 4 bytes is a magic number or not (namely whether the set identification information exists in the array or not is determined by the head address acquisition function), and if not, the original function is called for returning; if yes, continuing the following steps:

(1) Obtaining bitmapSize from fakeArray, and allocating bitmapSize-sized memory to Bitmap on Native heap (i.e. local heap) through calloc (bitmapSize, 1) (i.e. memory allocation function) (i.e. applying for memory-sized local memory from local heap through memory allocation function);

(2) Storing the allocated Bitmap pointer (namely the first address of the local memory) as address information into 9-12 bytes of fakeArray in the table 1;

(3) Returning the Bitmap pointer, and subsequently transferring the Bitmap pointer to a 2-dimensional vector graphic processing function library (namely Skia) for use by the native logic;

b. table 2 shows a correspondence between array contents of fakeArray and memory space. As shown in Table 2, the Bitmap pointers are stored into the 9-12 bytes of fakeArray in Table 1. These data populated in fakeArray will be used when later freeing Bitmap associative memory.

Table 2 correspondence between array contents of fakeArray and memory space

The release flow of Bitmap without the use of the method of the present disclosure:

in the memory storage byte array (mBuffer) of the native Bitmap pixel data, the memory release flow of the Bitmap corresponds to the release of the mBuffer object, and the memory release of the Bitmap pixel data can be triggered mainly by two modes: one is that after Java Bitmap objects are not referenced any more, when the Java Bitmap objects are recycled in a garbage recycling (Garbage Collection, GC) period, native Bitmap is destructed, so that the memory of Bitmap pixel data is released; one is to actively call a Bitmap recovery function, i.e., a Bitmap. Recovery () function to trigger the release of the Bitmap pixel data memory;

wherein, the mBuffer can be considered as a Java object applied in C language (i.e. C/C++) code, mainly referenced in two places:

C/C++ code adds mBuffer to the weak global reference table (Weak Global Reference table) for reference by creating weak global reference (array object) functions (i.e., newWeakGlobalRef (arrayObj) functions);

the Bitmap in Java is referenced by mBuffer, which is actually added to Global Reftable by NewGlobalRef (arrayObj) in C/C++ code, namely mBuffer is a Global ref (Global reference) associated with Java byte array;

The release order of the two references is to delete the global strong reference by the DeleteGlobalRef function (i.e. delete global reference function) (when the Bitmap is not used any more in the Skia, the strong reference deletion is triggered), delete the global weak reference by the DeleteWeakGlobalRef function (i.e. delete weak global reference function), and finally recycle the byte array object by GC.

The release flow of the Bitmap when the method is used is as follows:

DeleteWeakGlobalRef function invoked in proxy Bitmap release process:

1. judging whether the mBuffer is fakeArray or not in the proxy function (namely, proxyDeleteWeakGlobalRef function) (namely, determining whether set identification information is stored in an array or not by deleting a weak global reference function), if so, continuing to perform the following second step, and if not, jumping to the following fourth step to start execution;

2. extracting auxiliary data GlobalRef and Bitmap pointers (namely global reference information and address information) stored in the fakeArray from the proxy function;

3. releasing the memory allocated to the Bitmap corresponding to the Native heap Bitmap pointer, and then releasing the Global Ref from the Global Reftable;

4. releasing the mBuffer from Weak Global Reftable (i.e., weak global reference table);

wherein, mBuffer can correspond to fakeArray.

By modifying the creating flow of the Bitmap in the android system for storing the Bitmap pixel data by adopting Java heap allocation, the application program can provide the Bitmap with the capacity of memory for allocating the Bitmap pixel data from the Native heap. By modifying the release flow of the Bitmap in the android system, the memory allocated to the Bitmap pixel data from the Native heap can be normally released. The method of the embodiment of the disclosure can ensure that the Bitmap created by the application program on the Native heap can be normally used, thereby achieving the effect of reducing Java OOM problems of the application program and providing better use experience for users.

Example III

Fig. 3 is a schematic structural diagram of a memory processing device according to a third embodiment of the present disclosure, where the device may be implemented by software and/or hardware and is generally integrated on a terminal device.

As shown in fig. 3, the apparatus includes: the device comprises an acquisition module 310, a first application module 320, a second application module 330 and a storage module 340;

the acquiring module 310 is configured to acquire a memory size of a memory applied by the target object;

a first application module 320, configured to apply for a target memory with a set size in a target heap, where the set size is smaller than the memory size;

A second application module 330, configured to apply for the local memory with the memory size in the local heap;

a storage module 340, configured to store the target object in the local memory;

In this embodiment, the device is first configured to obtain, through the obtaining module 310, a memory size of a memory applied by the target object; secondly, applying for a target memory with a set size in the target heap by a first application module 320, wherein the set size is smaller than the memory size; then, through the second application module 330, the method is used for applying for the local memory with the memory size in the local heap; finally, the storage module 340 is configured to store the target object in the local memory; the set identification information is used for identifying that the applied memory is applied from the local heap, and the global reference information is used for identifying the storage position of the array in the global reference table. According to the device, the target memory is applied to the target heap, the local memory is applied to the local heap for storing the target object, the memory used by the target object can be changed from the target heap to the local heap, the available memory space of the target object is larger through the local heap, the OOM problem caused by storing the target object in the target heap is avoided, and the application program using effect is improved.

Optionally, the first application module 320 specifically includes:

the first application unit is used for applying for an array with a set size through an application function, and the array corresponds to the target memory with the set size on the target heap;

a modifying unit, configured to modify the size information of the array into the memory size;

the first storage unit is used for storing the setting identification information into the array;

and the second storage unit is used for storing the array into a global reference table and storing global reference information into the array.

Optionally, the second application module 330 specifically includes:

the first determining unit is used for determining whether the set identification information exists in the array or not through a head address acquisition function;

the second application unit is used for applying for the local memory with the memory size from the local heap through a memory allocation function if the set identification information exists in the array;

and the third storage unit is used for storing the head address of the local memory into the array as address information.

Optionally, the apparatus further includes:

and the releasing module is used for releasing the local memory and the array corresponding to the target memory stored in the global reference table by deleting the weak global reference function.

Optionally, the release module specifically includes:

a second determining unit, configured to determine whether the setting identification information is stored in the array by deleting a weak global reference function;

the acquisition unit is used for acquiring the global reference information and the address information through the deletion of the weak global reference function if the set identification information is stored in the array;

the memory releasing unit is used for releasing the local memory corresponding to the address information through the weak global reference function;

and the array releasing unit is used for releasing the array in the global reference table through the deletion weak global reference function.

Optionally, the device is applied to an android system with a target version, the target version is a version in which memory is allocated for the target object by the target heap, and the target heap is a Java heap.

Optionally, the target object is pixel data of a picture.

The memory processing device can execute the memory processing method provided by any embodiment of the disclosure, and has the corresponding functional modules and beneficial effects of the execution method.

Example IV

Fig. 4 is a schematic structural diagram of a terminal device according to a fourth embodiment of the present disclosure. Fig. 4 shows a schematic diagram of a structure of a terminal device 400 suitable for use in implementing embodiments of the present disclosure. The terminal device 400 in the embodiments of the present disclosure may include, but is not limited to, mobile electronics such as mobile phones, notebook computers, digital broadcast receivers, personal digital assistants (Personal Digital Assistant, PDAs), tablet computers (Portable Android Device, PAD), portable multimedia players (Portable Media Player, PMP), in-vehicle electronics (e.g., in-vehicle navigation electronics), and the like, as well as stationary electronics such as digital TVs, desktop computers, and the like. The terminal device 400 shown in fig. 4 is only one example and should not impose any limitation on the functionality and scope of use of the embodiments of the present disclosure.

As shown in fig. 4, the terminal apparatus 400 may include one or more processing devices (e.g., a central processor, a graphic processor, etc.) 401, which may perform various appropriate actions and processes according to a program stored in a Read-Only Memory (ROM) 402 or a program loaded from a storage device 408 into a random access Memory (Random Access Memory, RAM) 403. The one or more processing devices 401 implement the methods as provided by the present disclosure. In the RAM403, various programs and data necessary for the operation of the terminal apparatus 400 are also stored. The processing device 401, the ROM 402, and the RAM403 are connected to each other by a bus 404. An Input/Output (I/O) interface 405 is also connected to bus 404.

In general, the following devices may be connected to the I/O interface 405: input devices 406 including, for example, a touch screen, touchpad, keyboard, mouse, camera, microphone, accelerometer, gyroscope, etc.; an output device 407 including, for example, a liquid crystal display (Liquid Crystal Display, LCD), a speaker, a vibrator, and the like; storage 408 including, for example, magnetic tape, hard disk, etc., storage 408 being for storing one or more programs; and a communication device 409. The communication means 409 may allow the terminal device 400 to communicate with other devices wirelessly or by wire to exchange data. While fig. 4 shows a terminal device 400 having various means, it is to be understood that not all of the illustrated means are required to be implemented or provided. More or fewer devices may be implemented or provided instead.

In particular, according to embodiments of the present disclosure, the processes described above with reference to flowcharts may be implemented as computer software programs. For example, embodiments of the present disclosure include a computer program product comprising a computer program embodied on a computer readable medium, the computer program comprising program code for performing the method shown in the flowcharts. In such an embodiment, the computer program may be downloaded and installed from a network via communications device 409, or from storage 408, or from ROM 402. The above-described functions defined in the methods of the embodiments of the present disclosure are performed when the computer program is executed by the processing device 401.

It should be noted that the computer readable medium described in the present disclosure may be a computer readable signal medium or a computer readable storage medium, or any combination of the two. The computer readable storage medium can be, for example, but is not limited to, an electronic, magnetic, optical, electromagnetic, infrared, or semiconductor system, apparatus, or device, or a combination of any of the foregoing. More specific examples of the computer-readable storage medium may include, but are not limited to: an electrical connection having one or more wires, a portable computer diskette, a hard disk, a Random Access Memory (RAM), a read-Only Memory (ROM), an erasable programmable read-Only Memory (EPROM or flash Memory), an optical fiber, a portable compact disc read-Only Memory (CD-ROM), an optical storage device, a magnetic storage device, or any suitable combination of the foregoing. In the context of this disclosure, a computer-readable storage medium may be any tangible medium that can contain, or store a program for use by or in connection with an instruction execution system, apparatus, or device. In the present disclosure, however, the computer-readable signal medium may include a data signal propagated in baseband or as part of a carrier wave, with the computer-readable program code embodied therein. Such a propagated data signal may take any of a variety of forms, including, but not limited to, electro-magnetic, optical, or any suitable combination of the foregoing. A computer readable signal medium may also be any computer readable medium that is not a computer readable storage medium and that can communicate, propagate, or transport a program for use by or in connection with an instruction execution system, apparatus, or device. Program code embodied on a computer readable medium may be transmitted using any appropriate medium, including but not limited to: electrical wires, fiber optic cables, RF (radio frequency), and the like, or any suitable combination of the foregoing.

In some implementations, the clients, servers may communicate using any currently known or future developed network protocol, such as the hypertext transfer protocol (Hyper Text Transfer Protocol, HTTP), and may be interconnected with any form or medium of digital data communication (e.g., a communication network). Examples of communication networks include a Local Area Network (LAN), a Wide Area Network (WAN), the internet (e.g., the internet), and peer-to-peer networks (e.g., ad hoc peer-to-peer networks), as well as any currently known or future developed networks.

The computer readable medium may be contained in the terminal device 400; or may exist alone without being assembled into the terminal device 400.

The computer readable medium stores one or more computer programs which when executed by a processing device implement the method of: the computer-readable medium carries one or more programs which, when executed by the terminal device, cause the terminal device 400 to: computer program code for carrying out operations of the present disclosure may be written in one or more programming languages, including an object oriented programming language such as Java, smalltalk, C ++ and conventional procedural programming languages, such as the "C" programming language or similar programming languages. The program code may execute entirely on the user's computer, partly on the user's computer, as a stand-alone software package, partly on the user's computer and partly on a remote computer or entirely on the remote computer or server. In the case of a remote computer, the remote computer may be connected to the user's computer through any kind of network, including a Local Area Network (LAN) or a Wide Area Network (WAN), or may be connected to an external computer (for example, through the Internet using an Internet service provider).

The flowcharts and block diagrams in the figures illustrate the architecture, functionality, and operation of possible implementations of systems, methods and computer program products according to various embodiments of the present disclosure. Each block in the flowchart or block diagrams may represent a module, segment, or portion of code, which comprises one or more executable instructions for implementing the specified logical function(s). It should also be noted that, in some alternative implementations, the functions noted in the block may occur out of the order noted in the figures. For example, two blocks shown in succession may, in fact, be executed substantially concurrently, or the blocks may sometimes be executed in the reverse order, depending upon the functionality involved. It will also be noted that each block of the block diagrams and/or flowchart illustration, and combinations of blocks in the block diagrams and/or flowchart illustration, can be implemented by special purpose hardware-based systems which perform the specified functions or acts, or combinations of special purpose hardware and computer instructions.

The modules described in the embodiments of the present disclosure may be implemented in software or hardware. The name of a module does not in some cases define the module itself.

The functions described above herein may be performed, at least in part, by one or more hardware logic components. For example, without limitation, exemplary types of hardware logic components that may be used include: a field programmable gate array (Field Programmable Gate Array, FPGA), an application specific integrated circuit (Application Specific Integrated Circuit, ASIC), a special standard product (Application Specific Standard Parts, ASSP), a System On Chip (SOC), a complex programmable logic device (Complex Programming logic device, CPLD), and the like.

In the context of this disclosure, a machine-readable medium may be a tangible medium that can contain, or store a program for use by or in connection with an instruction execution system, apparatus, or device. The machine-readable medium may be a machine-readable signal medium or a machine-readable storage medium. The machine-readable medium may include, but is not limited to, an electronic, magnetic, optical, electromagnetic, infrared, or semiconductor system, apparatus, or device, or any suitable combination of the foregoing. More specific examples of a machine-readable storage medium would include an electrical connection based on one or more wires, a portable computer diskette, a hard disk, a Random Access Memory (RAM), a read-only memory (ROM), an erasable programmable read-only memory (EPROM or flash memory), an optical fiber, a portable compact disc read-only memory (CD-ROM), an optical storage device, a magnetic storage device, or any suitable combination of the foregoing.

In accordance with one or more embodiments of the present disclosure, example 1 provides a memory processing method, including:

acquiring the memory size of a memory applied by a target object;

applying for the local memory with the memory size in the local heap;

storing the target object in the local memory;

In accordance with one or more embodiments of the present disclosure, example 2 is in accordance with the method of example 1,

the applying for the target memory with the set size in the target heap includes:

applying for an array with a set size through an application function, wherein the array corresponds to a target memory with the set size on the target heap;

modifying the size information of the array into the memory size;

storing the setting identification information into the array;

Storing the array to a global reference table and storing global reference information to the array.

In accordance with one or more embodiments of the present disclosure, example 3 is in accordance with the method of example 1,

applying for the local memory with the memory size in the local heap, including:

determining whether the set identification information exists in the array or not through a first address acquisition function;

if yes, applying for the local memory with the memory size from the local heap through a memory allocation function;

and storing the head address of the local memory into the array as address information.

In accordance with one or more embodiments of the present disclosure, example 4 is in accordance with the method of example 1,

further comprises:

and releasing the array corresponding to the target memory stored in the local memory and the global reference table by deleting the weak global reference function.

In accordance with one or more embodiments of the present disclosure, example 5 is a method according to example 4,

releasing the array corresponding to the target memory stored in the local memory and the global reference table by deleting the weak global reference function comprises the following steps:

determining whether the set identification information is stored in the array or not by deleting a weak global reference function;

If yes, acquiring the global reference information and the address information through the weak global reference function;

releasing the local memory corresponding to the address information through the weak global reference function;

and releasing the array in the global reference table through the deletion weak global reference function.

In accordance with one or more embodiments of the present disclosure, example 6 is in accordance with the method of example 1,

the method is applied to an android system with a target version, wherein the target version is a version of memory allocated to the target object by the target heap, and the target heap is a Java heap.

In accordance with one or more embodiments of the present disclosure, example 7 is in accordance with the method of example 1,

the target object is pixel data of a picture.

In accordance with one or more embodiments of the present disclosure, example 8 provides a memory processing apparatus, comprising:

The storage module is used for storing the target object in the local memory;

According to one or more embodiments of the present disclosure, example 9 provides a terminal device, comprising:

one or more processing devices;

a storage means for storing one or more programs;

the one or more programs, when executed by the one or more processing devices, cause the one or more processing devices to implement the methods of any of examples 1-7.

According to one or more embodiments of the present disclosure, example 10 provides a computer-readable medium having stored thereon a computer program which, when executed by a processing device, implements a method as described in any of examples 1-7.

The foregoing description is only of the preferred embodiments of the present disclosure and description of the principles of the technology being employed. It will be appreciated by persons skilled in the art that the scope of the disclosure referred to in this disclosure is not limited to the specific combinations of features described above, but also covers other embodiments which may be formed by any combination of features described above or equivalents thereof without departing from the spirit of the disclosure. Such as those described above, are mutually substituted with the technical features having similar functions disclosed in the present disclosure (but not limited thereto).

Moreover, although operations are depicted in a particular order, this should not be understood as requiring that such operations be performed in the particular order shown or in sequential order. In certain circumstances, multitasking and parallel processing may be advantageous. Likewise, while several specific implementation details are included in the above discussion, these should not be construed as limiting the scope of the present disclosure. Certain features that are described in the context of separate embodiments can also be implemented in combination in a single embodiment. Conversely, various features that are described in the context of a single embodiment can also be implemented in multiple embodiments separately or in any suitable subcombination.

Although the subject matter has been described in language specific to structural features and/or methodological acts, it is to be understood that the subject matter defined in the appended claims is not necessarily limited to the specific features or acts described above. Rather, the specific features and acts described above are example forms of implementing the claims.

Claims

1. A memory processing method, the method comprising:

acquiring the memory size of a memory applied by a target object;

applying for the local memory with the memory size in the local heap;

storing the target object in the local memory;

2. The method of claim 1, wherein applying for the target memory of the set size in the target heap comprises:

modifying the size information of the array into the memory size;

storing the setting identification information into the array;

3. The method of claim 1, wherein applying for the memory size of the local memory in the local heap comprises:

4. The method as recited in claim 1, further comprising:

5. The method according to claim 4, wherein said releasing the array corresponding to the local memory and the target memory stored in the global reference table by deleting the weak global reference function comprises:

6. The method of claim 1, wherein the method is applied to a target version of an android system, the target version being a version in which memory is allocated for the target object by the target heap, the target heap being a Java heap.

7. The method of claim 1, wherein the target object is pixel data of a picture.

8. A memory processing apparatus, comprising:

the storage module is used for storing the target object in the local memory;

9. A terminal device, comprising:

one or more processing devices;

a storage means for storing one or more programs;

when the one or more programs are executed by the one or more processing devices, the one or more processing devices are caused to implement the method of any of claims 1-7.

10. A computer readable medium, on which a computer program is stored, characterized in that the program, when being executed by a processing device, implements the method according to any of claims 1-7.