jvm源码解读--02 Array<u1>* tags = MetadataFactory::new_writeable_array<u1>(loader_data, length, 0, CHECK_NULL); 函数引入的jvm内存分配解析

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<u1>* 的12*8个字节的内存分配和初始化,即12个MetaWord