current路径:
#0 Array<unsigned char>::operator new (size=8, loader_data=0x7fd4c802e868, length=87, read_only=false, __the_thread__=0x7fd4c800b800) at /home/atzhang/atzhang/openjdksource/openjdk8/openjdk/hotspot/src/share/vm/utilities/array.hpp:324
#1 0x00007fd4cebf27ba in MetadataFactory::new_writeable_array<unsigned char> (loader_data=0x7fd4c802e868, length=87, __the_thread__=0x7fd4c800b800) at /home/atzhang/atzhang/openjdksource/openjdk8/openjdk/hotspot/src/share/vm/memory/metadataFactory.hpp:52
#2 0x00007fd4cebf2537 in MetadataFactory::new_writeable_array<unsigned char> (loader_data=0x7fd4c802e868, length=87, value=0 '\000', __the_thread__=0x7fd4c800b800) at /home/atzhang/atzhang/openjdksource/openjdk8/openjdk/hotspot/src/share/vm/memory/metadataFactory.hpp:57
#3 0x00007fd4cebe9a95 in ConstantPool::allocate (loader_data=0x7fd4c802e868, length=87, __the_thread__=0x7fd4c800b800) at /home/atzhang/atzhang/openjdksource/openjdk8/openjdk/hotspot/src/share/vm/oops/constantPool.cpp:47
#4 0x00007fd4ceb28bbc in ClassFileParser::parse_constant_pool (this=0x7fd4d06f2010, __the_thread__=0x7fd4c800b800) at /home/atzhang/atzhang/openjdksource/openjdk8/openjdk/hotspot/src/share/vm/classfile/classFileParser.cpp:331
#5 0x00007fd4ceb34e84 in ClassFileParser::parseClassFile (this=0x7fd4d06f2010, name=0x7fd4cc1050e8, loader_data=0x7fd4c802e868, protection_domain=..., host_klass=..., cp_patches=0x0, parsed_name=..., verify=false, __the_thread__=0x7fd4c800b800) at /home/atzhang/atzhang/openjdksource/openjdk8/openjdk/hotspot/src/share/vm/classfile/classFileParser.cpp:3774
#6 0x00007fd4ceb439b5 in ClassFileParser::parseClassFile (this=0x7fd4d06f2010, name=0x7fd4cc1050e8, loader_data=0x7fd4c802e868, protection_domain=..., parsed_name=..., verify=false, __the_thread__=0x7fd4c800b800) at /home/atzhang/atzhang/openjdksource/openjdk8/openjdk/hotspot/src/share/vm/classfile/classFileParser.hpp:468
#7 0x00007fd4ceb417cb in ClassLoader::load_classfile (h_name=0x7fd4cc1050e8, __the_thread__=0x7fd4c800b800) at /home/atzhang/atzhang/openjdksource/openjdk8/openjdk/hotspot/src/share/vm/classfile/classLoader.cpp:931
#8 0x00007fd4cf181903 in SystemDictionary::load_instance_class (class_name=0x7fd4cc1050e8, class_loader=..., __the_thread__=0x7fd4c800b800) at /home/atzhang/atzhang/openjdksource/openjdk8/openjdk/hotspot/src/share/vm/classfile/systemDictionary.cpp:1304
#9 0x00007fd4cf17fced in SystemDictionary::resolve_instance_class_or_null (name=0x7fd4cc1050e8, class_loader=..., protection_domain=..., __the_thread__=0x7fd4c800b800) at /home/atzhang/atzhang/openjdksource/openjdk8/openjdk/hotspot/src/share/vm/classfile/systemDictionary.cpp:779
#10 0x00007fd4cf17e6be in SystemDictionary::resolve_or_null (class_name=0x7fd4cc1050e8, class_loader=..., protection_domain=..., __the_thread__=0x7fd4c800b800) at /home/atzhang/atzhang/openjdksource/openjdk8/openjdk/hotspot/src/share/vm/classfile/systemDictionary.cpp:232
#11 0x00007fd4cf17e12f in SystemDictionary::resolve_or_fail (class_name=0x7fd4cc1050e8, class_loader=..., protection_domain=..., throw_error=true, __the_thread__=0x7fd4c800b800) at /home/atzhang/atzhang/openjdksource/openjdk8/openjdk/hotspot/src/share/vm/classfile/systemDictionary.cpp:171
#12 0x00007fd4cf17e451 in SystemDictionary::resolve_or_fail (class_name=0x7fd4cc1050e8, throw_error=true, __the_thread__=0x7fd4c800b800) at /home/atzhang/atzhang/openjdksource/openjdk8/openjdk/hotspot/src/share/vm/classfile/systemDictionary.cpp:212
#13 0x00007fd4cf18327b in SystemDictionary::initialize_wk_klass (id=SystemDictionary::Object_klass_knum, init_opt=0, __the_thread__=0x7fd4c800b800) at /home/atzhang/atzhang/openjdksource/openjdk8/openjdk/hotspot/src/share/vm/classfile/systemDictionary.cpp:1866
#14 0x00007fd4cf18339e in SystemDictionary::initialize_wk_klasses_until (limit_id=SystemDictionary::Cloneable_klass_knum, start_id=@0x7fd4d06f29ec: SystemDictionary::Object_klass_knum, __the_thread__=0x7fd4c800b800) at /home/atzhang/atzhang/openjdksource/openjdk8/openjdk/hotspot/src/share/vm/classfile/systemDictionary.cpp:1882
#15 0x00007fd4cf186b86 in SystemDictionary::initialize_wk_klasses_through (end_id=SystemDictionary::Class_klass_knum, start_id=@0x7fd4d06f29ec: SystemDictionary::Object_klass_knum, __the_thread__=0x7fd4c800b800) at /home/atzhang/atzhang/openjdksource/openjdk8/openjdk/hotspot/src/share/vm/classfile/systemDictionary.hpp:408
#16 0x00007fd4cf1834d0 in SystemDictionary::initialize_preloaded_classes (__the_thread__=0x7fd4c800b800) at /home/atzhang/atzhang/openjdksource/openjdk8/openjdk/hotspot/src/share/vm/classfile/systemDictionary.cpp:1901
#17 0x00007fd4cf18319d in SystemDictionary::initialize (__the_thread__=0x7fd4c800b800) at /home/atzhang/atzhang/openjdksource/openjdk8/openjdk/hotspot/src/share/vm/classfile/systemDictionary.cpp:1843
#18 0x00007fd4cf1d41d1 in Universe::genesis (__the_thread__=0x7fd4c800b800) at /home/atzhang/atzhang/openjdksource/openjdk8/openjdk/hotspot/src/share/vm/memory/universe.cpp:288
#19 0x00007fd4cf1d6439 in universe2_init () at /home/atzhang/atzhang/openjdksource/openjdk8/openjdk/hotspot/src/share/vm/memory/universe.cpp:991
#20 0x00007fd4ced6fa5c in init_globals () at /home/atzhang/atzhang/openjdksource/openjdk8/openjdk/hotspot/src/share/vm/runtime/init.cpp:114
#21 0x00007fd4cf1b7756 in Threads::create_vm (args=0x7fd4d06f2e40, canTryAgain=0x7fd4d06f2dff) at /home/atzhang/atzhang/openjdksource/openjdk8/openjdk/hotspot/src/share/vm/runtime/thread.cpp:3424
#22 0x00007fd4cee22232 in JNI_CreateJavaVM (vm=0x7fd4d06f2e88, penv=0x7fd4d06f2e80, args=0x7fd4d06f2e40) at /home/atzhang/atzhang/openjdksource/openjdk8/openjdk/hotspot/src/share/vm/prims/jni.cpp:5166
#23 0x00007fd4d00bf780 in InitializeJVM (pvm=0x7fd4d06f2e88, penv=0x7fd4d06f2e80, ifn=0x7fd4d06f2e90) at /home/atzhang/atzhang/openjdksource/openjdk8/openjdk/jdk/src/share/bin/java.c:1145
#24 0x00007fd4d00bd6f9 in JavaMain (_args=0x7ffdde8bac20) at /home/atzhang/atzhang/openjdksource/openjdk8/openjdk/jdk/src/share/bin/java.c:371
#25 0x00007fd4d02d9ea5 in start_thread () from /lib64/libpthread.so.0
#26 0x00007fd4cfbe29fd in clone () from /lib64/libc.so.6进入这个函数
void* operator new(size_t size, ClassLoaderData* loader_data, int length, bool read_only, TRAPS) throw() {
size_t word_size = Array::size(length);
return (void*) Metaspace::allocate(loader_data, word_size, read_only,
MetaspaceObj::array_type(sizeof(T)), CHECK_NULL);
}说明length= word_size=12,进入标橘子的函数,解释一下这个T为u1,能看到为case1
static MetaspaceObj::Type array_type(size_t elem_size) { //elem_size=1
switch (elem_size) {
case 1: return TypeArrayU1Type; //这个
case 2: return TypeArrayU2Type;
case 4: return TypeArrayU4Type;
case 8: return TypeArrayU8Type;
default:
return TypeArrayOtherType;
}
} 进入主函数
MetaWord* Metaspace::allocate(ClassLoaderData* loader_data, size_t word_size, //word_size=12
bool read_only, MetaspaceObj::Type type, TRAPS) { //参数type= TypeArrayU1Type
if (HAS_PENDING_EXCEPTION) {
assert(false, "Should not allocate with exception pending");
return NULL; // caller does a CHECK_NULL too
}
assert(loader_data != NULL, "Should never pass around a NULL loader_data. "
"ClassLoaderData::the_null_class_loader_data() should have been used.");
// Allocate in metaspaces without taking out a lock, because it deadlocks
// with the SymbolTable_lock. Dumping is single threaded for now. We'll have
// to revisit this for application class data sharing.
if (DumpSharedSpaces) { //不进入
assert(type > MetaspaceObj::UnknownType && type < MetaspaceObj::_number_of_types, "sanity");
Metaspace* space = read_only ? loader_data->ro_metaspace() : loader_data->rw_metaspace();
MetaWord* result = space->allocate(word_size, NonClassType);
if (result == NULL) {
report_out_of_shared_space(read_only ? SharedReadOnly : SharedReadWrite);
}
space->record_allocation(result, type, space->vsm()->get_raw_word_size(word_size));
// Zero initialize.
Copy::fill_to_aligned_words((HeapWord*)result, word_size, 0);
return result;
}
MetadataType mdtype = (type == MetaspaceObj::ClassType) ? ClassType : NonClassType; //这里mdtype= NonClassType
// Try to allocate metadata.
MetaWord* result = loader_data->metaspace_non_null()->allocate(word_size, mdtype);
if (result == NULL) {
// Allocation failed.
if (is_init_completed()) {
// Only start a GC if the bootstrapping has completed.
// Try to clean out some memory and retry.
result = Universe::heap()->collector_policy()->satisfy_failed_metadata_allocation(
loader_data, word_size, mdtype);
}
}
if (result == NULL) {
report_metadata_oome(loader_data, word_size, mdtype, CHECK_NULL);
}
// Zero initialize.
Copy::fill_to_aligned_words((HeapWord*)result, word_size, 0);
return result;
}进入主函数,标记为黄色的
Metaspace* ClassLoaderData::metaspace_non_null() {
assert(!DumpSharedSpaces, "wrong metaspace!");
// If the metaspace has not been allocated, create a new one. Might want
// to create smaller arena for Reflection class loaders also.
// The reason for the delayed allocation is because some class loaders are
// simply for delegating with no metadata of their own.
if (_metaspace == NULL) { //不为0 直接返回
MutexLockerEx ml(metaspace_lock(), Mutex::_no_safepoint_check_flag);
// Check again if metaspace has been allocated while we were getting this lock.
if (_metaspace != NULL) {
return _metaspace;
}
if (this == the_null_class_loader_data()) {
assert (class_loader() == NULL, "Must be");
set_metaspace(new Metaspace(_metaspace_lock, Metaspace::BootMetaspaceType));
} else if (is_anonymous()) {
if (TraceClassLoaderData && Verbose && class_loader() != NULL) {
tty->print_cr("is_anonymous: %s", class_loader()->klass()->internal_name());
}
set_metaspace(new Metaspace(_metaspace_lock, Metaspace::AnonymousMetaspaceType));
} else if (class_loader()->is_a(SystemDictionary::reflect_DelegatingClassLoader_klass())) {
if (TraceClassLoaderData && Verbose && class_loader() != NULL) {
tty->print_cr("is_reflection: %s", class_loader()->klass()->internal_name());
}
set_metaspace(new Metaspace(_metaspace_lock, Metaspace::ReflectionMetaspaceType));
} else {
set_metaspace(new Metaspace(_metaspace_lock, Metaspace::StandardMetaspaceType));
}
}
return _metaspace;
}元空间 _metaspace
上边直接返回没什么可看的,现在看下这个_metaspace
(gdb) p *_metaspace
$2 = (Metaspace) {<CHeapObj<256u>> = {<AllocatedObj> = {_vptr.AllocatedObj = 0x7fd4cfa2c870 <vtable for Metaspace+16>}, <No data fields>},
static _compressed_class_space_size = 0x40000000, //默认大小40M
static _first_chunk_word_size = 0x80000, //第一个NonClassType类型的MetaChunk的大小
static _first_class_chunk_word_size = 0xc000, //第一个ClassType类型的MetaChunk的大小
static _commit_alignment = 0x1000, //commit内存的粒度
static _reserve_alignment = 0x1000, //reserve内存的粒度
_vsm = 0x7fd4c8050298, //NonClassType类型的元数据对应的SpaceManager
_class_vsm = 0x7fd4c8050328, //ClassType类型的元数据对应的SpaceManager
static _space_list = 0x7fd4c802e608, // NonClassType类型的元数据对应的VirtualSpaceList
static _class_space_list = 0x7fd4c802e3a8, // ClassType类型的元数据对应的VirtualSpaceList
static _chunk_manager_metadata = 0x7fd4c802e778, //NonClassType类型的元数据对应的ChunkManager
static _chunk_manager_class = 0x7fd4c802e518, // ClassType类型的元数据对应的ChunkManager
_alloc_record_head = 0x0, //AllocRecord链表的头部元素
_alloc_record_tail = 0x0} //AllocRecord链表的尾部元素这个现在还不太懂,慢慢来吧
进入主函数标橘子色的后半部分_metaspace->allocate(word_size, mdtype);
MetaWord* Metaspace::allocate(size_t word_size, MetadataType mdtype) {
// DumpSharedSpaces doesn't use class metadata area (yet)
// Also, don't use class_vsm() unless UseCompressedClassPointers is true.
if (is_class_space_allocation(mdtype)) {//不成立
return class_vsm()->allocate(word_size); //不进入
} else {
return vsm()->allocate(word_size);
}
}SpaceManager* vsm() const { return _vsm; }_vsm的天下,就是_vsm->allocate()
主流程接着看
MetaWord* SpaceManager::allocate(size_t word_size) {
MutexLockerEx cl(lock(), Mutex::_no_safepoint_check_flag);
size_t raw_word_size = get_raw_word_size(word_size);
BlockFreelist* fl = block_freelists();
MetaWord* p = NULL;
// Allocation from the dictionary is expensive in the sense that
// the dictionary has to be searched for a size. Don't allocate
// from the dictionary until it starts to get fat. Is this
// a reasonable policy? Maybe an skinny dictionary is fast enough
// for allocations. Do some profiling. JJJ
if (fl->total_size() > allocation_from_dictionary_limit) {
p = fl->get_block(raw_word_size);
}
if (p == NULL) {
p = allocate_work(raw_word_size);
}
return p;
}进入橘子程序
size_t get_raw_word_size(size_t word_size) {
size_t byte_size = word_size * BytesPerWord;
size_t raw_bytes_size = MAX2(byte_size, sizeof(Metablock)); //sizeof(Metablock)=24
//返回96
raw_bytes_size = align_size_up(raw_bytes_size, Metachunk::object_alignment());
size_t raw_word_size = raw_bytes_size / BytesPerWord;
//返回12
assert(raw_word_size * BytesPerWord == raw_bytes_size, "Size problem");
return raw_word_size;
}查看类结构
class Metablock : public Metabase<Metablock> {
friend class VMStructs;
public:
Metablock(size_t word_size) : Metabase<Metablock>(word_size) {}
};
// Super class of Metablock and Metachunk to allow them to
// be put on the FreeList and in the BinaryTreeDictionary.
template <class T>
class Metabase VALUE_OBJ_CLASS_SPEC {
size_t _word_size;
T* _next;
T* _prev;
protected:
Metabase(size_t word_size) : _word_size(word_size), _next(NULL), _prev(NULL) {}
public:
T* next() const { return _next; }
T* prev() const { return _prev; }
void set_next(T* v) { _next = v; assert(v != this, "Boom");}
void set_prev(T* v) { _prev = v; assert(v != this, "Boom");}
void clear_next() { set_next(NULL); }
void clear_prev() { set_prev(NULL); }
size_t size() const volatile { return _word_size; }
void set_size(size_t v) { _word_size = v; }
void link_next(T* ptr) { set_next(ptr); }
void link_prev(T* ptr) { set_prev(ptr); }
void link_after(T* ptr) {
link_next(ptr);
if (ptr != NULL) ptr->link_prev((T*)this);
}
uintptr_t* end() const { return ((uintptr_t*) this) + size(); }
bool cantCoalesce() const { return false; }
bool verify_chunk_in_free_list(T* tc) const { return true; }
bool verify_par_locked() { return true; }
void assert_is_mangled() const {/* Don't check "\*/}
bool is_free() { return true; }
};主流程,进入紫色程序
//进入到这个函数 BlockFreelist* fl = block_freelists();
BlockFreelist* block_freelists() const {
return (BlockFreelist*) &_block_freelists;BlockFreelist _block_freelists;查看内存内容
(gdb) p _block_freelists
$4 = {_dictionary = 0x0, static WasteMultiplier = 4}蓝色上边不执行的if判断
if (fl->total_size() > allocation_from_dictionary_limit) {
p = fl->get_block(raw_word_size);
}
size_t total_size() {
if (dictionary() == NULL) {
return 0; //执行到这里
} else {
return dictionary()->total_size();
}
}进入蓝色程序,这个就是_vsm
// Returns the address of spaced allocated for "word_size".
// This methods does not know about blocks (Metablocks)
MetaWord* SpaceManager::allocate_work(size_t word_size) {
assert_lock_strong(_lock);
// Is there space in the current chunk?
MetaWord* result = NULL;
// For DumpSharedSpaces, only allocate out of the current chunk which is
// never null because we gave it the size we wanted. Caller reports out
// of memory if this returns null.
if (DumpSharedSpaces) { //不进入,跳过
assert(current_chunk() != NULL, "should never happen");
inc_used_metrics(word_size);
return current_chunk()->allocate(word_size); // caller handles null result
}
if (current_chunk() != NULL) { //到这里 Metachunk* current_chunk() const { return _current_chunk; }
result = current_chunk()->allocate(word_size); //Metachunk* _current_chunk;
}
if (result == NULL) {
result = grow_and_allocate(word_size);
}
if (result != NULL) {
inc_used_metrics(word_size);
assert(result != (MetaWord*) chunks_in_use(MediumIndex),
"Head of the list is being allocated");
}
return result;
}主程序进入灰色的函数,是这个Metachunk的类进行了内存分配
//接着进入
MetaWord* Metachunk::allocate(size_t word_size) { //word_size =12
MetaWord* result = NULL;
// If available, bump the pointer to allocate.
if (free_word_size() >= word_size) {
result = _top;
_top = _top + word_size;
}
return result;
}看下Metachunk对象的内存结构
(gdb) p/x _current_chunk
$5 = 0x7fd4b8800000
(gdb) p/x * _current_chunk
$6 = {<Metabase<Metachunk>> = {_word_size = 0x80000, _next = 0x0, _prev = 0x0},
_container = 0x7fd4c802e678,
_top = 0x7fd4b88000a8,
_is_tagged_free = 0x0}查看Metachunk类的结果
class Metachunk : public Metabase<Metachunk> {
friend class TestMetachunk;
// The VirtualSpaceNode containing this chunk.
VirtualSpaceNode *_container;
// Current allocation top.
MetaWord *_top;
...省略方法
}进入黄色函数内部
进入free_word_size() 方法
size_t Metachunk::free_word_size() const {
return pointer_delta(end(), _top, sizeof(MetaWord));
}
inline size_t pointer_delta(const void* left,
const void* right,
size_t element_size) {
return (((uintptr_t) left) - ((uintptr_t) right)) / element_size;
}
看的这里就知道了是用_current_chunk的end()-_top地址
// Metachunk - Quantum of allocation from a Virtualspace
// Metachunks are reused (when freed are put on a global freelist) and
// have no permanent association to a SpaceManager.
// +--------------+ <- end --+ --+ 0x7fd4b8c00000
// | | | |
// | | | free |
// | | | |
// | | | | size | capacity
// | | | |
// | | <- top -- + | 0x7fd4b88000a8
// | | | |
// | | | used |
// | | | |
// | | | |
// +--------------+ <- bottom --+ --+看end()函数的实现,是在Metachunk的父类Metabase中定义的
class Metabase VALUE_OBJ_CLASS_SPEC {
size_t _word_size;
T* _next;
T* _prev;
protected:
size_t size() const volatile { return _word_size; }
Metabase(size_t word_size) : _word_size(word_size), _next(NULL), _prev(NULL) {}
public:
....
uintptr_t* end() const { return ((uintptr_t*) this) + size(); }
...
};那么这个end() 就是理解为Metabase的word_size=0x80000+ Metabase的地址 计算后得到 0x7fd4b8c00000
那么这个top就是Metachunk类中_top成员函数
接着进入红色函数
void SpaceManager::inc_used_metrics(size_t words) {
// Add to the per SpaceManager total
Atomic::add_ptr(words, &_allocated_blocks_words);
// Add to the global total
MetaspaceAux::inc_used(mdtype(), words);
}其中查看内存
// Sum of all space in allocated chunks
size_t _allocated_blocks_words; //15个
这条就牛逼了
Atomic::add_ptr(words, &_allocated_blocks_words); //word=12 ,
(gdb) p this
$25 = (SpaceManager * const) 0x7fd4c8050298
(gdb) p _allocated_blocks_words
$26 = 15进入分红函数
inline intptr_t Atomic::add_ptr(intptr_t add_value, volatile intptr_t* dest) {
intptr_t addend = add_value;
bool mp = os::is_MP();
__asm__ __volatile__ (LOCK_IF_MP(%3) "xaddq %0,(%2)"
: "=r" (addend)
: "0" (addend), "r" (dest), "r" (mp)
: "cc", "memory");
return addend + add_value;
}这个是内联汇编的打印汇编内容
//解释,这个是将12 加上 目标地址的值15,和为27,汇编指令为
(gdb) x/15i $pc
=> 0x7fd4ce975528 <Atomic::add_ptr(long, long volatile*)+32>: mov -0x8(%rbp),%rax //这个是参数1,为12
0x7fd4ce97552c <Atomic::add_ptr(long, long volatile*)+36>: mov -0x20(%rbp),%rdx //这个是参数2,为指针地址
0x7fd4ce975530 <Atomic::add_ptr(long, long volatile*)+40>: movzbl -0x9(%rbp),%ecx
0x7fd4ce975534 <Atomic::add_ptr(long, long volatile*)+44>: cmp $0x0,%cl
0x7fd4ce975537 <Atomic::add_ptr(long, long volatile*)+47>: je 0x7fd4ce97553a <Atomic::add_ptr(long, long volatile*)+50>
0x7fd4ce975539 <Atomic::add_ptr(long, long volatile*)+49>: lock xadd %rax,(%rdx) //交换叫加,等价于 xchg eax,(),那么$rax=15,(%rdx)=12,然后$rax=27
0x7fd4ce97553e <Atomic::add_ptr(long, long volatile*)+54>: mov %rax,-0x8(%rbp) 将27 存到指针地址,即为参数2的地址,将和存入了_allocated_blocks_words
0x7fd4ce975542 <Atomic::add_ptr(long, long volatile*)+58>: mov -0x18(%rbp),%rax
0x7fd4ce975546 <Atomic::add_ptr(long, long volatile*)+62>: mov -0x8(%rbp),%rdx
0x7fd4ce97554a <Atomic::add_ptr(long, long volatile*)+66>: add %rdx,%rax
0x7fd4ce97554d <Atomic::add_ptr(long, long volatile*)+69>: leaveq
0x7fd4ce97554e <Atomic::add_ptr(long, long volatile*)+70>: retq查看内存情况
(gdb) p this
$39 = (SpaceManager * const) 0x7fd4c8050298
(gdb) p * this
$40 = (SpaceManager) {<CHeapObj<256u>> = {<AllocatedObj> = {_vptr.AllocatedObj = 0x7fd4cfa2c890 <vtable for SpaceManager+16>}, <No data fields>},
_lock = 0x7fd4c802e8f8,
_mdtype = Metaspace::NonClassType,
_chunks_in_use = {0x0, 0x0, 0x0, 0x7fd4b8800000},
_current_chunk = 0x7fd4b8800000,
static _small_chunk_limit = 4,
_allocated_blocks_words = 27, //将上边的汇编操作将15变成了17
_allocated_chunks_words = 524288,
_allocated_chunks_count = 1,
_block_freelists = {_dictionary = 0x0, static WasteMultiplier = 4},
static _expand_lock_name = 0x7fd4cf466138 "SpaceManager chunk allocation lock",
static _expand_lock_rank = 3, static _expand_lock = 0x930758}(gdb) p _vsm
$42 = (SpaceManager *) 0x7fd4c8050298,上面的就是这个_vsm接着走流程 return result; 就是分配的top值
(gdb) p result
$43 = (MetaWord *) 0x7fd4b88000a8这个对象上边的黄色函数跳出的结果
接着走流程进入最早的橘色2
// Zero initialize.
Copy::fill_to_aligned_words((HeapWord*)result, word_size, 0);
copy.hpp
static void fill_to_aligned_words(HeapWord* to, size_t count, juint value = 0) {
assert_params_aligned(to);
pd_fill_to_aligned_words(to, count, value);
}
//copy_x86.cpp
static void pd_fill_to_aligned_words(HeapWord* tohw, size_t count, juint value) {
pd_fill_to_words(tohw, count, value);
}
static void pd_fill_to_words(HeapWord* tohw, size_t count, juint value) {
#ifdef AMD64
julong* to = (julong*) tohw;
julong v = ((julong) value << 32) | value;
while (count-- > 0) {
*to++ = v;
}
#else
juint* to = (juint*)tohw;
count *= HeapWordSize / BytesPerInt;
while (count-- > 0) {
*to++ = value;
}
#endif // AMD64
}打印内存结构
(gdb) p tohw
$44 = (HeapWord *) 0x7fd4b88000a8
//以上是使用0 进行填充
(gdb) x/40x 0x7fd4b88000a8
0x7fd4b88000a8: 0x00000000 0x00000000 0x00000000 0x00000000
0x7fd4b88000b8: 0x00000000 0x00000000 0x00000000 0x00000000
0x7fd4b88000c8: 0x00000000 0x00000000 0x00000000 0x00000000
0x7fd4b88000d8: 0x00000000 0x00000000 0x00000000 0x00000000
0x7fd4b88000e8: 0x00000000 0x00000000 0x00000000 0x00000000
0x7fd4b88000f8: 0x00000000 0x00000000 0x00000000 0x00000000
0x7fd4b8800108: 0xf7f7f7f7 0xf7f7f7f7 0xf7f7f7f7 0xf7f7f7f7至此就完成了 Array