CN112947931A - Wear leveling compiling method for loop-to-array based on phase change memory - Google Patents

Wear leveling compiling method for loop-to-array based on phase change memory Download PDF

Info

Publication number
CN112947931A
CN112947931A CN202110198085.9A CN202110198085A CN112947931A CN 112947931 A CN112947931 A CN 112947931A CN 202110198085 A CN202110198085 A CN 202110198085A CN 112947931 A CN112947931 A CN 112947931A
Authority
CN
China
Prior art keywords
global
loop
variable
array
function
Prior art date
Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
Granted
Application number
CN202110198085.9A
Other languages
Chinese (zh)
Other versions
CN112947931B (en
Inventor
李清安
王紫微
Current Assignee (The listed assignees may be inaccurate. Google has not performed a legal analysis and makes no representation or warranty as to the accuracy of the list.)
Wuhan University WHU
Original Assignee
Wuhan University WHU
Priority date (The priority date is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the date listed.)
Filing date
Publication date
Application filed by Wuhan University WHU filed Critical Wuhan University WHU
Priority to CN202110198085.9A priority Critical patent/CN112947931B/en
Publication of CN112947931A publication Critical patent/CN112947931A/en
Application granted granted Critical
Publication of CN112947931B publication Critical patent/CN112947931B/en
Active legal-status Critical Current
Anticipated expiration legal-status Critical

Links

Images

Classifications

    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F8/00—Arrangements for software engineering
    • G06F8/40—Transformation of program code
    • G06F8/41—Compilation
    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F8/00—Arrangements for software engineering
    • G06F8/40—Transformation of program code
    • G06F8/41—Compilation
    • G06F8/44—Encoding
    • G06F8/443—Optimisation

Landscapes

  • Engineering & Computer Science (AREA)
  • General Engineering & Computer Science (AREA)
  • Theoretical Computer Science (AREA)
  • Software Systems (AREA)
  • Physics & Mathematics (AREA)
  • General Physics & Mathematics (AREA)
  • Devices For Executing Special Programs (AREA)

Abstract

The invention discloses a wear leveling compiling method of a loop array based on a phase change memory, which comprises the steps of firstly collecting hot point variables positioned in a memory global data area; secondly, performing inter-process analysis to eliminate certain conditions that array conversion cannot be performed; then inserting an instruction for generating an array into the precursor basic block at the inlet of the loop, replacing the reading and writing of the global variable into the reading and writing of the generated array in the loop body, and inserting an instruction at the outlet of the loop to assign the value written in the array to the global variable; finally, the optimized intermediate expression assembly is linked into an executable file. The invention can effectively reduce the write peak value of the global data area and has better performance than the prior method. Meanwhile, the invention comprises a hot spot variable detection method, an inter-process analysis method and a method for carrying out escape analysis on the global variable, and provides basic algorithm support for a loop array conversion method.

Description

Wear leveling compiling method for loop-to-array based on phase change memory
Technical Field
The invention belongs to the technical field of computer storage, and relates to a wear leveling compilation method for a cycle to array based on a Phase Change Memory (PCM), in particular to a wear leveling compilation method for a global data area of a cycle to array based on a Phase Change Memory.
Background
The computer storage system comprises an internal memory and an external memory. The main Memory currently most widely used is Dynamic Random-Access Memory (DRAM). The main problem of the DRAM at present is that the integration density is limited, and the required hardware space is large, while the integration density of PCM is 2-4 times that of DRAM, and PCM can be integrated into a smaller chip. Further, DRAM is a semiconductor memory, and for DRAM, it is required to be periodically charged to refresh electric charges. PCM is a non-volatile memory that does not require refresh operations, and therefore consumes less power.
In order to solve the problems of low integration density and high power consumption of DRAM, research on Non-volatile Memory (NVM) has been advanced, wherein Phase Change Memory (PCM) is considered to be one of the most promising DRAM substitutes due to its characteristics of high integration density and low leakage power.
However, PCM has some disadvantages compared to DRAM, as shown in table 1.
TABLE 1
Performance of DRAM PCM
Read latency 20-50ns 50-500ns
Write latency 20-50ns 100ns-10us
Reading energy consumption 0.8J/GB 1J/GB
Writing energy consumption 1.2J/GB 6J/GB
Write durability >1016 105-109
Density of 1× 2-4×
Write endurance of PCM is 105-109Next, the write endurance of DRAM is greater than 1016Next, the process is carried out. Poor PCM write endurance is a major factor hindering its development, and imbalances in memory writes can accelerate PCM damage. To solve the problem of write endurance of PCM, researchers have proposed various approaches to different memory partitions. In previous studies, most of them are directed to the wear leveling method of the stack area or the stack area of PCM, and there is no wear leveling compilation method for studying the global data area.
Disclosure of Invention
The invention aims to solve the problems and provides a wear leveling compiling method based on a global data area of a phase change memory. The method converts the reading and writing of the global variable in the loop of the source program into the reading and writing of the generated array with the specified size so as to reduce the frequent reading and writing of the global hot variable.
The technical scheme adopted by the invention is as follows: a wear leveling compiling method of a loop conversion array based on a phase change memory comprises the following steps:
step 1: collecting writing frequency information of a global variable of a source program;
step 2: calculating the size of an array to be generated according to the writing times of the global variable in the step 1;
the specific implementation of the step 2 comprises the following substeps:
step 2.1: counting according to the global variable write frequency information in the step 1Average value W of global variable write timesavg；
Step 2.2: counting the global hot variable information, if the global variable GiNumber of times of writing WiAnd the average value W of the write times of the global variables generated in the step 2.1avgRatio W ofi/WavgIf the global variable is larger than or equal to the threshold value N, the global variable is considered to be a global hot variable Ghot；
Step 2.3: calculating WiAnd WavgThe magnitude of the ratio is the global hot spot variable GhotSize of the required arrayi；
Step 2.4: name of global hot spot variableiValue of allocated memory addressiAnd the desired array sizeiAll writing into disk files;
and step 3: generating an intermediate representation of the source program, namely LLVM intermediate language IR;
and 4, step 4: reading global hotspot variable information generated in the step 2 from a disk through an LLVM Pass;
and 5: performing inter-process analysis based on the intermediate representation generated in the step 3 to obtain a function set directly and indirectly called by each function contained in the program;
step 6: for each function, collecting loop-related information, i.e. the entry and exit basic blocks of the loop, from which a loop is uniquely determined;
and 7: collecting global hotspot variables read and written in a cycle to generate a global hotspot variable set read and written in the cycle;
and 8: performing escape analysis on the global hotspot variable set of the cyclic reading and writing obtained in the step 7;
and step 9: performing cycle revolution group operation on the global hot spot variables which are obtained in the step 8 and do not escape;
step 10: the transformed intermediate representation assembly is linked into a new executable file.
Compared with the prior art, the invention has the following advantages and beneficial effects:
(1) the invention creatively provides a wear leveling compiling method of a loop-to-array set aiming at a global area.
(2) The loss equalization algorithm provided by the invention only considers the hot point variable without considering all variables, and compared with the existing heuristic algorithm SWL, the heuristic algorithm is unlikely to reach the optimum and has poor performance, and the SWL is a method based on the access information of collected data.
Drawings
FIG. 1 is a flow chart of an embodiment of the present invention;
FIG. 2 is a schematic diagram of different cycle configurations in an embodiment of the present invention.
Detailed Description
In order to facilitate the understanding and implementation of the present invention for those of ordinary skill in the art, the present invention is further described in detail with reference to the accompanying drawings and examples, it is to be understood that the embodiments described herein are merely illustrative and explanatory of the present invention and are not restrictive thereof.
Referring to fig. 1, the loss equalization compiling method for a loop to array based on a phase change memory provided by the invention converts the input intermediate representation through the conversion Pass compiled by the LLVM, and converts the reading and writing of global variables into the reading and writing of the array; the method specifically comprises the following steps:
step 1: collecting writing frequency information of a global variable of a source program;
in this embodiment, the specific implementation of step 1 includes the following substeps:
step 1.1: obtaining symbol table information of an ELF (executable and Linking Format) executable file, and further collecting and obtaining global variable information of a source program, wherein the global variable information comprises a memory address, a type, a size and an identifier of variable allocation;
step 1.2: redirecting the global variable information collected in the step 1.1 to a disk file;
step 1.3: and (3) performing instruction instrumentation on the binary file during operation by adopting a pin tool of Intel, dynamically instrumentation a write instruction of the program by inputting the memory address information of the global variable collected in the step 1.1, and adding 1 to the write frequency of the global variable if the operation address of the write instruction is the memory address of the global variable collected in the step 1.1.
Step 2: calculating the size of an array to be generated according to the information related to the writing times of the global variable in the step 1;
in this embodiment, the specific implementation of step 2 includes the following substeps:
step 2.1: according to the global variable write frequency information in the step 1, counting the average value W of the global variable write frequencyavg；
Step 2.2: counting the global hot variable information, if the global variable GiNumber of times of writing WiAnd the average value W of the write times of the global variables generated in the step 2.1avgRatio W ofi/WavgIf the global variable is greater than or equal to the threshold N (the present implementation threshold N is 100), the global variable is considered to be the global hot variable Ghot；
Step 2.3: calculating WiAnd WavgThe magnitude of the ratio is the global hot spot variable GhotSize of the required arrayi；
Step 2.4: name of global hot spot variableiValue of allocated memory addressiAnd the desired array sizeiAll writing into disk files;
and step 3: generating an intermediate representation of the source program, namely LLVM intermediate language IR;
in this embodiment, a source program source.c input is generated with LLVM intermediate representation source.ll using a command clean-emit-LLVM-S- < input files >.
And 4, step 4: reading global hotspot variable information generated in the step 2 from a disk through an LLVM Pass;
in this embodiment, the global hot spot variable G in step 2 is read from the disk by the translation Pass of LLVMhotAnd (4) information to detect global hot spot variables and prepare for loop to loop array.
And 5: performing inter-process analysis based on the intermediate representation generated in the step 3 to obtain a function set directly and indirectly called by each function contained in the program;
in this embodiment, the specific implementation of step 5 includes the following substeps:
step 5.1: traverse each function FaThe included instruction is used for detecting whether the function includes a function calling instruction or not; if so, the operand of the call instruction is obtained, i.e. the called function FbF is obtained after traversal is finishedaFunction set for direct call
Figure BDA0002946761350000041
At this time, the one-to-one correspondence relationship between the function and the function set directly called by the function is obtained: f → setF；
Step 5.2: for the function F of step 5.1, set is traversedFGet set for each function f infI.e. the set of functions called directly by function f, update setF＝setF∪setfSet of setsFWhen the size of (d) is constant, the obtained setFAll function sets called directly as well as indirectly for function F, i.e. the set of all functions reachable by function F.
Step 6: for each function, collecting loop-related information, i.e. the entry and exit basic blocks of the loop, from which a loop is uniquely determined;
in this embodiment, for each function, the basic block is traversed, and all loop entry/exit basic blocks loop included in the function are collectedbegin/loopend. For example, three different cycles and their corresponding IR expressions are shown in FIG. 2: for loop, while loop and do-while loop, each loop has corresponding entry basic block and exit basic block, and a specific loop can be uniquely determined by the entry basic block and the exit basic block.
And 7: collecting global hotspot variables read and written in a cycle to generate a global hotspot variable set read and written in the cycle;
in this embodiment, the inlet and outlet for each cycle collected in step 6 are essentiallyWhether the instructions of all basic blocks contained in the traversal loop are aligned with the global hot spot variable G read in the step 4 or not is determined by the blockhotReading and writing are carried out, all read-written global hot spot variables are marked to generate a global hot spot traversal set for cyclic reading and writing
Figure BDA0002946761350000051
And 8: performing escape analysis on the global hotspot variable set of the cyclic reading and writing obtained in the step 7;
in the present embodiment, other functions F e set called directly or indirectly for the function F to which the loop entry/exit basic block belongsFWherein setFSet of all functions reachable for the function F obtained in step 5.2F(ii) a If the calling of the function f occurs in the loop uniquely determined by the loop entry/exit basic block and the function f refers to or modifies the global hot spot variable of the loop read-write collected in the step 7
Figure BDA0002946761350000052
Then the global hot spot variable GhotIf the global hot variable is replaced by the array, the value of the array needs to be assigned to the global hot variable before the function F calls the function F, so that the function F uses the correct value of the global hot variable, an additional write operation can be generated in a loop body, the array conversion of the global hot variable which is subjected to the escape is not performed, the global hot variable which is subjected to the escape is skipped to directly process the next global hot variable, and otherwise, the next conversion work is performed.
And step 9: performing cycle revolution group operation on the global hot spot variables which are obtained in the step 8 and do not escape;
in this embodiment, the specific implementation of step 9 includes the following sub-steps:
step 9.1: at loop entry basic block loopbeginIncludes inserting an LLVM IR instruction at the end of the predecessor basic block, including the generated array coarse [ size ] replacing the global variablei]The size of the array is the array corresponding to the global hotspot variable generated in the step 2Size, 0 th element of the array, ary [0 ]]Initializing to a value of a global hotspot variable;
step 9.2: traversing all basic block instructions contained in the loop, and if the operand of the read/write instruction is the global hot spot variable, replacing the operand with the array generated in the step 9.1;
step 9.3: basic block loop at the exit of the loopendAnd inserting an instruction at the tail end, and assigning the value written in the array last to the global hotspot variable.
Step 10: linking the transformed intermediate representation assembly into a new executable file;
in this embodiment, the transformed IR file can be transformed into an assembly file by the llc command of the LLVM, and then a new executable file that is transformed into an array by a loop can be generated by assembly and linking.
The invention provides a wear leveling compiling method of a global data area of a loop array (loop2array) based on a Phase Change Memory (PCM), which comprises the following steps that firstly, a loop2array algorithm collects hot point variables of the global area; secondly, the loop2array algorithm performs inter-process analysis to eliminate certain conditions that array conversion cannot be performed; then inserting an instruction for generating an array into a precursor basic block at a loop inlet by a loop2array algorithm, replacing reading and writing of the global variable in a loop body with reading and writing of the generated array, and inserting an instruction at a loop outlet to assign a value written in the array to the global variable; finally, the optimized intermediate expression assembly is linked into an executable file. The invention creatively provides a wear leveling compiling method aiming at a loop-to-array of a global area. The loss balance compiling method of the loop array based on the phase change memory can effectively reduce the write peak value of the global data area, the loop2array algorithm does not convert all global variables, only global hot point variables are converted, and the loop2array is realized by representing conversion Pass through the middle of LLVM without obtaining a large amount of memory access information, so that the method has better performance than the existing method. Meanwhile, the algorithm comprises a hot spot variable detection method, an inter-process analysis method and a method for carrying out escape analysis on global variables, and provides basic algorithm support for a loop-to-array method.
It should be understood that parts of the specification not set forth in detail are well within the prior art.
It should be understood that the above description of the preferred embodiments is given for clarity and not for any purpose of limitation, and that various changes, substitutions and alterations can be made herein without departing from the spirit and scope of the invention as defined by the appended claims.

Claims (10)

1. A wear leveling compilation method of a loop conversion array based on a phase change memory is characterized by comprising the following steps:
step 1: collecting writing frequency information of a global variable of a source program;
step 2: calculating the size of an array to be generated according to the writing times of the global variable in the step 1;
the specific implementation of the step 2 comprises the following substeps:
step 2.1: according to the global variable write frequency information in the step 1, counting the average value W of the global variable write frequencyavg；
Step 2.2: counting global hot spot variable information; if the global variable GiNumber of times of writing WiAnd the average value W of the write times of the global variables generated in the step 2.1avgRatio W ofi/WavgIf the global variable is larger than or equal to the threshold value N, the global variable is considered to be a global hot variable Ghot；
Step 2.3: calculating WiAnd WavgThe magnitude of the ratio is the global hot spot variable GhotSize of the required arrayi；
Step 2.4: name of global hot spot variableiValue of allocated memory addressiAnd the desired array sizeiAll writing into disk files;
and step 3: generating an intermediate representation of the source program, namely LLVM intermediate language IR;
and 4, step 4: reading global hotspot variable information generated in the step 2 from a disk through an LLVM Pass;
and 5: performing inter-process analysis based on the intermediate representation generated in the step 3 to obtain a function set directly and indirectly called by each function contained in the program;
step 6: for each function, collecting loop-related information, i.e. the entry and exit basic blocks of the loop, from which a loop is uniquely determined;
and 7: collecting global hotspot variables read and written in a cycle to generate a global hotspot variable set read and written in the cycle;
and 8: performing escape analysis on the global hotspot variable set of the cyclic reading and writing obtained in the step 7;
and step 9: performing cycle revolution group operation on the global hot spot variables which are obtained in the step 8 and do not escape;
step 10: the transformed intermediate representation assembly is linked into a new executable file.
2. The wear-leveling compilation method for the phase-change memory-based loop-through array according to claim 1, wherein the step 1 is realized by the following steps:
step 1.1: obtaining symbol table information of an ELF executable file, and further collecting and obtaining global variable information of a source program, wherein the global variable information comprises a memory address, a type, a size and an identifier of variable allocation;
step 1.2: redirecting the global variable information collected in the step 1.1 to a disk file;
step 1.3: and (3) performing instruction instrumentation on the binary file during operation by adopting a pin tool of Intel, dynamically instrumentation a write instruction of the program by inputting the memory address information of the global variable collected in the step 1.1, and adding 1 to the write frequency of the global variable if the operation address of the write instruction is the memory address of the global variable collected in the step 1.1.
3. The wear-leveling compilation method for phase change memory based loop-to-array sets according to claim 1, wherein: in step 3, generating an LLVM intermediate representation source.ll for the input source program source.c by using a command of clean-emit-LLVM-S- < input files >.
4. The wear-leveling compilation method for phase change memory based loop-to-array sets according to claim 1, wherein: in step 4, reading the global hot spot variable G in the step 2 from the disk through the conversion Pass of the LLVMhotAnd (4) information to detect global hot spot variables and prepare for loop to loop array.
5. The wear-leveling compilation method for phase-change memory based loop-to-array sets according to claim 1, wherein the step 5 is implemented by the following sub-steps:
step 5.1: traverse each function FaThe included instruction is used for detecting whether the function includes a function calling instruction or not; if so, the operand of the call instruction is obtained, i.e. the called function FbF is obtained after traversal is finishedaFunction set for direct callFaAt this time, the one-to-one correspondence relationship between the function and the function set directly called by the function is obtained: f → setF；
Step 5.2: for the function F of step 5.1, set is traversedFGet set for each function f infI.e. the set of functions called directly by function f, update setF＝setF∪setfSet of setsFWhen the size of (d) is constant, the obtained setFAll function sets called directly as well as indirectly for function F, i.e. the set of all functions reachable by function F.
6. The wear-leveling compilation method for phase change memory based loop-to-array sets according to claim 1, wherein: in step 6, for each function, the basic block is traversed, and all loop entry/exit basic blocks loop included in the function are collectedbegin/loopend。
7. The wear-leveling compilation method for phase change memory based loop-to-array sets according to claim 1, wherein: in step 7, for the entry and exit basic blocks of each loop collected in step 6, whether the instructions of all basic blocks included in the traversal loop are for the global hot spot variable G read in step 4 or nothotReading and writing are carried out, all read-written global hot spot variables are marked to generate a global hot spot traversal set for cyclic reading and writing
Figure FDA0002946761340000031
8. The wear-leveling compilation method for phase change memory-based loop-to-array sets according to claim 5, wherein: in step 8, the other function F e set called directly or indirectly for the function F to which the loop entry/exit basic block belongsFWherein setFSet of all functions reachable for the function F obtained in step 5.2F(ii) a If the calling of the function f occurs in the loop uniquely determined by the loop entry/exit basic block and the function f refers to or modifies the global hot spot variable of the loop read-write collected in the step 7
Figure FDA0002946761340000032
Then the global hot spot variable GhotIf the global hot variable is replaced by the array, the value of the array needs to be assigned to the global hot variable before the function F calls the function F, so that the function F uses the correct value of the global hot variable, an additional write operation can be generated in a loop body, the array conversion of the global hot variable which is subjected to the escape is not performed, the global hot variable which is subjected to the escape is skipped to directly process the next global hot variable, and otherwise, the next conversion work is performed.
9. The wear-leveling compilation method for phase-change memory based loop-through arrays according to claim 1, wherein the step 9 is realized by the following steps:
step 9.1: at loop entry basic block loopbeginIncludes inserting an LLVM IR instruction at the end of the predecessor basic block, including the generated array coarse [ size ] replacing the global variablei]The size of the array is the size of the array corresponding to the global hotspot variable generated in step 2, and the 0 th element of the array, namely, the array [0 ]]Initializing to a value of a global hotspot variable;
step 9.2: traversing all basic block instructions contained in the loop, and if the operand of the read/write instruction is the global hot spot variable, replacing the operand with the array generated in the step 9.1;
step 9.3: basic block loop at the exit of the loopendAnd inserting an instruction at the tail end, and assigning the value written in the array last to the global hotspot variable.
10. The wear-leveling compilation method for phase change memory-based loop-through arrays according to any one of claims 1 to 9, wherein: in step 10, the transformed IR file can be transformed into an assembly file by the llc command of LLVM, and then a new executable file transformed into an array by a loop can be generated by assembly and linking.
CN202110198085.9A 2021-02-22 2021-02-22 Wear-leveling compiling method for cyclic rotation group based on phase change memory Active CN112947931B (en)

Priority Applications (1)

Application Number Priority Date Filing Date Title
CN202110198085.9A CN112947931B (en) 2021-02-22 2021-02-22 Wear-leveling compiling method for cyclic rotation group based on phase change memory

Applications Claiming Priority (1)

Application Number Priority Date Filing Date Title
CN202110198085.9A CN112947931B (en) 2021-02-22 2021-02-22 Wear-leveling compiling method for cyclic rotation group based on phase change memory

Publications (2)

Publication Number Publication Date
CN112947931A true CN112947931A (en) 2021-06-11
CN112947931B CN112947931B (en) 2023-10-03

Family

ID=76245245

Family Applications (1)

Application Number Title Priority Date Filing Date
CN202110198085.9A Active CN112947931B (en) 2021-02-22 2021-02-22 Wear-leveling compiling method for cyclic rotation group based on phase change memory

Country Status (1)

Country Link
CN (1) CN112947931B (en)

Citations (6)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
CN101477472A (en) * 2009-01-08 2009-07-08 上海交通大学 Multi-core multi-threading construction method for hot path in dynamic binary translator
WO2013095644A1 (en) * 2011-12-23 2013-06-27 Intel Corporation Page miss handler including wear leveling logic
US20140019949A1 (en) * 2012-07-10 2014-01-16 Loring Craymer Method and System for Automated Improvement of Parallelism in Program Compilation
CN105765524A (en) * 2013-10-04 2016-07-13 英特尔公司 Techniques for heterogeneous core assignment
CN109918903A (en) * 2019-03-06 2019-06-21 西安电子科技大学 A kind of program non-control attack guarding method based on LLVM compiler
CN111684422A (en) * 2018-02-05 2020-09-18 美光科技公司 CPU cache flush to persistent memory

Patent Citations (6)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
CN101477472A (en) * 2009-01-08 2009-07-08 上海交通大学 Multi-core multi-threading construction method for hot path in dynamic binary translator
WO2013095644A1 (en) * 2011-12-23 2013-06-27 Intel Corporation Page miss handler including wear leveling logic
US20140019949A1 (en) * 2012-07-10 2014-01-16 Loring Craymer Method and System for Automated Improvement of Parallelism in Program Compilation
CN105765524A (en) * 2013-10-04 2016-07-13 英特尔公司 Techniques for heterogeneous core assignment
CN111684422A (en) * 2018-02-05 2020-09-18 美光科技公司 CPU cache flush to persistent memory
CN109918903A (en) * 2019-03-06 2019-06-21 西安电子科技大学 A kind of program non-control attack guarding method based on LLVM compiler

Non-Patent Citations (1)

* Cited by examiner, † Cited by third party
Title
沈凡凡;何炎祥;张军;江南;李清安;李建华;: "一种SRAM辅助新型非易失性缓存的磨损均衡方法", 计算机学报, no. 03 *

Also Published As

Publication number Publication date
CN112947931B (en) 2023-10-03

Similar Documents

Publication Publication Date Title
US8250286B2 (en) Block management method, and storage system and controller using the same
Qiu et al. Data allocation for hybrid memory with genetic algorithm
Wang et al. Exploring hybrid memory for GPU energy efficiency through software-hardware co-design
US8161464B2 (en) Compiling source code
US7367024B2 (en) Compiler-driven dynamic memory allocation methodology for scratch-pad based embedded systems
CN101763316B (en) Method for dynamically distributing isomerism storage resources on instruction parcel based on virtual memory mechanism
CN101739358B (en) Method for dynamically allocating on-chip heterogeneous memory resources by utilizing virtual memory mechanism
CN113093993B (en) Flash memory space dynamic allocation method and solid state disk
US20100042775A1 (en) Block management method for flash memory, and storage system and controller using the same
US20100057979A1 (en) Data transmission method for flash memory and flash memory storage system and controller using the same
CN109002257B (en) Data distribution optimization method based on variable scratch pad memory
Bock et al. Analyzing the impact of useless write-backs on the endurance and energy consumption of PCM main memory
Li et al. Compiler-assisted preferred caching for embedded systems with STT-RAM based hybrid cache
Gai et al. Smart energy-aware data allocation for heterogeneous memory
Li et al. Pattern-based write scheduling and read balance-oriented wear-leveling for solid state drivers
CN102804142B (en) Use double byte sequence compiler optimized code
Kannan et al. A software solution for dynamic stack management on scratch pad memory
CN112947931B (en) Wear-leveling compiling method for cyclic rotation group based on phase change memory
Li et al. A wear-leveling-aware dynamic stack for PCM memory in embedded systems
Kandemir et al. Improving memory energy using access pattern classification
Udayakumaran et al. An integrated scratch-pad allocator for affine and non-affine code
Feng et al. Multiple subpage writing FTL in MLC by exploiting dual mode operations
Zhou et al. Compiler-driven register re-assignment for register file power-density and temperature reduction
Wu et al. Effective stack wear leveling for nvm
Huang et al. Register allocation for write activity minimization on non-volatile main memory for embedded systems

Legal Events

Date Code Title Description
PB01 Publication
PB01 Publication
SE01 Entry into force of request for substantive examination
SE01 Entry into force of request for substantive examination
GR01 Patent grant
GR01 Patent grant