jdk8-mips64-public/hotspot: src/share/vm/memory/oopFactory.cpp@5cfd8d19e546

6786503: Overflow list performance can be improved
Summary: Avoid overflow list walk in CMS & ParNew when it is unnecessary. Fix a couple of correctness issues, including a C-heap leak, in ParNew at the intersection of promotion failure, work queue overflow and object array chunking. Add stress testing option and related assertion checking.
Reviewed-by: jmasa

     1 /*

     2  * Copyright 1997-2007 Sun Microsystems, Inc.  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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,

    20  * CA 95054 USA or visit www.sun.com if you need additional information or

    21  * have any questions.

    22  *

    23  */

    25 # include "incls/_precompiled.incl"

    26 # include "incls/_oopFactory.cpp.incl"

    29 typeArrayOop oopFactory::new_charArray(const char* utf8_str, TRAPS) {

    30   int length = utf8_str == NULL ? 0 : UTF8::unicode_length(utf8_str);

    31   typeArrayOop result = new_charArray(length, CHECK_NULL);

    32   if (length > 0) {

    33     UTF8::convert_to_unicode(utf8_str, result->char_at_addr(0), length);

    34   }

    35   return result;

    36 }

    38 typeArrayOop oopFactory::new_permanent_charArray(int length, TRAPS) {

    39   return typeArrayKlass::cast(Universe::charArrayKlassObj())->allocate_permanent(length, THREAD);

    40 }

    42 typeArrayOop oopFactory::new_permanent_byteArray(int length, TRAPS) {

    43   return typeArrayKlass::cast(Universe::byteArrayKlassObj())->allocate_permanent(length, THREAD);

    44 }

    47 typeArrayOop oopFactory::new_permanent_shortArray(int length, TRAPS) {

    48   return typeArrayKlass::cast(Universe::shortArrayKlassObj())->allocate_permanent(length, THREAD);

    49 }

    52 typeArrayOop oopFactory::new_permanent_intArray(int length, TRAPS) {

    53   return typeArrayKlass::cast(Universe::intArrayKlassObj())->allocate_permanent(length, THREAD);

    54 }

    57 typeArrayOop oopFactory::new_typeArray(BasicType type, int length, TRAPS) {

    58   klassOop type_asKlassOop = Universe::typeArrayKlassObj(type);

    59   typeArrayKlass* type_asArrayKlass = typeArrayKlass::cast(type_asKlassOop);

    60   typeArrayOop result = type_asArrayKlass->allocate(length, THREAD);

    61   return result;

    62 }

    65 objArrayOop oopFactory::new_objArray(klassOop klass, int length, TRAPS) {

    66   assert(klass->is_klass(), "must be instance class");

    67   if (klass->klass_part()->oop_is_array()) {

    68     return ((arrayKlass*)klass->klass_part())->allocate_arrayArray(1, length, THREAD);

    69   } else {

    70     assert (klass->klass_part()->oop_is_instance(), "new object array with klass not an instanceKlass");

    71     return ((instanceKlass*)klass->klass_part())->allocate_objArray(1, length, THREAD);

    72   }

    73 }

    75 objArrayOop oopFactory::new_system_objArray(int length, TRAPS) {

    76   int size = objArrayOopDesc::object_size(length);

    77   KlassHandle klass (THREAD, Universe::systemObjArrayKlassObj());

    78   objArrayOop o = (objArrayOop)

    79     Universe::heap()->permanent_array_allocate(klass, size, length, CHECK_NULL);

    80   // initialization not needed, allocated cleared

    81   return o;

    82 }

    85 constantPoolOop oopFactory::new_constantPool(int length,

    86                                              bool is_conc_safe,

    87                                              TRAPS) {

    88   constantPoolKlass* ck = constantPoolKlass::cast(Universe::constantPoolKlassObj());

    89   return ck->allocate(length, is_conc_safe, CHECK_NULL);

    90 }

    93 constantPoolCacheOop oopFactory::new_constantPoolCache(int length, TRAPS) {

    94   constantPoolCacheKlass* ck = constantPoolCacheKlass::cast(Universe::constantPoolCacheKlassObj());

    95   return ck->allocate(length, CHECK_NULL);

    96 }

    99 klassOop oopFactory::new_instanceKlass(int vtable_len, int itable_len, int static_field_size,

   100                                        int nonstatic_oop_map_size, ReferenceType rt, TRAPS) {

   101   instanceKlassKlass* ikk = instanceKlassKlass::cast(Universe::instanceKlassKlassObj());

   102   return ikk->allocate_instance_klass(vtable_len, itable_len, static_field_size, nonstatic_oop_map_size, rt, CHECK_NULL);

   103 }

   106 constMethodOop oopFactory::new_constMethod(int byte_code_size,

   107                                            int compressed_line_number_size,

   108                                            int localvariable_table_length,

   109                                            int checked_exceptions_length,

   110                                            bool is_conc_safe,

   111                                            TRAPS) {

   112   klassOop cmkObj = Universe::constMethodKlassObj();

   113   constMethodKlass* cmk = constMethodKlass::cast(cmkObj);

   114   return cmk->allocate(byte_code_size, compressed_line_number_size,

   115                        localvariable_table_length, checked_exceptions_length,

   116                        is_conc_safe,

   117                        CHECK_NULL);

   118 }

   121 methodOop oopFactory::new_method(int byte_code_size, AccessFlags access_flags,

   122                                  int compressed_line_number_size,

   123                                  int localvariable_table_length,

   124                                  int checked_exceptions_length,

   125                                  bool is_conc_safe,

   126                                  TRAPS) {

   127   methodKlass* mk = methodKlass::cast(Universe::methodKlassObj());

   128   assert(!access_flags.is_native() || byte_code_size == 0,

   129          "native methods should not contain byte codes");

   130   constMethodOop cm = new_constMethod(byte_code_size,

   131                                       compressed_line_number_size,

   132                                       localvariable_table_length,

   133                                       checked_exceptions_length,

   134                                       is_conc_safe, CHECK_NULL);

   135   constMethodHandle rw(THREAD, cm);

   136   return mk->allocate(rw, access_flags, CHECK_NULL);

   137 }

   140 methodDataOop oopFactory::new_methodData(methodHandle method, TRAPS) {

   141   methodDataKlass* mdk = methodDataKlass::cast(Universe::methodDataKlassObj());

   142   return mdk->allocate(method, CHECK_NULL);

   143 }

   146 compiledICHolderOop oopFactory::new_compiledICHolder(methodHandle method, KlassHandle klass, TRAPS) {

   147   compiledICHolderKlass* ck = (compiledICHolderKlass*) Universe::compiledICHolderKlassObj()->klass_part();

   148   compiledICHolderOop c = ck->allocate(CHECK_NULL);

   149   c->set_holder_method(method());

   150   c->set_holder_klass(klass());

   151   return c;

   152 }

Mercurial > jdk8-mips64-public > hotspot / file revision

src/share/vm/memory/oopFactory.cpp@5cfd8d19e546

src/share/vm/memory/oopFactory.cpp