Patents
Literature
Hiro is an intelligent assistant for R&D personnel, combined with Patent DNA, to facilitate innovative research.
Hiro

192 results about "Refuse collector" patented technology

Off-heap direct-memory data stores, methods of creating and/or managing off-heap direct-memory data stores, and/or systems including off-heap direct-memory data store

Certain example embodiments relate to a highly-concurrent, predictable, fast, self-managed, in-process space for storing data that is hidden away from the garbage collector and its related pauses. More particularly, certain example embodiments relate to improved memory management techniques for computer systems that leverage an off-heap direct-memory data store that is massively scalable and highly efficient. The off-heap store may be provided in connection with a Java-based environment, and garbage collection may be completely or nearly completely avoided for the off-heap store. The off-heap store may be integrated into a tiered storage solution in certain example embodiments.
Owner:SOFTWARE AG USA

Binned remembered sets

A garbage collector that performs collection incrementally in accordance with the train algorithm employs remembered sets to keep track of locations where references to objects in respective car sections were written. The remembered sets are implemented as multi-level hash tables. The entries in the top-level hash table are pointers to constituent hash tables in which entries representing the reference locations are placed. When a constituent hash table becomes full, the collector thins it by allocating a new constituent table, transferring some of the previously full table's entries to the new table, and dividing further reference-location-representing entries among them in accordance with a hash function having an expanded range.
Owner:ORACLE INT CORP

Object sampling technique for runtime observations of representative instances thereof

With better knowledge of the behavior of objects in a running application, it is possible to improve execution environment decisions that affect management of such objects. For example, if available, object lifetime statistics could be employed in decisions that affect how and where objects are placed, e.g., on allocation or during operation of automatic dynamic memory management facilities such as a garbage collector. Typically, instrumenting all objects to sample lifetimes or other characteristics would impose an impractical level of overhead. We present a technique for dynamic sampling of a subset of allocated objects that incurs low runtime overheads. Coupled with automatic memory management or collection facilities, this technique allows us to improve the efficiency of a collector by segregating objects, sampled and non-sampled alike, based on observed characteristics such as object lifetime. The sampling techniques facilitate tracking of many kinds of object information. For purposes of illustration, an exemplary implementation is described in which such sampling techniques are exploited to improve performance of generational garbage collectors.
Owner:ORACLE INT CORP

Garbage-first garbage collection

A garbage collector treats a garbage-collected heap as divided into heap regions, for each of which it maintains a respective remembered set, whose entries list the locations where references located in the heap outside that region refer to references inside that region. The remembered sets are used during space-incremental collection operations on collection sets of those regions; if the garbage collector determines that objects in the collection set are not referred to directly or indirectly from outside the collection set, it reclaims the memory space that they occupy. It places entries into the remembered sets independently of the locations at which the references were found, so any region can be chosen for inclusion in any collection set; no predetermined collection order is required. Instead, the garbage collector performs global marking operations and uses the results to select for collection-set membership the regions that it can most likely collect efficiently.
Owner:ORACLE INT CORP

Garbage collector with eager read barrier

A garbage collection system that needs to meet real-time requirements uses an eager read barrier that performs a forwarding operation as soon as a quantity is loaded. The barrier maintains a to-space invariant by including a forwarding pointer in the header of objects to be moved or accessed that normally points to the object itself. However, if the object has been moved, the forwarding pointer points to the new object location. The eager read barrier maintains the registers and stack cells such that the registers and stack cells always point into to-space. Barrier-sinking and common sub-expression elimination are used to minimize the overhead associated with the read barrier.
Owner:IBM CORP

Write-barrier maintenance in a garbage collector

An approach is provided for maintaining a write barrier during an assignment operation between a source object and a target object. A source tag is obtained from a first reference to the source object, and a target tag is obtained from a second reference to the target object. The source tag and the target tag are compared, such that if the source tag is in a predetermined relationship with the target tag, then a data structure (e.g., a remember table or exit table) associated with the write barrier is updated in accordance with the assignment operation. In one embodiment, the routine to update the data structure is dispatched from a function table based on a tag value in a header associated with the source object.
Owner:ORACLE INT CORP

Space-efficient, depth-first parallel copying collection technique making use of work-stealing on the same structures that maintain the stack of items to be scanned

A copying-type garbage collector operates in multiple concurrent threads. Each thread evacuates potentially reachable objects from the from space to the to space in a depth-first manner: if a thread has evacuated an object containing references to any from-space objects, it evacuates all of that object's descendants before it evacuates any other reachable objects. To keep track of descendants that must be evacuated before non-descendants can be, the thread places objects containing references to non-evacuated objects into a linked list maintained by pointers that it installs in the from-space locations from which the objects on the list were evacuated. Additionally, it divides the to space into local-allocation buffers (“LABs”) to which respective threads exclusively evacuate objects, and each thread maintains a LAB stack representing all the LABs it has filled that still contain references to unevacuated from-space objects. When a thread has completed evacuating the descendants of evacuees in all of its LABs, it “steals” work from other threads. It may do so, for instance, by processing a reference in an object belonging to another thread's list, by transferring to its own list one or more objects from another thread's list, or by transferring to its own LAB stack one or more LABs from another thread's LAB stack.
Owner:ORACLE INT CORP

Method and program for space-efficient representation of objects in a garbage-collected system

A system includes a processor for executing a collector program to perform a method (e.g., a method of collection). The method includes using an object model during a collection phase that is different than an object model used during program execution. The processor may also perform a method including assigning a hash code to at least some objects, and consulting a structure that maintains a mapping of objects to hashcode values to determine said hashcode for one of said objects. The processor may also perform a method including storing a class pointer and garbage collector state information in a single word, and accessing said class pointer by masking out non-class bits.
Owner:IBM CORP

Unmanned ship used for on-water garbage cleaning

The invention provides an unmanned ship used for on-water garbage cleaning. The unmanned ship used for on-water garbage cleaning adopts a stable double-ship-body structure, and a garbage salvage device includes a three-blade fan wheel, a bucket type chained conveying device, an automatic air jetting device and a garbage collection box. The ship has three working modes, namely the random operationmode, the semi-autonomous operation mode and the emergency mode. The designed automatic air jetting device can achieve automatic air jetting at the time of salvage, garbage adsorbed on a with-hole bucket type stainless steel net plate and a nail rake are blown, the garbage thus can naturally and vertically fall into the garbage collection box, kinetic energy is provided by the additional-value energy of a motor, and energy conservation and environment protection are achieved.
Owner:CHONGQING UNIV OF POSTS & TELECOMM

Age segregation for garbage collector

A garbage collector treats a heap as divided into regions. From a candidate set of those regions, it selects the collection sets on which it performs collection increments from among those regions in accordance with a selection criterion separate from the ages of the objects that those regions contain. It nonetheless segregates objects according to age, placing objects in such a manner that no candidate-set region containing an object whose age is less than some predetermined maximum also contains an object of a different age.
Owner:ORACLE INT CORP

Transparent garbage collection of resources

Techniques for transparently registering non-memory resources used by a program with a garbage collector so that the non-memory resources can be freed when the program is finished using them. The techniques automatically determine from the program that the execution will use a resource and then automatically modify the program's behavior so that the resource is registered. When the program is finished with the resource, it can be determined from the registry whether the resource must be freed. In one embodiment, the technique is employed in a garbage collector for doing resource garbage collection with legacy C and C++ programs. The garbage collector locates invocations that allocate such resources in the code and modifies the code so that when it is executed, the resources are registered. The techniques can also be used to ensure that finalizers associated with objects are executed before the object is freed. In this use, the invocation of the constructor for the object is modified so that the object and its finalizer are registered. When the object is no longer in use, the garbage collector uses the registry to obtain the object's finalizer, which it executes before it frees the object. Where the object represents a resource, execution of the finalizer will free the resource.
Owner:CA TECH INC

Maximizing throughput for a garbage collector

Some embodiments of the present invention provide a system that executes a garbage collector in a computing system. During operation, the system obtains a throughput model for the garbage collector and estimates a set of characteristics associated with the garbage collector. Next, the system applies the characteristics to the throughput model to estimate a throughput of the garbage collector. The system then determines a level of performance for the garbage collector based on the estimated throughput. Finally, the system adjusts a tunable parameter for the garbage collector based on the level of performance to increase the throughput of the garbage collector.
Owner:ORACLE INT CORP

Compression refuse collector and hydraulic system thereof

The invention provides a hydraulic system, which comprises a double-oil-pump, an main oil passage, a first valve set, a second valve set, a first cylinder system, a second cylinder system, a control unit and an oil return unit. The first valve set, the control unit, the oil return unit and the second valve set are connected through the main oil passage sequentially. The control unit comprises a multi-way reversing valve, and the oil return unit is communicated with an oil return port of the main oil passage and comprises an internal oil passage. The hydraulic system has a combination state and a linkage state. When in the combination state, hydraulic oil of a first oil pump flows through the first valve set and the control unit sequentially to enter the inside of the oil return unit through an oil port of the multi-way reversing valve of the control unit, and then combined with hydraulic oil of a second oil pump in the second valve set. When in the linkage state, the multi-way reversing valve of the control unit is located in the middle, the first valve set and the second valve set complete operation respectively. The invention further provides a compression refuse collector adopting the hydraulic system.
Owner:ZOOMLION ENVIRONMENTAL IND CO LTD

System and method for deterministic garbage collection in a virtual machine environment

In a virtual machine, Java Virtual Machine, or other runtime environment, a system and a method for improving the garbage collection times of the virtual machine memory. The JVM, or a garbage collector operating therein, can estimate, for an area of the memory space, the sum of the pause times for garbage collection of the software objects within the area, and control the garbage collection process so that the sum of the pause times for garbage collection will be lower than a target pause time limit, with a high degree of probability. A preselected compaction area can be pre-compacted to keep the compaction time within the target limit. The garbage collector can also predict the time required for final marking and repeat precleaning until the predicted final marking time is within the limits for pause times, and can improve pause times by redirecting application worker threads to do garbage collector work when entering or leaving the memory subsystem.
Owner:ORACLE INT CORP

Combining write-barriers within an inner loop with fixed step

ActiveUS7225439B2Reduce in quantityWithout compromising garbage collector performanceData processing applicationsSoftware engineeringArray data structureInner loop
The present invention provides a technique for reducing the number of write barriers executed in mutator code without compromising garbage collector performance. To that end, when mutator instructions located within an inner-most nested loop (“inner loop”) modify references stored in one or more arrays, a compiler defers emitting write barriers corresponding to the reference modifications until after the inner loop is emitted. By deferring emission of write barriers, the mutator may execute a write barrier for each card spanned by the array instead of executing a typically larger number of write barriers corresponding to each reference modification made in an array. Thus, the invention enables the compiler to reduce the amount of write-barrier overhead performed by the mutator, consequently enabling the mutator to execute faster and more efficiently.
Owner:ORACLE INT CORP

Hot-swapping a dynamic code generator

Embodiments of the invention relate to hot-swapping a live dynamic code generator. In an embodiment, hot-swapping is done in the Java execution environment. The dynamic code generator to be hot-swapped is stored in a module of a shared library separated from other components of the Java environment such as the garbage collector, the class loader, the Java Native Interface, the threading and synchronization package, etc. A graphical user interface (GUI) is provided so that the user can interact with the execution environment to control and perform hot-swapping.
Owner:HEWLETT-PACKARD ENTERPRISE DEV LP +1

Code preparation technique employing lock-free pointer operations

A methodology has been discovered for transforming garbage collection-dependent algorithms, shared object implementations and / or concurrent software mechanisms into a form that does not presume the existence of an independent, or execution environment provided, garbage collector. Algorithms, shared object implementations and / or mechanisms designed or transformed using techniques described herein provide explicit reclamation of storage using lock-free pointer operations. Transformations can be applied to lock-free algorithms and shared object implementations and preserve lock-freedom of such algorithms and implementations. As a result, existing and future lock-free algorithms and shared object implementations that depend on a garbage-collected execution environment can be exploited in environments that do not provide garbage collection. Furthermore, algorithms and shared object implementations that employ explicit reclamation of storage using lock-free pointer operations such as described herein may be employed in the implementation of a garbage collector itself.
Owner:ORACLE INT CORP

Collection-set selection using a small priority queue

A space-incremental garbage collector performs marking operations that are usually separated by several collection increments. It uses the marking results to compute collection-efficiency metrics for regions into which it treats the heap as divided. It bases its selection of regions for successive increments' collection sets on the metrics' values, whose computations also depend on the sizes of the regions' “remembered sets,” i.e., on the lists of locations where references to objects in those regions have been observed. Although the remembered-set sizes therefore potentially change between collection increments, the collector re-computes metrics in most collection increments for only a subset of the regions. It selects the subset in accordance with a sorting of all regions that it performed at the end of the most recent completed marking operation.
Owner:ORACLE INT CORP

Globally distributed load balancing

InactiveUS6934741B2Avoid expensive operationLower performance costsDigital computer detailsMultiprogramming arrangementsMachine instructionDistributed computing
A garbage collector employs a plurality of task queues for a parallel-execution operation in a garbage-collection cycle. Each task queue is associated with a different ordered pair of the threads that perform the parallel-execution operation in parallel. One of the threads, referred to as that task queue's “enqueuer” thread, is the only one that can “push” onto that queue an identifier of a dynamically identified task. The other thread, referred to as that task queue's “dequeuer,” is the only one that can “pop” tasks from that task queue for execution. Since, for each task queue, there is only one thread that can “push” task identifiers on to it and only one thread that can “pop” task identifiers from it, the garbage collector can share dynamically identified tasks optimally among its threads without suffering the cost imposed by making combinations of otherwise separate machine instructions atomic.
Owner:ORACLE INT CORP

Leaf avoidance during garbage collection in a Java Virtual Machine

A system, method and program product for optimizing the mark phase of garbage collection in a JVM. A garbage collector is provided for removing unused objects, wherein the garbage collector includes: a traversing system for traversing object fields in objects obtained from a work queue, wherein the traversing system includes a leaf identifying system for determining whether object fields contain a leaf node; and a marking system for marking objects as live.
Owner:IBM CORP

Merging trains in a collector based on the train algorithm

A garbage collector that employs the train algorithm determines whether futile collections have been occurring or the number of trains has reached a maximum. When either situation occurs, it merges a plurality of existing trains into a single new train. If the collector detects futile collection, it merges the oldest train with one of the other trains. If the number of trains reaches a maximum, the collection so merges trains that the next train addition will not cause the number of trains to exceed the maximum.
Owner:ORACLE INT CORP

Determining whether a JAVA object has been scan-missed by a garbage collector scan

A Java object is scan-missed during the mark phase of a garbage collection cycle. A list of any unscanned objects, comprising all objects of a particular object type, is created during a sweep phase of the garbage collection cycle. After the garbage collection cycle is completed, and the application resumes, for every PUTFIELD / GETFIELD operation on the object type that is part of a specific parent object, a comparison is made with the relevant information in the unscanned objects list. A scan-miss is identified by determining whether the current object being referenced by the application is a part of the unscanned object list that has been created during the sweep phase of the garbage collection cycle.
Owner:IBM CORP

Efficiently supporting the existence of long trains in a generation managed by the train algorithm

A garbage collector that divides a dynamically allocated heap into car sections grouped into trains in accordance with the train algorithm subdivides large trains into subtrains. When an object that is reachable from the train-algorithm-managed generation of the heap is evacuated from a car being collected during a collection increment, it is placed into the last car in the subtrain in which the reference to it resides, even if that car is not the last car in the train to which the reference's subtrain belongs. The train-algorithm test for dead trains is performed not only on top-level trains but also on sub-trains.
Owner:ORACLE INT CORP

Method and apparatus for implementing modular garbage collectors

Methods and apparatus for efficiently enabling garbage collectors to be swapped into and out of virtual machine environments are disclosed. According to one aspect of the present invention, an interface for reclaiming memory in a multi-threaded virtual machine environment that has a virtual machine includes a first module that is associated with the virtual machine and a second module that is separate from the first module but interfaces with the first module. The first module includes a first routine for initiating a garbage collection process within the virtual machine environment, a second routine for scanning roots associated with the virtual machine environment, and a third routine for following roots through objects associated with the virtual machine environment. The second module includes a fourth routine for initializing a heap in the virtual machine environment, a fifth routine for allocating an object in the virtual machine environment, and a sixth routine for performing the garbage collection process. In one embodiment, the second module also includes a seventh routine for implementing read and write barriers for the garbage collection process.
Owner:ORACLE INT CORP
Who we serve
  • R&D Engineer
  • R&D Manager
  • IP Professional
Why Patsnap Eureka
  • Industry Leading Data Capabilities
  • Powerful AI technology
  • Patent DNA Extraction
Social media
Patsnap Eureka Blog
Learn More
PatSnap group products