/*
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*
*/
#ifndef SHARE_VM_MEMORY_ITERATOR_HPP
#define SHARE_VM_MEMORY_ITERATOR_HPP
#include "memory/allocation.hpp"
#include "memory/memRegion.hpp"
#include "runtime/prefetch.hpp"
// The following classes are C++ `closures` for iterating over objects, roots and spaces
class CodeBlob;
class nmethod;
class ReferenceProcessor;
class DataLayout;
// Closure provides abortability.
protected:
bool _abort;
public:
// A subtype can use this mechanism to indicate to some iterator mapping
// functions that the iteration should cease.
};
// OopClosure is used for iterating through roots (oop*)
public:
// In support of post-processing of weak links of KlassKlass objects;
// see KlassKlass::oop_oop_iterate().
virtual const bool should_remember_klasses() const {
return false;
}
// In support of post-processing of weak references in
// ProfileData (MethodDataOop) objects; see, for example,
// VirtualCallData::oop_iterate().
virtual const bool should_remember_mdo() const { return false; }
// The methods below control how object iterations invoking this closure
// should be performed:
// If "true", invoke on header klass field.
// Controls how prefetching is done for invocations of this closure.
}
// True iff this closure may be safely applied more than once to an oop
// location without an intervening "major reset" (like the end of a GC).
virtual bool idempotent() { return false; }
virtual bool apply_to_weak_ref_discovered_field() { return false; }
#ifdef ASSERT
static bool _must_remember_klasses;
static bool must_remember_klasses();
static void set_must_remember_klasses(bool v);
#endif
};
// ObjectClosure is used for iterating through an object space
public:
// Called for each object.
};
public:
};
// Applies an oop closure to all ref fields in objects iterated over in an
// object iteration.
public:
};
// A version of ObjectClosure with "memory" (see _previous_address below)
public:
// A return value of "true" can be used by the caller to decide
// if this object's end should *NOT* be recorded in
// _previous_address above.
};
// A version of ObjectClosure that is expected to be robust
// in the face of possibly uninitialized objects.
public:
};
// The following are used in CompactibleFreeListSpace and
// ConcurrentMarkSweepGeneration.
// Blk closure (abstract class)
public:
};
// A version of BlkClosure that is expected to be robust
// in the face of possibly uninitialized objects.
public:
guarantee(false, "call do_blk_careful instead");
return 0;
}
};
// SpaceClosure is used for iterating over spaces
class Space;
class CompactibleSpace;
public:
// Called for each space
};
public:
// Called for each compactible space
virtual void do_space(CompactibleSpace* s) = 0;
};
// CodeBlobClosure is used for iterating through code blobs
// in the code cache or on thread stacks
public:
// Called for each code blob.
};
public:
// Called for each code blob, but at most once per unique blob.
// = { if (!nmethod(cb)->test_set_oops_do_mark()) do_newly_marked_nmethod(cb); }
protected:
bool _active;
public:
// = { if (active) nmethod::oops_do_marking_prologue(); }
~MarkScope();
// = { if (active) nmethod::oops_do_marking_epilogue(); }
};
};
// Applies an oop closure to all ref fields in code blobs
// iterated over in an object iteration.
bool _do_marking;
public:
// = { cb->oops_do(_cl); }
// = { if (_do_marking) super::do_code_blob(cb); else cb->oops_do(_cl); }
};
// MonitorClosure is used for iterating over monitors in the monitors cache
class ObjectMonitor;
public:
// called for each monitor in cache
virtual void do_monitor(ObjectMonitor* m) = 0;
};
// A closure that is applied without any arguments.
public:
// I would have liked to declare this a pure virtual, but that breaks
// in mysterious ways, for unknown reasons.
virtual void do_void();
};
// YieldClosure is intended for use by iteration loops
// to incrementalize their work, allowing interleaving
// of an interruptable task so as to allow other
// threads to run (which may not otherwise be able to access
// exclusive resources, for instance). Additionally, the
// closure also allows for aborting an ongoing iteration
// by means of checking the return value from the polling
// call.
public:
virtual bool should_return() = 0;
};
// Abstract closure for serializing data (read or write).
public:
// Return bool indicating whether closure implements read or write.
virtual bool reading() const = 0;
virtual void do_int(int* i) = 0;
virtual void do_ptr(void** p) = 0;
// the passed in value and fail is they don't match. This allows
// for verification that sections of the serialized data are of the
// correct length.
};
public:
// Clear LSB in symbol address; it can be set by CPSlot.
}
// Store symbol, adjusting new pointer if the original pointer was adjusted
// (symbol references in constant pool slots have their LSB set to 1).
}
};
#ifdef ASSERT
// This class is used to flag phases of a collection that
// can unload classes and which should override the
// should_remember_klasses() and remember_klass() of OopClosure.
// The _must_remember_klasses is set in the contructor and restored
// in the destructor. _must_remember_klasses is checked in assertions
// in the OopClosure implementations of should_remember_klasses() and
// remember_klass() and the expectation is that the OopClosure
// implementation should not be in use if _must_remember_klasses is set.
// Instances of RememberKlassesChecker can be place in
// marking phases of collections which can do class unloading.
// RememberKlassesChecker can be passed "false" to turn off checking.
// It is used by CMS when CMS yields to a different collector.
bool _saved_state;
bool _do_check;
public:
_do_check(true) {
// The ClassUnloading unloading flag affects the collectors except
// for CMS.
// CMS unloads classes if CMSClassUnloadingEnabled is true or
// if ExplicitGCInvokesConcurrentAndUnloadsClasses is true and
// the current collection is an explicit collection. Turning
// on the checking in general for
// ExplicitGCInvokesConcurrentAndUnloadsClasses and
// UseConcMarkSweepGC should not lead to false positives.
ClassUnloading && !UseConcMarkSweepGC ||
if (_do_check) {
}
}
if (_do_check) {
}
}
};
#endif // ASSERT
#endif // SHARE_VM_MEMORY_ITERATOR_HPP