jdk8-mips64-public/hotspot: src/share/vm/gc_implementation/parallelScavenge/pcTasks.hpp@1e9a9d2e6509 (annotated)

src/share/vm/gc_implementation/parallelScavenge/pcTasks.hpp@1e9a9d2e6509 (annotated)

src/share/vm/gc_implementation/parallelScavenge/pcTasks.hpp

Thu, 21 Oct 2010 11:55:10 -0700

author: never
date: Thu, 21 Oct 2010 11:55:10 -0700
changeset 2262: 1e9a9d2e6509
parent 2188: 8b10f48633dc
child 2314: f95d63e2154a
permissions: -rw-r--r--

6970683: improvements to hs_err output
Reviewed-by: kvn, jrose, dholmes, coleenp

 /*
  * Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
  * 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.
  *
  */
 // Tasks for parallel compaction of the old generation
 //
 // Tasks are created and enqueued on a task queue. The
 // tasks for parallel old collector for marking objects
 // are MarkFromRootsTask and ThreadRootsMarkingTask.
 //
 // MarkFromRootsTask's are created
 // with a root group (e.g., jni_handles) and when the do_it()
 // method of a MarkFromRootsTask is executed, it starts marking
 // form it's root group.
 //
 // ThreadRootsMarkingTask's are created for each Java thread.  When
 // the do_it() method of a ThreadRootsMarkingTask is executed, it
 // starts marking from the thread's roots.
 //
 // The enqueuing of the MarkFromRootsTask and ThreadRootsMarkingTask
 // do little more than create the task and put it on a queue.  The
 // queue is a GCTaskQueue and threads steal tasks from this GCTaskQueue.
 //
 // In addition to the MarkFromRootsTask and ThreadRootsMarkingTask
 // tasks there are StealMarkingTask tasks.  The StealMarkingTask's
 // steal a reference from the marking stack of another
 // thread and transitively marks the object of the reference
 // and internal references.  After successfully stealing a reference
 // and marking it, the StealMarkingTask drains its marking stack
 // stack before attempting another steal.
 //
 // ThreadRootsMarkingTask
 //
 // This task marks from the roots of a single thread. This task
 // enables marking of thread roots in parallel.
 //
 class ParallelTaskTerminator;
 class ThreadRootsMarkingTask : public GCTask {
  private:
   JavaThread* _java_thread;
   VMThread* _vm_thread;
  public:
   ThreadRootsMarkingTask(JavaThread* root) : _java_thread(root), _vm_thread(NULL) {}
   ThreadRootsMarkingTask(VMThread* root) : _java_thread(NULL), _vm_thread(root) {}
   char* name() { return (char *)"thread-roots-marking-task"; }
   virtual void do_it(GCTaskManager* manager, uint which);
 };
 //
 // MarkFromRootsTask
 //
 // This task marks from all the roots to all live
 // objects.
 //
 //
 class MarkFromRootsTask : public GCTask {
  public:
   enum RootType {
     universe              = 1,
     jni_handles           = 2,
     threads               = 3,
     object_synchronizer   = 4,
     flat_profiler         = 5,
     management            = 6,
     jvmti                 = 7,
     system_dictionary     = 8,
     vm_symbols            = 9,
     reference_processing  = 10,
     code_cache            = 11
   };
  private:
   RootType _root_type;
  public:
   MarkFromRootsTask(RootType value) : _root_type(value) {}
   char* name() { return (char *)"mark-from-roots-task"; }
   virtual void do_it(GCTaskManager* manager, uint which);
 };
 //
 // RefProcTaskProxy
 //
 // This task is used as a proxy to parallel reference processing tasks .
 //
 class RefProcTaskProxy : public GCTask {
   typedef AbstractRefProcTaskExecutor::ProcessTask ProcessTask;
   ProcessTask & _rp_task;
   uint          _work_id;
 public:
   RefProcTaskProxy(ProcessTask & rp_task, uint work_id)
     : _rp_task(rp_task),
       _work_id(work_id)
   { }
 private:
   virtual char* name() { return (char *)"Process referents by policy in parallel"; }
   virtual void do_it(GCTaskManager* manager, uint which);
 };
 //
 // RefEnqueueTaskProxy
 //
 // This task is used as a proxy to parallel reference processing tasks .
 //
 class RefEnqueueTaskProxy: public GCTask {
   typedef AbstractRefProcTaskExecutor::EnqueueTask EnqueueTask;
   EnqueueTask& _enq_task;
   uint         _work_id;
 public:
   RefEnqueueTaskProxy(EnqueueTask& enq_task, uint work_id)
     : _enq_task(enq_task),
       _work_id(work_id)
   { }
   virtual char* name() { return (char *)"Enqueue reference objects in parallel"; }
   virtual void do_it(GCTaskManager* manager, uint which)
   {
     _enq_task.work(_work_id);
   }
 };
 //
 // RefProcTaskExecutor
 //
 // Task executor is an interface for the reference processor to run
 // tasks using GCTaskManager.
 //
 class RefProcTaskExecutor: public AbstractRefProcTaskExecutor {
   virtual void execute(ProcessTask& task);
   virtual void execute(EnqueueTask& task);
 };
 //
 // StealMarkingTask
 //
 // This task is used to distribute work to idle threads.
 //
 class StealMarkingTask : public GCTask {
  private:
    ParallelTaskTerminator* const _terminator;
  private:
  public:
   char* name() { return (char *)"steal-marking-task"; }
   StealMarkingTask(ParallelTaskTerminator* t);
   ParallelTaskTerminator* terminator() { return _terminator; }
   virtual void do_it(GCTaskManager* manager, uint which);
 };
 //
 // StealRegionCompactionTask
 //
 // This task is used to distribute work to idle threads.
 //
 class StealRegionCompactionTask : public GCTask {
  private:
    ParallelTaskTerminator* const _terminator;
  public:
   StealRegionCompactionTask(ParallelTaskTerminator* t);
   char* name() { return (char *)"steal-region-task"; }
   ParallelTaskTerminator* terminator() { return _terminator; }
   virtual void do_it(GCTaskManager* manager, uint which);
 };
 //
 // UpdateDensePrefixTask
 //
 // This task is used to update the dense prefix
 // of a space.
 //
 class UpdateDensePrefixTask : public GCTask {
  private:
   PSParallelCompact::SpaceId _space_id;
   size_t _region_index_start;
   size_t _region_index_end;
  public:
   char* name() { return (char *)"update-dense_prefix-task"; }
   UpdateDensePrefixTask(PSParallelCompact::SpaceId space_id,
                         size_t region_index_start,
                         size_t region_index_end);
   virtual void do_it(GCTaskManager* manager, uint which);
 };
 //
 // DrainStacksCompactionTask
 //
 // This task processes regions that have been added to the stacks of each
 // compaction manager.
 //
 // Trying to use one draining thread does not work because there are no
 // guarantees about which task will be picked up by which thread.  For example,
 // if thread A gets all the preloaded regions, thread A may not get a draining
 // task (they may all be done by other threads).
 //
 class DrainStacksCompactionTask : public GCTask {
  uint _stack_index;
  uint stack_index() { return _stack_index; }
  public:
   DrainStacksCompactionTask(uint stack_index) : GCTask(),
                                                 _stack_index(stack_index) {};
   char* name() { return (char *)"drain-region-task"; }
   virtual void do_it(GCTaskManager* manager, uint which);
 };

Mercurial > jdk8-mips64-public > hotspot / annotate

src/share/vm/gc_implementation/parallelScavenge/pcTasks.hpp@1e9a9d2e6509 (annotated)

src/share/vm/gc_implementation/parallelScavenge/pcTasks.hpp