Class / Patent application number | Description | Number of patent applications / Date published |
707206000 | Garbage collection | 84 |
20080201393 | IDENTIFYING UNNECESSARY SYNCHRONIZATION OBJECTS IN SOFTWARE APPLICATIONS - Methods and apparatus, including computer program products, for identifying unnecessary synchronization objects in software applications. A computer-implemented method for determining a usefulness of synchronization objects includes, in a multi-threaded application program, tracking threads as they are created and terminated, intercepting application program interfaces (APIs) used to create and destroy thread synchronization objects, in the API wrappers, tracking existing synchronization objects in a list, and associating a list entry for each of the synchronization objects with a unique bit in a bit field. | 08-21-2008 |
20080208937 | IMAGE INPUT APPARATUS AND INFORMATION REGISTRATION METHOD - A disclosed image input apparatus is connected via a network to one or more information processing apparatuses and is capable of registering multiple service entries at once according to a registration request sent from any one of the information processing apparatuses. The disclosed image input apparatus includes a service entry storage space; a service entry area reservation unit configured to reserve service entry areas in the service entry storage space; and a service entry update unit configured to register the service entries in the reserved service entry areas if available and to register the service entries in non-reservation areas of the service entry storage space if the reserved service entry areas are not available. | 08-28-2008 |
20080208938 | Distributed Database System Providing Data and Space Management Methodology - A distributed database system providing data and space management methodology. In a distributed system comprising a plurality of servers sharing access to data pages, a method for setting a timestamp indicating when modifications to data pages are made in a non-regressing fashion comprises steps of: maintaining a local sequence at each server and an allocation page timestamp on an allocation page; upon allocation of a data page, applying a timestamp to the data page which is greater than the allocation page timestamp; upon modification of a given data page at a particular server, setting the timestamp on the given data page to the greater of the local sequence at the particular server and an existing timestamp already on the given data page; and when data pages are deallocated, adjusting the allocation page timestamp to a value greater than the timestamp value on any deallocated data page. | 08-28-2008 |
20080215648 | EFFICIENT PARALLEL BITWISE SWEEP DURING GARBAGE COLLECTION - A method, system, and program for efficient parallel bitwise sweeps of larger objects during garbage collection are provided. During a bitwise sweep, a helper thread scans a mark vector looking for a consecutive sequence of unmarked bits of a sufficient length following a marked bit. Once a consecutive sequence of unmarked bits of a sufficient length following a marked bit is detected, the helper thread fetches the size of a marked object corresponding to the marked bit. If the size of the marked object exceeds a size represented by the consecutive sequence of unmarked bits, the remainder of the bits representing the marked object are skipped, such that once a marked object is identified as potentially exceeding an object fetch threshold the helper thread efficiently skips the remainder of the bits represents the marked object and continues scanning for a number of consecutive zeroes indicating free space. | 09-04-2008 |
20080215649 | SYSTEM FOR DETECTING PROGRAM PHASES WITH PERIODIC CALL-STACK SAMPLING DURING GARBAGE COLLECTION - A system for associating a phase with an activation of a computer program that supports garbage collection include: a plurality of stacks, each stack including at least one stack frame that includes an activation count; and a processor with logic for performing steps of: zeroing the activation count whenever the program creates a new stack frame and after garbage collection is performed; determining whether an interval has transpired during program execution; examining each stack frame's content and incrementing the activation count for each frame of the stacks once the interval has transpired; detecting the phase whose activation count is non-zero and associating the phase with the activation; and ensuring that when the phase ends, an action is immediately performed. | 09-04-2008 |
20080222224 | System and Method of Identification of Dangling Pointers - A method and system to identifying the use of dangling pointers in software instrumentation irrespective of the location of the pointer in the memory. The main memory is preferably segmented into three parts defined as a first memory, a version segment and a pointer version segment. By use of the version segment and pointer version stored in the pointer version segment, checksum are made on a pointer version with a version on dereferencing a pointer in the first memory to identify references to a dangling pointer on negative determination. Identified dangling pointer may be reported to the end user. | 09-11-2008 |
20080222225 | AUTONOMIC RETENTION CLASSES - The embodiments of the invention provide methods, computer program products, etc. for autonomic retention classes when retaining data within storage devices. More specifically, a method of determining whether to retain data within at least one storage device begins by storing data items in at least one storage device. Furthermore, the method maintains access statistics for each of the data items, an age of each of the data items, and an administrator-defined importance value of each of the data items. Following this, a retention value is calculated for each of the data items based on the access statistics for each of the data items, the age of each of the data items, and the administrator-defined importance value of each of the data items. | 09-11-2008 |
20080235305 | Dense prefix generation for garbage collection - A technique for establishing a dense prefix for a memory in a computer system. Memory is divided into a plurality of chunks. An efficiency factor is generated for each chunk in one or more chunks contained in the plurality of chunks. The efficiency factor may be based on an amount of memory to be reclaimed, an amount of memory to be scanned and an amount of memory to be copied relative to the chunk. A dense prefix is then established for the memory based on an efficiency factor associated with a chunk. | 09-25-2008 |
20080235306 | GARBAGE COLLECTION IN NONVOLATILE MEMORIES USING DATA ATTRIBUTES, COMPUTER PROGRAM PRODUCTS AND METHODS OF OPERATING THE SAME - A garbage collection apparatus of a nonvolatile memory can include a first-block management module that is configured to manage a plurality of first blocks, where each of the first blocks includes at least one respective invalid page of the nonvolatile memory. A second-block management module is configured to manage a plurality of second blocks to be allocated for storing data and/or metadata in the nonvolatile memory and is further configured to perform garbage collection for the nonvolatile memory. A control module is configured to allocate ones of the second blocks to respective ones of the first blocks according to when the at least one respective invalid page in each of the first blocks was generated or used. | 09-25-2008 |
20080235307 | LOCALITY WITH PARALLEL HIERARCHICAL COPYING GARBAGE COLLECTION - Disclosed is a garbage collection algorithm that achieves hierarchical copy order with parallel garbage collection threads. More specifically, the present invention provides a garbage collection method and system for copying objects from a from-space to a to-space. The method comprises the steps of (a) having multiple threads that simultaneously perform work for garbage collection (GC), (b) examining the placement of objects on blocks, and (c) changing the placement of objects on blocks based on step (b). Preferably, the method includes the additional step of calculating a placement of object(s) based on step (b), and using the result of the calculation for step (c). For example, the calculation may be used to increase the frequency of intra-block pointers and/or to increase the frequency of siblings on the same block. | 09-25-2008 |
20080235308 | LOCALITY WITH PARALLEL HIERARCHICAL COPYING GARBAGE COLLECTION - Disclosed is a garbage collection algorithm that achieves hierarchical copy order with parallel garbage collection threads. More specifically, the present invention provides a garbage collection method and system for copying objects from a from-space to a to-space. The method comprises the steps of (a) having multiple threads that simultaneously perform work for garbage collection (GC), (b) examining the placement of objects on blocks, and (c) changing the placement of objects on blocks based on step (b). Preferably, the method includes the additional step of calculating a placement of object(s) based on step (b), and using the result of the calculation for step (c). For example, the calculation may be used to increase the frequency of intra-block pointers and/or to increase the frequency of siblings on the same block. | 09-25-2008 |
20080235309 | Concurrent Collection of Cyclic Garbage in Reference Counting Systems - The present invention provides techniques that allow concurrent collection of cyclic garbage on reference counting systems. In general, candidate objects are found that may be part of cyclic garbage. Each candidate object has a reference count. Two tests are performed to determine if concurrent operations have affected the reference counts of the candidate objects. If concurrent operations have not affected the reference counts, the candidate objects are collected as garbage. Additionally, during garbage collection, the decrements to reference counts are delayed so that increments occur before decrements and so that decrements are held a predetermined time before being applied. This prevents decrementing a reference and collecting a cycle as garbage right before a reference is added to an object in the cycle | 09-25-2008 |
20080243965 | COOPERATIVE DLL UNLOAD - Loading and unloading a plurality of libraries on a computing device having a loader lock and internal and external counts for each library in the plurality of libraries is disclosed. The libraries assume an initialize state, followed by an initialized state, a pending unload state, and an unload state according to when the internal and external counts are incremented and decremented. When in the pending unload state, the functions of a library that include functions that require acquiring the loader lock exit, the internal count is decremented by one, and the loader lock is released. Prior to entering the pending unload state, a library may be placed into a reloadable state. A library in the reloadable state may be reloaded upon request until a timer times out. When the timer times out, the library in the reloadable state transitions into the pending unload state. | 10-02-2008 |
20080243966 | SYSTEM AND METHOD FOR MANAGING TEMPORARY STORAGE SPACE OF A DATABASE MANAGEMENT SYSTEM - A method and system to manage temporary storage space of a relational database management system by receiving a data segment allocation request from an application, allocating a data segment to the application, marking the data segment as allocated in a space map page, and indicating a usage status of the data segment. The method also includes receiving a mass delete command from the application, indicating reception of the mass delete command in a table-related control block, and marking the data segment as unavailable in the space map page. The method may also include indicating reception of the mass delete commit command in the table-related control block to enable the application to reuse the data segment. | 10-02-2008 |
20080243967 | Duplicate record processing - Duplicate record processing is enabled employing on customizable rules. Detected duplicate records are merged, deleted, deactivated, or moved based on one or more sets of customizable rules. Different rule sets may be used for each record type, or a rule set reused for different records. Hierarchical relationships between master and child records are adjusted upon duplicate processing based on rules and/or record attributes. | 10-02-2008 |
20080243968 | Method and system for object age detection in garbage collection heaps - A system and method are provided for object age detection in garbage collection heaps. In one embodiment, ages of objects in a garbage collection heap at a first virtual machine at a server are determined by detecting a number of garbage collections each object has survived. An age is associated to each object according to the determined ages. The objects are grouped in age ranges, wherein the age ranges correspond to the determined ages. The age ranges are communicated to a second virtual machine at a client. | 10-02-2008 |
20080243969 | Method and system for customizing allocation statistics - A system and method are provided to customize allocation statistics. In one embodiment, a tag is associated to one or more threads to receive allocation statistic information relating to the one or more tagged threads, the one or more threads are tagged prior to performing an allocation statistic session. The allocation statistic session is performed via a plurality of threads at a first virtual machine at a server. A plurality of threads performing the allocation statistic session includes the one or more tagged threads is determined. The allocation statistic information relating to the one or more tagged threads is extracted, if the plurality of threads includes the one or more tagged threads. | 10-02-2008 |
20080243970 | Method and system for providing loitering trace in virtual machines - A system and method are provided for performing loitering trace in virtual machines. In one embodiment, status of objects in a garbage collection heap at a first virtual machine at a server is identified, in response to a memory leak. First objects that are used are identified. Second objects that are alive and not being used are identified. Information regarding the first objects and the second objects is communicated to a second virtual machine at a client. | 10-02-2008 |
20080250088 | Concurrent evacuation of the young generation - The invention relates to a method for performing generational garbage collection on a heap comprising a plurality of generations. The method involves dividing a young generation of the heap into a first young generation and a second young generation, evacuating the first young generation concurrently with allocating the second young generation, and evacuating the second young generation concurrently with allocating the first young generation and subsequent to fully evacuating the first young generation. | 10-09-2008 |
20080250089 | IMPROVING LOCALITY WITH PARALLEL HIERARCHICAL COPYING GARBAGE COLLECTION - Disclosed is a garbage collection algorithm that achieves hierarchical copy order with parallel garbage collection threads. More specifically, the present invention provides a garbage collection method and system for copying objects from a from-space to a to-space. The method comprises the steps of (a) having multiple threads that simultaneously perform work for garbage collection (GC), (b) examining the placement of objects on blocks, and (c) changing the placement of objects on blocks based on step (b). Preferably, the method includes the additional step of calculating a placement of object(s) based on step (b), and using the result of the calculation for step (c). For example, the calculation may be used to increase the frequency of intra-block pointers and/or to increase the frequency of siblings on the same block. | 10-09-2008 |
20080256149 | SYSTEM AND METHOD FOR DEPENDENT FAILURE-AWARE ALLOCATION OF DISTRIBUTED DATA-PROCESSING SYSTEMS - A system and method for allocating distributed processing systems includes inputting component descriptions in a distributed processing system and determining importance of each component. Capacity and failure characteristics of resource groups representing units of available processing capacity are also input. Components are assigned to a plurality of resource groups based on the capacity. Each resource group includes components where the failure characteristics permit simultaneous failures, such that in the event of such failures, an output value of the application is maximized. | 10-16-2008 |
20080263114 | EFFICIENT ACCESS OF FLASH DATABASES - Techniques for efficient access to flash databases are described. In one implementation, a method includes performing an operation on a flash database, supplementing at least one portion of a node translation table corresponding to at least one node involved in the operation, and semantically compressing at least one portion of the node translation table. The semantic compression includes discarding at least one log entry that is rendered obsolete by at least one subsequent log entry, and incrementing a version number of the log entries corresponding to the at least one portion of the node translation table. In further embodiments, discarding at least one log entry includes discarding at least one log entry that is at least one of opposed by or overruled by at least one subsequent log entry. | 10-23-2008 |
20080281885 | Interleaved garbage collections - An automated memory management or garbage collection routine uses a first garbage collection routine to perform garbage collection on new objects, and a second garbage collection routine to perform garbage collection on old objects. The two garbage collection routines are operated concurrently, with each routine separately marking objects to be reclaimed. The second routine may operate in a background mode by traversing a tree of objects from a copy of memory, while the first routine may operate on actual memory. | 11-13-2008 |
20080281886 | Concurrent, lock-free object copying - Described is a technology by which a real-time data relocating mechanism is provided for multiprocessing environments, including supporting lock-free programs that run in parallel. The relocating mechanism moves an object by using a status field related to the data field, possibly in an interim (wide) object space, which is then copied to a to-space object. The status information for each data field of the original object contains information indicating where a current version of the data for each field is present, that is, in the original, wide or to-space object. In one example, a handshake mechanism of a garbage collector establishes preparation and copy phases between the mechanism and other threads that determine where memory accesses occur. Also described is support for program thread compare-and-swap (CAS) operations and/or multi-word atomic operations. | 11-13-2008 |
20080281887 | Application specific garbage collection system - On a platform or virtual machine, a system and method is provided that allows an application to implement its own Garbage Collection (GC) utility that can be designed and tuned for the specific application. The GC utility can be bundled with the application, and can be installed on the platform as necessary along with the application. When the application is activated, the specific GC utility is also activated. Such specific GC utility can provide improvements in performance. The present invention may be used on any type of platform, such as a Java platform, and any type of hardware such as mobile devices. | 11-13-2008 |
20080281888 | System and method for concurrent compacting self pacing garbage collection using loaded value and access barriers - A method, system, and computer program product for managing a heap of memory allocated to a program being executed on a data processing system is disclosed. A limited amount of memory is allocated to a program being executed by a mutator on a data processing system. The memory comprises memory objects. The disclosed method identifies memory objects, which are allocated to the program but are not referenced anymore. These dead memory objects are freed and made available for further allocation in the program. The memory objects that are still referenced are organized in compact contiguous blocks. Thus, the disclosed method recycles memory allocated to the program. The disclosed method is executed iteratively and concurrently with the execution of the program. The disclosed method does not interfere with program execution. Amount of memory required is specified before the commencement of the disclosed method and the same amount is freed without any surplus. | 11-13-2008 |
20080301207 | Systems and methods for cascading destruction of electronic data in electronic evidence management - Systems and methods are provided for managing the destruction of documents in an organization that includes a cascaded destruction of the documents in distributed systems. The systems and methods include capturing electronic evidence in a central evidence management system as objects from sources in the distributed systems. The objects are stored in a repository. When documents are eligible to be deleted, the central evidence management system destroys the objects representing the documents in the repository. A delete command is sent to agents at the sources in the distributed system that causes the agents to delete and destroy the documents from the file systems in the distributed systems. | 12-04-2008 |
20090006505 | System and Method for Managing Memory - A method that allows use of a memory page dirty bit by a number of modules. | 01-01-2009 |
20090006506 | METHOD AND SYSTEM FOR GARBAGE COLLECTION OF NATIVE RESOURCES - A system and method for enabling automatic and fast garbage collection of native resources. Native code of mixed-language components is directed to perform dynamic allocation of native entities (such as objects, structures, etc.) through a Native Entity Factory (NEF) component instead of using low-level native language operators. Using the NEF component enables tracing dynamic native entity allocations, and driving a virtual machine garbage collector component based on native-heap activity. | 01-01-2009 |
20090006507 | System and method for ordering reclamation of unreachable objects - The present invention is a method and system for ordering reclamation of unreachable objects in a garbage collection system. After unreachable objects are determined, they are given a chance to declare dependence relationships. The system then determines zero-depended objects based on these declarations and destructs zero-depended objects. After destruction, their dependence relationships are removed or ignored by the system. By repeating destructing zero-depended objects, objects are destructed in an order that meet up the requirement from dependence declarations of application program. Therefore, it guarantees safety for destructors to use/access other unreachable objects. | 01-01-2009 |
20090013017 | Methods, Systems, and Computer Program Products for Optimizing Virtual Machine Memory Consumption - A method, system, and computer program product for optimizing virtual machine (VM) memory consumption are provided. The method includes monitoring VM accesses to a plurality of objects in a heap, and identifying a dead object among the objects in the heap. The method also includes copying the dead object to a data storage device as a serialized object, and replacing the dead object in the heap with a loader object. The loader object is smaller than the dead object and includes a reference to the serialized object. | 01-08-2009 |
20090024679 | APPARATUS, SYSTEM, AND METHOD FOR IMPROVING SYSTEM PERFORMANCE IN A LARGE MEMORY HEAP ENVIRONMENT - A memory management system is disclosed having a first memory heap module that assigns newly created objects to a first memory category and assigns persistent objects to a second memory category. The memory management system further assigns infrequently accessed persistent objects to a third memory category. A garbage collecting module collects garbage on objects in the first and second memory categories, but does not access objects in the third memory category. An operating system pages inactive objects assigned to the third memory category to a stable store. A user can debug the system, checking how many objects are assigned to the third memory category, and how many objects assigned to the third memory category are not accessed after initial allocation. Objects can be assigned to the third memory category based on selected criteria including time since access, likelihood of future object access, object size, and object priority. | 01-22-2009 |
20090030958 | Extended garbage collection - Extended garbage collection is disclosed. It is determined, based at least in part on data stored in a data structure accessible to the respective garbage collecting entity of each of a plurality of runtime systems, that a local object is associated with one or more external objects. The local object is retained, even if the local object has been determine to be unreachable locally in a local runtime system with which the local object is associated, if at least one of said one or more external objects has been determined to be reachable within an external runtime environment with which the at least one external object is associated. | 01-29-2009 |
20090030959 | Associative references in a garbage collected programming environment - Associative references in a garbage collected programming environment is disclosed. An indication that an object is not reachable from any root object. The object is kept alive if it is determined by a garbage collection process, based at least in part on data other than data comprising the object or managed by an application with which the object is associated, that the object is associated with at least one other object that has been determined to be reachable. | 01-29-2009 |
20090037500 | Storing nodes representing respective chunks of files in a data store - To provide a data store, nodes representing respective chunks of files are stored in a predefined structure that defines relationships among the nodes, where the files are divided into the chunks. The nodes are collected into plural groups stored in persistent storage, where some of the nodes are collected into a particular one of the groups according to a locality relationship of the some of the nodes. | 02-05-2009 |
20090037501 | METHOD AND SYSTEM FOR MANAGING MEMORY FOR A PROGRAM USING AREA - If garbage collection is executed in every thread-local heap in order to secure processing responsiveness, a memory area may be fragmented or collectable areas may be reduced as the program execution proceeds. To overcome such problems, memory is divided into an area where thread specific data is allocated and an area where referenceable data from other threads is allocated, and is managed separately. More specifically, data that is referenced specifically by each thread is allocated to a thread-local heap, while data that is referenced from other threads is allocated to a global heap. | 02-05-2009 |
20090037502 | OBJECT ORIENTED BASED METHODOLOGY FOR MODELING BUSINESS FUNCTIONALITY FOR ENABLING IMPLEMENTATION IN A WEB BASED ENVIRONMENT - A computer method and apparatus defining Business Classes for modeling business activities comprising the steps of representing business activities as the interaction between one or more Business Classes, and entering into a computer and storing in an electronic format the Business Classes and the relationships existing between the Business Classes. | 02-05-2009 |
20090049110 | APPARATUS AND SYSTEM FOR REORGANIZING A SET OF DATABASE PARTITIONS - An apparatus and system are disclosed for reorganizing a set of database partitions based on a ranked set of database partitions. The apparatus includes an evaluation module to determine a fragmentation indicator for each database partition within a set of database partitions. A ranking module ranks the set of database partitions according to a rank criteria. The rank criteria includes, at a minimum, the fragmentation indicator. A reorganization module reorganizes a subset of the database partitions in the ranked set of database partitions. The subset is selected, at least in part, by a rank order for the ranked set of database partitions. The subset may be selected such that ranked database partitions satisfying a dynamic reorganization threshold are included in the subset. | 02-19-2009 |
20090063594 | COMPUTER SYSTEM MEMORY MANAGEMENT - The number of CPU cycles required to reclaim object memory space in a memory management process is reduced by using a two phase approach. A data structure exists for each object that is to be loaded into object memory space. One part of the data structure is the object definition. The other part is a MM (Memory Management) immunity annotation or value that controls the frequency with which the object must actually be examined to determine if it is suitable for reclamation. On each iteration of the memory management process, the object's MM immunity value is tested to determine whether it is greater than a predetermined threshold. If greater than the threshold, the value is decremented, but the object is not actually examined for its suitability for removal. If the value equals the threshold, the object itself is examined. If it is found to be suitable, it is removed to reclaim the object memory space it previously occupied, If it is actually examined but is found not to be suitable for removal, the MM immunity value is reset to its original value or is otherwise adjusted to prevent examination of the object for a certain number of future iterations of the memory management process. | 03-05-2009 |
20090063595 | METHOD AND APPARATUS FOR UPDATING REFERENCES TO OBJECTS IN A GARBAGE COLLECTION OPERATION - The illustrative embodiments described herein provide a computer-implemented method, apparatus, and computer program product for updating references to objects. The process identifies a set of references associated with a set of live objects at a garbage collection safe point in response to detecting the garbage collection safe point. The set of live objects are at a set of first locations in a storage device. The process updates the set of references such that the set of references refer to a set of second locations of the set of live object in response to detecting a garbage collection operation. The set of second locations is in the storage device. | 03-05-2009 |
20090063596 | BACKUP DATA ERASURE METHOD - According to this invention, a computer system has a host computer, a first storage subsystem providing a first volume, a second storage subsystem providing a second volume for storing a copy of data stored in the first volume. The computer system stores copy configuration information including correspondence between the first volume and the second volume. The management computer transmits the data erasure request to the first storage subsystem upon reception of a first data erasure request for erasing the first volume. The first storage subsystem stops a copying process of data stored in the first volume to the second volume, transmits a second data erasure request for erasing the second volume to the second storage subsystem, and erases the data stored in the first volume. Thus, in the case of erasing data stored in a storage area, corresponding data stored in a destination storage area is also erased so that security risks can be reduced. | 03-05-2009 |
20090083347 | DATA STORAGE APPARATUS, IMAGE FORMING APPARATUS AND DATA DELETION METHOD - A data storage apparatus having a plurality of hard disk drives, having: a deletion control section which executes complete deletion processes of the plurality of hard disk drives simultaneously; and a display control section to form a progress status display information of the complete deletion processes by the deletion control section, which display information represents all the progress statuses of the plurality of the hard disk drives, and to display the display information on a display section. | 03-26-2009 |
20090083348 | Memory Management Using Garbage Collection of Objects in Child Scoped Memory Areas - Mechanisms of memory management in a scoped memory system of a data processing system having a one or more scoped memory areas are provided. The mechanisms identify a set of one or more child scoped memory areas of the scoped memory area for garbage collection. The mechanisms further identify, in each scoped memory area of the set, references to the scoped memory area for garbage collection as root references for objects allocated in the scoped memory area of the scoped memory system, thereby generating a set of root references. The mechanisms also recursively traversing and marking objects that are referenced from the set of root references and that are allocated in the scoped memory area of the scoped memory system and identify objects in the scoped memory area of the scoped memory system that are not so marked. The identified objects are discarded from the scoped memory system. | 03-26-2009 |
20090083349 | Memory Management for Garbage Collection of Critical Real Time Threads - Mechanisms of memory management in a real time runtime environment having a garbage collected memory heap are provided. The runtime environment includes a critical real time thread that is precluded from accessing the garbage collected memory heap. The runtime environment further includes a scoped memory area for the allocation of objects therein for access by the critical real time thread. The mechanisms determine whether the critical real time thread is in a defined state in which a delay associated with garbage collection can be accommodated by the critical thread. The mechanisms further initiate, in response to a determination that the critical real time thread is in the defined state, a process of garbage collection of the scoped memory area. | 03-26-2009 |
20090089345 | METHOD AND SYSTEM FOR MINOR GARBAGE COLLECTION IN A MULTITASKING ENVIRONMENT - A method for minor garbage collection in a multitasking environment involves marking cards as clean, where the cards designate ranges of memory locations in a shared older generation. The method further involves marking a card as dirty when a reference field of an object within the card is modified, where a memory location of the reference field is designated by the card, where the reference field references a live young object in a task-specific young generation, and where the task-specific young generation is associated with a first task. The method further involves marking the card as single-dirty when the card only includes roots of live young objects in the task-specific young generation, and optimizing task-specific minor garbage collection for a second task by skipping the card when the card is marked as single-dirty. | 04-02-2009 |
20090094300 | NONDEFERRED REFERENCE-COUNTING GARBAGE COLLECTION USING OVERLOOKING ROOTS - A reference-counting garbage collection system utilizing overlooking roots injects eager reference-counting updates into the program. An overlooking roots reference-counting subsumption optimization tool identifies redundant reference-counting updates and removes them, lowering the number of reference-counting update calls and improving execution throughput. The optimization tool also includes new overlooking root relationships in order to permit other unnecessary reference-counting updates to be removed during optimization. Reference-counting updates which are specialized based on the overlooking root information are also included in the program. | 04-09-2009 |
20090094301 | APPLICATIONS OF OVERLOOKING ROOT INFORMATION FOR IMPROVING NONDEFERRED REFERENCE-COUNTING GARBAGE COLLECTION - A reference-counting garbage collection system utilizing overlooking roots injects eager reference-counting updates into the program. An overlooking roots reference-counting subsumption optimization tool identifies redundant reference-counting updates and removes them, lowering the number of reference-counting update calls and improving execution throughput. The optimization tool also includes new overlooking root relationships in order to permit other unnecessary reference-counting updates to be removed during optimization. Reference-counting updates which are specialized based on the overlooking root information are also included in the program. | 04-09-2009 |
20090100116 | ELECTRONIC EQUIPMENT AND MEMORY MANAGING PROGRAM - The present invention claims and discloses an electronic equipment capable of executing a processing executing program that performs a predetermined processing. The electronic equipment comprises a memory; a setting unit that sets an allocation time for a memory region in the memory that the processing executing program is to use; and a memory leak detecting unit that detects when the memory region has not been deallocated within the allocation time. | 04-16-2009 |
20090112952 | LOW LATENCY OPTIMIZATION FOR GENERATIONAL GARBAGE COLLECTION - A solution for handling objects in a nursery heap that includes a garbage collector monitoring engine, a size adjustor program, and/or a promotion program. The garbage collector monitoring engine can monitor occurrences of global garbage collection events performed by a global garbage collector program as well as occurrences of nursery garbage collection events performed by a nursery garbage collector. The size adjustor program can dynamically adjust a size of a nursery heap based upon programmatically deterministic events detected by the garbage collector monitoring engine. The promotion program can dynamically adjust conditions of promotion for nursery objects, wherein when additional space is needed in the nursery heap to reduce nursery garbage collection induced latency, the promotion program changes promotion criteria to ensure objects are promoted more frequently from the nursery heap. | 04-30-2009 |
20090112953 | ENHANCED GARBAGE COLLECTION IN A MULTI-NODE ENVIRONMENT - Embodiments of the invention enhance a garbage collection process running on a parallel system or distributed computing environment. Using a garbage collector in such an environment allows a more in-depth analysis to be performed than is possible on other systems. This is because the number of compute nodes present in many parallel systems, and the connections between them, allows the overhead of doing advanced analysis to be spread across the nodes and the results of that analysis to be shared among the nodes. | 04-30-2009 |
20090119354 | METHOD, SYSTEM, AND PROGRAM IMPLEMENTING RETENTION POLICIES TO ARCHIVE RECORDS - Provided are a method, system, and program for receiving a request to remove a record. A determination is made as to whether a state associated with the record includes at least one hold state and whether the state associated with the record includes at least a retention period that has not expired. The request to remove the record is denied in response to determining that the state associated with the record includes at least one of at least one hold state and one retention period that has not expired. | 05-07-2009 |
20090125574 | Software Pipelining On a Network On Chip - Memory sharing in a software pipeline on a network on chip (‘NOC’), the NOC including integrated processor (‘IP’) blocks, routers, memory communications controllers, and network interface controllers, with each IP block adapted to a router through a memory communications controller and a network interface controller, where each memory communications controller controlling communications between an IP block and memory, and each network interface controller controlling inter-IP block communications through routers, including segmenting a computer software application into stages of a software pipeline, the software pipeline comprising one or more paths of execution; allocating memory to be shared among at least two stages including creating a smart pointer, the smart pointer including data elements for determining when the shared memory can be deallocated; determining, in dependence upon the data elements for determining when the shared memory can be deallocated, that the shared memory can be deallocated; and deallocating the shared memory. | 05-14-2009 |
20090132622 | METHOD AND SYSTEM FOR GARBAGE COLLECTION - A method and system for garbage collection are provided. A memory allocation request is received for an object. An object identifier is generated for the object. A first memory location is allocated to the object. A translation table is generated storing a map of the object identifier and the first memory location. A data structure is generated for the object. A mark flag is set based on the number of references of the object. Data stored in the first memory location is moved to a second memory location based upon the value of the mark flag. The data is deleted from the first memory location based upon a value of the mark flag. | 05-21-2009 |
20090132623 | INFORMATION PROCESSING DEVICE HAVING DATA FIELD AND OPERATION METHODS OF THE SAME - An information processing device includes a memory array and a controller. The memory array includes a data field that stores file data and a management information field that stores information regarding the data field. The controller controls a writing operation to the memory array. The controller stores a portion of the file data, corresponding to a product of a positive-integer and a predetermined unit block size, in the data field by block units, with reference to the data field information of the management information field. | 05-21-2009 |
20090138533 | Electronic album providing system and file providing system - The electronic album providing system, with which publishing and viewing of an electronic album by a system user is possible, includes: a first decision unit that detects whether or not a designated reader who has been designated by a publisher has viewed the album, and that decides that a first condition has become valid when a number of persons who have completed viewing to a total number of the designated readers reaches a predetermined value; a second decision unit that decides that a second condition has become valid when a time limit for publishing the album that has been set in advance arrives; and a deletion unit that performs deletion control of the album when at least one of the first condition and the second condition becomes valid. | 05-28-2009 |
20090144349 | MEMORY MANAGEMENT - A method of memory management for a software application in execution in a computer system, the method comprising the steps of:
| 06-04-2009 |
20090150465 | Object Deallocation System and Method - A method, apparatus and program product deallocate an object from a memory heap in a virtual machine environment by, in part, determining that the object is replaceable using an object reference associated with the object. The object may additionally be automatically determined as being properly removable by using a value indicative of a number of object references associated with the object. Where these conditions are met, the object may be removed from the memory heap. Where a new object can fit into a space within the memory from which the object was removed, the new object may be automatically allocated into the space. The object may be designated as being replaceable using automated or manual processes. A garbage collector algorithm may additionally execute, as needed. | 06-11-2009 |
20090172051 | ONLINE INCREMENTAL DATABASE DUMP - Various embodiments may include taking an initial dump of a database table and tracking changes to the database table, with regard to but outside of transactions, since a most recent full or partial dump has been taken. A partial dump, in such embodiments, may be taken since the most recent full or partial dump and used to create a data structure which may be used to update only those database table rows modified since a last full or partial dump. As a result, the dumps of a database table will include a single full dump and may include one or more partial dumps. These full and partial dumps may then be instantiated to create or update an instance of the database table. In some embodiments, dumps may be taken directly to a mirrored instance of a database table. | 07-02-2009 |
20090182792 | METHOD AND APPARATUS TO PERFORM INCREMENTAL TRUNCATES IN A FILE SYSTEM - The present invention provides a computer implemented method for truncating a file in a file system. The file system receives a request to truncate a file to a target size, the file having a first inode. The file system creates a second inode to a transient directory, wherein the second inode holds a plurality of in-progress entries. The file system sets a target size in the first inode. The file system writes a truncate entry to a journal, the truncate entry comprising a predetermined size. The file system truncates the file by up to the predetermined size. The file system determines that the file is above the target size. Responsive to a determination that the file is above the target size, the file system repeats the truncating step and the determining step. Responsive to a determination that the file is not above the target size, the file system applies the in-progress entries from the transient directory. | 07-16-2009 |
20090187614 | Managing Dynamically Allocated Memory in a Computer System - Managing dynamically allocated memory in a computer system in which garbage collection process is scheduled separately from data processing comprises initiating a system program and providing system memory for use by the system program, the system program being arranged to provide a processing environment, initiating an application program within the processing environment for performing one or more units of processing, allocating a portion of the memory for use by the application program for performing the processing, providing a first unit of processing to the application program, determining the proportion of the provided system memory in use on completion of processing of the first unit; and if the proportion exceeds a predetermined threshold, providing a memory recovery instruction to the system program to identify elements in the system memory occupied by objects or data inaccessible to the application program and to free the elements of the provided system memory. | 07-23-2009 |
20090204654 | SYSTEM AND METHOD FOR ASYNCHRONOUS PARALLEL GARBAGE COLLECTION - A system and method for asynchronously graying and blackening objects in the marking phase of parallel garbage collection. The system and method use a matrix to control a series of linked list of work to be grayed and blackened. The threads of the garbage collector are each assigned entries within the matrix upon which they may either gray an entry in the linked list or blacken and entry on the linked list. Further restrictions upon the use of the matrix allow non-garbage collection thread to asynchronously or synchronously add objects to be processed by the garbage collector. | 08-13-2009 |
20090234897 | EFFICIENT HEAP UTILIZATION & PARTITIONING - A method comprising calculating first and second allocation speeds respectively for at least a first space and a second space in a runtime environment's memory space; and partitioning the runtime environment's memory space in proportion to said first and second space's respective allocation speeds so that the first space is filled to a first threshold level approximately at the same time as the second space is filled to a second threshold level. | 09-17-2009 |
20090248766 | METHOD AND APPARATUS FOR IMPROVING PARALLEL MARKING GARBAGE COLLECTORS THAT USE EXTERNAL BITMAPS - A method for performing garbage collection involves obtaining a first reference bitmap including a block address and a set of mark bits, obtaining a first reference, identifying a mark bit of the set of mark bits based on the first reference, comparing an address associated with the mark bit with the first reference to generate a comparison, selecting an existing word from a global bit map based on the block address and the comparison, calculating a new word based on the set of mark bits and the existing word, replacing the existing word in the global bit map with the new word, and reclaiming a block of memory for reuse based on the global bit map after replacing the existing word. | 10-01-2009 |
20090254596 | PROVIDING A PUBLISHING MECHANISM FOR MANAGED OBJECTS - Publishing an object. Memory for an object may be reserved so as to lock the memory from being access by garbage collection threads or other user threads. While the lock is in place, type and size information can be installed for the object. If the reservation is being made to allow garbage collection threads to operate on the object, then the type may be a specialized type that indicates that the object has no references. Reservations can also be made to allow the intended type information to be installed for the object. An indication can be made that the object is well formed, thus unlocking the object and allowing garbage collection threads, other user threads, or both to access the object. The locking and unlocking may be performed by accessing an API provided by a system garbage collector. | 10-08-2009 |
20090259701 | METHODS AND SYSTEMS FOR SPACE MANAGEMENT IN DATA DE-DUPLICATION - The present invention is directed toward methods and systems for data de-duplication. More particularly, in various embodiments, the present invention provides systems and methods for data de-duplication that may utilize storage reclamation. In various embodiments, data de-duplication may be performed using data storage reclamation by reconciling a list of all active tags against a list of all tags present within the object store itself. Any tags found to be in the object store that have no corresponding active usage may then be deleted. In some embodiments additional steps may be taken to avoid race conditions in deleting tags that are needed by incoming data. In some embodiments the object store may request the lists. In other embodiments, a runtime list, in which each new tag is entered as they are returned from the object store. In another embodiment the object store may maintain this list directly. | 10-15-2009 |
20090259702 | USING AN OVERFLOW LIST TO PROCESS MARK OVERFLOW - Mark stack overflow list. A method may be practiced in a computing environment including application code that implements garbage collection functionality. The garbage collection functionality includes pushing object references onto a mark stack, such that objects referenced on the mark stack can be marked so as to prevent memory for the objects from being recycled for use with other objects instances. The method includes acts for handling overflows of a mark stack. The method includes accessing a reference to an object. The object is processed by attempting to enumerate references to other objects from the object onto a mark stack. An overflow condition of the mark stack is detected for a referenced other object. A reference to the referenced other object is placed on an overflow list. References from the overflow list are processed. | 10-15-2009 |
20090265402 | EFFICIENTLY MARKING OBJECTS WITH LARGE REFERENCE SETS - Adding references to objects to a mark stack. A limited number of references to objects referenced by an object with a large number of object references are added to the stack. An object is accessed. A determination is made that references in the object should be added to a mark stack using a reference in the mark stack to the object in conjunction with a pointer. The pointer is used to track which references in the object have been placed on the mark stack. A reference to the object on the mark stack is accessed. A pointer is initialized. A reference to another object referenced by the object is pushed onto the mark stack. The pointer is incremented. It is then determined that that more references should be pushed to the mark stack. Acts of pushing references onto the mark stack and incrementing the pointer are repeated. | 10-22-2009 |
20090265403 | FILE SYSTEM | 10-22-2009 |
20090271460 | MEMORY MANAGEMENT METHOD AND SYSTEM - A memory management method and a system for performing garbage collection. The method includes the steps of providing in a memory space a heap partitioned into a plurality of areas including an area for object allocation and a To area for future object allocation. In garbage collection, an object reachable from a root set among objects allocated in the area of use is copied into the To area. In addition, a finalizable object among the objects allocated in the area of use is set as a finalization target. Here, the finalizable object is an object unreachable from the root set and has a finalize method. After the garbage collection is completed, the finalizable object of finalization target allocated in the area of use is finalized. | 10-29-2009 |
20090276478 | METHOD AND SYSTEM FOR HYBRID GARBAGE COLLECTION OF MULTI-TASKING SYSTEMS - In general, the invention relates to a method for garbage collection. The method includes examining old regions to obtain a mark bitmap, a connectivity matrix, and fragmentation information, where the mark bitmap describes marked words and unmarked words for the old regions. The method further includes identifying a fragmented region in the old regions based on the fragmentation information, where the fragmented region includes at least one of the marked words. The method further includes copying the at least one of the marked words to a new region allocated from a pool of free regions, designating each of the unmarked words not in the fragmented region as free, adjusting a cross-region reference to the fragmented region in the marked words to point to the new region based on the connectivity matrix, and adding the fragmented region to the pool of free regions. | 11-05-2009 |
20090287752 | RECORDING/REPRODUCING APPARATUS AND INFORMATION PROCESSING METHOD - A recording/reproducing apparatus is capable of searching a file at high speed without an increase in number of times of rewriting the data on an external storage medium. The recording/reproducing apparatus includes: an input/output unit for receiving data from and sending data to an external storage medium and a storage unit for accumulating the data. The apparatus also includes a control unit for reading out a file system for controlling audio/video data. The audio/vide data has been recorded on the external storage medium from the external storage medium and then accumulating the file system in the storage unit through the input/output unit. The apparatus further includes a data base control unit for constructing a database on the basis of attribute information of the audio/video data contained in a file system accumulated in the storage unit and deleting data accumulated in the database at the time of removal of the external storage medium. | 11-19-2009 |
20090292749 | Per thread garbage collection - Per thread garbage collection is disclosed. Objects associated only with a thread that created them are tracked. At a garbage collection time for a particular thread, it is determined which objects associated only with that thread remain reachable from a restricted root set associated with the thread. Any thread-only objects that are not determined to be reachable are garbage collected. | 11-26-2009 |
20090300085 | OVERFLOW PER SEGMENT - Per-segment overflow ranges. One method includes acts for handling overflows of a mark stack. A reference to an object is accessed. The object is processed by attempting to place references to other objects referenced in the object onto a mark stack. An overflow condition of the mark stack is detected. A range in a segment is defined which includes the object that caused the overflow condition. The range is assigned on a per segment basis such that the range is defined to only include addresses in a single segment. | 12-03-2009 |
20090300086 | SCHEDULING AND PERFORMING GARBAGE COLLECTION IN A REAL-TIME SYSTEM WITH GUARANTEED SPACE BOUNDS - A method for performing garbage collection for a real-time application uses a memory for determining an amount of memory required to run the garbage collection process and waits until the determined amount of memory is available, then allocates memory space for the application by segmenting the memory space into a number of pages of a predetermined size. A mutator is used for assuring that only non-null, unmarked objects are placed into a write buffer. A hybrid collector is used for removing the dead objects and defragmenting the memory space. | 12-03-2009 |
20090307292 | DYNAMICALLY CHANGING A GARBAGE COLLECTOR IN A MANAGED RUNTIME SYSTEM - Machine-readable media, methods, and apparatus are described to dynamically change a garbage collector in a managed runtime system ( | 12-10-2009 |
20090319588 | GENERIC DATABASE SANITIZER - A method of generating a test database from a deployed database by “sanitizing”, or removing sensitive data, is employed for recreating problem scenarios from a customer site, verifying compatibility of customer data with database version updates, and for performance testing using actual, rather than generated, database structures. In database management operations, in can be beneficial to use data generated from actual operational scenarios rather than artificially generated data created from a test pattern. Data generated from actual operation, such has at a customer site, assures compatibility with the relation patterns and record volumes employed by the customer (user). However, databases often contain sensitive information that would be inappropriate, illegal, or vulnerable in a testing environment. Accordingly, the generated test database overwrites sensitive data values with benign, or generic values while preserving the structure and relations of the data stored. | 12-24-2009 |
20090327372 | Garbage Collection via Multiobjects - Computer system, method and article of manufacture for garbage collection in computer systems that combines individual objects into linearized trees called multiobjects and thereafter utilizes multiobjects to implement most memory management operations such as detection of dead objects and compaction without the need to inspect individual objects, thereby improving performance and reducing power consumption. | 12-31-2009 |
20090327373 | METHOD FOR PERFORMING MEMORY LEAK ANALYSIS INSIDE A VIRTUAL MACHINE - A method, system, computer program product, and computer program storage device for performing a memory leak analysis inside a virtual machine is disclosed. By utilizing thread stack(s), class statics, and/or a list of root objects, a DFS algorithm starts execution at root objects in the thread stack(s), class statics, and/or a list of root objects. Upon fully processing an object, a reachability (sum of sizes of all child objects plus a size of the object itself) of the object is calculated. When the reachability of the object is larger than a threshold and when all reachabilities of children of the objects are less than another threshold (i.e., a largest child reachability of the object is less than another threshold), the object is determined as a potential source of a memory leak. | 12-31-2009 |
20090327374 | METHOD AND APPARATUS FOR PERFORMING CONCURRENT GARBAGE COLLECTION - One embodiment of the present invention provides a system that facilitates performing concurrent garbage collection. Note that the system uses hardware-supported GC barriers. During operation, the system executes a first mutator thread. While executing the first mutator thread, the system performs a garbage-collection operation using a garbage-collector thread. Performing the garbage-collection operation involves: discovering a live object in a from-space, which is being collected; creating a copy of the live object to a to-space, where live objects are copied to during garbage collection; and replacing the live object in the from-space with a forwarding pointer which points to a location of the copy of the live object in the to-space. Note that in some embodiments, the system marks cache lines comprising the live object in from-space as “forwarded,” which prevents any mutator threads from touching the cache lines. Additionally, in some embodiments, the system determines if the first mutator thread holds any additional references to the from-space. If so, the system leaves the first mutator thread marked as “dirty,” wherein dirty is the initial state for mutator threads. If not, the system marks the first mutator thread as “clean.” | 12-31-2009 |
20090327375 | Method and Apparatus for Handling Edge-Cases of Event-Driven Disposition - Retention of data is managed and data holds are enforced. At least one event consumer data source contains data that is subject to a retention schedule that defines rules for the disposition of the data. An enterprise retention management (ERM) application accepts at least one hold request that defines at least a portion of the data that must be held from disposition. A disposition request is also accepted by the ERM that comprises an instruction to dispose of at least a portion of the data based on the rules within the retention schedule. The disposition request is filtered to dispose of the portion of data identified in the disposition request minus the held data, which comprises disposition survivor data. An event-driven disposition mechanism disposes of the disposition survivor data as soon as possible after the disposition survivor data is released from hold or unlocked. | 12-31-2009 |
20090327376 | B-FILE ABSTRACTION FOR EFFICIENTLY ARCHIVING SELF-EXPIRING DATA - Systems and methods are provided for data processing and storage management. In an illustrative implementation an exemplary computing environment comprises at least one data store, a data processing and storage management engine (B-File engine) and at least one instruction set to instruct the B-File engine to process and/or store data according to a selected data processing and storage management paradigm. In an illustrative operation, the illustrative B-File engine can generate a B-File comprising multiple buckets and store sample items in a random bucket according to a selected distribution. When the size of the B -FILE grows to reach a selected threshold (e.g., maximum available space), the B-File engine can shrink the B-File by discarding the largest bucket. Additionally, the B-File engine can append data to existing buckets and explicitly cluster data when erasing data such that data can be deleted together into the same flash block. | 12-31-2009 |
20090327377 | Copying entire subgraphs of objects without traversing individual objects - Copying or compacting performance in garbage collection is improved by copying a first memory area (preferably comprising multiple objects) to a second memory area without traversing individual objects in the copied memory area and adjusting all copied memory locations identified as pointers in a metadata data structure. An entire linearized subgraph of the object graph can be copied at a time. | 12-31-2009 |
20100017447 | Managing Garbage Collection in a Data Processing System - A computer implemented method, apparatus, and computer program product for managing garbage collection. Monitoring is performed for a garbage collection state in a virtual machine. Responsive to detecting the garbage collection state, a priority for a set of garbage collection threads is increased. | 01-21-2010 |
20100057792 | Determining the Address Range of a Subtree of a Linearized Tree - A method and computer system for determining the memory address range of a subtree of a linearized tree of objects or the original version of such tree when the tree has been modified or is concurrently being modified by other threads. The primary application of the method is in garbage collection for multiprocessor shared memory computers with very large memories, but it is also relevant for a number of other applications. | 03-04-2010 |