WO2001061498A1 - Adaptive memory allocation - Google Patents
Adaptive memory allocation Download PDFInfo
- Publication number
- WO2001061498A1 WO2001061498A1 PCT/US2001/004682 US0104682W WO0161498A1 WO 2001061498 A1 WO2001061498 A1 WO 2001061498A1 US 0104682 W US0104682 W US 0104682W WO 0161498 A1 WO0161498 A1 WO 0161498A1
- Authority
- WO
- WIPO (PCT)
- Prior art keywords
- memory
- linked
- lists
- access
- access tree
- Prior art date
Links
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F12/00—Accessing, addressing or allocating within memory systems or architectures
- G06F12/02—Addressing or allocation; Relocation
- G06F12/0223—User address space allocation, e.g. contiguous or non contiguous base addressing
- G06F12/023—Free address space management
Landscapes
- Engineering & Computer Science (AREA)
- Theoretical Computer Science (AREA)
- Physics & Mathematics (AREA)
- General Engineering & Computer Science (AREA)
- General Physics & Mathematics (AREA)
- Information Retrieval, Db Structures And Fs Structures Therefor (AREA)
Abstract
This function maintains two trees: a fast access tree referring to memory blocks of a size most often requested, and a general access tree referring to memory blocks of a size less often requested. After satifying a request for a memory block, the function adjusts the trees to ensure that the fast access tree refers to memory blocks of the size most often requested. By providing such functionality, the function improves its performace over time through self-adaptation.
Description
ADAPTIVE MEMORY ALLOCATION
FIELD OF THE INVENTION
This invention relates generally to data processing systems, and more particularly, to methods for optimizing the allocation and deallocation of shared memory to programs executing in a data processing system.
BACKGROUND OF THE INVENTION
During execution, programs typically make many dynamic memory access requests. Such requests involve requesting allocation of memory from a system call (e.g., malloc), utilizing the memory, and deallocating the memory using a system call (e.g., free). Dynamic memory allocation is a fundamental and very important part of many computer programs. It is therefore desirable to improve the performance of memory access functions.
SUMMARY OF THE INVENTION
In accordance with methods and systems consistent with the present invention, an improved memory access function (e.g., malloc) is provided that dynamically improves its performance by changing its operation at runtime. The memory access function adapts its operation based on previous memory access requests to be able to provide the fastest response to those kinds of memory access requests that it predicts will be the most common. For purposes of this description "access to system memory" includes both requests for allocation of system memory and release of • system memory, or deallocation. Similarly, a "memory request" refers to either an allocation (a request for system memory), or a deallocation (a return of previously requested memory).
In accordance with methods and systems consistent with the present invention, as embodied and broadly described herein, a method is provided in a data processing system for allocating memory. The method receives a memory request for a reference to a block of memory. Then it returns the reference to the block of memory to satisfy the request. Next, it adjusts an operation of the memory access function based on the memory request.
Furthermore, in accordance with methods and system consistent with the present invention, as embodied and broadly described herein, a system for providing access to memory includes a memory which further includes a program including a
memory access function that provides access to memory and adjusts its operation according to a memory request for a reference to a block of memory, and a processor for executing the program.
BRIEF DESCRIPTION OF THE DRAWINGS
Fig. 1 depicts a block diagram of a data processing system suitable for practicing methods and systems consistent with the present invention;
Fig. 2 depicts in greater details the general access tree and the fast access tree depicted in Fig. 1 ;
Figs. 3A & 3B depict a flow diagram illustrating operations performed to allocate memory in accordance with the principles of the present invention; and
Fig. 4 depicts a flow diagram illustrating operations performed to deallocate memory in accordance with the principles of the present invention.
DETAILED DESCRIPTION
Methods and systems consistent with the present invention provide a function called "smart-alloc" that adapts in real-time the memory allocation process to threads executing in a data processing system. More specifically, smart-alloc observes past memory allocation behavior and adjusts the process of providing memory access such that the most frequently requested memory blocks of a specific size are allocated faster than less frequently requested memory block sizes. Smart-alloc is a language- independent library function which may be linked to one or more programs operating in a multi-processing environment. Overview
When a program begins execution, smart-alloc secures access to an amount of memory that may be accessed as needed by threads executing within the program. Upon receiving a pointer from a system memory call to an amount of memory- requested, smart-alloc divides the memory into blocks of varying sizes, grouping blocks of like size together in a linked-list, referred to as a free memory linked-list. Smart-alloc creates two trees that point to the free memory linked-lists: a fast access tree and a general access tree. As a program executes, the fast access tree points to the most frequently accessed memory block sizes, and the general access tree points to block sizes not pointed to by the fast access tree. Each free memory linked-list will be pointed to by either the general access tree, or the fast access tree, but not both.
Upon receiving a request from an executing thread for access to memory, smart-alloc increments a counter associated with the block size that will be used to satisfy the memory request. To satisfy the memory request, smart-alloc first determines whether the fast access tree points to memory blocks of the size needed to satisfy the request. If the fast access tree includes memory blocks of the size needed to satisfy the request, smart-alloc satisfies the request from the fast access tree. Otherwise, smart-alloc satisfies the request from the general access tree. If a request is satisfied from the general access tree, smart-alloc compares the value of the counter associated with the allocated block size to the counter values for block sizes included in the fast access tree to determine whether the general access tree refers to block sizes most frequently requested. If the counter value for the allocated block size (from the general access tree) is greater than any of the counter values of block sizes included in the fast access tree, smart-alloc replaces that general access tree pointer to the block size having the highest counter value with a pointer from the fast access tree, and replaces the pointer to the block size included in the fast access tree having the lowest counter value with a pointer from the general access tree. This process ensures that the fast access tree continues to point to the most frequently requested block sizes.
Smart-alloc also receives requests from executing threads desiring to release references to blocks of memory. After receiving a released reference, smart-alloc adds the reference to the free memory linked-list that includes memory blocks corresponding to the size of the returned reference. Implementation Details
Fig. 1 depicts a block diagram of a data processing system 100 suitable for practicing methods and implementing systems consistent with the present invention. Data processing system 100 includes computer 102 connected to network 105. Computer 102 includes secondary storage 110, processors 120a... n, output device 130, input device 140, and memory 150. Memory 150 includes programs 155, 160, and 165, operating system 170, and shared memory 180. Operating system 170 includes a system shared memory access function, malloc 182. Each of programs 155, 160, and 165 includes smart-alloc 185, a shared memory access function operating in accordance with the principles of the present invention. Each instance of smart-alloc 185 includes two data structures, a fast access tree 186 and a general
access tree 187 that are used by smart-alloc 185 when allocating and deallocating memory.
Programs 155, 160, and 165 share access to shared memory 180. Programs 155, 160, and 165 may include a single thread or multiple threads. Although multiple processors are shown, one skilled in the art will appreciate that programs 155, 160, and 165 may execute on a single processor to implement methods and practice systems consistent with the present invention.
Operating system 170 represents the Solaris® operating system from Sun Microsystems, Inc., which specifically facilitates multi-threaded program execution, although any operating system may be used to implement methods and systems consistent with the present invention.
Although aspects of this implementation are depicted as being stored in memory 150, one skilled in the art will appreciate that all or part of systems and methods consistent with the present invention may be stored on or read from other computer readable media, such as secondary storage devices, like hard disks, floppy disks, and CD-ROM; a digital signal received from a network such as the Internet; or other forms of RAM or ROM, either currently known or later developed. Sun, Sun Microsystems, and the Sun logo are trademark or registered trademarks of Sun Microsystems, Inc. in the United States and other countries.
Fig. 2 depicts general access tree 202 and fast access tree 204 pointing to free memory linked-lists 262-272. In this example, general access tree 202 includes two main branches: branch 206 including pointers to free memory linked-lists containing references to memory blocks of a size less than or equal to 4K and branch 208 including pointers to free memory linked-lists containing references to memory blocks of a size greater than 4K. Branches 210, 215, and 225 serve as head pointers to free memory linked-lists 262, 266, and 272, which include memory blocks of size IK, 4K, and 64K, respectively. Fast access tree 204 also includes two main branches, 230 and 240. Fast access tree 204 further includes head pointers 250, 255, and 260 to free memory linked-lists 264, 268, and 270, including memory blocks of size 2K, 8K, and 16K, respectively, indicating that these memory block sizes were most frequently accessed by the threads executing in the associated program. General access tree 202 may include additional branches that include head pointers to additional free memory
linked-lists. Fast access tree 204, however, only includes head pointers to a specific number of free memory linked-lists, typically no more than eight. A "head pointer" is a pointer to the beginning of a free memory linked-list. Thus, because the fast access tree does not typically grow as large as the general access tree, accesses to the fast access tree are faster than accesses to the general access tree.
Figs. 3 A & 3B depict a flow diagram of a smart-alloc function operating in accordance with the principles of the present invention. First, smart-alloc requests access to an amount of memory from a system memory call included as part of an operating system (step 305). If the amount of memory is available (step 310), the system memory call returns to smart-alloc a pointer to the amount of memory requested (step 315). Upon receiving a pointer to a requested amount of memory, smart-alloc divides the memory into blocks of varying sizes and builds a free memory linked-list for each block size (step 318). The block sizes in the free memory linked- lists begin at IK and increase in an amount equal to double the size of a previous block. For example, IK, 2K, 4K, 8K, 16K, etc. Once the free memory linked-lists are created, smart-alloc creates the general access tree which includes head pointers to each of the free memory linked-lists (step 320). Initially, the fast access tree is empty. As a program executes and a series of memory requests are processed, the fast access tree is populated as discussed below.
Upon receiving a memory request from an executing thread (step 325), smart- alloc increments the value of a counter associated with the block size used to satisfy the request (step 330). Thus, if a thread requests 1026 bytes of memory and the free memory linked-lists include IK and 2K blocks, a reference to the 2K block will be returned to the requesting thread, and the value of the counter associated with the 2K free memory linked-list will be incremented. If this memory request is satisfied from the fast access tree (step 335), processing ends.
Otherwise, if the memory request is satisfied from the general access tree (step 340), then the counter associated with the block size used to satisfy the request is compared with the counter for block sizes pointed to by the fast access tree (step 370). Smart-alloc then determines whether the block size should be added to the free memory linked-list pointed to by the fast access tree step 375 because it includes memory blocks of a size most often requested by the executing program. In this step,
smart-alloc compares the value of the counter associated with a block size included in the general access tree with the value of the counter of a block size included in the fast access tree. If the counter value for the block in the general access tree is greater than the counter value for the block in the fast access tree, the pointer from the general access will be replaced with a pointer from the fast access tree. Additionally, the fast access tree pointer that points to the block size having the lowest counter value is replaced with the pointer from the general access tree (step 380). Changing the pointers in this manner ensures that the fast access tree continually points to the most frequently allocated block sizes, thereby increasing the efficiency of memory allocation. Otherwise, if the counter value associated with the block in the general access tree is not greater than the counter value of any of the free memory linked-lists pointed to by the fast access tree, processing ends.
If a memory request cannot be satisfied from either the general or fast access trees, smart-alloc requests additional memory from a system memory call (step 345). If the additional memory is available (step 350), a pointer to the amount of memory is returned to smart-alloc (step 355), the memory is divided into blocks that are added to the free memory linked-lists pointed to by a pointer from the general access tree (step 360), and processing continues to step 335. Otherwise, if the requested amount of memory is not available, the system memory call returns a null pointer to smart-alloc (step 365), and processing ends.
Fig. 4 depicts a flow diagram of operations performed by smart-alloc when a thread releases a reference to a block of memory. Upon receiving a reference to a block of memory from an executing thread (step 410), smart-alloc adds the reference to the appropriate free memory linked-list (step 430) and processing ends. Conclusion
Methods and systems operating in accordance with the principles of the present invention optimize the process of allocating memory to threads executing in programs operating in a data processing system by adapting the allocation process according to the behavior of an executing program. This smart-alloc function is a library function that may be linked to any program executing in a data processing system. As discussed above, smart-alloc operates in the user space and does not require accessing the operating system each time memory is allocated or deallocated.
These distributive and adaptive features of smart-alloc allow it to minimize the number of accesses to the operating system, a costly and time consuming event, and ultimately yields increased system performance.
Methods and systems consistent with the present invention are applicable to all single and multi-threaded programs written in all computer programming languages, including Fortran 77, Fortran 90, Java, C, and C++. Although maximum increases in efficiency will be realized in a multi-processor computing environment, methods and systems consistent with the present invention may also provide operational benefits in a single or multi-threaded, single processor environment.
Although the foregoing description has been described with reference to a specific implementation, those skilled in the art will know of various changes in form and detail which may be made without departing from the spirit and scope of the present invention as defined in the appended claims and the full scope of their equivalents.
Claims
1. A method in a data processing system for allocating memory by a memory allocation function, comprising the steps defined by the memory allocation function of: receiving a memory request for a reference to a block of memory; returning the reference to the block of memory to satisfy the request; and adjusting an operation of the memory allocation function based on the memory request.
2. The method of claim 1 , further including the step of forming a plurality of linked-lists referring to memory blocks of a common size.
3. The method of claim 2, wherein the step of returning includes the step of setting a fast access tree to refer to a first of the plurality of linked-lists.
4. The method of claim 3, further including a step of ensuring that the fast access tree refers to one of the plurality of linked-lists that is most frequently requested.
5. The method of claim 2, wherein the step of returning includes the step of setting a general access tree to refer to a second of the plurality of linked-lists.
6. A method in a data processing system for providing access to a memory that includes an operating system with a system memory call, the memory further including a program which includes a memory access function, comprising the steps performed by the memory access function of: requesting access to a portion of memory via the system memory call; receiving from the system memory call a pointer to the portion of memory; dividing the portion of memory into memory blocks, a plurality of the memory blocks being of different sizes; forming a plurality of linked-lists, each linked-list referring to memory blocks of a common size, each linked-list having an associated counter; setting a fast access tree to refer to a first of the plurality of linked-lists; setting a general access tree to refer to a second of the plurality of linked-lists; receiving a memory request; determining which among the plurality of linked-lists contains a memory block that will satisfy the memory request; incrementing the counter associated with the determined linked-list; returning a reference to the memory block on the determined linked-list; comparing the counters of the plurality of linked-lists to identify a predetermined number of linked-lists with a largest counter; and ensuring that the fast access tree is set to refer to the identified linked-lists with the largest counter.
7. A system for allocating memory, comprising: means for receiving a memory request for a reference to a block of memory; means for returning the reference to the block of memory to satisfy the request; and means for adjusting an operation of a memory access function based on the memory request.
8. A data processing system for providing access to memory, comprising: a memory including: a program including a memory access function that provides access to memory and that adjusts its operation according to a memory request for a reference to a block of memory; and a processor for executing the program.
9. The data processing system of claim 8, further including an operating system with a system memory function, and wherein the memory access function provides access to memory by utilizing the system memory function.
10. The data processing system of claim 8, wherein the memory access function includes a plurality of linked-lists referred to by a fast access tree.
11. The data processing system of claim 10, wherein the fast access tree refers to one of the plurality of linked-lists that is most frequently accessed.
12. The data processing system of claim 10, wherein a most frequently accessed memory block size is included in the fast access tree.
13. The data processing system of claim 8, wherein the memory access function includes a plurality of linked-lists referred to by a general access tree.
14. The data processing system of claim 13, wherein a least frequently accessed memory block size is included in the general access tree.
15. The data processing system of claim 8, further including a plurality of linked-lists, each linked-list referring to memory blocks of a common size.
16. The data processing system of claim 15, wherein each of the plurality of linked-lists has an associated counter indicating a number of times that the associated linked-list has been accessed.
17. A computer-readable medium including instructions for performing a method for allocating memory by a memory allocation function, the method comprising the steps performed by the memory allocation function of: receiving a memory request.for a reference to a block of memory; returning the reference to the block of memory to satisfy the request; and adjusting an operation of the memory allocation function based on the memory request.
18. The computer-readable medium of claim 15, further including instructions for forming a plurality of linked-lists referring to memory blocks of a common size.
19. The computer-readable medium of claim 18, wherein the instructions for returning include instructions for setting a fast access tree to refer to a first of the plurality of linked-lists.
20. The computer-readable medium of claim 19, further including instructions for inserting a most frequently accessed memory block size into the fast access tree.
21. The computer-readable medium of claim 19, further including instructions for ensuring that the fast access tree refers to one of the plurality of linked-lists that is most frequently requested.
22. The computer-readable medium of claim 18, wherein the instructions for returning include instructions for setting a general access tree to refer to a second of the plurality of linked-lists .
23. The computer-readable medium of claim 22, further including instructions for inserting a least frequently accessed memory block size into the general access tree.
Applications Claiming Priority (2)
Application Number | Priority Date | Filing Date | Title |
---|---|---|---|
US09/504,876 US7035989B1 (en) | 2000-02-16 | 2000-02-16 | Adaptive memory allocation |
US09/504,876 | 2000-02-16 |
Publications (1)
Publication Number | Publication Date |
---|---|
WO2001061498A1 true WO2001061498A1 (en) | 2001-08-23 |
Family
ID=24008086
Family Applications (1)
Application Number | Title | Priority Date | Filing Date |
---|---|---|---|
PCT/US2001/004682 WO2001061498A1 (en) | 2000-02-16 | 2001-02-14 | Adaptive memory allocation |
Country Status (2)
Country | Link |
---|---|
US (1) | US7035989B1 (en) |
WO (1) | WO2001061498A1 (en) |
Cited By (1)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
EP2284710A1 (en) * | 2009-08-04 | 2011-02-16 | Giesecke & Devrient GmbH | Method for managing storage resources in a portable data carrier |
Families Citing this family (20)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US7330956B1 (en) * | 2002-04-16 | 2008-02-12 | Emc Corporation | Bucket based memory allocation |
US8060680B2 (en) * | 2002-09-16 | 2011-11-15 | Hewlett-Packard Development Company, L.P. | Method of allocating memory |
JP4402565B2 (en) * | 2004-10-28 | 2010-01-20 | 富士通株式会社 | Virtual storage management program, method and apparatus |
US7379953B2 (en) * | 2005-02-22 | 2008-05-27 | International Business Machines Corporation | Systems and methods for resource-adaptive workload management |
US7809918B1 (en) * | 2005-07-22 | 2010-10-05 | American Megatrends, Inc. | Method, apparatus, and computer-readable medium for providing physical memory management functions |
US7752468B2 (en) * | 2006-06-06 | 2010-07-06 | Intel Corporation | Predict computing platform memory power utilization |
US7797508B2 (en) * | 2007-07-31 | 2010-09-14 | International Business Machines Corporation | Fair memory resource control for mapped memory |
US8839225B2 (en) | 2008-01-23 | 2014-09-16 | International Business Machines Corporation | Generating and applying patches to a computer program code concurrently with its execution |
US8108649B2 (en) * | 2008-06-13 | 2012-01-31 | International Business Machines Corporation | Method of memory management for server-side scripting language runtime system |
US9489405B2 (en) * | 2011-06-25 | 2016-11-08 | International Business Machines Corporation | Geometric array data structure |
US8924632B2 (en) * | 2011-09-16 | 2014-12-30 | Apple Inc. | Faster tree flattening for a system having non-volatile memory |
US9417881B2 (en) * | 2012-01-30 | 2016-08-16 | Nvidia Corporation | Parallel dynamic memory allocation using a lock-free pop-only FIFO |
CN103365720B (en) | 2012-03-28 | 2017-12-05 | 国际商业机器公司 | For dynamically adjusting the method and system of global Heap Allocation under multi-thread environment |
US9086957B2 (en) | 2012-08-02 | 2015-07-21 | International Business Machines Corporation | Requesting a memory space by a memory controller |
KR102146334B1 (en) * | 2013-01-17 | 2020-08-20 | 삼성전자 주식회사 | Method and system for dynamically changing page allocator |
US9189360B2 (en) * | 2013-06-15 | 2015-11-17 | Intel Corporation | Processor that records tracing data in non contiguous system memory slices |
US10229043B2 (en) | 2013-07-23 | 2019-03-12 | Intel Business Machines Corporation | Requesting memory spaces and resources using a memory controller |
CA2832571C (en) * | 2013-11-07 | 2021-01-12 | Ibm Canada Limited - Ibm Canada Limitee | Allocation aware heap fragmentation metrics |
US9710381B2 (en) | 2014-06-18 | 2017-07-18 | International Business Machines Corporation | Method and apparatus for cache memory data processing |
KR20210055339A (en) * | 2019-11-07 | 2021-05-17 | 에스케이하이닉스 주식회사 | Storage device and operating method thereof |
Citations (3)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
EP0703534A1 (en) * | 1994-09-19 | 1996-03-27 | Siemens Aktiengesellschaft | Computer memory management system |
US5742793A (en) * | 1991-12-18 | 1998-04-21 | Intel Corporation | Method and apparatus for dynamic memory management by association of free memory blocks using a binary tree organized in an address and size dependent manner |
WO1999010812A1 (en) * | 1997-08-22 | 1999-03-04 | Koninklijke Philips Electronics N.V. | Memory management with compaction of data blocks |
Family Cites Families (95)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
EP0138535A3 (en) | 1983-10-13 | 1987-01-28 | British Telecommunications Plc | Visual display logic simulation system |
US4685082A (en) | 1985-02-22 | 1987-08-04 | Wang Laboratories, Inc. | Simplified cache with automatic update |
US4812996A (en) | 1986-11-26 | 1989-03-14 | Tektronix, Inc. | Signal viewing instrumentation control system |
US5146593A (en) | 1989-03-06 | 1992-09-08 | International Business Machines Corporation | Procedure call interface |
EP0390339B1 (en) | 1989-03-29 | 1996-01-03 | Hewlett-Packard Company | Path measurement and analysis tool for evaluating the performance of software designs |
US5075847A (en) | 1989-05-26 | 1991-12-24 | Hewlett-Packard Company | Method and apparatus for computer program encapsulation |
WO1990014629A2 (en) | 1989-05-26 | 1990-11-29 | Massachusetts Institute Of Technology | Parallel multithreaded data processing system |
US5119465A (en) | 1989-06-19 | 1992-06-02 | Digital Equipment Corporation | System for selectively converting plurality of source data structures through corresponding source intermediate structures, and target intermediate structures into selected target structure |
US5274821A (en) | 1989-08-14 | 1993-12-28 | International Business Machines Corporation | Communication between prolog and an external process |
US5179702A (en) | 1989-12-29 | 1993-01-12 | Supercomputer Systems Limited Partnership | System and method for controlling a highly parallel multiprocessor using an anarchy based scheduler for parallel execution thread scheduling |
US5079707A (en) | 1990-01-19 | 1992-01-07 | The Boeing Company | Integrated certification-calibration system for a testing system having multiple test instruments |
US5073851A (en) | 1990-02-21 | 1991-12-17 | Apple Computer, Inc. | Apparatus and method for improved caching in a computer system |
US5325499A (en) | 1990-09-28 | 1994-06-28 | Tandon Corporation | Computer system including a write protection circuit for preventing illegal write operations and a write poster with improved memory |
JPH04137046A (en) | 1990-09-28 | 1992-05-12 | Toshiba Corp | Operating system for electronic computer |
US5297274A (en) | 1991-04-15 | 1994-03-22 | International Business Machines Corporation | Performance analysis of program in multithread OS by creating concurrently running thread generating breakpoint interrupts to active tracing monitor |
JPH0816877B2 (en) | 1991-06-10 | 1996-02-21 | インターナショナル・ビジネス・マシーンズ・コーポレイション | Method and system for real-time capture and reduction of resource data for data processing system |
JP3259969B2 (en) | 1991-07-09 | 2002-02-25 | 株式会社東芝 | Cache memory controller |
US5301312A (en) | 1991-08-21 | 1994-04-05 | International Business Machines Corporation | Method and system for utilizing benign fault occurrence to measure interrupt-blocking times |
CA2078315A1 (en) | 1991-09-20 | 1993-03-21 | Christopher L. Reeve | Parallel processing apparatus and method for utilizing tiling |
GB9123271D0 (en) | 1991-11-02 | 1991-12-18 | Int Computers Ltd | Data processing system |
US5438659A (en) | 1992-10-08 | 1995-08-01 | Hewlett-Packard Company | Object-action user interface management system |
US5390314A (en) | 1992-10-09 | 1995-02-14 | American Airlines, Inc. | Method and apparatus for developing scripts that access mainframe resources that can be executed on various computer systems having different interface languages without modification |
US5553235A (en) | 1992-10-23 | 1996-09-03 | International Business Machines Corporation | System and method for maintaining performance data in a data processing system |
US5353401A (en) | 1992-11-06 | 1994-10-04 | Ricoh Company, Ltd. | Automatic interface layout generator for database systems |
US5913223A (en) | 1993-01-25 | 1999-06-15 | Sheppard; Douglas Parks | Low power set associative cache memory |
US5535364A (en) | 1993-04-12 | 1996-07-09 | Hewlett-Packard Company | Adaptive method for dynamic allocation of random access memory to procedures having differing priorities based on first and second threshold levels of free RAM |
US5675790A (en) | 1993-04-23 | 1997-10-07 | Walls; Keith G. | Method for improving the performance of dynamic memory allocation by removing small memory fragments from the memory pool |
US5325533A (en) | 1993-06-28 | 1994-06-28 | Taligent, Inc. | Engineering system for modeling computer programs |
US5519866A (en) | 1993-06-28 | 1996-05-21 | Taligent, Inc. | Method and apparatus of incrementally linking components of a modeled computer program |
US5497458A (en) | 1993-07-06 | 1996-03-05 | Dell Usa, L.P. | Cache testability circuit for embedded diagnostics |
US5748961A (en) | 1993-07-12 | 1998-05-05 | Digital Equipment Corporation | Efficient method and apparatus for compiling and linking modules of computer code in a large software system |
US5500881A (en) | 1993-07-12 | 1996-03-19 | Digital Equipment Corporation | Language scoping for modular, flexible, concise, configuration descriptions |
GB9320982D0 (en) | 1993-10-12 | 1993-12-01 | Ibm | A data processing system |
US5450542A (en) | 1993-11-30 | 1995-09-12 | Vlsi Technology, Inc. | Bus interface with graphics and system paths for an integrated memory system |
US5845310A (en) | 1993-12-15 | 1998-12-01 | Hewlett-Packard Co. | System and methods for performing cache latency diagnostics in scalable parallel processing architectures including calculating CPU idle time and counting number of cache misses |
US5485619A (en) | 1993-12-29 | 1996-01-16 | International Business Machines Corporation | Array variable transformation system employing subscript table mapping to scalar loop indices |
US5636374A (en) | 1994-01-04 | 1997-06-03 | Intel Corporation | Method and apparatus for performing operations based upon the addresses of microinstructions |
US5539907A (en) | 1994-03-01 | 1996-07-23 | Digital Equipment Corporation | System for monitoring computer system performance |
US5640550A (en) | 1994-04-15 | 1997-06-17 | Coker; Drake | Computer system for generating SQL statements from COBOL code |
US5963975A (en) | 1994-04-19 | 1999-10-05 | Lsi Logic Corporation | Single chip integrated circuit distributed shared memory (DSM) and communications nodes |
US5710727A (en) | 1994-05-04 | 1998-01-20 | National Instruments Corporation | System and method for creating resources in an instrumentation system |
CA2147036A1 (en) | 1994-05-16 | 1995-11-17 | Yih-Farn Robin Chen | System and method for selective regression testing |
US5724262A (en) | 1994-05-31 | 1998-03-03 | Paradyne Corporation | Method for measuring the usability of a system and for task analysis and re-engineering |
US5574922A (en) | 1994-06-17 | 1996-11-12 | Apple Computer, Inc. | Processor with sequences of processor instructions for locked memory updates |
US5613063A (en) | 1994-07-01 | 1997-03-18 | Digital Equipment Corporation | Method and apparatus for checking validity of memory operations |
US5689712A (en) | 1994-07-27 | 1997-11-18 | International Business Machines Corporation | Profile-based optimizing postprocessors for data references |
US6006031A (en) | 1994-10-07 | 1999-12-21 | Tandem Computers Incorporated | Method and apparatus for reconciling conflicting translations by factoring and parameterizing differences |
US5745897A (en) | 1994-11-21 | 1998-04-28 | Bay Networks Group, Inc. | Method and system for compiling management information base specifications |
US5740433A (en) | 1995-01-24 | 1998-04-14 | Tandem Computers, Inc. | Remote duplicate database facility with improved throughput and fault tolerance |
US5675802A (en) | 1995-03-31 | 1997-10-07 | Pure Atria Corporation | Version control system for geographically distributed software development |
US5920895A (en) | 1995-04-24 | 1999-07-06 | Microsoft Corporation | Mapped file input/output with delayed zeroing |
US5696937A (en) | 1995-04-28 | 1997-12-09 | Unisys Corporation | Cache controller utilizing a state machine for controlling invalidations in a network with dual system busses |
US5581696A (en) | 1995-05-09 | 1996-12-03 | Parasoft Corporation | Method using a computer for automatically instrumenting a computer program for dynamic debugging |
US6101525A (en) | 1995-05-19 | 2000-08-08 | Emc Corporation | Method and apparatus for shared memory cleanup |
US5812799A (en) | 1995-06-07 | 1998-09-22 | Microunity Systems Engineering, Inc. | Non-blocking load buffer and a multiple-priority memory system for real-time multiprocessing |
US5737547A (en) | 1995-06-07 | 1998-04-07 | Microunity Systems Engineering, Inc. | System for placing entries of an outstanding processor request into a free pool after the request is accepted by a corresponding peripheral device |
JP3051972B2 (en) | 1995-08-24 | 2000-06-12 | 日本アイ・ビー・エム株式会社 | Communication method between processors of parallel computer |
US6016474A (en) | 1995-09-11 | 2000-01-18 | Compaq Computer Corporation | Tool and method for diagnosing and correcting errors in a computer program |
US5774724A (en) | 1995-11-20 | 1998-06-30 | International Business Machines Coporation | System and method for acquiring high granularity performance data in a computer system |
US5784698A (en) | 1995-12-05 | 1998-07-21 | International Business Machines Corporation | Dynamic memory allocation that enalbes efficient use of buffer pool memory segments |
US5734822A (en) | 1995-12-29 | 1998-03-31 | Powertv, Inc. | Apparatus and method for preprocessing computer programs prior to transmission across a network |
US5850554A (en) | 1995-12-29 | 1998-12-15 | Intel Corporation | Compiler tool set for efficiently generating and easily managing multiple program versions of different types |
US5805795A (en) | 1996-01-05 | 1998-09-08 | Sun Microsystems, Inc. | Method and computer program product for generating a computer program product test that includes an optimized set of computer program product test cases, and method for selecting same |
US5867649A (en) | 1996-01-23 | 1999-02-02 | Multitude Corporation | Dance/multitude concurrent computation |
US5740431A (en) | 1996-01-24 | 1998-04-14 | Electronic Data Systems Corporation | Configuration file management |
AU722149B2 (en) | 1996-02-29 | 2000-07-20 | Bt Financial Group Pty Limited | Determination of software functionality |
JPH09259153A (en) | 1996-03-19 | 1997-10-03 | Mitsubishi Electric Corp | Device and method for generating batch execution control program |
US5748892A (en) | 1996-03-25 | 1998-05-05 | Citrix Systems, Inc. | Method and apparatus for client managed flow control on a limited memory computer system |
US5970510A (en) | 1996-04-10 | 1999-10-19 | Northrop Grumman Corporation | Distributed memory addressing system |
US5860024A (en) | 1996-04-15 | 1999-01-12 | Advanced Micro Devices, Inc. | Microprocessor with automatic name generation including performance indication |
US5978892A (en) | 1996-05-03 | 1999-11-02 | Digital Equipment Corporation | Virtual memory allocation in a virtual address space having an inaccessible gap |
US5787480A (en) | 1996-07-17 | 1998-07-28 | Digital Equipment Corporation | Lock-up free data sharing |
US5890171A (en) | 1996-08-06 | 1999-03-30 | Microsoft Corporation | Computer system and computer-implemented method for interpreting hypertext links in a document when including the document within another document |
US6101325A (en) | 1996-10-10 | 2000-08-08 | Microsoft Corporation | Parameterized packaging system for programming languages |
US5905488A (en) | 1996-10-11 | 1999-05-18 | Xerox Corporation | Local inking with gray pixels |
JPH10124325A (en) | 1996-10-25 | 1998-05-15 | Toshiba Corp | Method and device for optimum arrangement of variable, and computer-readable recording medium stored with optimum arrangement program for variable |
JPH10177560A (en) | 1996-12-17 | 1998-06-30 | Ricoh Co Ltd | Storage device |
US5857097A (en) | 1997-03-10 | 1999-01-05 | Digital Equipment Corporation | Method for identifying reasons for dynamic stall cycles during the execution of a program |
US5835705A (en) | 1997-03-11 | 1998-11-10 | International Business Machines Corporation | Method and system for performance per-thread monitoring in a multithreaded processor |
US6049855A (en) | 1997-07-02 | 2000-04-11 | Micron Electronics, Inc. | Segmented memory system employing different interleaving scheme for each different memory segment |
US5991708A (en) | 1997-07-07 | 1999-11-23 | International Business Machines Corporation | Performance monitor and method for performance monitoring within a data processing system |
US6044438A (en) | 1997-07-10 | 2000-03-28 | International Business Machiness Corporation | Memory controller for controlling memory accesses across networks in distributed shared memory processing systems |
US5872977A (en) | 1997-08-08 | 1999-02-16 | International Business Machines Corporation | Object-oriented method and apparatus for creating a makefile |
US5974536A (en) | 1997-08-14 | 1999-10-26 | Silicon Graphics, Inc. | Method, system and computer program product for profiling thread virtual memory accesses |
US5991893A (en) | 1997-08-29 | 1999-11-23 | Hewlett-Packard Company | Virtually reliable shared memory |
US5987479A (en) | 1997-09-24 | 1999-11-16 | Sony Corporation, Inc. | Large block allocation for disk-based file systems |
US6072951A (en) | 1997-10-15 | 2000-06-06 | International Business Machines Corporation | Profile driven optimization of frequently executed paths with inlining of code fragment (one or more lines of code from a child procedure to a parent procedure) |
US6065019A (en) | 1997-10-20 | 2000-05-16 | International Business Machines Corporation | Method and apparatus for allocating and freeing storage utilizing multiple tiers of storage organization |
US6088771A (en) | 1997-10-24 | 2000-07-11 | Digital Equipment Corporation | Mechanism for reducing latency of memory barrier operations on a multiprocessor system |
US6018793A (en) | 1997-10-24 | 2000-01-25 | Cirrus Logic, Inc. | Single chip controller-memory device including feature-selectable bank I/O and architecture and methods suitable for implementing the same |
US5974510A (en) | 1997-10-31 | 1999-10-26 | Advanced Micro Devices, Inc. | Method for testing the non-cacheable region functioning of a cache memory controller |
US6066181A (en) | 1997-12-08 | 2000-05-23 | Analysis & Technology, Inc. | Java native interface code generator |
US6098169A (en) | 1997-12-23 | 2000-08-01 | Intel Corporation | Thread performance analysis by monitoring processor performance event registers at thread switch |
US6014517A (en) | 1998-01-06 | 2000-01-11 | Emc Corporation | Automatic creation of C to assembler interface |
US6077312A (en) | 1998-05-06 | 2000-06-20 | International Business Machines Corporation | Apparatus, program product and method of debugging utilizing a context sensitive breakpoint |
-
2000
- 2000-02-16 US US09/504,876 patent/US7035989B1/en not_active Expired - Lifetime
-
2001
- 2001-02-14 WO PCT/US2001/004682 patent/WO2001061498A1/en active Application Filing
Patent Citations (3)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US5742793A (en) * | 1991-12-18 | 1998-04-21 | Intel Corporation | Method and apparatus for dynamic memory management by association of free memory blocks using a binary tree organized in an address and size dependent manner |
EP0703534A1 (en) * | 1994-09-19 | 1996-03-27 | Siemens Aktiengesellschaft | Computer memory management system |
WO1999010812A1 (en) * | 1997-08-22 | 1999-03-04 | Koninklijke Philips Electronics N.V. | Memory management with compaction of data blocks |
Non-Patent Citations (1)
Title |
---|
"CACHING OBJECTS IN A DATA SPACE", IBM TECHNICAL DISCLOSURE BULLETIN,IBM CORP. NEW YORK,US, vol. 37, no. 10, 1 October 1994 (1994-10-01), pages 587 - 590, XP000475787, ISSN: 0018-8689 * |
Cited By (1)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
EP2284710A1 (en) * | 2009-08-04 | 2011-02-16 | Giesecke & Devrient GmbH | Method for managing storage resources in a portable data carrier |
Also Published As
Publication number | Publication date |
---|---|
US7035989B1 (en) | 2006-04-25 |
Similar Documents
Publication | Publication Date | Title |
---|---|---|
US7035989B1 (en) | Adaptive memory allocation | |
US6209066B1 (en) | Method and apparatus for memory allocation in a multi-threaded virtual machine | |
US6065019A (en) | Method and apparatus for allocating and freeing storage utilizing multiple tiers of storage organization | |
US6427195B1 (en) | Thread local cache memory allocator in a multitasking operating system | |
US5692185A (en) | Object space manager method and circuit | |
US5819304A (en) | Random access memory assembly | |
US6341338B1 (en) | Protocol for coordinating the distribution of shared memory | |
US5802341A (en) | Method for the dynamic allocation of page sizes in virtual memory | |
US6058460A (en) | Memory allocation in a multithreaded environment | |
US5651136A (en) | System and method for increasing cache efficiency through optimized data allocation | |
US6785888B1 (en) | Memory allocator for a multiprocessor computer system | |
US6848033B2 (en) | Method of memory management in a multi-threaded environment and program storage device | |
US6363468B1 (en) | System and method for allocating memory by partitioning a memory | |
US5797004A (en) | System and method for caching and allocating thread synchronization constructs | |
US8271550B2 (en) | Memory piece categorization | |
US7624246B2 (en) | Method and system for memory allocation in a multiprocessing environment | |
US6353829B1 (en) | Method and system for memory allocation in a multiprocessing environment | |
US6401182B1 (en) | Method and apparatus for memory management | |
CN111984425B (en) | Memory management method, device and equipment for operating system | |
US20070180002A1 (en) | Method and apparatus for reducing object pre-tenuring overhead in a generational garbage collector | |
US20220269675A1 (en) | Hash-based data structure | |
WO2001061471A2 (en) | An implementation for nonblocking memory allocation | |
KR100315500B1 (en) | Memory allocating method | |
CN117311997B (en) | Memory management method and device of computing chip and computing chip | |
Bassen et al. | Return of an object in two-stack dynamic memory |
Legal Events
Date | Code | Title | Description |
---|---|---|---|
AL | Designated countries for regional patents |
Kind code of ref document: A1 Designated state(s): AT BE CH CY DE DK ES FI FR GB GR IE IT LU MC NL PT SE TR |
|
121 | Ep: the epo has been informed by wipo that ep was designated in this application | ||
DFPE | Request for preliminary examination filed prior to expiration of 19th month from priority date (pct application filed before 20040101) | ||
122 | Ep: pct application non-entry in european phase |