1 /*

     2  * Copyright (c) 2000, 2015, Oracle and/or its affiliates. All rights reserved.

     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

     4  *

     5  * This code is free software; you can redistribute it and/or modify it

     6  * under the terms of the GNU General Public License version 2 only, as

     7  * published by the Free Software Foundation.

     8  *

     9  * This code is distributed in the hope that it will be useful, but WITHOUT

    10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

    12  * version 2 for more details (a copy is included in the LICENSE file that

    13  * accompanied this code).

    14  *

    15  * You should have received a copy of the GNU General Public License version

    16  * 2 along with this work; if not, write to the Free Software Foundation,

    17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

    18  *

    19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

    20  * or visit www.oracle.com if you need additional information or have any

    21  * questions.

    22  *

    23  */

    24 

    25 #include "precompiled.hpp"

    26 #include "classfile/stringTable.hpp"

    27 #include "classfile/systemDictionary.hpp"

    28 #include "code/codeCache.hpp"

    29 #include "gc_interface/collectedHeap.inline.hpp"

    30 #include "memory/sharedHeap.hpp"

    31 #include "oops/oop.inline.hpp"

    32 #include "runtime/atomic.inline.hpp"

    33 #include "runtime/fprofiler.hpp"

    34 #include "runtime/java.hpp"

    35 #include "utilities/copy.hpp"

    36 #include "utilities/workgroup.hpp"

    37 

    38 SharedHeap* SharedHeap::_sh;

    39 

    40 SharedHeap::SharedHeap() :

    41   CollectedHeap(),

    42   _workers(NULL)

    43 {

    44   _sh = this;  // ch is static, should be set only once.

    45   if (UseConcMarkSweepGC || UseG1GC) {

    46     _workers = new FlexibleWorkGang("GC Thread", ParallelGCThreads,

    47                             /* are_GC_task_threads */true,

    48                             /* are_ConcurrentGC_threads */false);

    49     if (_workers == NULL) {

    50       vm_exit_during_initialization("Failed necessary allocation.");

    51     } else {

    52       _workers->initialize_workers();

    53     }

    54   }

    55 }

    56 

    57 bool SharedHeap::heap_lock_held_for_gc() {

    58   Thread* t = Thread::current();

    59   return    Heap_lock->owned_by_self()

    60          || (   (t->is_GC_task_thread() ||  t->is_VM_thread())

    61              && _thread_holds_heap_lock_for_gc);

    62 }

    63 

    64 void SharedHeap::set_par_threads(uint t) {

    65   assert(t == 0 || !UseSerialGC, "Cannot have parallel threads");

    66   _n_par_threads = t;

    67 }

    68 

    69 SharedHeap::StrongRootsScope::StrongRootsScope(SharedHeap* heap, bool activate)

    70   : MarkScope(activate), _sh(heap)

    71 {

    72   if (_active) {

    73     Threads::change_thread_claim_parity();

    74     // Zero the claimed high water mark in the StringTable

    75     StringTable::clear_parallel_claimed_index();

    76   }

    77 }

    78 

    79 SharedHeap::StrongRootsScope::~StrongRootsScope() {

    80   Threads::assert_all_threads_claimed();

    81 }

    82 

    83 void SharedHeap::set_barrier_set(BarrierSet* bs) {

    84   _barrier_set = bs;

    85   // Cached barrier set for fast access in oops

    86   oopDesc::set_bs(bs);

    87 }

    88 

    89 void SharedHeap::post_initialize() {

    90   CollectedHeap::post_initialize();

    91   ref_processing_init();

    92 }

    93 

    94 void SharedHeap::ref_processing_init() {}