/*
* 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.
*
*/
class HeapRegion;
class G1CollectedHeap;
class G1RemSet;
class ConcurrentMark;
class DirtyCardToOopClosure;
class CMBitMap;
class CMMarkStack;
class G1ParScanThreadState;
class CMTask;
class ReferenceProcessor;
// A class that scans oops in a given heap region (much as OopsInGenClosure
// scans oops in a generation.)
protected:
public:
};
protected:
bool _during_initial_mark;
bool _mark_in_progress;
public:
bool apply_to_weak_ref_discovered_field() { return true; }
};
public:
template <class T> void do_oop_nv(T* p);
};
public:
G1ParScanClosure(G1CollectedHeap* g1, G1ParScanThreadState* par_scan_state, ReferenceProcessor* rp) :
{
_ref_processor = rp;
}
template <class T> void do_oop_nv(T* p);
};
}
}
}
public:
G1ParScanPartialArrayClosure(G1CollectedHeap* g1, G1ParScanThreadState* par_scan_state, ReferenceProcessor* rp) :
{
}
return &_scanner;
}
template <class T> void do_oop_nv(T* p);
};
template <class T> void do_oop_work(T* p);
protected:
// Mark the object if it's not already marked. This is used to mark
// objects pointed to by roots that are guaranteed not to move
// during the GC (i.e., non-CSet objects). It is MT-safe.
// Mark the object if it's not already marked. This is used to mark
// objects pointed to by roots that have been forwarded during a
// GC. It is MT-safe.
public:
ReferenceProcessor* rp) :
}
template <class T> void do_oop_nv(T* p) {
do_oop_work(p);
}
};
// The following closure types are no longer used but are retained
// for historical reasons:
// typedef G1ParCopyClosure<false, G1BarrierRS, false> G1ParScanHeapRSClosure;
// typedef G1ParCopyClosure<false, G1BarrierRS, true> G1ParScanAndMarkHeapRSClosure;
// The following closure type is defined in g1_specialized_oop_closures.hpp:
//
// typedef G1ParCopyClosure<false, G1BarrierEvac, false> G1ParScanHeapEvacClosure;
// We use a separate closure to handle references during evacuation
// failure processing.
// We could have used another instance of G1ParScanHeapEvacClosure
// (since that closure no longer assumes that the references it
// handles point into the collection set).
public:
OopClosure* oc) :
template <class T> void do_oop_nv(T* p);
bool apply_to_weak_ref_discovered_field() { return true; }
bool do_header() { return false; }
};
public:
template <class T> void do_oop_nv(T* p);
bool apply_to_weak_ref_discovered_field() { return true; }
bool do_header() { return false; }
};
// Closure for iterating over object fields during concurrent marking
private:
public:
template <class T> void do_oop_nv(T* p);
};
// Closure to scan the root regions during concurrent marking
private:
public:
template <class T> void do_oop_nv(T* p);
};
// Closure that applies the given two closures in sequence.
// Used by the RSet refinement code (when updating RSets
// during an evacuation pause) to record cards containing
// pointers into the collection set.
public:
template <class T> void do_oop_nv(T* p);
};
// A closure that returns true if it is actually applied
// to a reference
bool _triggered;
public:
template <class T> void do_oop_nv(T* p);
};
// A closure which uses a triggering closure to determine
// whether to apply an oop closure.
public:
template <class T> void do_oop_nv(T* p);
};
bool _record_refs_into_cset;
int _worker_i;
public:
bool record_refs_into_cset,
int worker_i = 0);
}
return result;
}
bool apply_to_weak_ref_discovered_field() { return true; }
template <class T> void do_oop_nv(T* p);
};
#endif // SHARE_VM_GC_IMPLEMENTATION_G1_G1OOPCLOSURES_HPP