CN112860444B

CN112860444B - Memory calling information determining method and device, storage medium and electronic equipment

Info

Publication number: CN112860444B
Application number: CN202110451587.8A
Authority: CN
Inventors: 聂磊
Original assignee: Tencent Technology Shenzhen Co Ltd
Current assignee: Tencent Technology Shenzhen Co Ltd
Priority date: 2021-04-26
Filing date: 2021-04-26
Publication date: 2021-08-20
Anticipated expiration: 2041-04-26
Also published as: CN112860444A

Abstract

The invention discloses a method and a device for determining memory calling information, a storage medium and electronic equipment. Wherein, the method comprises the following steps: in the running process of the target application, stack information generated by calling a memory each time by the target application is obtained, wherein the stack information comprises a function address of a memory calling function used by calling the memory each time, the stack information generated by calling the memory each time is recorded in a stack information file, and after the running of the target application is finished, the memory calling information in the running process of the target application is determined according to the stack information file, wherein the memory calling information comprises a function name of the memory calling function used by calling the memory each time by the target application. The invention solves the technical problem that the time consumption for determining the memory calling information is too long in the related technology, so that the application program is easy to be blocked.

Description

Memory calling information determining method and device, storage medium and electronic equipment

Technical Field

The invention relates to the field of computers, in particular to a method and a device for determining memory calling information, a storage medium and electronic equipment.

Background

In the related art, in the process of running an application program, a single memory application is generally obtained to obtain the size of the memory required to be applied for running the application program, and then the system returns an application result.

In order to obtain a detailed memory distribution situation, each memory application needs to be clearly presented, and since the subsequent processing operation required after each memory application is time-consuming, the process of determining the memory calling information in the related art is very complicated, the processing time-consuming is too long, and the technical problem of blocking of the application program is caused.

In view of the above problems, no effective solution has been proposed.

Disclosure of Invention

The embodiment of the invention provides a method and a device for determining memory calling information, a storage medium and electronic equipment, which are used for at least solving the technical problem that the time consumption for determining the memory calling information is too long in the related technology, so that an application program is easy to be blocked.

According to an aspect of the embodiments of the present invention, a method for determining memory call information is provided, including: in the running process of a target application, stack information generated by calling a memory each time by the target application is obtained, wherein the stack information comprises a function address of a memory calling function used by calling the memory each time; recording stack information generated by calling the memory each time in a stack information file; after the target application finishes running, determining memory calling information during the running of the target application according to the stack information file, wherein the memory calling information comprises a function name of a memory calling function used by the target application for calling the memory each time.

According to another aspect of the embodiments of the present invention, there is also provided a device for determining memory call information, including: the system comprises an acquisition module, a storage module and a processing module, wherein the acquisition module is used for acquiring stack information generated by calling a memory each time by a target application in the running process of the target application, and the stack information comprises a function address of a memory calling function used for calling the memory each time; the recording module is used for recording the stack information generated by calling the memory each time in a stack information file; and the determining module is used for determining the memory calling information during the operation of the target application according to the stack information file after the operation of the target application is finished, wherein the memory calling information comprises the function name of a memory calling function used by the target application for calling the memory each time.

Optionally, the obtaining module includes: the detection unit is used for detecting whether a target calling function is requested to be operated or not in the operation process of the target application; the processing unit is used for intercepting the target calling function and acquiring stack information corresponding to the target calling function when the target calling function is detected to be requested to run, wherein the acquired stack information comprises a function address of a current memory calling function, and the current memory calling function is used for calling a memory through the target calling function; and the running unit is used for running the target calling function after the stack information corresponding to the target calling function is acquired.

Optionally, the processing unit includes: a modifying subunit, configured to modify a function address of the target call function into a target address, so as to intercept the target call function, where the target address is a function address of a preset target obtaining function, and the target obtaining function is used to obtain stack information corresponding to the target call function; and the operation subunit is used for jumping to the target address and operating the target acquisition function so as to acquire stack information corresponding to the target calling function.

Optionally, the first detection unit includes: the device comprises a first detection subunit, configured to detect whether to run a first call function in a running process of the target application, where the current memory call function is used to apply for a first amount of memory through the first call function, and the target call function includes the first call function.

Optionally, the first detection unit includes: a second detecting subunit, configured to detect whether a second call function is run in a process of running the target application, where the current memory call function is used to release a second amount of memory through the second call function, and the target call function includes the second call function.

Optionally, the determining module includes: the acquisition unit is used for acquiring stack information generated by calling the memory each time by the target application from the stack information file; the conversion unit is used for converting the stack information generated by calling the memory each time into a function name of a memory calling function used by calling the memory each time; and the determining unit is used for determining the memory calling information when the target application runs according to the function name of the memory calling function used for calling the memory each time.

Optionally, the determining unit is configured to determine the memory call information when the target application runs according to a function name of a memory call function used for calling the memory each time in the following manner: and executing merging operation on the function name of the memory calling function used for calling the memory each time to obtain the memory calling information.

Optionally, the determining unit is configured to perform a merging operation on the function name of the memory call function used for calling the memory each time in the following manner, so as to obtain the memory call information: and under the condition that the memory calling function used for calling the memory each time comprises a group of functions with a hierarchical relationship, performing merging operation on the function name of the memory calling function used for calling the memory each time according to the hierarchy to obtain the memory calling information.

Optionally, the determining unit is configured to perform a merging operation on the function name of the memory call function used for calling the memory each time according to a hierarchy in the following manner, so as to obtain the memory call information: under the condition that a first group of functions and a second group of functions have a hierarchical relationship and a first function located at a first level in the first group of functions is the same as a second function located at the first level in the second group of functions, carrying out merging operation on function names of the first group of functions and function names of the second group of functions according to a hierarchy to obtain function names of a third group of functions, wherein the third group of functions have a hierarchical relationship and the function names of the functions located at the first level in the third group of functions are the same as the function name of the first function.

Optionally, the determining unit is configured to perform a merging operation on the function names of the first group of functions and the function names of the second group of functions in a hierarchical manner to obtain the function names of a third group of functions: combining the function names of the functions at the ith level in the first set of functions and the functions at the ith level in the second set of functions into the function name of the function at the ith level in the third set of functions, wherein i is a natural number of 2 or more, and the function name of the function at the ith level in the third set of functions is the same as the function name of the function at the ith level in the first set of functions; determining a function name of a function located at the i-th level in the third group of functions to include the function names of the functions located at the i-th level in the first group of functions and the second group of functions, in a case where the functions located at the i-th level in the first group of functions and the second group of functions are different.

Optionally, the determining unit is configured to perform a merging operation on the function name of the memory call function used for calling the memory each time according to a hierarchy in the following manner, so as to obtain the memory call information: and determining the number of memories called by the third group of functions according to the first number and the second number under the condition that the first group of functions and the second group of functions have a hierarchical relationship, the first group of functions call a first number of memories, the second group of functions call a second number of memories, and the first function and the second function are the same.

Optionally, the determining unit is configured to determine, according to the first number and the second number, the number of memories of the third group of function calls by: applying for the first amount of memory in the first group of functions and applying for the second amount of memory in the second group of functions, and determining the amount of memory applied for by the third group of functions as the sum of the first amount and the second amount; applying for the first amount of memory in the first group of functions, releasing the second amount of memory in the second group of functions, and determining the amount of memory applied for by the third group of functions as the difference between the first amount and the second amount; determining the amount of memory freed by the third set of functions as the sum of the first amount and the second amount, when the first set of functions frees the first amount of memory, when the second set of functions frees the second amount of memory.

Optionally, the recording module includes: the first recording unit is used for recording the stack information acquired each time in the stack information file when the stack information generated by calling the memory by the target application is acquired each time; or the second recording unit is configured to record, when stack information generated by calling the memory by the target application is acquired each time, the stack information acquired each time in a temporary storage space, and record, when the operation of the target application is finished, the stack information acquired each time stored in the temporary storage space in the stack information file.

Optionally, the apparatus is configured to obtain stack information generated by the target application calling the memory each time, by: acquiring a function address of a memory calling function used by the target application for calling the memory each time and the number of the memories called each time, wherein the stack information comprises the function address of the memory calling function used for calling the memory each time and the number of the memories called each time; the device is used for determining the memory calling information of the target application during operation according to the stack information file in the following way: and determining the function name of a memory calling function used by the target application for calling the memory each time and the number of the memories called each time according to the stack information file.

According to another aspect of the embodiments of the present invention, there is also provided a computer-readable storage medium, in which a computer program is stored, where the computer program is configured to execute the method for determining the memory call information when the computer program runs.

According to another aspect of the embodiments of the present invention, there is also provided an electronic device, including a memory and a processor, where the memory stores a computer program, and the processor is configured to execute the method for determining the memory call information through the computer program.

In the embodiment of the invention, the method comprises the steps of acquiring stack information generated by calling a memory each time by a target application in the running process of the target application, wherein the stack information comprises a function address of a memory calling function used by calling the memory each time, recording the stack information generated by calling the memory each time in a stack information file, and determining the memory calling information in the running process of the target application according to the stack information file after the running of the target application is finished, wherein the memory calling information comprises a function name of the memory calling function used by the target application for calling the memory each time, and the technical framework and the flow for calling the memory are modified to shorten the memory calling time so as to realize the technical effect of avoiding the application program jamming when the memory occupation statistics is carried out in a complex scene, thereby solving the problem that the process for determining the memory calling information in the related technology is very complicated, the processing time is too long, so that the technical problem of unsmooth application program is caused.

Drawings

The accompanying drawings, which are included to provide a further understanding of the invention and are incorporated in and constitute a part of this application, illustrate embodiment(s) of the invention and together with the description serve to explain the invention without limiting the invention. In the drawings:

fig. 1 is a schematic diagram of an application environment of an optional memory call information determination method according to an embodiment of the present invention;

fig. 2 is a flowchart illustrating an optional method for determining memory call information according to an embodiment of the present invention;

fig. 3 is a schematic diagram of an alternative method for determining memory call information according to an embodiment of the present invention;

fig. 4 is a schematic diagram of another alternative method for determining memory call information according to an embodiment of the present invention;

fig. 5 is a schematic diagram illustrating an alternative method for determining memory call information according to an embodiment of the present invention;

fig. 6 is a schematic diagram illustrating an alternative method for determining memory call information according to an embodiment of the present invention;

fig. 7 is a schematic diagram illustrating an alternative method for determining memory call information according to an embodiment of the present invention;

FIG. 8 is a diagram illustrating an alternative method for determining memory call information according to an embodiment of the present invention;

FIG. 9 is a diagram illustrating an alternative method for determining memory call information according to an embodiment of the present invention;

FIG. 10 is a diagram illustrating an alternative method for determining memory call information according to an embodiment of the present invention;

FIG. 11 is a diagram illustrating an alternative method for determining memory call information according to an embodiment of the present invention;

FIG. 12 is a diagram illustrating an alternative method for determining memory call information according to an embodiment of the present invention;

FIG. 13 is a diagram illustrating an alternative method for determining memory call information according to an embodiment of the present invention;

FIG. 14 is a diagram illustrating an alternative method for determining memory call information according to an embodiment of the present invention;

FIG. 15 is a diagram illustrating an alternative method for determining memory call information according to an embodiment of the present invention;

FIG. 16 is a diagram illustrating an alternative method for determining memory call information according to an embodiment of the present invention;

FIG. 17 is a diagram illustrating an alternative method for determining memory call information according to an embodiment of the present invention;

fig. 18 is a schematic structural diagram of an alternative memory call information determining apparatus according to an embodiment of the present invention;

fig. 19 is a schematic structural diagram of an alternative electronic device according to an embodiment of the invention.

Detailed Description

In order to make the technical solutions of the present invention better understood, the technical solutions in the embodiments of the present invention will be clearly and completely described below with reference to the drawings in the embodiments of the present invention, and it is obvious that the described embodiments are only a part of the embodiments of the present invention, and not all of the embodiments. All other embodiments, which can be derived by a person skilled in the art from the embodiments given herein without making any creative effort, shall fall within the protection scope of the present invention.

It should be noted that the terms "first," "second," and the like in the description and claims of the present invention and in the drawings described above are used for distinguishing between similar elements and not necessarily for describing a particular sequential or chronological order. It is to be understood that the data so used is interchangeable under appropriate circumstances such that the embodiments of the invention described herein are capable of operation in sequences other than those illustrated or described herein. Furthermore, the terms "comprises," "comprising," and "having," and any variations thereof, are intended to cover a non-exclusive inclusion, such that a process, method, system, article, or apparatus that comprises a list of steps or elements is not necessarily limited to those steps or elements expressly listed, but may include other steps or elements not expressly listed or inherent to such process, method, article, or apparatus.

First, partial nouns or terms appearing in the description of the embodiments of the present application are applicable to the following explanations:

memory: the bridge for communicating the external memory and the CPU is one of indexes for measuring the resource consumption of game operation.

Hook: a common program development processing means can intercept the function required to be called by a memory, and call the original function again after executing an inserted program.

Stacking: an ordered set of function names of the computer logic is executed.

Stack symbolization: the method for acquiring the function names acquires the calling contents of the functions according to the mapping relation among different types of function names.

The invention is illustrated below with reference to examples:

according to an aspect of the embodiment of the present invention, a method for determining memory call information is provided, and optionally, in this embodiment, the method for determining memory call information may be applied to a hardware environment formed by a server 101 and a user terminal 103 as shown in fig. 1. As shown in fig. 1, a server 101 is connected to a terminal 103 through a network, and may be configured to provide a service to a user terminal or a client installed on the user terminal, where the client may be a video client, an instant messaging client, a browser client, an education client, a game client, or the like. The database 105 may be provided on or separate from the server for providing data storage services for the server 101, such as a game data storage server, and the network may include, but is not limited to: a wired network, a wireless network, wherein the wired network comprises: a local area network, a metropolitan area network, and a wide area network, the wireless network comprising: bluetooth, WIFI, and other wireless communication enabled networks, the user terminal 103 may be a terminal configured with a target application, and may include but is not limited to at least one of the following: the server may be a single server, or a server cluster composed of a plurality of servers, or a cloud server, and the target application 107 using the method for determining the memory call information is displayed through the user terminal 103, or the target application 107 using the method for determining the memory call information is displayed through the client 109 on the server 101.

As shown in fig. 1, the method for determining the memory call information may be implemented in the user terminal 103 by the following steps:

s1, starting the target application 107 in the user terminal 103, and acquiring stack information generated by calling the memory each time by the target application 107 in the running process of the target application 107, wherein the stack information comprises a function address of a memory calling function used by calling the memory each time;

s2, recording stack information generated by calling the memory each time in the stack information file in the user terminal 103;

s3, after the target application 107 finishes running, determining, in the user terminal 103, memory call information during running of the target application 107 according to the stack information file, where the memory call information includes a function name of a memory call function used by the target application 107 to call a memory each time.

Optionally, in this embodiment, the method for determining the memory call information may also be used by a client configured in the server, and the method for determining the memory call information may be implemented by the client 109 on the server 101 through the following steps:

s1, in the process of the client 109 on the server 101 acquiring the running of the target application 107, stack information generated by the target application 107 calling the memory each time, where the stack information includes a function address of a memory calling function used for calling the memory each time;

s2, recording stack information generated by calling the memory each time in the stack information file on the client 109 on the server 101;

s3, after the target application 107 finishes running, determining, on the client 109 on the server 101, memory call information during running of the target application 107 according to the stack information file, where the memory call information includes a function name of a memory call function used by the target application 107 to call a memory each time.

Optionally, in this embodiment, the method for determining the memory call information may include, but is not limited to, asynchronous use by the target application 107 configured on the user terminal 103 and a client on the server 101.

Optionally, in this embodiment, the method for determining the memory call information may further include, but is not limited to, distributed use of each node in a preset block chain.

The blockchain is a novel application mode of computer technologies such as distributed data storage, point-to-point transmission, a consensus mechanism and an encryption algorithm. A block chain (Blockchain), which is essentially a decentralized database, is a series of data blocks associated by using a cryptographic method, and each data block contains information of a batch of network transactions, so as to verify the validity (anti-counterfeiting) of the information and generate a next block. The blockchain may include a blockchain underlying platform, a platform product services layer, and an application services layer.

The block chain underlying platform can comprise processing modules such as user management, basic service, intelligent contract and operation monitoring. The user management module is responsible for identity information management of all blockchain participants, and comprises public and private key generation maintenance (account management), key management, user real identity and blockchain address corresponding relation maintenance (authority management) and the like, and under the authorization condition, the user management module supervises and audits the transaction condition of certain real identities and provides rule configuration (wind control audit) of risk control; the basic service module is deployed on all block chain node equipment and used for verifying the validity of the service request, recording the service request to storage after consensus on the valid request is completed, for a new service request, the basic service firstly performs interface adaptation analysis and authentication processing (interface adaptation), then encrypts service information (consensus management) through a consensus algorithm, transmits the service information to a shared account (network communication) completely and consistently after encryption, and performs recording and storage; the intelligent contract module is responsible for registering and issuing contracts, triggering the contracts and executing the contracts, developers can define contract logics through a certain programming language, issue the contract logics to a block chain (contract registration), call keys or other event triggering and executing according to the logics of contract clauses, complete the contract logics and simultaneously provide the function of upgrading and canceling the contracts; the operation monitoring module is mainly responsible for deployment, configuration modification, contract setting, cloud adaptation in the product release process and visual output of real-time states in product operation, such as: alarm, monitoring network conditions, monitoring node equipment health status, and the like.

The platform product service layer provides basic capability and an implementation framework of typical application, and developers can complete block chain implementation of business logic based on the basic capability and the characteristics of the superposed business. The application service layer provides the application service based on the block chain scheme for the business participants to use.

The above is merely an example, and the present embodiment is not particularly limited.

Optionally, as an optional implementation manner, as shown in fig. 2, the method for determining the memory call information includes:

s202, in the running process of the target application, stack information generated by calling a memory each time by the target application is obtained, wherein the stack information comprises a function address of a memory calling function used for calling the memory each time;

s204, recording stack information generated by calling the memory each time in a stack information file;

and S206, after the target application is finished running, determining memory calling information during the running of the target application according to the stack information file, wherein the memory calling information comprises the function name of a memory calling function used by the target application for calling the memory each time.

Optionally, in this embodiment, the application scenarios of the method for determining the memory call information may include, but are not limited to, a plurality of application scenarios such as medical treatment, finance, credit investigation, banking, government affairs, government, game, energy, education, security, building, live broadcast, traffic, internet of things, and industry.

Taking application to a game scene as an example, fig. 3 is a schematic diagram of a method for determining optional memory call information according to an embodiment of the present invention, as shown in fig. 3, where a target application shown in fig. 3 is a game application, the method includes, but is not limited to, the following steps:

s1, after the interactive operation aiming at the virtual interactive object 'enter' is obtained, as the 'enter' interactive operation needs to call the memory for data processing, the application Hook operation is started to be executed, so that the function address for memory calling in the game application is modified into the function address for intercepting the current memory calling information, and the subsequent path is modified into the function for executing the memory calling corresponding to the 'enter' virtual interactive object;

the above modification may include, but is not limited to, being implemented based on open source technology xHook.

S2, acquiring all stack information through the modified function address, wherein the stack information includes but is not limited to the function address of the memory call function used by the current call memory;

s3, recording all stack information in stack information file, and storing in client or user terminal;

and S4, after the current game in the game application is ended, determining the memory call information of the target application in operation according to the stack information file, wherein the memory call information of the target application in operation can include but is not limited to processing the function address of the memory call function by using stack symbolization, so as to realize the purpose of converting the stack information into a function name which is easily recognized by a worker.

The above is merely an example, and the present embodiment is not limited in any way.

Taking application to a live scene as an example, fig. 4 is a schematic diagram of another optional method for determining memory call information according to an embodiment of the present invention, as shown in fig. 4, where a target application shown in fig. 4 is a live application, the method includes, but is not limited to, the following steps:

s1, after acquiring the interactive operation aiming at the 'broadcasting' of the virtual interactive object, starting to execute the application Hook operation because the 'broadcasting' interactive operation needs to call the memory for data processing, so as to modify the function address for memory call in the live broadcast application into the function address for intercepting the current memory call information, and modify the subsequent path into the function for executing the memory call corresponding to the 'broadcasting' virtual interactive object;

and S4, after the current live broadcast in the live broadcast application is finished, determining the memory call information during the operation of the target application according to the stack information file, wherein the memory call information during the operation of the target application can include but is not limited to processing the function address of the memory call function by using stack symbolization, so as to convert the stack information into a function name which is easy to be recognized by a worker.

Taking an application scene applied to rendering an image as an example, fig. 5 is a schematic diagram of a further optional method for determining memory call information according to an embodiment of the present invention, as shown in fig. 5, where a target application shown in fig. 5 is a rendering application, the method includes, but is not limited to, the following steps:

s1, after the interactive operation aiming at the rendering of the virtual interactive object is obtained, because the rendering interactive operation needs to call the memory for data processing, the application Hook operation is started to be executed, the function address for memory calling in the rendering application is modified into the function address for intercepting the current memory calling information, and the subsequent path is modified into the function for executing the memory calling corresponding to the rendering of the virtual interactive object;

and S4, after the current rendering in the rendering application is finished, determining the memory call information of the target application in operation according to the stack information file, wherein the memory call information of the target application in operation can include but is not limited to processing the function address of the memory call function by using stack symbolization, so as to realize the purpose of converting the stack information into a function name which is easy to be recognized by a worker.

Optionally, in this embodiment, the target application may include, but is not limited to, an application program that requires a large amount of call memory, in addition to the game application, the rendering application, and the live application.

Optionally, in this embodiment, the stack information may include, but is not limited to, a pointer address of a function called by the target application in each memory call process, a number of times the function is called, and a number of times the memory is called.

Optionally, in this embodiment, the recording of the stack information generated by calling the memory each time in the stack information file includes, but is not limited to, the following steps:

when stack information generated by calling a memory by a target application is acquired each time, recording the acquired stack information in a stack information file each time; or

When the stack information generated by calling the memory by the target application is acquired each time, recording the acquired stack information in the temporary storage space each time, and when the operation of the target application is finished, recording the acquired stack information stored in the temporary storage space each time in the stack information file.

Optionally, in this embodiment, after the target application finishes running, determining, according to the stack information file, that the memory call information during the running of the target application may include, but is not limited to symbolizing the stack information in the stack information file, and merging the memory call information obtained after symbolization, which includes a function name of a memory call function used by the target application to call the memory each time, so as to obtain the memory call information capable of being visually displayed.

For example, fig. 6 is a schematic diagram of another optional method for determining memory call information according to an embodiment of the present invention, as shown in fig. 6, specifically including, but not limited to, the following steps:

s1, in the running process of the target application, the target application calls the memory each time to carry out single memory application;

s2, executing Hook operation to the memory application operation;

s3, acquiring current stack information;

the method includes, but is not limited to, obtaining a pointer address of the memory application;

s4, symbolizing stack information;

the method may include, but is not limited to, converting the pointer address into a function name;

s5, merging the memory calling information with the same function name;

s6, applying for the memory size n;

s7, the system returns the application result.

In the process of executing the method, since the processing of steps S5 and S6 is too time-consuming, the steps may be adjusted to execute the method for calling the memory call information, and fig. 7 is a schematic diagram of another optional method for determining the memory call information according to the embodiment of the present invention, as shown in fig. 7, specifically including but not limited to the following steps:

s2, executing Hook operation to the memory application operation;

s3, acquiring current stack information;

s4, storing the stack information as a local file;

s5, placing stack information, and directly applying for the memory size n;

s6, the system returns the application result; .

And S7, after the target application is operated, generating a memory statistical result according to the stack information stored as the local file.

It should be noted that, by replacing steps S4 and S5 shown in fig. 6 with steps S4, S5 and S7 shown in fig. 7, the processing flow for the stack information is moved from the process of the target application to the end of the target application, so that the technical effects of improving the calling efficiency of the memory information, reducing the time consumed by the memory calling, and avoiding the target application being stuck can be achieved.

Optionally, in this embodiment, the determining, according to the stack information file, the memory call information of the target application during running may include, but is not limited to, performing conversion according to a preset conversion mode, and the determining, when the stack information is a pointer address of a called function, may include, but is not limited to, converting the pointer address into a function name using an addr2line mode.

By the embodiment, the stack information generated by calling the memory each time by the target application is acquired in the running process of the target application, wherein the stack information comprises the function address of the memory calling function used by calling the memory each time, the stack information generated by calling the memory each time is recorded in the stack information file, and after the running of the target application is finished, the memory calling information in the running process of the target application is determined according to the stack information file, wherein the memory calling information comprises the function name of the memory calling function used by calling the memory each time by the target application, and the technical framework and the flow for calling the memory are modified to shorten the memory calling time, so that the memory occupation statistics is carried out in a complex scene, the technical effect of avoiding the application program jamming is achieved, and furthermore, the problem that the process for determining the memory calling information in the related technology is very complicated is solved, the processing time is too long, so that the technical problem of unsmooth application program is caused.

As an optional scheme, in the process of running the target application, obtaining stack information generated by the target application calling the memory each time includes:

detecting whether a target calling function is requested to be operated or not in the operation process of the target application;

when a target calling function is detected to be requested to run, intercepting the target calling function, and acquiring stack information corresponding to the target calling function, wherein the acquired stack information comprises a function address of a current memory calling function, and the current memory calling function is used for calling a memory through the target calling function;

and after stack information corresponding to the target calling function is acquired, the target calling function is operated.

Optionally, in this embodiment, the target call function may include, but is not limited to, a call function for applying for a memory application, or a call function for releasing a memory.

Optionally, in this embodiment, the obtaining of the stack information corresponding to the target call function may include, but is not limited to, obtaining the stack information corresponding to the target call function by retrieving a current stack when it is detected that the target call function is requested to be executed, where the stack information includes, but is not limited to, a function address of the memory call function, for example, a pointer address of the memory call function.

Optionally, in this embodiment, the intercepting the target call function may include, but is not limited to, replacing a function that applies for or releases the memory with a function that grabs current stack information using Hook technology, and recalling the target call function by the replaced function.

For example, fig. 8 is a schematic diagram of another optional method for determining memory call information according to an embodiment of the present invention, as shown in fig. 8, specifically including, but not limited to, the following steps:

s1, detecting a Malloc function (corresponding to the aforementioned target call function);

s2, modifying Malloc address jump by using open source technology xHook under the condition that the Malloc function is detected;

s3, insert an Unwind _ Backtrace (function for acquiring stack information corresponding to the target call function) function, generate a MyMalloc function, and recall the Malloc function after capturing the current stack information.

By the embodiment, whether a target calling function is requested to be operated is detected in the operation process of a target application, when the target calling function is detected to be operated, the target calling function is intercepted, and stack information corresponding to the target calling function is acquired, wherein the acquired stack information comprises a function address of a current memory calling function, the current memory calling function is used for calling a memory through the target calling function, after the stack information corresponding to the target calling function is acquired, the current stack information is acquired by modifying a jump address of a calling function for applying the memory or a calling function for releasing the memory in a mode of operating the target calling function, and further, the determination of the memory calling information can be realized after the target application is operated, so that the memory calling duration is shortened, the method and the device have the advantages that the technical effect of preventing the application program from being stuck when the memory occupation statistics is carried out in a complex scene is achieved, and further the technical problem that the application program is stuck due to the fact that the process of determining the memory calling information is very complicated and the processing time is too long in the related technology can be solved.

As an optional scheme, intercepting a target call function and acquiring stack information corresponding to the target call function includes:

modifying the function address of the target calling function into a target address to intercept the target calling function, wherein the target address is the function address of a preset target obtaining function, and the target obtaining function is used for obtaining stack information corresponding to the target calling function;

and jumping to a target address, and operating a target acquisition function to acquire stack information corresponding to the target calling function.

Optionally, in this embodiment, the modifying the function address of the target call function to the target address may include, but is not limited to, modifying the function address of the target call function to a function address of a function for acquiring stack information corresponding to the target call function using an xHook technique, so as to intercept the target call function, where the target acquisition function may include, but is not limited to, an Unwind _ background function, and the first call function may include, but is not limited to, a Malloc function for applying for a memory, or a free function for releasing a memory.

Through the embodiment, the function address of the target calling function is modified into the target address to intercept the target calling function, wherein the target address is the function address of a preset target acquiring function, the target acquiring function is used for acquiring the stack information corresponding to the target calling function, the target acquiring function jumps to the target address to operate the target acquiring function, the jump address of the calling function for applying for the memory is modified into the target address to acquire the current stack information through the target acquiring function in a manner of acquiring the stack information corresponding to the target calling function, and further, the subsequent determination of the memory calling information can be realized after the target application is operated, the memory calling duration is shortened, the memory occupation statistics is carried out in a complex scene, the technical effect of avoiding the application program from being stuck is achieved, and furthermore, the problem that the process of determining the memory calling information in the related technology is very complicated is solved, the processing time is too long, so that the technical problem of unsmooth application program is caused.

As an optional scheme, in the process of running the target application, detecting whether to request to run the target call function includes:

in the running process of the target application, whether a first calling function is run or not is detected, wherein the current memory calling function is used for applying for a first amount of memory through the first calling function, and the target calling function comprises the first calling function.

and detecting whether a second calling function is operated or not in the operation process of the target application, wherein the current memory calling function is used for releasing a second amount of memory through the second calling function, and the target calling function comprises the second calling function.

Optionally, in this embodiment, the modifying the function address of the target call function to the target address may include, but is not limited to, modifying the function address of the target call function to a function address of a function for acquiring stack information corresponding to the target call function using an xHook technique, so as to intercept the target call function, where the target acquisition function may include, but is not limited to, an Unwind _ background function, and the target call function may include, but is not limited to, a Malloc function (corresponding to the foregoing first call function) for applying for memory, or a free function (corresponding to the foregoing second call function) for releasing memory.

By the embodiment, whether a first call function is operated or not is detected in the operation process of a target application, wherein a current memory call function is used for applying for a first amount of memory through the first call function, the target call function comprises the first call function, whether a second call function is operated or not is detected in the operation process of the target application, wherein the current memory call function is used for releasing a second amount of memory through the second call function, the target call function comprises the second call function, and the memory application or the memory release can be realized again by modifying the address of the first call function for applying for the memory or the address of the second call function for releasing the memory as a target address, so that the memory call failure is avoided, and the stack information corresponding to the first call function or the stack information corresponding to the second call function is obtained through the target obtaining function, furthermore, the memory calling duration can be shortened conveniently after the target application is finished, the technical effect of avoiding the application program jamming when the memory occupation statistics is carried out in a complex scene is achieved, and the technical problems that the application program jamming occurs due to the fact that the process of determining the memory calling information is very complicated and the processing time is too long in the related technology can be solved.

As an optional scheme, determining memory call information of the target application during running according to the stack information file includes:

s1, acquiring stack information generated by calling the memory each time by the target application from the stack information file;

s2, converting the stack information generated by calling the memory each time into the function name of the memory calling function used by calling the memory each time;

and S3, determining the memory calling information when the target application operates according to the function name of the memory calling function used for calling the memory each time.

Optionally, in this embodiment, the obtaining of the stack information generated by the target application calling the memory each time in the stack information file may include, but is not limited to, obtaining the stack information generated by the target application calling the memory each time according to the stack information file obtained by storing after the obtained stack information.

Optionally, in this embodiment, the converting the stack information generated by calling the memory each time to the function name of the memory calling function used by calling the memory each time may be implemented by including, but not limited to, symbolizing the stack information, and specifically, may include, but not limited to, converting all pointer addresses (corresponding to the stack information) into words (corresponding to the function name) by addr2 line.

Optionally, in this embodiment, the determining the memory call information of the target application during running according to the function name of the memory call function used for calling the memory each time may include, but is not limited to, merging part of the memory call information according to the function name of the memory call function to obtain more refined memory call information.

For example, fig. 9 is a schematic diagram of another optional method for determining memory call information according to an embodiment of the present invention, as shown in fig. 9, the method specifically includes, but is not limited to, the following steps:

s1, acquiring stack information file to obtain the stack information;

s2, symbolizing stack information to obtain the function name corresponding to the stack information;

and S3, merging to determine the memory calling information of the target application during operation according to the function name.

Fig. 10 is a schematic diagram of another optional method for determining memory call information according to an embodiment of the present invention, as shown in fig. 10, where the stack information may include, but is not limited to, stack information 1002, the function name may include, but is not limited to, a function name 1004, and each stack information in the stack information 1002 is converted into a function name in the function name 1004 by a conversion function 1006, and the conversion function 1006 may include, but is not limited to, an addr2line function.

By the embodiment, the technical effects of acquiring the stack information generated by calling the memory each time by the target application in the stack information file, converting the stack information generated by calling the memory each time into the function name of the memory calling function used by calling the memory each time, determining the memory calling information during the operation of the target application according to the function name of the memory calling function used by calling the memory each time are adopted, after the operation of the target application is finished, symbolizing the stack information according to the acquired stack information to obtain the corresponding function name, merging the calling information of the functions according to the function name so as to realize the determination of the memory calling information after the operation of the target application is finished, shortening the memory calling time, enabling the memory occupation statistics in a complex scene, and avoiding the application program card pause are achieved, furthermore, the technical problems that the process of determining the memory calling information is very complicated, the processing time is too long, and the application program is blocked in the related technology can be solved.

As an optional scheme, determining memory call information of the target application during running according to a function name of a memory call function used for calling the memory each time includes:

and executing merging operation on the function name of the memory calling function used for calling the memory each time to obtain memory calling information.

Optionally, in this embodiment, the function names may include, but are not limited to, being determined according to stack information, and the same stack information corresponds to the same function name.

For example, fig. 11 is a schematic diagram of another optional method for determining memory call information according to an embodiment of the present invention, as shown in fig. 11, where the stack information at least includes a plurality of stack information of "0 x125e 558", function names corresponding to the stack information of "0 x125e 558" may be merged, and in a merging process, the number of calls of the function corresponding to the function name and a memory size for applying for a memory or releasing the memory are also merged at the same time, so as to generate memory statistical information as the determined memory call information.

According to the embodiment, the mode that the function name of the memory calling function used for calling the memory each time is combined is adopted to obtain the memory calling information, the calling information of the function is combined according to the function name after the target application is finished running, so that the memory calling information is determined after the target application is finished running, the memory calling time is shortened, the memory occupation statistics is carried out in a complex scene, the technical effect that an application program is blocked is avoided, and the technical problems that the application program is blocked due to the fact that the process for determining the memory calling information is very complicated, the processing time is too long and the application program is blocked in the related technology can be solved.

As an optional scheme, performing a merge operation on a function name of a memory call function used for calling a memory each time to obtain memory call information includes:

and under the condition that the memory calling function used for calling the memory each time comprises a group of functions with a hierarchical relationship, performing merging operation on the function name of the memory calling function used for calling the memory each time according to the hierarchy to obtain memory calling information.

Optionally, in this embodiment, the memory call function may include, but is not limited to, a set of call functions having a hierarchical relationship, for example, an "ARootAddedByMe" function and a "Thread _ start" function are a set of functions having a hierarchical relationship, where the "ARootAddedByMe" is a first hierarchy and the "Thread _ start" is a second hierarchy.

For example, as shown in fig. 9, different function names in the memory call information may belong to different hierarchies, and the memory call information with the same function name in the same hierarchy is merged to obtain the memory statistical data required by the staff, where a represents the memory call function in the first hierarchy, B, C, D represents the memory call function in the second hierarchy, B2, C2, and D1 represent the memory call function in the third hierarchy, and so on, when the upper hierarchy of the memory call functions corresponding to D12 and D22 is the memory call function with the same function name, the memory call information corresponding to the upper hierarchy of D12 and D22 is merged to obtain D1.

According to the embodiment, under the condition that the memory calling function used for calling the memory each time comprises a group of functions with a hierarchical relationship, the function name of the memory calling function used for calling the memory each time is merged according to the hierarchy to obtain the memory calling information, after the target application is finished running, the calling information of the function is merged according to the function name, so that the memory calling information is determined after the target application is finished running, the memory calling time is shortened, the memory occupation statistics is carried out in a complex scene, the technical effect of avoiding the application program jamming is achieved, and the technical problems that the process for determining the memory calling information is very complicated, the processing time is too long and the application program jamming is caused in the related technology can be solved.

As an optional scheme, performing a merge operation on a function name of a memory call function used for calling a memory each time according to a hierarchy to obtain memory call information includes:

and under the condition that the first group of functions and the second group of functions have a hierarchical relationship and a first function located at a first hierarchy in the first group of functions is the same as a second function located at a first hierarchy in the second group of functions, carrying out merging operation on the function names of the first group of functions and the function names of the second group of functions according to a hierarchy to obtain the function names of a third group of functions, wherein the third group of functions have a hierarchical relationship and the function name of the function located at the first hierarchy in the third group of functions is the same as the function name of the first function.

Optionally, in this embodiment, the first set of functions and the second set of functions may include, but are not limited to, a function to be called during the running of the target application, fig. 12 is a schematic diagram of another optional method for determining memory call information according to an embodiment of the present invention, as shown in fig. 12, a first function located at a first hierarchical level in the first set of functions is an "ARootAddedByMe" function in the first set of functions for applying for memory shown in fig. 12, a second function located at a first hierarchical level in the second set of functions is an "ARootAddedByMe" function in the second set of functions for releasing memory shown in fig. 12, and when a first function in the first set of functions and a second function in the second set of functions have the same function name, a function name of the first set of functions and a function name of the second set of functions are merged, so as to obtain a function name of a third set of functions, and the memory size and the number of calls called by the function are combined, where n1 in (n 1, 2, ARootAddedByMe) shown in fig. 12 is the memory size, and 2 is the number of calls, i.e., the name of the function.

By the embodiment, under the condition that the first group of functions and the second group of functions have a hierarchical relationship and the first function located at the first hierarchy in the first group of functions and the second function located at the first hierarchy in the second group of functions are the same, the function names of the first group of functions and the function names of the second group of functions are merged according to the hierarchy to obtain the function names of the third group of functions, wherein the third group of functions has the hierarchical relationship and the function name of the function located at the first hierarchy in the third group of functions is the same as the function name of the first function, by merging the calling information of the functions according to the function names after the target application operation is finished, the determination of the memory calling information is realized after the target application operation is finished, the memory calling duration is shortened, and the memory occupation statistics is performed in a complex scene, the technical effect of avoiding the application program from being stuck is achieved, and the technical problem that the application program is stuck due to the fact that the process of determining the memory calling information is very complicated and the processing time is too long in the related technology can be solved.

As an optional scheme, performing a merging operation on the function names of the first group of functions and the function names of the second group of functions according to a hierarchy to obtain function names of a third group of functions includes:

under the condition that the functions at the ith level in the first group of functions and the functions at the ith level in the second group of functions are the same, merging the function names of the functions at the ith level in the first group of functions and the functions at the ith level in the second group of functions into the function name of the functions at the ith level in the third group of functions, wherein i is a natural number which is 2 or more than or equal to 2, and the function name of the function at the ith level in the third group of functions is the same as the function name of the function at the ith level in the first group of functions;

in the case where the functions at the i-th level in the first group of functions and the functions at the i-th level in the second group of functions are different, the function name of the function at the i-th level in the third group of functions is determined to include the function names of the functions at the i-th level in the first group of functions and the functions at the i-th level in the second group of functions.

Optionally, in this embodiment, the ith hierarchy is a hierarchy other than the first hierarchy, and in the case that the functions at the ith hierarchy in the first group of functions and the functions at the ith hierarchy in the second group of functions are the same, merging the function names of the functions at the ith hierarchy in the first group of functions and the functions at the ith hierarchy in the second group of functions into a function name of the function at the ith hierarchy in the third group of functions, where i is a natural number equal to or greater than 2, and the function name of the function at the ith hierarchy in the third group of functions is the same as the function name of the function at the ith hierarchy in the first group of functions, which may include but is not limited to, as shown in fig. 12, where i =2 is taken as an example, where the first function at the ith hierarchy in the first group of functions in fig. 12 for applying for memory, and the second function at the ith hierarchy in the second group of functions in fig. 12 for releasing memory The "Thread _ start" function, when the function names of the first function in the first group of functions and the second function in the second group of functions are the same, performs a merge operation on the function names of the first function and the second function to obtain a function name "Thread _ start" of the third group of functions, and merges the memory size called by the function and the number of calls, where n1 in (n 1, 2, Thread _ start) shown in fig. 12 is the memory size, and 2 is the number of calls, i.e., the function name.

Optionally, in this embodiment, in the case that the functions in the first group of functions and the functions in the second group of functions located at the ith level are different, determining the function name of the function in the third group of functions located at the ith level as including the function name of the function in the first group of functions and the function in the second group of functions located at the ith level may include, but is not limited to, as shown in fig. 13, fig. 13 is a schematic diagram of still another optional method for determining memory call information according to an embodiment of the present invention, where the first function in the first group of functions located at the ith level is a "Thread _ start" function in the first group of functions for applying for memory shown in fig. 13, the second function in the second group of functions located at the ith level is a "start" function in the second group of functions for releasing memory shown in fig. 13, and when the function names of the first function in the first group of functions and the second function in the second group of functions are different, the function names of the first group of functions and the function names of the second group of functions are merged to obtain the function names "Thread _ start" and "start" of the third group of functions, and the memory size and the calling times of the function are respectively recorded, where n1 in (n 1, 2, Thread _ start) shown in fig. 13 is the memory size, and 2 is the calling times, i.e., the function names.

With the present embodiment, in a manner that, in a case where functions at the i-th level in the first group of functions and in the second group of functions are the same, function names of the functions at the i-th level in the first group of functions and in the second group of functions are merged into a function name of a function at the i-th level in a third group of functions, where i is a natural number of 2 or more, the function name of the function at the i-th level in the third group of functions is the same as the function name of the function at the i-th level in the first group of functions, and in a case where the functions at the i-th level in the first group of functions and in the second group of functions are different, the function name of the function at the i-th level in the third group of functions is determined to include the function names of the functions at the i-th level in the first group of functions and in the second group of functions, after the end of the target application operation, the method comprises the steps of combining corresponding calling times of function calling information with the same function name and calling the size of a memory, and recording calling information with different function names respectively, so that the memory calling information is determined after the target application is finished, the memory calling time is shortened, the memory occupation statistics is carried out in a complex scene, the technical effect of preventing an application program from being stuck is achieved, and the technical problems that the process of determining the memory calling information is very complicated, the processing time is too long and the application program is stuck in the related technology can be solved.

and under the condition that the first group of functions and the second group of functions have a hierarchical relationship, the first group of functions call a first amount of memories, the second group of functions call a second amount of memories, and the first functions and the second functions are the same, determining the amount of memories called by the third group of functions according to the first amount and the second amount.

Optionally, in this embodiment, the first group of functions calling the first amount of memory may include, but is not limited to, the amount of memory of a first function call in the first group of functions, the second group of functions calling the second amount of memory may include, but is not limited to, the amount of memory of a second function call in the second group of functions, and the determining the amount of memory of the third group of function calls according to the first amount and the second amount may include, but is not limited to, determining the amount of memory of the third group of function calls according to whether the first function and the second function are used for applying for memory or releasing memory.

For example, as shown in fig. 12, if a first group of functions is used to apply for a memory, and a second group of functions is used to release the memory, the memory amounts called by the first and second functions are subtracted to obtain the memory amount called by a third group of functions, that is, the first function is recorded as + n1, the second function is recorded as-n 2, and the functions in the third group of functions at the same level as the first and second functions are recorded as + n1-n 2.

For example, as shown in fig. 12, if the first and second groups of functions are both used for applying for the memory, the memory amounts called by the first and second functions are added to obtain the memory amount called by the third group of functions, that is, the first function is recorded as + n1, the second function is recorded as + n2, and the functions in the third group of functions at the same level as the first and second functions are recorded as + n1+ n 2.

By the embodiment, in the case that the first group of functions and the second group of functions have a hierarchical relationship, the first group of functions calls a first amount of memory, the second group of functions calls a second amount of memory, and the first function and the second function are the same, the number of memories called by the third group of functions is determined according to the first number and the second number, and after the target application is finished running, the function calling information with the same function name is combined with the number of the called memories, so that the memory calling information is determined after the target application is finished running, the memory calling duration is shortened, the memory occupation statistics is performed in a complex scene, the technical effect of application program blockage is avoided, and furthermore, the problems that the process for determining the memory calling information in the related technology is very complicated and the processing time is too long are solved, causing the technical problem of jamming of the application program.

As an optional scheme, determining the number of memories of the third group of function calls according to the first number and the second number includes:

applying a first quantity of memories for the first group of functions and a second quantity of memories for the second group of functions, and determining the quantity of the memories applied for the third group of functions as the sum of the first quantity and the second quantity;

applying for a first amount of memory in the first group of functions, releasing a second amount of memory in the second group of functions, and determining the amount of memory applied for by the third group of functions as the difference between the first amount and the second amount;

the first set of functions releases a first amount of memory, the second set of functions releases a second amount of memory, and the amount of memory released by the third set of functions is determined as the sum of the first amount and the second amount.

Optionally, in this embodiment, the above-mentioned applying for the first number of memories from the first group of functions and applying for the second number of memories from the second group of functions, and determining the number of memories applied for the third group of functions as a sum of the first number and the second number may include, but is not limited to, as shown in fig. 13, in a case that both the first group of functions and the second group of functions are used for applying for memories, determining the number of memories applied for the functions with the same function name in the first group of functions and the second group of functions as a sum of the first number and the second number, where the first number is recorded as n1, the second number is recorded as n2, and the number of memories called by the third group of functions is + n1+ n 2.

Optionally, in this embodiment, the above-mentioned applying for the first amount of memory in the first group of functions and releasing the second amount of memory in the second group of functions, and determining the amount of memory applied for the third group of functions as the difference between the first amount and the second amount may include, but is not limited to, as shown in fig. 12, in a case where the first group of functions applies for the memory and the second group of functions releases the memory, determining the amount of memory applied for the functions with the same function name in the first group of functions and the second group of functions as the difference between the first amount and the second amount, where the first amount is recorded as n1, the second amount is recorded as n2, and the amount of memory called by the third group of functions is + n1-n 2.

Optionally, in this embodiment, fig. 14 is a schematic diagram of another optional method for determining memory call information according to an embodiment of the present invention, where the first group of functions releases a first amount of memory, the second group of functions releases a second amount of memory, and determining the amount of memory released by the third group of functions as a sum of the first amount and the second amount includes, but is not limited to, as shown in fig. 14, in a case that both the first group of functions and the second group of functions are used to release memory, determining the amount of application memory corresponding to a function with the same function name in the first group of functions and the second group of functions as a sum of the first amount and the second amount, where the first amount is recorded as n1, the second amount is recorded as n2, and the amount of memory called by the third group of functions is — n1-n 2.

Optionally, in this embodiment, fig. 15 is a schematic diagram of another optional method for determining memory call information according to an embodiment of the present invention, as shown in fig. 15, when both the first group of functions and the second group of functions are used for applying for a memory, the number of application memories corresponding to the functions with the same function name in the first group of functions and the second group of functions is determined as the sum of a first number and a second number, where the first number is recorded as n1, the second number is recorded as n2, and the number of application memories corresponding to the functions with different function names in the first group of functions and the second group of functions is recorded as + n1+ n2, for example, the Thread _ start function and the start function in the first group of functions, and the number of application memories applied by the Thread _ start function and the start function in the third group of functions are recorded respectively.

By the embodiment, the method includes applying a first amount of memory to a first group of functions and applying a second amount of memory to a second group of functions, determining the amount of memory applied by a third group of functions as the sum of the first amount and the second amount, applying the first amount of memory to the first group of functions and releasing the second amount of memory from the second group of functions, determining the amount of memory applied by the third group of functions as the difference between the first amount and the second amount, releasing the first amount of memory from the first group of functions and releasing the second amount of memory from the second group of functions, and determining the amount of memory released by the third group of functions as the sum of the first amount and the second amount, and merging function call information with the same function name corresponding to the number of call memories after the target application is finished to facilitate the subsequent determination of the memory call information after the target application is finished running, the memory calling time is shortened, the technical effect of avoiding the application program from being blocked when the memory occupation statistics is carried out in a complex scene is achieved, and furthermore, the technical problems that the application program is blocked due to the fact that the process of determining the memory calling information is very complicated and the processing time is too long in the related technology can be solved.

As an alternative to this, it is possible to,

acquiring stack information generated by calling a memory each time by a target application, wherein the stack information comprises: acquiring a function address of a memory calling function used by a target application for calling a memory each time and the number of the memories called each time, wherein stack information comprises the function address of the memory calling function used for calling the memory each time and the number of the memories called each time;

determining memory calling information of the target application during operation according to the stack information file, wherein the memory calling information comprises: and determining the function name of the memory calling function used by the target application for calling the memory each time and the number of the memories called each time according to the stack information file.

Optionally, in this embodiment, the determining, according to the stack information file, the function name of the memory call function used by the target application for calling the memory each time and the number of the memories called each time may include, but are not limited to, merging the numbers of the memories called by the functions with the same function name to obtain the total number of calls of the function, so as to facilitate subsequent memory statistics and display.

For example, fig. 16 is a schematic diagram of another alternative method for determining memory call information according to an embodiment of the present invention, as shown in fig. 16, which may include but is not limited to generating a memory statistics file as shown in fig. 16 according to a stack information file, where the memory statistics file records names of calling functions and other information corresponding to the functions, including but not limited to a level where the functions are located, a memory value called by the functions, a number of times the functions are called, and the like, and may include but is not limited to displaying the memory call information through a tree structure to obtain the memory statistics file, in the memory statistics file, determining a function name of a memory call function used by a target application each time the memory is called and a number of memories called each time according to the stack information file may include but is not limited to adding the number of calls of functions in the same level, as shown in fig. 16, the second level includes a function start with a call memory value of 529.8MB and a call frequency of 1407851 times, and also includes a function Thread _ start with a call memory value of 300.8MB and a call frequency of 421787 times, so that the call memory value of the ARootAddeByMe function included in the previous level is about 829.8MB, and the call frequency is 1829638 times.

Through the embodiment, the method for determining the memory call information by the target application comprises the steps of obtaining the function address of the memory call function used by the target application for calling the memory each time and the memory number called each time, wherein the stack information comprises the function address of the memory call function used by the target application for calling the memory each time and the memory number called each time, and determining the function name of the memory call function used by the target application for calling the memory each time and the memory number called each time according to the stack information file, so that the CPU occupancy rate of the main thread in the running process of the target application can be reduced, as shown in FIG. 17, the CPU occupancy rate of the main thread in the running process of the target application in the prior art is about 88.3%, while the CPU occupancy rate of the main thread in the running process of the target application is about 46.1% by adopting the method of the present invention, that is to say, the invention can obviously reduce the CPU occupancy rate of the main thread in the running process of the target application, shorten the calling time of the memory, count the memory occupancy in a complex scene, and avoid the technical effect of blocking the application program, thereby solving the technical problems of blocking the application program caused by very complicated process of determining the calling information of the memory and overlong processing time consumption in the related technology.

It should be noted that, for simplicity of description, the above-mentioned method embodiments are described as a series of acts or combination of acts, but those skilled in the art will recognize that the present invention is not limited by the order of acts, as some steps may occur in other orders or concurrently in accordance with the invention. Further, those skilled in the art should also appreciate that the embodiments described in the specification are preferred embodiments and that the acts and modules referred to are not necessarily required by the invention.

According to another aspect of the embodiment of the present invention, there is further provided a device for determining memory call information, which is used for implementing the method for determining memory call information. As shown in fig. 18, the apparatus includes:

an obtaining module 1802, configured to obtain, in a process of running a target application, stack information generated when the target application calls a memory each time, where the stack information includes a function address of a memory call function used for calling the memory each time;

a recording module 1804, configured to record stack information generated by calling the memory each time in a stack information file;

a determining module 1806, configured to determine, according to the stack information file, memory call information when the target application runs after the target application runs, where the memory call information includes a function name of a memory call function used by the target application to call the memory each time.

As an alternative, the obtaining module 1802 includes:

the detection unit is used for detecting whether a target calling function is requested to be operated or not in the operation process of the target application;

the processing unit is used for intercepting the target calling function and acquiring stack information corresponding to the target calling function when the target calling function is detected to be requested to run, wherein the acquired stack information comprises a function address of the current memory calling function, and the current memory calling function is used for calling the memory through the target calling function;

and the running unit is used for running the target calling function after the stack information corresponding to the target calling function is acquired.

As an alternative, the processing unit includes:

the modification subunit is used for modifying the function address of the target calling function into a target address so as to intercept the target calling function, wherein the target address is the function address of a preset target acquisition function, and the target acquisition function is used for acquiring stack information corresponding to the target calling function;

and the operation subunit is used for jumping to the target address and operating the target acquisition function so as to acquire the stack information corresponding to the target calling function.

As an alternative, the first detection unit includes:

the first detection subunit is configured to detect whether to run a first call function in a running process of the target application, where a current memory call function is used to apply for a first amount of memory through the first call function, and the target call function includes the first call function.

As an alternative, the first detection unit includes:

and the second detection subunit is configured to detect whether to run a second call function in the running process of the target application, where the current memory call function is used to release a second amount of memory through the second call function, and the target call function includes the second call function.

As an optional solution, the determining module 1806 includes:

the acquisition unit is used for acquiring stack information generated by calling the memory each time by the target application from the stack information file;

the conversion unit is used for converting stack information generated by calling the memory each time into a function name of a memory calling function used by calling the memory each time;

and the determining unit is used for determining the memory calling information when the target application runs according to the function name of the memory calling function used for calling the memory each time.

As an optional scheme, the determining unit is configured to determine, according to a function name of a memory call function used for calling the memory each time, memory call information of the target application in operation by:

As an optional scheme, the determining unit is configured to perform a merge operation on a function name of a memory call function used for calling the memory each time in the following manner, so as to obtain the memory call information:

As an optional scheme, the determining unit is configured to perform a merge operation on a function name of a memory call function used for calling the memory each time according to a hierarchy in the following manner, so as to obtain the memory call information:

As an alternative, the determining unit is configured to perform a merging operation on the function names of the first group of functions and the function names of the second group of functions in a hierarchical manner to obtain the function names of the third group of functions, where:

As an optional solution, the determining unit is configured to determine, according to the first number and the second number, the number of memories of the third group of function calls by:

As an optional solution, the recording module 1804 includes:

the first recording unit is used for recording the stack information acquired each time in the stack information file when the stack information generated by calling the memory by the target application is acquired each time; or

And the second recording unit is used for recording the stack information acquired each time into the temporary storage space when the stack information generated by calling the memory by the target application is acquired each time, and recording the stack information acquired each time stored in the temporary storage space into the stack information file when the operation of the target application is finished.

As an alternative to this, it is possible to,

the device is used for acquiring stack information generated by calling the memory each time the target application calls the memory by the following method: acquiring a function address of a memory calling function used by a target application for calling a memory each time and the number of the memories called each time, wherein stack information comprises the function address of the memory calling function used for calling the memory each time and the number of the memories called each time;

the device is used for determining the memory calling information of the target application during operation according to the stack information file in the following way: and determining the function name of the memory calling function used by the target application for calling the memory each time and the number of the memories called each time according to the stack information file.

According to another aspect of the embodiment of the present invention, there is further provided an electronic device for implementing the method for determining memory call information, where the electronic device may be the terminal device or the server shown in fig. 1. The present embodiment takes the electronic device as a server as an example for explanation. As shown in fig. 19, the electronic device comprises a memory 1902 and a processor 1904, the memory 1902 having stored therein a computer program, the processor 1904 being arranged to perform the steps of any of the method embodiments described above via the computer program.

Optionally, in this embodiment, the electronic device may be located in at least one network device of a plurality of network devices of a computer network.

Optionally, in this embodiment, the processor may be configured to execute the following steps by a computer program:

s1, in the running process of the target application, stack information generated by the target application calling the memory each time is obtained, wherein the stack information comprises a function address of a memory calling function used by calling the memory each time;

s2, recording the stack information generated by calling the memory each time in a stack information file;

and S3, after the target application finishes running, determining memory calling information during the running of the target application according to the stack information file, wherein the memory calling information comprises the function name of a memory calling function used by the target application for calling the memory each time.

Alternatively, it can be understood by those skilled in the art that the structure shown in fig. 19 is only an illustration, and the electronic device may also be a terminal device such as a smart phone (e.g., an Android phone, an iOS phone, etc.), a tablet computer, a palmtop computer, a Mobile Internet Device (MID), a PAD, and the like. Fig. 19 is a diagram illustrating a structure of the electronic device. For example, the electronics may also include more or fewer components (e.g., network interfaces, etc.) than shown in FIG. 19, or have a different configuration than shown in FIG. 19.

The memory 1902 may be used to store software programs and modules, such as program instructions/modules corresponding to the method and apparatus for determining memory call information in the embodiments of the present invention, and the processor 1904 executes various functional applications and data processing by running the software programs and modules stored in the memory 1902, that is, implements the method for determining memory call information. The memory 1902 may include high-speed random access memory, and may also include non-volatile memory, such as one or more magnetic storage devices, flash memory, or other non-volatile solid-state memory. In some examples, the memory 1902 may further include memory located remotely from the processor 1904, which may be connected to a terminal over a network. Examples of such networks include, but are not limited to, the internet, intranets, local area networks, mobile communication networks, and combinations thereof. The storage 1902 may be used for storing information such as, but not limited to, memory call data, stack data, and the like. As an example, as shown in fig. 19, the memory 1902 may include, but is not limited to, an obtaining module 1802, a recording module 1804, and a determining module 1806 in the device for determining the memory call information, and may also include, but is not limited to, other module units in the device for determining the memory call information, which is not described in detail in this example.

Optionally, the transmitting device 1906 is used for receiving or sending data via a network. Examples of the network may include a wired network and a wireless network. In one example, the transmission device 1906 includes a Network adapter (NIC) that can be connected to a router via a Network cable and other Network devices so as to communicate with the internet or a local area Network. In one example, the transmission device 1906 is a Radio Frequency (RF) module, which is used for communicating with the internet in a wireless manner.

In addition, the electronic device further includes: a display 1908 for displaying the function name; and a connection bus 1910 for connecting the respective module parts in the above-described electronic apparatus.

In other embodiments, the terminal device or the server may be a node in a distributed system, where the distributed system may be a blockchain system, and the blockchain system may be a distributed system formed by connecting a plurality of nodes through a network communication. Nodes can form a Peer-To-Peer (P2P, Peer To Peer) network, and any type of computing device, such as a server, a terminal, and other electronic devices, can become a node in the blockchain system by joining the Peer-To-Peer network.

According to an aspect of the application, a computer program product or computer program is provided, comprising computer instructions, the computer instructions being stored in a computer readable storage medium. The processor of the computer device reads the computer instructions from the computer-readable storage medium, and the processor executes the computer instructions to cause the computer device to perform the methods provided in the various alternative implementations of the determining aspect of the memory call information. Wherein the computer program is arranged to perform the steps of any of the above method embodiments when executed.

Alternatively, in the present embodiment, the above-mentioned computer-readable storage medium may be configured to store a computer program for executing the steps of:

Alternatively, in this embodiment, a person skilled in the art may understand that all or part of the steps in the methods of the foregoing embodiments may be implemented by a program instructing hardware associated with the terminal device, where the program may be stored in a computer-readable storage medium, and the storage medium may include: flash disks, Read-Only memories (ROMs), Random Access Memories (RAMs), magnetic or optical disks, and the like.

The above-mentioned serial numbers of the embodiments of the present invention are merely for description and do not represent the merits of the embodiments.

The integrated unit in the above embodiments, if implemented in the form of a software functional unit and sold or used as a separate product, may be stored in the above computer-readable storage medium. Based on such understanding, the technical solution of the present invention may be embodied in the form of a software product, which is stored in a storage medium and includes several instructions for causing one or more computer devices (which may be personal computers, servers, network devices, etc.) to execute all or part of the steps of the method according to the embodiments of the present invention.

In the above embodiments of the present invention, the descriptions of the respective embodiments have respective emphasis, and for parts that are not described in detail in a certain embodiment, reference may be made to related descriptions of other embodiments.

In the several embodiments provided in the present application, it should be understood that the disclosed client may be implemented in other manners. The above-described embodiments of the apparatus are merely illustrative, and for example, the division of the units is only one type of division of logical functions, and there may be other divisions when actually implemented, for example, a plurality of units or components may be combined or may be integrated into another system, or some features may be omitted, or not executed. In addition, the shown or discussed mutual coupling or direct coupling or communication connection may be an indirect coupling or communication connection through some interfaces, units or modules, and may be in an electrical or other form.

The units described as separate parts may or may not be physically separate, and parts displayed as units may or may not be physical units, may be located in one place, or may be distributed on a plurality of network units. Some or all of the units can be selected according to actual needs to achieve the purpose of the solution of the embodiment.

In addition, functional units in the embodiments of the present invention may be integrated into one processing unit, or each unit may exist alone physically, or two or more units are integrated into one unit. The integrated unit can be realized in a form of hardware, and can also be realized in a form of a software functional unit.

The foregoing is only a preferred embodiment of the present invention, and it should be noted that, for those skilled in the art, various modifications and decorations can be made without departing from the principle of the present invention, and these modifications and decorations should also be regarded as the protection scope of the present invention.

Claims

1. A method for determining memory call information is characterized by comprising the following steps:

in the running process of a target application, stack information generated by calling a memory each time by the target application is obtained, wherein the stack information comprises a function address of a memory calling function used by calling the memory each time and the number of the memories called each time;

recording stack information generated by calling the memory each time in a stack information file;

after the target application finishes running, determining memory calling information during the running of the target application according to the stack information file, wherein the memory calling information comprises a function name of a memory calling function used by the target application for calling a memory each time;

determining memory calling information of the target application during operation according to the stack information file, wherein the determining memory calling information comprises:

combining the function names of the functions at the ith level in the first group of functions and the functions at the ith level in the second group of functions into the function name of the function at the ith level in a third group of functions under the condition that the functions at the ith level in the first group of functions and the functions at the ith level in the second group of functions are the same, wherein i is a natural number greater than or equal to 2, and the function name of the function at the ith level in the third group of functions is the same as the function name of the function at the ith level in the first group of functions;

determining a function name of a function located at the ith level in the third set of functions to include the function names of the functions located at the ith level in the first set of functions and the second set of functions, if the functions located at the ith level in the first set of functions and the second set of functions are different;

and determining the number of memories called by the third group of functions according to the first number and the second number under the condition that the first group of functions and the second group of functions have a hierarchical relationship, the first group of functions call a first number of memories, the second group of functions call a second number of memories, and the first function and the second function are the same.

2. The method according to claim 1, wherein the obtaining of stack information generated by the target application each time the target application calls the memory during the running of the target application comprises:

when the target calling function is detected to be requested to run, intercepting the target calling function, and acquiring stack information corresponding to the target calling function, wherein the acquired stack information comprises a function address of a current memory calling function, and the current memory calling function is used for calling a memory through the target calling function;

and after stack information corresponding to the target calling function is acquired, operating the target calling function.

3. The method of claim 2, wherein intercepting the target call function and obtaining stack information corresponding to the target call function comprises:

and jumping to the target address, and operating the target acquisition function to acquire stack information corresponding to the target calling function.

4. The method according to claim 2, wherein the detecting whether the target calling function is requested to be executed during the running of the target application comprises:

and detecting whether a first calling function is operated or not in the operation process of the target application, wherein the current memory calling function is used for applying for a first amount of memory through the first calling function, and the target calling function comprises the first calling function.

5. The method according to claim 2, wherein the detecting whether the target calling function is requested to be executed during the running of the target application comprises:

6. The method according to claim 1, wherein the determining memory call information of the target application while running according to the stack information file comprises:

acquiring stack information generated by calling a memory each time by the target application from the stack information file;

converting the stack information generated by calling the memory each time into a function name of a memory calling function used by calling the memory each time;

and determining the memory calling information when the target application runs according to the function name of the memory calling function used for calling the memory each time.

7. The method according to claim 6, wherein the determining the memory call information when the target application runs according to the function name of the memory call function used for calling the memory each time comprises:

and executing merging operation on the function name of the memory calling function used for calling the memory each time to obtain the memory calling information.

8. The method according to claim 7, wherein the performing a merge operation on the function name of the memory call function used for each call to the memory to obtain the memory call information comprises:

and under the condition that the memory calling function used for calling the memory each time comprises a group of functions with a hierarchical relationship, performing merging operation on the function name of the memory calling function used for calling the memory each time according to the hierarchy to obtain the memory calling information.

9. The method according to claim 8, wherein the performing a merge operation on the function name of the memory call function used for each memory call according to the hierarchy to obtain the memory call information comprises:

under the condition that a first group of functions and a second group of functions have a hierarchical relationship and a first function located at a first level in the first group of functions is the same as a second function located at the first level in the second group of functions, carrying out merging operation on function names of the first group of functions and function names of the second group of functions according to a hierarchy to obtain function names of a third group of functions, wherein the third group of functions have a hierarchical relationship and the function names of the functions located at the first level in the third group of functions are the same as the function name of the first function.

10. The method of claim 9, wherein determining the amount of memory for the third set of function calls based on the first amount and the second amount comprises:

applying for the first amount of memory in the first group of functions and applying for the second amount of memory in the second group of functions, and determining the amount of memory applied for by the third group of functions as the sum of the first amount and the second amount;

applying for the first amount of memory in the first group of functions, releasing the second amount of memory in the second group of functions, and determining the amount of memory applied for by the third group of functions as the difference between the first amount and the second amount;

determining the amount of memory freed by the third set of functions as the sum of the first amount and the second amount, when the first set of functions frees the first amount of memory, when the second set of functions frees the second amount of memory.

11. The method according to any one of claims 1 to 10,

the obtaining stack information generated by calling the memory each time by the target application includes: acquiring a function address of a memory calling function used by the target application for calling the memory each time and the number of the memories called each time, wherein the stack information comprises the function address of the memory calling function used for calling the memory each time and the number of the memories called each time;

determining memory calling information of the target application during operation according to the stack information file, wherein the determining memory calling information comprises: and determining the function name of a memory calling function used by the target application for calling the memory each time and the number of the memories called each time according to the stack information file.

12. A computer-readable storage medium, characterized in that it comprises a stored program, wherein the program is executable by a terminal device or a computer to perform the method of any one of claims 1 to 11.

13. An electronic device comprising a memory and a processor, characterized in that the memory has stored therein a computer program, the processor being arranged to execute the method of any of claims 1 to 11 by means of the computer program.