/*
* 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.
*
*/
#include "memory/allocation.hpp"
#include "utilities/growableArray.hpp"
//
// psTasks.hpp is a collection of GCTasks used by the
// parallelScavenge collector.
//
class GCTask;
class OopClosure;
class OopStack;
class ObjectStartArray;
class ParallelTaskTerminator;
class MutableSpace;
class PSOldGen;
class Thread;
class VMThread;
//
// ScavengeRootsTask
//
// This task scans all the roots of a given type.
//
//
public:
enum RootType {
};
private:
public:
};
//
// ThreadRootsTask
//
// This task scans the roots of a single thread. This task
// enables scanning of thread roots in parallel.
//
private:
public:
};
//
// StealTask
//
// This task is used to distribute work to idle threads.
//
private:
public:
};
//
// SerialOldToYoungRootsTask
//
// This task is used to scan for roots in the perm gen
private:
public:
};
//
// OldToYoungRootsTask
//
// This task is used to scan old to young roots in parallel
//
// A GC thread executing this tasks divides the generation (old gen)
// into slices and takes a stripe in the slice as its part of the
// work.
//
// +===============+ slice 0
// | stripe 0 |
// +---------------+
// | stripe 1 |
// +---------------+
// | stripe 2 |
// +---------------+
// | stripe 3 |
// +===============+ slice 1
// | stripe 0 |
// +---------------+
// | stripe 1 |
// +---------------+
// | stripe 2 |
// +---------------+
// | stripe 3 |
// +===============+ slice 2
// ...
//
// A task is created for each stripe. In this case there are 4 tasks
// created. A GC thread first works on its stripe within slice 0
// and then moves to its stripe in the next slice until all stripes
// exceed the top of the generation. Note that having fewer GC threads
// than stripes works because all the tasks are executed so all stripes
// will be covered. In this example if 4 tasks have been created to cover
// all the stripes and there are only 3 threads, one of the threads will
// get the tasks with the 4th stripe. However, there is a dependence in
// CardTableExtension::scavenge_contents_parallel() on the number
// of tasks created. In scavenge_contents_parallel the distance
// to the next stripe is calculated based on the number of tasks.
// If the stripe width is ssize, a task's next stripe is at
// ssize * number_of_tasks (= slice_stride). In this case after
// finishing stripe 0 in slice 0, the thread finds the stripe 0 in slice1
// by adding slice_stride to the start of stripe 0 in slice 0 to get
// to the start of stride 0 in slice 1.
private:
public:
uint stripe_total) :
};
#endif // SHARE_VM_GC_IMPLEMENTATION_PARALLELSCAVENGE_PSTASKS_HPP