Overview  Package  Class   Use  Tree  Serialized  Deprecated  Index  Help 
 PREV   NEXT FRAMES    NO FRAMES    

Uses of Interface
org.mmtk.utility.Constants

Packages that use Constants
org.jikesrvm.mm.mminterface   
org.jikesrvm.mm.mmtk   
org.jikesrvm.mm.mmtk.gcspy   
org.jikesrvm.scheduler   
org.mmtk.plan   
org.mmtk.plan.concurrent   
org.mmtk.plan.concurrent.marksweep   
org.mmtk.plan.copyms   
org.mmtk.plan.generational   
org.mmtk.plan.generational.copying   
org.mmtk.plan.generational.immix   
org.mmtk.plan.generational.marksweep   
org.mmtk.plan.immix   
org.mmtk.plan.markcompact   
org.mmtk.plan.marksweep   
org.mmtk.plan.nogc   
org.mmtk.plan.poisoned   
org.mmtk.plan.refcount   
org.mmtk.plan.refcount.backuptrace   
org.mmtk.plan.refcount.fullheap   
org.mmtk.plan.refcount.generational   
org.mmtk.plan.semispace   
org.mmtk.plan.semispace.gcspy   
org.mmtk.plan.semispace.gctrace   
org.mmtk.plan.semispace.usePrimitiveWriteBarriers   
org.mmtk.plan.stickyimmix   
org.mmtk.plan.stickyms   
org.mmtk.policy   
org.mmtk.policy.immix   
org.mmtk.utility   
org.mmtk.utility.alloc   
org.mmtk.utility.deque   
org.mmtk.utility.heap   
org.mmtk.utility.options   
org.mmtk.utility.sanitychecker   
org.mmtk.vm   
 

Uses of Constants in org.jikesrvm.mm.mminterface
 

Classes in org.jikesrvm.mm.mminterface that implement Constants
 class Barriers
           
 class MemoryManager
          The interface that the MMTk memory manager presents to Jikes RVM
 class Monitor
          This class allows JMTk to register call backs with Callbacks.
static class Selected.Collector
           
static class Selected.Mutator
           
static class Selected.Plan
           
 class ThreadContext
          RVMThread must extend this class to associate appropriate context with processor.
 

Uses of Constants in org.jikesrvm.mm.mmtk
 

Classes in org.jikesrvm.mm.mmtk that implement Constants
 class ScanBootImage
          Scan the boot image for references using the boot image reference map
 class ScanStatics
          Class that determines all JTOC slots (statics) that hold references
 class Statistics
           
 

Uses of Constants in org.jikesrvm.mm.mmtk.gcspy
 

Classes in org.jikesrvm.mm.mmtk.gcspy that implement Constants
 class Util
          This class provides generally useful methods.
 

Uses of Constants in org.jikesrvm.scheduler
 

Classes in org.jikesrvm.scheduler that implement Constants
 class RVMThread
          A generic java thread's execution context.
 

Uses of Constants in org.mmtk.plan
 

Classes in org.mmtk.plan that implement Constants
 class CollectorContext
          This class (and its sub-classes) implement per-collector thread behavior.
 class ComplexPhase
          Phases of a garbage collection.
 class ConcurrentPhase
          Phases of a garbage collection.
 class ControllerCollectorContext
           
 class MutatorContext
          This class (and its sub-classes) implement per-mutator thread behavior.
 class ParallelCollector
          TODO: Documentation.
 class ParallelCollectorGroup
          This class represents a pool of collector contexts that can be triggered to perform collection activity.
 class Phase
          A garbage collection proceeds as a sequence of phases.
 class Plan
          This abstract class implements the global core functionality for all memory management schemes.
 class Simple
          This abstract class implements the core functionality for simple collectors.
 class SimpleCollector
          This class (and its sub-classes) implement per-collector thread behavior and state.
 class SimpleMutator
          This class (and its sub-classes) implement per-mutator thread behavior and state.
 class SimplePhase
          Phases of a garbage collection.
 class StopTheWorld
          This abstract class implements the core functionality for stop-the-world collectors.
 class StopTheWorldCollector
          This class (and its sub-classes) implement per-collector thread behavior and state.
 class StopTheWorldMutator
          This class (and its sub-classes) implement per-mutator thread behavior and state.
 class Trace
          This abstract class implements the core functionality for a transitive closure over the heap.
 class TraceLocal
          This abstract class and its global counterpart implement the core functionality for a transitive closure over the heap graph.
 

Uses of Constants in org.mmtk.plan.concurrent
 

Classes in org.mmtk.plan.concurrent that implement Constants
 class Concurrent
          This class implements the global state of a concurrent collector.
 class ConcurrentCollector
          This class implements per-collector thread behavior and state for a concurrent collector.
 class ConcurrentMutator
          This class implements per-mutator thread behavior and state for a simple whole-heap concurrent collector.
 

Uses of Constants in org.mmtk.plan.concurrent.marksweep
 

Classes in org.mmtk.plan.concurrent.marksweep that implement Constants
 class CMS
          This class implements the global state of a concurrent mark-sweep collector.
 class CMSCollector
          This class implements per-collector thread behavior and state for the CMS plan, which implements a full-heap concurrent mark-sweep collector.
 class CMSMutator
          This class implements per-mutator thread behavior and state for the CMS plan, which implements a full-heap concurrent mark-sweep collector.
 class CMSTraceLocal
          This class implements the thread-local functionality for a transitive closure over a mark-sweep space.
 

Uses of Constants in org.mmtk.plan.copyms
 

Classes in org.mmtk.plan.copyms that implement Constants
 class CopyMS
          This class implements the global state of a full-heap collector with a copying nursery and mark-sweep mature space.
 class CopyMSCollector
          This class implements per-collector thread behavior and state for the CopyMS plan.
 class CopyMSMutator
          This class implements per-mutator thread behavior and state for the CopyMS plan.
 class CopyMSTraceLocal
          This class implements the thread-local functionality for a transitive closure over a coping/mark-sweep hybrid collector.
 

Uses of Constants in org.mmtk.plan.generational
 

Classes in org.mmtk.plan.generational that implement Constants
 class Gen
          This abstract class implements the core functionality of generic two-generation copying collectors.
 class GenCollector
          This abstract class implements per-collector thread behavior and state for generational copying collectors.
 class GenMatureTraceLocal
          This abstract class implements the core functionality for a transitive closure over the heap graph.
 class GenMutator
          This abstract class implements per-mutator thread behavior and state for generational copying collectors.
 class GenNurseryTraceLocal
          This class implements the core functionality for a transitive closure over the heap graph.
 

Uses of Constants in org.mmtk.plan.generational.copying
 

Classes in org.mmtk.plan.generational.copying that implement Constants
 class GenCopy
          This class implements the functionality of a standard two-generation copying collector.
 class GenCopyCollector
          This class implements per-collector thread behavior and state for the GenCopy two-generational copying collector.
 class GenCopyMatureTraceLocal
          This class implements the core functionality for a transitive closure over the heap graph, specifically in a Generational copying collector.
 class GenCopyMutator
          This class implements per-mutator thread behavior and state for the GenCopy two-generational copying collector.
 

Uses of Constants in org.mmtk.plan.generational.immix
 

Classes in org.mmtk.plan.generational.immix that implement Constants
 class GenImmix
          This class implements the functionality of a two-generation copying collector where the higher generation is an immix space.
 class GenImmixCollector
          This class implements per-collector thread behavior and state for the GenImmix two-generational copying collector.
 class GenImmixMatureDefragTraceLocal
          This class implements the core functionality for a transitive closure over the heap graph, specifically in a defragmenting pass over a generational immix collector.
 class GenImmixMatureTraceLocal
          This class implements the core functionality for a transitive closure over the heap graph, specifically in a generational immix collector.
 class GenImmixMutator
          This class implements per-mutator thread behavior and state for the GenImmix two-generational copying collector.
 

Uses of Constants in org.mmtk.plan.generational.marksweep
 

Classes in org.mmtk.plan.generational.marksweep that implement Constants
 class GenMS
          This class implements the functionality of a two-generation copying collector where the higher generation is a mark-sweep space (free list allocation, mark-sweep collection).
 class GenMSCollector
          This class implements per-collector thread behavior and state for the GenMS two-generational copying collector.
 class GenMSMatureTraceLocal
          This class implements the core functionality for a transitive closure over the heap graph, specifically in a Generational Mark-Sweep collector.
 class GenMSMutator
          This class implements per-mutator thread behavior and state for the GenMS two-generational copying collector.
 

Uses of Constants in org.mmtk.plan.immix
 

Classes in org.mmtk.plan.immix that implement Constants
 class Immix
          This class implements the global state of an immix collector.
 class ImmixCollector
          This class implements per-collector thread behavior and state for the Immix plan, which implements a full-heap immix collector.
 class ImmixDefragTraceLocal
          This class implements the thread-local functionality for a defragmenting transitive closure over an immix space.
 class ImmixMutator
          This class implements per-mutator thread behavior and state for the Immix plan, which implements a full-heap immix collector.
 class ImmixTraceLocal
          This class implements the thread-local functionality for a transitive closure over an immix space.
 

Uses of Constants in org.mmtk.plan.markcompact
 

Classes in org.mmtk.plan.markcompact that implement Constants
 class MC
          This class implements the global state of a simple sliding mark-compact collector.
 class MCCollector
          This class implements per-collector thread behavior and state for the MC plan, which implements a full-heap mark-compact collector.
 class MCForwardTraceLocal
          This class implements the thread-local functionality for a transitive closure over a mark-compact space during the forwarding phase.
 class MCMarkTraceLocal
          This class implements the thread-local functionality for a transitive closure over a mark-compact space during the initial marking phase.
 class MCMutator
          This class implements per-mutator thread behavior and state for the MC plan, which implements a full-heap mark-compact collector.
 

Uses of Constants in org.mmtk.plan.marksweep
 

Classes in org.mmtk.plan.marksweep that implement Constants
 class MS
          This class implements the global state of a simple mark-sweep collector.
 class MSCollector
          This class implements per-collector thread behavior and state for the MS plan, which implements a full-heap mark-sweep collector.
 class MSMutator
          This class implements per-mutator thread behavior and state for the MS plan, which implements a full-heap mark-sweep collector.
 class MSTraceLocal
          This class implements the thread-local functionality for a transitive closure over a mark-sweep space.
 

Uses of Constants in org.mmtk.plan.nogc
 

Classes in org.mmtk.plan.nogc that implement Constants
 class NoGC
          This class implements the global state of a a simple allocator without a collector.
 class NoGCCollector
          This class implements per-collector thread behavior and state for the NoGC plan, which simply allocates (without ever collecting until the available space is exhausted.
 class NoGCMutator
          This class implements per-mutator thread behavior and state for the NoGC plan, which simply allocates (without ever collecting until the available space is exhausted.
 class NoGCTraceLocal
          This class implements the thread-local core functionality for a transitive closure over the heap graph.
 

Uses of Constants in org.mmtk.plan.poisoned
 

Classes in org.mmtk.plan.poisoned that implement Constants
 class Poisoned
          This class implements a poisoned collector, that is essentially a test case for read and write barriers in the VM.
 class PoisonedCollector
          This class implements a poisoned collector, that is essentially a test case for read and write barriers in the VM.
 class PoisonedMutator
          This class implements a poisoned collector, that is essentially a test case for read and write barriers in the VM.
 

Uses of Constants in org.mmtk.plan.refcount
 

Classes in org.mmtk.plan.refcount that implement Constants
 class RCBase
          This class implements the global state of a reference counting collector.
 class RCBaseCollector
          This class implements the collector context for a reference counting collector.
 class RCBaseMutator
          This class implements the mutator context for a reference counting collector.
 class RCDecBuffer
          This class implements a dec-buffer for a reference counting collector
 class RCHeader
           
 

Uses of Constants in org.mmtk.plan.refcount.backuptrace
 

Classes in org.mmtk.plan.refcount.backuptrace that implement Constants
 class BTTraceLocal
          This class implements the thread-local core functionality for a transitive closure over the heap graph.
 

Uses of Constants in org.mmtk.plan.refcount.fullheap
 

Classes in org.mmtk.plan.refcount.fullheap that implement Constants
 class RC
          This class implements the global state of a reference counting collector.
 class RCCollector
          This class implements the collector context for a reference counting collector.
 class RCFindRootSetTraceLocal
          This class implements the thread-local core functionality for a transitive closure over the heap graph.
 class RCMutator
          This class implements the mutator context for a reference counting collector.
 

Uses of Constants in org.mmtk.plan.refcount.generational
 

Classes in org.mmtk.plan.refcount.generational that implement Constants
 class GenRC
          This class implements the global state of a a simple reference counting collector.
 class GenRCCollector
          This class implements the collector context for a simple reference counting collector.
 class GenRCFindRootSetTraceLocal
          This class implements the thread-local core functionality for a transitive closure over the heap graph.
 class GenRCMutator
          This class implements the mutator context for a simple reference counting collector.
 

Uses of Constants in org.mmtk.plan.semispace
 

Classes in org.mmtk.plan.semispace that implement Constants
 class SS
          This class implements a simple semi-space collector.
 class SSCollector
          This class implements per-collector thread behavior and state for the SS plan, which implements a full-heap semi-space collector.
 class SSMutator
          This class implements per-mutator thread behavior and state for the SS plan, which implements a full-heap semi-space collector.
 class SSTraceLocal
          This class implements the core functionality for a transitive closure over the heap graph.
 

Uses of Constants in org.mmtk.plan.semispace.gcspy
 

Classes in org.mmtk.plan.semispace.gcspy that implement Constants
 class SSGCspy
          This class extends a simple semi-space collector to instrument it for GCspy.
 class SSGCspyCollector
          This class implements per-collector thread behavior and state for the SSGCspy plan.
 class SSGCspyMutator
          This class implements per-mutator thread behavior and state for the SSGCspy plan.
 class SSGCspyTraceLocal
          This class implements the core functionality for a transitive closure over the heap graph.
 

Uses of Constants in org.mmtk.plan.semispace.gctrace
 

Classes in org.mmtk.plan.semispace.gctrace that implement Constants
 class GCTrace
          This plan has been modified slightly to perform the processing necessary for GC trace generation.
 class GCTraceCollector
          This class implements per-collector thread behavior and state for the GCTrace plan, which implements a GC tracing algorithm.
 class GCTraceMutator
          This class implements per-mutator thread behavior and state for the GCTrace plan, which implements a GC tracing algorithm.
 class GCTraceTraceLocal
          This plan has been modified slightly to perform the processing necessary for GC trace generation.
 

Uses of Constants in org.mmtk.plan.semispace.usePrimitiveWriteBarriers
 

Classes in org.mmtk.plan.semispace.usePrimitiveWriteBarriers that implement Constants
 class UsePrimitiveWriteBarriers
          This class exercises primitive write barriers The write barriers contain no payloads but merely perform a write to the heap
 class UsePrimitiveWriteBarriersCollector
          This class extends the SSCollector class as part of the UsePrimitiveWriteBarriers collector.
 class UsePrimitiveWriteBarriersMutator
          This class extends the SSMutator class as part of the UsePrimitiveWriteBarriers collector.
 

Uses of Constants in org.mmtk.plan.stickyimmix
 

Classes in org.mmtk.plan.stickyimmix that implement Constants
 class StickyImmix
          This class implements the global state of a simple sticky mark bits collector, based on an immix collector.
 class StickyImmixCollector
          This class implements per-collector thread behavior and state for the StickMS plan, which implements a generational sticky mark bits immix collector.
 class StickyImmixMutator
          This class implements per-mutator thread behavior and state for the StickyImmix plan, which implements a generational mark-sweep collector.
 class StickyImmixNurseryTraceLocal
          This class implements the thread-local functionality for a transitive closure over a sticky-immix space.
 

Uses of Constants in org.mmtk.plan.stickyms
 

Classes in org.mmtk.plan.stickyms that implement Constants
 class StickyMS
          This class implements the global state of a simple sticky mark bits collector, based a simple on mark-sweep collector.
 class StickyMSCollector
          This class implements per-collector thread behavior and state for the StickMS plan, which implements a generational sticky mark bits mark-sweep collector.
 class StickyMSMutator
          This class implements per-mutator thread behavior and state for the StickyMS plan, which implements a generational mark-sweep collector.
 class StickyMSNurseryTraceLocal
          This class implements the thread-local functionality for a transitive closure over a mark-sweep space.
 

Uses of Constants in org.mmtk.policy
 

Classes in org.mmtk.policy that implement Constants
 class BaseLargeObjectSpace
          Each instance of this class corresponds to one treadmill space.
 class CopyLocal
          This class implements unsynchronized (local) elements of a copying collector.
 class CopySpace
          This class implements tracing functionality for a simple copying space.
 class ExplicitFreeListLocal
          This class implements unsynchronized (local) elements of an explicitly managed collector.
 class ExplicitFreeListSpace
          Each instance of this class corresponds to one *space*.
 class ExplicitLargeObjectSpace
          Each instance of this class corresponds to one explicitly managed large object space.
 class ImmortalLocal
          This class implements unsynchronized (local) elements of an immortal space.
 class ImmortalSpace
          This class implements tracing for a simple immortal collection policy.
 class LargeObjectLocal
          Each instance of this class is intended to provide fast, unsynchronized access to a treadmill.
 class LargeObjectSpace
          Each instance of this class corresponds to one explicitly managed large object space.
 class MarkCompactLocal
          This class implements unsynchronized (local) elements of a sliding mark-compact collector.
 class MarkCompactSpace
          This class implements functionality for a simple sliding mark-compact space.
 class MarkSweepLocal
          This class implements unsynchronized (local) elements of a mark-sweep collector.
 class MarkSweepSpace
          Each instance of this class corresponds to one mark-sweep *space*.
 class RawPageSpace
          Each instance of this class corresponds to one raw page space.
 class SegregatedFreeListSpace
          Each instance of this class corresponds to one mark-sweep *space*.
 class Space
          This class defines and manages spaces.
 

Uses of Constants in org.mmtk.policy.immix
 

Classes in org.mmtk.policy.immix that implement Constants
 class Block
          This class defines operations over block-granularity meta-data
 class Chunk
           
 class ChunkList
           
 class CollectorLocal
          This class implements unsynchronized (local) elements of an immix collector.
 class Defrag
           
 class ImmixSpace
          Each instance of this class corresponds to one immix space.
 class Line
           
 class MutatorLocal
           
 

Uses of Constants in org.mmtk.utility
 

Classes in org.mmtk.utility that implement Constants
(package private)  class BaseGenericFreeList
          This is a very simple, generic malloc-free allocator.
 class Conversions
           
 class DoublyLinkedList
          FIXME This class must be re-written as it makes the assumption that the implementation language (Java) and the language being implemented are the same.
 class GenericFreeList
          This is a very simple, generic malloc-free allocator.
 class Log
          Error and trace logging.
 class Memory
          This class implements basic memory copying, setting and clearing operations.
 class SimpleHashtable
          This class implements a simple hashtable.
 class TraceGenerator
          Class that supports scanning Objects and Arrays for references during tracing, handling those references, and computing death times
 class Treadmill
          FIXME The DoublyLinkedList class, upon which this depends, must be re-written as it makes the assumption that the implementation language (Java) and the language being implemented are the same.
 

Uses of Constants in org.mmtk.utility.alloc
 

Classes in org.mmtk.utility.alloc that implement Constants
 class Allocator
          This abstract base class provides the basis for processor-local allocation.
 class BlockAllocator
          This class implements "block" data structures of various sizes.
 class BumpPointer
          This class implements a bump pointer allocator that allows linearly scanning through the allocated objects.
 class EmbeddedMetaData
          This plan implements constants and access methods for meta data that is embedded in allocation spaces (rather than kept on the side).
 class ImmixAllocator
           
 class LargeObjectAllocator
          This abstract class implements core functionality for a generic large object allocator.
 class SegregatedFreeList<S extends SegregatedFreeListSpace>
          This abstract class implements the fast past for a segregated free list.
 class SegregatedFreeListLocal<S extends SegregatedFreeListSpace>
          This abstract class implements a simple segregated free list.
 

Uses of Constants in org.mmtk.utility.deque
 

Classes in org.mmtk.utility.deque that implement Constants
 class AddressDeque
          This supports unsynchronized enqueuing and dequeuing of addresses
 class AddressPairDeque
          This supports unsynchronized enqueuing and dequeuing of address pairs
 class AddressTripleDeque
          This supports unsynchronized enqueuing and dequeuing of address triples
(package private)  class Deque
          Class that defines a doubly-linked double-ended queue (deque).
 class LocalDeque
          Note this may perform poorly when being used as a FIFO structure with insertHead and pop operations operating on the same buffer.
(package private)  class LocalQueue
          This class implements a local (unsynchronized) queue.
(package private)  class LocalSSB
          This class implements a local (unsynchronized) sequential store buffer.
 class ObjectReferenceBuffer
          This class is a combination of a Deque and a TraceStep, designed to include intelligent processing of child references as objects are scanned.
 class ObjectReferenceDeque
          This supports unsynchronized enqueuing and dequeuing of object references
 class SharedDeque
          This supports unsynchronized enqueuing and dequeuing of buffers for shared use.
 class SortSharedDeque
          This supports unsynchronized enqueuing and dequeuing of buffers for shared use.
 class SortTODAddressStack
          This supports unsynchronized pushing and popping of addresses.
 class SortTODObjectReferenceStack
          This supports unsynchronized pushing and popping of object references.
 class SortTODSharedDeque
          This class specializes SortSharedQueue to sort objects according to their time of death (TOD).
 class TraceBuffer
          This supports unsynchronized enqueuing and dequeuing of tracing data and bulk processing of the buffer.
 class WriteBuffer
          This supports unsynchronized insertion of write buffer values.
 

Uses of Constants in org.mmtk.utility.heap
 

Classes in org.mmtk.utility.heap that implement Constants
 class ConcurrentZeroingContext
          This context concurrently zeroes a space when triggered.
 class FreeListPageResource
          This class manages the allocation of pages for a space.
 class HeapGrowthManager
          This class is responsible for growing and shrinking the heap size by observing heap utilization and GC load.
 class Mmapper
          This class implements mmapping and protection of virtual memory.
 class MonotonePageResource
          This class manages the allocation of pages for a space.
 class PageResource
          This class manages the allocation of pages for a space.
 class SpaceDescriptor
          This class manages the encoding and decoding of space descriptors.
 class VMRequest
          This class manages the encoding and decoding of virtual memory requests.
 

Uses of Constants in org.mmtk.utility.options
 

Classes in org.mmtk.utility.options that implement Constants
 class TraceRate
          The granularity of the trace being produced.
 

Uses of Constants in org.mmtk.utility.sanitychecker
 

Classes in org.mmtk.utility.sanitychecker that implement Constants
 class SanityChecker
          This class performs sanity checks for Simple collectors.
 class SanityCheckerLocal
          This class performs sanity checks for Simple collectors.
 class SanityDataTable
          This class implements a simple hashtable to store and retrieve per object information for sanity checking.
 class SanityRootTraceLocal
          This class implements the parallel root-gathering part of a sanity check.
 class SanityTraceLocal
          This class implements the simply sanity closure.
 

Uses of Constants in org.mmtk.vm
 

Classes in org.mmtk.vm that implement Constants
 class Scanning
           
 

Overview  Package  Class   Use  Tree  Serialized  Deprecated  Index  Help 
 PREV   NEXT FRAMES    NO FRAMES