archive/jdk
1
0
Fork 0
mirror of https://github.com/openjdk/jdk.git synced 2025-09-21 03:24:38 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

6964458: Reimplement class meta-data storage to use native memory

Browse source 
Remove PermGen, allocate meta-data in metaspace linked to class loaders, rewrite GC walking, rewrite and rename metadata to be C++ classes

Co-authored-by: Stefan Karlsson <stefan.karlsson@oracle.com>
Co-authored-by: Mikael Gerdin <mikael.gerdin@oracle.com>
Co-authored-by: Tom Rodriguez <tom.rodriguez@oracle.com>
Reviewed-by: jmasa, stefank, never, coleenp, kvn, brutisso, mgerdin, dholmes, jrose, twisti, roland
This commit is contained in:
Jon Masamitsu 2012-09-01 13:25:18 -04:00 • committed by Coleen Phillimore
parent 36eee7c8c8
commit 5c58d27aac
853 changed files with 26124 additions and 82956 deletions
Download patch file Download diff file Expand all files Collapse all files

145
hotspot/src/share/vm/ci/ciObject.hpp
View file

@ -1,5 +1,5 @@
/*
* Copyright (c) 1999, 2011, Oracle and/or its affiliates. All rights reserved.
* 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
@ -25,6 +25,7 @@
#ifndef SHARE_VM_CI_CIOBJECT_HPP
#define SHARE_VM_CI_CIOBJECT_HPP
#include "ci/ciBaseObject.hpp"
#include "ci/ciClassList.hpp"
#include "memory/allocation.hpp"
#include "runtime/handles.hpp"
@ -45,10 +46,10 @@
//
// Within the VM, the oop and klass hierarchies are separate.
// The compiler interface does not preserve this separation --
// the distinction between `klassOop' and `Klass' are not
// 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.
class ciObject : public ResourceObj {
class ciObject : public ciBaseObject {
CI_PACKAGE_ACCESS
friend class ciEnv;
@ -57,13 +58,7 @@ private:
// handle may, in a small set of cases, correctly be NULL.
jobject _handle;
ciKlass* _klass;
uint _ident;
enum { FLAG_BITS = 2 };
enum {
PERM_FLAG = 1,
SCAVENGABLE_FLAG = 2
};
protected:
ciObject();
ciObject(oop o);
@ -77,30 +72,17 @@ protected:
return JNIHandles::resolve_non_null(_handle);
}
void init_flags_from(oop x) {
int flags = 0;
if (x != NULL) {
if (x->is_perm())
flags |= PERM_FLAG;
if (x->is_scavengable())
flags |= SCAVENGABLE_FLAG;
}
_ident |= flags;
}
void init_flags_from(oop x);
// Virtual behavior of the print() method.
virtual void print_impl(outputStream* st) {}
virtual const char* type_string() { return "ciObject"; }
void set_ident(uint id);
public:
// The klass of this ciObject.
ciKlass* klass();
// A number unique to this object.
uint ident();
// Are two ciObjects equal?
bool equals(ciObject* obj);
@ -119,11 +101,6 @@ public:
// True if is_perm is true or ScavengeRootsInCode > 1.
bool should_be_constant();
// Is this object guaranteed to be in the permanent part of the heap?
// If so, CollectedHeap::can_elide_permanent_oop_store_barriers is relevant.
// If the answer is false, no guarantees are made.
bool is_perm() { return (_ident & PERM_FLAG) != 0; }
// Might this object possibly move during a scavenge operation?
// If the answer is true and ScavengeRootsInCode==0, the oop cannot be embedded in code.
bool is_scavengable() { return (_ident & SCAVENGABLE_FLAG) != 0; }
@ -137,57 +114,29 @@ public:
// be registered with the oopRecorder.
jobject constant_encoding();
virtual bool is_object() const { return true; }
// What kind of ciObject is this?
virtual bool is_null_object() const { return false; }
virtual bool is_call_site() const { return false; }
virtual bool is_cpcache() const { return false; }
virtual bool is_instance() { return false; }
virtual bool is_member_name() const { return false; }
virtual bool is_method() { return false; }
virtual bool is_method_data() { return false; }
virtual bool is_method_handle() const { return false; }
virtual bool is_array() { return false; }
virtual bool is_obj_array() { return false; }
virtual bool is_type_array() { return false; }
virtual bool is_symbol() { return false; }
virtual bool is_type() { return false; }
virtual bool is_return_address() { return false; }
virtual bool is_klass() { return false; }
virtual bool is_instance_klass() { return false; }
virtual bool is_method_klass() { return false; }
virtual bool is_array_klass() { return false; }
virtual bool is_obj_array_klass() { return false; }
virtual bool is_type_array_klass() { return false; }
virtual bool is_symbol_klass() { return false; }
virtual bool is_klass_klass() { return false; }
virtual bool is_instance_klass_klass() { return false; }
virtual bool is_array_klass_klass() { return false; }
virtual bool is_obj_array_klass_klass() { return false; }
virtual bool is_type_array_klass_klass() { return false; }
// Is this a type or value which has no associated class?
// It is true of primitive types and null objects.
virtual bool is_classless() const { return false; }
// Is this ciObject a Java Language Object? That is,
// is the ciObject an instance or an array
virtual bool is_java_object() { return false; }
// Does this ciObject represent a Java Language class?
// That is, is the ciObject an instanceKlass or arrayKlass?
virtual bool is_java_klass() { return false; }
// Is this ciObject the ciInstanceKlass representing
// java.lang.Object()?
virtual bool is_java_lang_Object() { return false; }
// Does this ciObject refer to a real oop in the VM?
//
// Note: some ciObjects refer to oops which have yet to be
// created. We refer to these as "unloaded". Specifically,
// there are unloaded ciMethods, ciObjArrayKlasses, and
// ciInstanceKlasses. By convention the ciNullObject is
// considered loaded, and primitive types are considered loaded.
// Note: some ciObjects refer to oops which have yet to be created.
// We refer to these as "unloaded". Specifically, there are
// unloaded instances of java.lang.Class,
// java.lang.invoke.MethodHandle, and java.lang.invoke.MethodType.
// By convention the ciNullObject is considered loaded, and
// primitive types are considered loaded.
bool is_loaded() const {
return handle() != NULL || is_classless();
}
@ -201,10 +150,6 @@ public:
assert(is_call_site(), "bad cast");
return (ciCallSite*) this;
}
ciCPCache* as_cpcache() {
assert(is_cpcache(), "bad cast");
return (ciCPCache*) this;
}
ciInstance* as_instance() {
assert(is_instance(), "bad cast");
return (ciInstance*)this;
@ -213,14 +158,6 @@ public:
assert(is_member_name(), "bad cast");
return (ciMemberName*)this;
}
ciMethod* as_method() {
assert(is_method(), "bad cast");
return (ciMethod*)this;
}
ciMethodData* as_method_data() {
assert(is_method_data(), "bad cast");
return (ciMethodData*)this;
}
ciMethodHandle* as_method_handle() {
assert(is_method_handle(), "bad cast");
return (ciMethodHandle*) this;
@ -237,62 +174,6 @@ public:
assert(is_type_array(), "bad cast");
return (ciTypeArray*)this;
}
ciSymbol* as_symbol() {
assert(is_symbol(), "bad cast");
return (ciSymbol*)this;
}
ciType* as_type() {
assert(is_type(), "bad cast");
return (ciType*)this;
}
ciReturnAddress* as_return_address() {
assert(is_return_address(), "bad cast");
return (ciReturnAddress*)this;
}
ciKlass* as_klass() {
assert(is_klass(), "bad cast");
return (ciKlass*)this;
}
ciInstanceKlass* as_instance_klass() {
assert(is_instance_klass(), "bad cast");
return (ciInstanceKlass*)this;
}
ciMethodKlass* as_method_klass() {
assert(is_method_klass(), "bad cast");
return (ciMethodKlass*)this;
}
ciArrayKlass* as_array_klass() {
assert(is_array_klass(), "bad cast");
return (ciArrayKlass*)this;
}
ciObjArrayKlass* as_obj_array_klass() {
assert(is_obj_array_klass(), "bad cast");
return (ciObjArrayKlass*)this;
}
ciTypeArrayKlass* as_type_array_klass() {
assert(is_type_array_klass(), "bad cast");
return (ciTypeArrayKlass*)this;
}
ciKlassKlass* as_klass_klass() {
assert(is_klass_klass(), "bad cast");
return (ciKlassKlass*)this;
}
ciInstanceKlassKlass* as_instance_klass_klass() {
assert(is_instance_klass_klass(), "bad cast");
return (ciInstanceKlassKlass*)this;
}
ciArrayKlassKlass* as_array_klass_klass() {
assert(is_array_klass_klass(), "bad cast");
return (ciArrayKlassKlass*)this;
}
ciObjArrayKlassKlass* as_obj_array_klass_klass() {
assert(is_obj_array_klass_klass(), "bad cast");
return (ciObjArrayKlassKlass*)this;
}
ciTypeArrayKlassKlass* as_type_array_klass_klass() {
assert(is_type_array_klass_klass(), "bad cast");
return (ciTypeArrayKlassKlass*)this;
}
// Print debugging output about this ciObject.
void print(outputStream* st);