class AutoreleasePoolPage 
{
    // EMPTY_POOL_PLACEHOLDER is stored in TLS when exactly one pool is 
  ...
    id *next;
    pthread_t const thread;
    AutoreleasePoolPage * const parent;  //这里表明它是个双向链表
    AutoreleasePoolPage *child;
    uint32_t const depth;
    uint32_t hiwat;
  ...
    }

   AutoreleasePoolPage(AutoreleasePoolPage *newParent) 
        : magic(), next(begin()), thread(pthread_self()),
          parent(newParent), child(nil), 
  ...
    }

   ~AutoreleasePoolPage() 
    {
        check();
  ...
            // Restart from hotPage() every time, in case -release 
            // autoreleased more objects
           AutoreleasePoolPage *page = hotPage();  //hotPage

            // fixme I think this `while` can be `if`, but I can't prove it
  ...
#if DEBUG
        // we expect any children to be completely empty
       for (AutoreleasePoolPage *page = child; page; page = page->child) {
            assert(page->empty());
        }
  ...
        // Not recursive: we don't want to blow out the stack 
        // if a thread accumulates a stupendous amount of garbage
       AutoreleasePoolPage *page = this;
        while (page->child) page = page->child;

       AutoreleasePoolPage *deathptr;
        do {
            deathptr = page;
  ...

        // reinstate TLS value while we work
       setHotPage((AutoreleasePoolPage *)p);

       if (AutoreleasePoolPage *page = coldPage()) {
            if (!page->empty()) pop(page->begin());  // pop all of the pools
            if (DebugMissingPools || DebugPoolAllocation) {
  ...
    }

   static AutoreleasePoolPage *pageForPointer(const void *p) 
    {
        return pageForPointer((uintptr_t)p);
    }

   static AutoreleasePoolPage *pageForPointer(uintptr_t p) 
    {
       AutoreleasePoolPage *result;
        uintptr_t offset = p % SIZE;

       assert(offset >= sizeof(AutoreleasePoolPage));

       result = (AutoreleasePoolPage *)(p - offset);
        result->fastcheck();

  ...
    }

   static inline AutoreleasePoolPage *hotPage() 
    {
       AutoreleasePoolPage *result = (AutoreleasePoolPage *)
            tls_get_direct(key);
        if ((id *)result == EMPTY_POOL_PLACEHOLDER) return nil;
  ...
    }

   static inline void setHotPage(AutoreleasePoolPage *page) 
    {
        if (page) page->fastcheck();
  ...
    }

   static inline AutoreleasePoolPage *coldPage() 
    {
       AutoreleasePoolPage *result = hotPage();
        if (result) {
            while (result->parent) {
  ...
    static inline id *autoreleaseFast(id obj)
    {
       AutoreleasePoolPage *page = hotPage();
        if (page && !page->full()) {
            return page->add(obj);
  ...

    static __attribute__((noinline))
   id *autoreleaseFullPage(id obj, AutoreleasePoolPage *page)
    {
        // The hot page is full. 
  ...
        do {
            if (page->child) page = page->child;
           else page = new AutoreleasePoolPage(page);
        } while (page->full());

  ...

        // Install the first page.
       AutoreleasePoolPage *page = new AutoreleasePoolPage(nil);
        setHotPage(page);
        
  ...
    id *autoreleaseNewPage(id obj)
    {
       AutoreleasePoolPage *page = hotPage();
        if (page) return autoreleaseFullPage(obj, page);
        else return autoreleaseNoPage(obj);
 ....
    static inline void pop(void *token) 
    {
       AutoreleasePoolPage *page;
        id *stop;

 ....
        if (DebugPoolAllocation  &&  page->empty()) {
            // special case: delete everything during page-per-pool debugging
           AutoreleasePoolPage *parent = page->parent;
            page->kill();
            setHotPage(parent);
 ....
    static void init()
    {
       int r __unused = pthread_key_init_np(AutoreleasePoolPage::key, 
                                            AutoreleasePoolPage::tls_dealloc);
        assert(r == 0);
    }
 ....
        _objc_inform("AUTORELEASE POOLS for thread %p", pthread_self());

       AutoreleasePoolPage *page;
        ptrdiff_t objects = 0;
        for (page = coldPage(); page; page = page->child) {
 ....
        // Check and propagate high water mark
        // Ignore high water marks under 256 to suppress noise.
       AutoreleasePoolPage *p = hotPage();
        uint32_t mark = p->depth*COUNT + (uint32_t)(p->next - p->begin());
        if (mark > p->hiwat  &&  mark > 256) {
 ....
{
    assert(!isTaggedPointer());
   return AutoreleasePoolPage::autorelease((id)this);
}

 ....
objc_autoreleasePoolPush(void)
{
   return AutoreleasePoolPage::push();
}

 ....
objc_autoreleasePoolPop(void *ctxt)
{
   AutoreleasePoolPage::pop(ctxt);
}

 ....
_objc_autoreleasePoolPrint(void)
{
   AutoreleasePoolPage::printAll();
}

 ....
void arr_init(void) 
{
   AutoreleasePoolPage::init();
    SideTableInit();
}