jdk8-mips64-public/hotspot: src/share/vm/ci/ciObject.cpp@01522ca68fc7 (annotated)

src/share/vm/ci/ciObject.cpp@01522ca68fc7 (annotated)

src/share/vm/ci/ciObject.cpp

Tue, 18 Jun 2013 12:31:07 -0700

author: johnc
date: Tue, 18 Jun 2013 12:31:07 -0700
changeset 5277: 01522ca68fc7
parent 4037: da91efe96a93
child 6680: 78bbf4d43a14
permissions: -rw-r--r--

8015237: Parallelize string table scanning during strong root processing
Summary: Parallelize the scanning of the intern string table by having each GC worker claim a given number of buckets. Changes were also reviewed by Per Liden <per.liden@oracle.com>.
Reviewed-by: tschatzl, stefank, twisti

 /*
  * Copyright (c) 1999, 2012, 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.
  *
  */
 #include "precompiled.hpp"
 #include "ci/ciObject.hpp"
 #include "ci/ciUtilities.hpp"
 #include "gc_interface/collectedHeap.inline.hpp"
 #include "oops/oop.inline2.hpp"
 // ciObject
 //
 // This class represents an oop in the HotSpot virtual machine.
 // Its subclasses are structured in a hierarchy which mirrors
 // an aggregate of the VM's oop and klass hierarchies (see
 // oopHierarchy.hpp).  Each instance of ciObject holds a handle
 // to a corresponding oop on the VM side and provides routines
 // for accessing the information in its oop.  By using the ciObject
 // hierarchy for accessing oops in the VM, the compiler ensures
 // that it is safe with respect to garbage collection; that is,
 // GC and compilation can proceed independently without
 // interference.
 //
 // Within the VM, the oop and klass hierarchies are separate.
 // The compiler interface does not preserve this separation --
 // the distinction between `Klass*' and `Klass' are not
 // reflected in the interface and instead the Klass hierarchy
 // is directly modeled as the subclasses of ciKlass.
 // ------------------------------------------------------------------
 // ciObject::ciObject
 ciObject::ciObject(oop o) {
   ASSERT_IN_VM;
   if (ciObjectFactory::is_initialized()) {
     _handle = JNIHandles::make_local(o);
   } else {
     _handle = JNIHandles::make_global(o);
   }
   _klass = NULL;
   init_flags_from(o);
 }
 // ------------------------------------------------------------------
 // ciObject::ciObject
 //
 ciObject::ciObject(Handle h) {
   ASSERT_IN_VM;
   if (ciObjectFactory::is_initialized()) {
     _handle = JNIHandles::make_local(h());
   } else {
     _handle = JNIHandles::make_global(h);
   }
   _klass = NULL;
   init_flags_from(h());
 }
 // ------------------------------------------------------------------
 // ciObject::ciObject
 //
 // Unloaded klass/method variant.  `klass' is the klass of the unloaded
 // klass/method, if that makes sense.
 ciObject::ciObject(ciKlass* klass) {
   ASSERT_IN_VM;
   assert(klass != NULL, "must supply klass");
   _handle = NULL;
   _klass = klass;
 }
 // ------------------------------------------------------------------
 // ciObject::ciObject
 //
 // NULL variant.  Used only by ciNullObject.
 ciObject::ciObject() {
   ASSERT_IN_VM;
   _handle = NULL;
   _klass = NULL;
 }
 // ------------------------------------------------------------------
 // ciObject::klass
 //
 // Get the ciKlass of this ciObject.
 ciKlass* ciObject::klass() {
   if (_klass == NULL) {
     if (_handle == NULL) {
       // When both _klass and _handle are NULL, we are dealing
       // with the distinguished instance of ciNullObject.
       // No one should ask it for its klass.
       assert(is_null_object(), "must be null object");
       ShouldNotReachHere();
       return NULL;
     }
     GUARDED_VM_ENTRY(
       oop o = get_oop();
       _klass = CURRENT_ENV->get_klass(o->klass());
     );
   }
   return _klass;
 }
 // ------------------------------------------------------------------
 // ciObject::equals
 //
 // Are two ciObjects equal?
 bool ciObject::equals(ciObject* obj) {
   return (this == obj);
 }
 // ------------------------------------------------------------------
 // ciObject::hash
 //
 // A hash value for the convenience of compilers.
 //
 // Implementation note: we use the address of the ciObject as the
 // basis for the hash.  Use the _ident field, which is well-behaved.
 int ciObject::hash() {
   return ident() * 31;
 }
 // ------------------------------------------------------------------
 // ciObject::constant_encoding
 //
 // The address which the compiler should embed into the
 // generated code to represent this oop.  This address
 // is not the true address of the oop -- it will get patched
 // during nmethod creation.
 //
 //
 //
 // Implementation note: we use the handle as the encoding.  The
 // nmethod constructor resolves the handle and patches in the oop.
 //
 // This method should be changed to return an generified address
 // to discourage use of the JNI handle.
 jobject ciObject::constant_encoding() {
   assert(is_null_object() || handle() != NULL, "cannot embed null pointer");
   assert(can_be_constant(), "oop must be NULL or perm");
   return handle();
 }
 // ------------------------------------------------------------------
 // ciObject::can_be_constant
 bool ciObject::can_be_constant() {
   if (ScavengeRootsInCode >= 1)  return true;  // now everybody can encode as a constant
   return handle() == NULL;
 }
 // ------------------------------------------------------------------
 // ciObject::should_be_constant()
 bool ciObject::should_be_constant() {
   if (ScavengeRootsInCode >= 2)  return true;  // force everybody to be a constant
   if (is_null_object()) return true;
   ciEnv* env = CURRENT_ENV;
     // We want Strings and Classes to be embeddable by default since
     // they used to be in the perm world.  Not all Strings used to be
     // embeddable but there's no easy way to distinguish the interned
     // from the regulars ones so just treat them all that way.
     if (klass() == env->String_klass() || klass() == env->Class_klass()) {
       return true;
     }
   if (EnableInvokeDynamic &&
       (klass()->is_subclass_of(env->MethodHandle_klass()) ||
        klass()->is_subclass_of(env->CallSite_klass()))) {
     assert(ScavengeRootsInCode >= 1, "must be");
     // We want to treat these aggressively.
     return true;
   }
   return handle() == NULL;
 }
 // ------------------------------------------------------------------
 // ciObject::should_be_constant()
 void ciObject::init_flags_from(oop x) {
   int flags = 0;
   if (x != NULL) {
     assert(Universe::heap()->is_in_reserved(x), "must be");
     if (x->is_scavengable())
       flags |= SCAVENGABLE_FLAG;
   }
   _ident |= flags;
 }
 // ------------------------------------------------------------------
 // ciObject::print
 //
 // Print debugging output about this ciObject.
 //
 // Implementation note: dispatch to the virtual print_impl behavior
 // for this ciObject.
 void ciObject::print(outputStream* st) {
   st->print("<%s", type_string());
   GUARDED_VM_ENTRY(print_impl(st);)
   st->print(" ident=%d %s address=0x%x>", ident(),
         is_scavengable() ? "SCAVENGABLE" : "",
         (address)this);
 }
 // ------------------------------------------------------------------
 // ciObject::print_oop
 //
 // Print debugging output about the oop this ciObject represents.
 void ciObject::print_oop(outputStream* st) {
   if (is_null_object()) {
     st->print_cr("NULL");
   } else if (!is_loaded()) {
     st->print_cr("UNLOADED");
   } else {
     GUARDED_VM_ENTRY(get_oop()->print_on(st);)
   }
 }

Mercurial > jdk8-mips64-public > hotspot / annotate

src/share/vm/ci/ciObject.cpp@01522ca68fc7 (annotated)

src/share/vm/ci/ciObject.cpp