2. 程式人生 > >mimalloc記憶體分配程式碼分析

mimalloc記憶體分配程式碼分析

阿新 • • 發佈：2019-07-21

這篇文章中我們會介紹一下mimalloc的實現，其中可能涉及上一篇文章提到的內容，如果不瞭解的可以先看下這篇mimalloc剖析。首先我們需要了解的是其整體結構，mimalloc的結構如下圖所示

 
mimalloc整體結構
在mimalloc中，每個執行緒都有一個Thread Local的堆，每個執行緒在進行記憶體的分配時均從該執行緒對應的堆上進行分配。在一個堆中會有一個或多個segment，一個segment會對應一個或多個頁，而記憶體的分配就是在這些頁上進行。mimalloc將頁分為三類：
  • small型別的segment的大小為4M，其負責分配大小小於MI_SMALL_SIZE_MAX的記憶體塊，該segment中一個頁的大小均為64KB，因此在一個segment中會包含多個頁，每個頁中會有多個塊
  • large型別的segment的大小為4M，其負責分配大小處於MI_SMALL_SIZE_MAX與MI_LARGE_SIZE_MAX之間的記憶體塊，該segment中僅會有一個頁，該頁佔據該segment的剩餘所有空間，該頁中會有多個塊
  • huge型別的segment，該類segment的負責分配大小大於MI_LARGE_SIZE_MAX的記憶體塊，該類segment的大小取決於需要分配的記憶體的大小，該segment中也僅包含一個頁，該頁中僅會有一個塊

根據heap的定義我們可以看到其有pages_free_direct陣列、pages陣列、Thread Delayed Free List以及一些元資訊。其中pages_free_direct陣列中每個元素對應一個記憶體塊大小的類別，其內容為一個指標，指向一個負責分配對應大小記憶體塊的頁，mimalloc在分配比較小的記憶體時可以通過該陣列直接找到對應的頁，然後試圖從該頁上分配記憶體，從而提升效率。pages陣列中每個元素為一個佇列，該佇列中所有的頁大小均相同，這些頁可能來自不同的segment，其中陣列的最後一個元素(即pages[MI_BIN_FULL])就是前文提到的Full List，倒數第二個元素(即pages[MIN_BIN_HUGE])包含了所有的huge型別的頁。thread_delayed_free就是前文提到的Thread Delayed Free List，用來讓執行緒的擁有者能夠將頁面從Full List中移除。   
struct mi_heap_s {
  mi_tld_t*             tld;
  mi_page_t*            pages_free_direct[MI_SMALL_WSIZE_MAX + 2];
  mi_page_queue_t       pages[MI_BIN_FULL + 1];
  volatile mi_block_t*  thread_delayed_free;
  uintptr_t             thread_id;
  uintptr_t             cookie;
  uintptr_t             random;
  size_t                page_count;
  bool                  no_reclaim;
};
在heap的定義中我們需要特別注意的一個成員是tld(即Thread Local Data)。其成員包括指向對應堆的heap_backing，以及用於segment分配的segment tld以及os tld。 
struct mi_tld_s {
  unsigned long long  heartbeat;
  mi_heap_t*          heap_backing;
  mi_segments_tld_t   segments;
  mi_os_tld_t         os;
  mi_stats_t          stats;
};

typedef struct mi_segments_tld_s {
  // 該佇列中所有的segment均有空閒頁，由於large與huge型別的segment僅有一個頁，因此該佇列中所有segment均為small型別
  mi_segment_queue_t  small_free;
  size_t              current_size;
  size_t              peak_size;
  size_t              cache_count;
  size_t              cache_size;
  // segment的快取
  mi_segment_queue_t  cache;
  mi_stats_t*         stats;
} mi_segments_tld_t;

typedef struct mi_os_tld_s {
  uintptr_t           mmap_next_probable;
  void*               mmap_previous;
  uint8_t*            pool;
  size_t              pool_available;
  mi_stats_t*         stats;
} mi_os_tld_t;

mi_malloc

首先要說明一下，所有貼出的原始碼都可能會有一定程度的刪減，例如一些平臺相關的程式碼，一些用於資訊統計的程式碼都可能被刪去。接下來我們跟著mi_malloc來看一下記憶體分配的流程，其流程僅有兩部，獲取該執行緒擁有的堆，然後從這個堆上分配一塊記憶體。 
extern inline void* mi_malloc(size_t size) mi_attr_noexcept {
  return mi_heap_malloc(mi_get_default_heap(), size);
}

獲取執行緒擁有的堆

首先介紹一下mimalloc有哪些堆，mimalloc會為每個執行緒保留一個Thread Local的堆，每個執行緒均使用該堆進行記憶體分配，除此之外還有一個全域性變數_mi_heap_main，該堆會被主執行緒視為Thread Local的堆，由於某些OS會用malloc來進行Thread Local的記憶體分配，因此_mi_heap_main在mimalloc尚未初始化時也會被視作預設的堆來進行記憶體分配。
我們先來看一下mi_get_default_heap，該函式會直接返回一個Thread Local的_mi_heap_default，但是該Thread Local預設是被初始化為_mi_heap_empty，之後在呼叫mi_heap_malloc時如果發現該Thread Local並未初始化則會將其初始化為一個新的堆。 
static inline mi_heap_t* mi_get_default_heap(void) {
#ifdef MI_TLS_RECURSE_GUARD
  if (!_mi_process_is_initialized) return &_mi_heap_main;
#endif
  return _mi_heap_default;
}

從堆上分配記憶體

由於mimalloc的堆維護了pages_free_direct陣列，可以直接通過該陣列來找到所有針對對應大小的small型別的頁，因此我們可以看到當需要分配的記憶體塊大小小於等於MI_SMALL_SIZE_MAX會呼叫mi_heap_malloc_small從堆上進行記憶體的分配，否則呼叫_mi_malloc_generic從堆上分配記憶體。當然由於pages_free_direct中指向的頁可能Free List已經為空了，那麼其最終還是會呼叫_mi_malloc_generic來進行新的記憶體的分配。 
extern inline void* mi_heap_malloc(mi_heap_t* heap, size_t size) mi_attr_noexcept {
  void* p;
  if (mi_likely(size <= MI_SMALL_SIZE_MAX)) {
    p = mi_heap_malloc_small(heap, size);
  }
  else {
    p = _mi_malloc_generic(heap, size);
  }
  return p;
}
先貼一張從堆上分配記憶體的總體流程圖，接下來我們仔細介紹一下這兩個函式具體的呼叫。 mi_heap_malloc流程圖

分配Small型別的記憶體塊

我們先來看一下mi_heap_malloc_small，其首先從堆的pages_free_direct陣列中找到負責分配對應大小記憶體塊的頁，之後呼叫_mi_page_malloc從該頁的Free List中分配一塊記憶體，如果該頁的Free List為空則呼叫_mi_malloc_generic來進行記憶體的分配。 
extern inline void* mi_heap_malloc_small(mi_heap_t* heap, size_t size) mi_attr_noexcept {
  mi_page_t* page = _mi_heap_get_free_small_page(heap,size);
  return _mi_page_malloc(heap, page, size);
}

extern inline void* _mi_page_malloc(mi_heap_t* heap, mi_page_t* page, size_t size) mi_attr_noexcept {
  mi_block_t* block = page->free;
  if (mi_unlikely(block == NULL)) {
    return _mi_malloc_generic(heap, size);
  }
  page->free = mi_block_next(page,block);
  page->used++;

  ...

  return block;
}

分配Large或者Huge型別的記憶體塊

接下來我們看一下_mi_malloc_generic，該函式呼叫的原因可能有如下兩種：
  • 需要分配small型別的記憶體塊，但是由pages_free_direct獲得的頁的Free List已經為空
  • 需要分配large或者huge型別的記憶體塊

我們可以看到_mi_malloc_generic的流程可以歸納為：
  • 如果需要的話進行全域性資料/執行緒相關的資料/堆的初始化
  • 呼叫回撥函式(即實現前文所說的deferred free)
  • 找到或分配新的頁
  • 從頁中分配記憶體
void* _mi_malloc_generic(mi_heap_t* heap, size_t size) mi_attr_noexcept
{
  if (mi_unlikely(!mi_heap_is_initialized(heap))) {
    mi_thread_init();
    heap = mi_get_default_heap();
  }

  _mi_deferred_free(heap, false);

  mi_page_t* page;
  if (mi_unlikely(size > MI_LARGE_SIZE_MAX)) {
    if (mi_unlikely(size >= (SIZE_MAX - MI_MAX_ALIGN_SIZE))) {
      page = NULL;
    }
    else {
      page = mi_huge_page_alloc(heap,size);
    }
  }
  else {
    page = mi_find_free_page(heap,size);
  }
  if (page == NULL) return NULL;

  return _mi_page_malloc(heap, page, size);
}

初始化

前面我們提到過每個執行緒都有一個Thread Local的堆，該堆預設被設為_mi_heap_empty。如果呼叫_mi_malloc_generic時發現該執行緒的堆為_mi_heap_empty則進行初始化。mi_thread_init會首先呼叫mi_process_init來進行程序相關資料的初始化，之後初始化Thread Local的堆。 
void mi_thread_init(void) mi_attr_noexcept
{
  // ensure our process has started already
  mi_process_init();

  // initialize the thread local default heap
  if (_mi_heap_init()) return;  // returns true if already initialized

  ...

  #endif
}
我們可以看到mi_process_init僅會被呼叫一次，其初始化了_mi_heap_main，其會被設為主執行緒的Thread Local的堆。其註冊了mi_process_done為執行緒結束的回撥函式，並呼叫mi_process_setup_auto_thread_done來設定mi_thread_done為執行緒結束時的回撥函式，而_mi_os_init則是用來設定一些與OS有關的常量，例如頁面大小等。 
void mi_process_init(void) mi_attr_noexcept {
  // ensure we are called once
  if (_mi_process_is_initialized) return;
  // access _mi_heap_default before setting _mi_process_is_initialized to ensure
  // that the TLS slot is allocated without getting into recursion on macOS
  // when using dynamic linking with interpose.
  mi_heap_t* h = _mi_heap_default;
  _mi_process_is_initialized = true;

  _mi_heap_main.thread_id = _mi_thread_id();
  uintptr_t random = _mi_random_init(_mi_heap_main.thread_id)  ^ (uintptr_t)h;
  #ifndef __APPLE__
  _mi_heap_main.cookie = (uintptr_t)&_mi_heap_main ^ random;
  #endif
  _mi_heap_main.random = _mi_random_shuffle(random);

  atexit(&mi_process_done);
  mi_process_setup_auto_thread_done();
  mi_stats_reset();
  _mi_os_init();
}
我們來看一下mi_process_done與mi_thread_done分別做了什麼。 我們可以看到mi_process_done主要是呼叫了mi_collect來回收已經分配的記憶體，該函式呼叫的也是mi_heap_collect_ex，不過由於其呼叫的引數不同，行為會稍有不同，在此處的呼叫會收集abandon segment，然後釋放這些segment。 
static void mi_process_done(void) {
  // only shutdown if we were initialized
  if (!_mi_process_is_initialized) return;
  // ensure we are called once
  static bool process_done = false;
  if (process_done) return;
  process_done = true;

  #ifndef NDEBUG
  mi_collect(true);
  #endif
}
mi_thread_done則主要是呼叫_mi_heap_done來回收部分資源。該函式會先把_mi_heap_default重新設為預設值，如果是主執行緒就設為_mi_heap_main，否則設為_mi_heap_empty。如果該執行緒不是主執行緒的話則呼叫_mi_heap_collect_abandon來回收記憶體並釋放動態分配的heap，如果是主執行緒的話會呼叫_mi_heap_destroy_pages來回收頁。 
static bool _mi_heap_done(void) {
  mi_heap_t* heap = _mi_heap_default;
  if (!mi_heap_is_initialized(heap)) return true;

  // reset default heap
  _mi_heap_default = (_mi_is_main_thread() ? &_mi_heap_main : (mi_heap_t*)&_mi_heap_empty);

  // todo: delete all non-backing heaps?

  // switch to backing heap and free it
  heap = heap->tld->heap_backing;
  if (!mi_heap_is_initialized(heap)) return false;

  // collect if not the main thread 
  if (heap != &_mi_heap_main) {
    _mi_heap_collect_abandon(heap);
  }

  // merge stats
  _mi_stats_done(&heap->tld->stats);

  // free if not the main thread
  if (heap != &_mi_heap_main) {
    _mi_os_free(heap, sizeof(mi_thread_data_t), &_mi_stats_main);
  }
#if (MI_DEBUG > 0)
  else {
    _mi_heap_destroy_pages(heap);
  }
#endif
  return false;
}
在mimalloc中，如果一個執行緒結束了，那麼其對應的Thread Local的堆就可以釋放了，但是在該堆中還可能存在有一些記憶體塊正在被使用，且此時會將對應的segment設定為ABANDON，之後由其他執行緒來獲取該segment，之後利用該segment進行對應的記憶體分配與釋放(mimalloc也有一個no_reclaim的選項，設定了該選項的堆不會主動獲取其他執行緒ABANDON的segment)。
接下來我們來看一下_mi_heap_collect_abandon，其實際呼叫了mi_heap_collect_ex，下面的程式碼中略去了部分不會被_mi_heap_done使用到的分支。該函式的流程如下：
  • 呼叫deferred free回撥函式
  • 標記當前堆的Full List中的所有頁面為Normal，從而讓其在釋放時加入Thread Free List，因為該segment之後可能會被其他執行緒接收
  • 釋放該堆的Thread Delayed Free List中的記憶體塊(不是每頁一個的Thread Free List)
  • 遍歷該堆所擁有的所有頁，對每個頁呼叫一次mi_heap_page_collect
  • 呼叫_mi_page_free_collect將頁中的Local Free List以及Thread Free List追加到Free List之後
  • 如果該頁沒有正在使用的塊則呼叫_mi_page_free將該頁釋放回對應的segment中，如果segment中所有的空閒頁均被釋放則可能直接釋放對應的segment回OS或加入堆的快取中
  • 如果該頁尚有正在使用的塊則將該頁標記為abandon，當某個segment中所有的頁均被標記為abandon後會將對應的segment加入全域性的abandon segment list中(堆中並未保留有哪些segment的資訊，因此需要遍歷所有頁來完成這一操作)
  • 釋放堆中所有快取的segment
static void mi_heap_collect_ex(mi_heap_t* heap, mi_collect_t collect)
{
  _mi_deferred_free(heap,collect > NORMAL);
  if (!mi_heap_is_initialized(heap)) return;

  // 一些接收abandon list中的segment的程式碼
  ...

  // if abandoning, mark all full pages to no longer add to delayed_free
  if (collect == ABANDON) {
    for (mi_page_t* page = heap->pages[MI_BIN_FULL].first; page != NULL; page = page->next) {
      _mi_page_use_delayed_free(page, false);  // set thread_free.delayed to MI_NO_DELAYED_FREE      
    }
  }

  // free thread delayed blocks. 
  // (if abandoning, after this there are no more local references into the pages.)
  _mi_heap_delayed_free(heap);

  // collect all pages owned by this thread
  mi_heap_visit_pages(heap, &mi_heap_page_collect, &collect, NULL);
  mi_assert_internal( collect != ABANDON || heap->thread_delayed_free == NULL );
  
  // collect segment caches
  if (collect >= FORCE) {
    _mi_segment_thread_collect(&heap->tld->segments);
  }
}

Huge型別頁面的分配

由於huge型別的頁面對應的segment中僅有一個頁，且該頁僅能分配一個塊，因此其會重新分配一個segment，從中建立新的頁面。mi_huge_page_alloc會呼叫mi_page_fresh_alloc分配一個頁面，然後將其插入堆對應的BIN中(即heap->pages[MI_BIN_HUGE])。由下圖可以看到Small與Large型別頁面分配時所呼叫的mi_find_free_page也會呼叫該函式來進行頁面的分配，接下來我們就介紹一下mi_page_fresh_alloc。 _mi_malloc_generic函式呼叫關係 我們可以看到mi_page_fresh_alloc主要做了三件事，先從堆中分配一個新的頁，並對該頁進行初始化，最後將該頁加入對應的BIN中。其中mi_segment_page_alloc就是從堆中找到一個足夠容納新頁的segment並分配一個新的頁，其會根據需要分配的記憶體塊的大小呼叫mi_segment_small_page_alloc/mi_segment_large_page_alloc/mi_segment_huge_page_alloc。 
static mi_page_t* mi_page_fresh_alloc(mi_heap_t* heap, mi_page_queue_t* pq, size_t block_size) {
  mi_page_t* page = _mi_segment_page_alloc(block_size, &heap->tld->segments, &heap->tld->os);
  if (page == NULL) return NULL;
  mi_page_init(heap, page, block_size, &heap->tld->stats);
  mi_page_queue_push(heap, pq, page);
  return page;
}
mi_huge_page_alloc/mi_large_page_alloc
mi_huge_page_alloc與mi_large_page_alloc非常類似，因為這兩種型別記憶體塊對應的segment都僅有一個頁，稍有區別的是large型別的segment的大小為4M，而huge型別的segment大小取決於需要的記憶體塊的大小。因為這兩種型別的塊的分配必須獲取新的segment，因此其均呼叫mi_segment_alloc獲取一個新的segment，然後在新獲取的segment中建立一個新的頁並標記該頁為正在使用。
接下來介紹一下其中用於分配新segment的函式mi_segment_alloc的流程：
  • 計算segment的大小，頁的大小
  • 從cache中試圖找到一個足夠大的segment，如果segment中有較多未使用的空間則會將部分空間釋放回OS
  • 設定segment的元資訊
mi_segment_small_page_alloc
Small型別的頁的分配稍微有些不同，因為large與huge型別的記憶體塊其對應的segment中均只有一個頁，而small型別的segment中每個頁均有多個頁，因此mimalloc在堆中儲存了一個segment small free list，該佇列中所有的segment均為small型別且均有空閒的頁。mi_segment_small_page_alloc會首先從該列表中試圖找到一個有空閒頁的segment，然後從該segment中分配一頁，如果分配完成後該segment中已經沒有空閒頁了則將其移出該列表，如果沒有找到則會呼叫mi_segment_alloc新分配一個segment並將其加入該列表中。

Small/Large型別頁面的分配

由於Small與Large型別的頁面中均可以包含多個塊，因此分配這兩種型別的記憶體塊時需要查詢已有的頁面，檢視其中是否有頁中有尚未分配的記憶體塊。因此其會首先找到對應的BIN，遍歷其中的所有頁面，試圖擴充套件Free List(包括利用尚未使用的空間、合併Local Free List與Thread Free List)從而找到一個有足夠空間的頁。由於在該過程中會進行Free List的合併，因此其還會釋放一些完全空閒的頁，進而可能導致segment的釋放。如果在遍歷完BIN後仍舊沒有找到空閒頁則會mi_page_fresh來分配一個新的頁，在該過程中會呼叫_mi_segment_try_reclaim_abandoned來試圖獲取一個abandon的segment，但是要注意的是重新獲取一個segment並不一定會帶來新的頁，因為可能接收的segment為large或huge型別或者其已經沒有空閒頁了，在這種情況下會去呼叫mi_page_fresh_alloc去獲取新的segment和頁或者從已有的segment中分配新的頁。

從頁中分配記憶體塊

此時我們終於獲得了一個空閒頁，我們可以從該頁中分配一個記憶體塊了，其程式碼如下。我們可以看到其首先檢查了一下當前頁的Free List是否為空，如果為空則呼叫_mi_malloc_generic，這是因為該函式的呼叫入口有兩種，第一種是分配small型別的記憶體塊時呼叫的mi_heap_malloc_small，第二種才是_mi_malloc_generic。
這裡需要介紹一下mimalloc更新pages_free_direct的機制，mimalloc通過在將一個頁向BIN中新增或者移除頁時更新對應的pages free direct陣列，由於對齊的問題，因此一個頁面的分配可能需要改變多個pages_free_direct的指向。 
extern inline void* _mi_page_malloc(mi_heap_t* heap, mi_page_t* page, size_t size) mi_attr_noexcept {
  mi_block_t* block = page->free;
  if (mi_unlikely(block == NULL)) {
    return _mi_malloc_generic(heap, size); // slow path
  }
  mi_assert_internal(block != NULL && _mi_ptr_page(block) == page);
  // pop from the free list
  page->free = mi_block_next(page,block);
  page->used++;

  ...

  return block;
}

總結

以上就是mimalloc中用於記憶體分配部分的程式碼的解析了，其中還有很多沒有講到的地方，例如其向OS請求記憶體部分的程式碼等等。文章如果有哪裡有問題，歡迎提出，對該專案感興趣的可以去看一下其倉庫1，或者參考這篇文章2。

引用

[1] https://github.com/microsoft/mimalloc [2] https://www.microsoft.com/en-us/research/publication/mimalloc-free-list-sharding-in-action/

相關推薦

mimalloc記憶體分配程式碼分析

這篇文章中我們會介紹一下mimalloc的實現，其中可能涉及上一篇文章提到的內容，如果不瞭解的可以先看下這篇mimalloc剖析。首先我們需要了解的是其整體結構，mimalloc的結構如下圖所示   mimalloc整體結構 在mimalloc中，每個執行緒都有

死磕Netty原始碼之記憶體分配詳解(二)PoolArena記憶體分配結構分析

前言 在應用層通過設定PooledByteBufAllocator來執行ByteBuf的分配，但是最終的記憶體分配工作被委託給PoolArena。由於Netty通常用於高併發系統所以各個執行緒進行記憶體分配時競爭不可避免，這可能會極大的影響記憶體分配的效率，為

深入理解JVM學習筆記(三十、JVM 記憶體分配----逃逸分析與棧上分配）

一、概念 我們之前提到過，JVM堆已經不是物件記憶體分配的唯一選擇。 棧上分配就是java虛擬機器提供的一種優化技術，基本思想是對於那些執行緒私有的物件（指的是不可能被其他執行緒訪問的物件），可以將它們打散分配在棧上，而不是分配在堆上。分配在棧上的好處是可以在函式呼叫結束

通過簡單的程式碼分析.NET物件記憶體分配

System.Windows.Forms.Button btn = new Button(); 以中間賦值符號為界限，先看左邊。System.Windows.Forms 是名稱空間，放在一邊。後面是 Button btn，也就是型別名稱,變數名的形式。 其實這跟 int i 沒區別，因為 int i 就是

反彙編C++ OOP程式碼 分析建構函式如何被呼叫 以及簡單的C++物件記憶體模型

在今天進行C++程式碼的思考時，產生一個疑問，就是C++類的建構函式是如何被呼叫的 於是就做了一個簡單的實驗來驗證自己的想法。 //main.cpp #include &lt;stdio.h&gt; class People{ private: int i; i

muduo原始碼分析(2) --記憶體分配

寫在前面： ​ 這個原始碼是分析libevent-2.0.20-stable, 並非最新版本的libevent，作者並沒有全看原始碼，在這裡會推薦以下參考的一些網站，也歡迎大家在不足的地方提出來進行討論。 什麼都沒包裝的記憶體管理 ​ 預設情況下,l

（轉）Oracle 11g記憶體分配分析(oracle 11g Memory Allocation Analysis)

開始用oracle11g有一段時間了，一直沒有整理Oracle記憶體方面的特點，尤其是在oracle11g裡面引入了 memory_max_target 和 memory_target之後，有了些新的變化和安排在memory方面； Oracle對記憶體的管理的優化從未間斷，

Libevent原始碼分析-----記憶體分配

    Libevent的記憶體分配函式還是比較簡單的，並沒有定義記憶體池之類的東西。如同前一篇部落格那樣，給予Libevent庫的使用者充分的設定權(定製)，即可以設定使用者(Libevent庫的使用者)自己的記憶體分配函式。至於怎麼分配，主動權在於使用者。但在設定(定製)

jdk原始碼分析（四）——垃圾收集器與記憶體分配策略

本章介紹的垃圾收集器與記憶體分配策略主要就三點。 第一點：垃圾收集（垃圾回收）。問題：哪些記憶體需要回收？什麼時候回收？如何回收？ 第二點：介紹垃圾收集器。問題：有幾種型別是垃圾收集器？根據第一點的介紹，屬於那種型別的？ 第三點：記憶體分配。問題：怎麼分配的？ 一、垃

Allocations分析記憶體分配

Allocations Allocations用來分析靜態記憶體分配。 Demo App Demo是一個簡單的圖片應用：首頁只有一個簡單的入口；次級頁面會讀取本地圖片，加濾鏡，然後按照瀑布流的方式顯示出來；第三個頁面提供大圖顯示； 執行程式碼：點選Photo

記憶體分配（堆、棧、BSS、程式碼段、資料段）

這兩天看了馬士兵老師的視訊、視訊中提到了一個萬能鑰匙、就是了解程式執行中對記憶體的操作、主要講了堆、棧、Data、說真的有點暈、看了兩遍、也就略懂一二、在這做個小小知道總結 簡介        

Netty原始碼分析第5章(ByteBuf)---->第8節: subPage級別的記憶體分配

  Netty原始碼分析第五章: ByteBuf   第八節: subPage級別的記憶體分配   上一小節我們剖析了page級別的記憶體分配邏輯, 這一小節帶大家剖析有關subPage級別的記憶體分配 通過之前的學習我們知道, 如果我們分配一個緩衝區大小遠

分析java.util.ArrayList的記憶體分配

看原始碼：java.util.ArrayList.class檔案，進行分析： /** * Default initial capacity. */ private static final int DEFAULT_CAPACITY =

Linux中的記憶體分配和釋放之slab分配器分析（完）

        我們在上篇文章分析cache_grow()函式的時候涉及兩個函式，我們沒有細說。一個就是kmem_getpages()和kmem_freepages()函式，這兩個函式有3個引數。kmem_cahce_t:主要是把申請到的物件加到這個快取記憶體內   flag

python原始碼分析----記憶體分配（2）

早就應該寫部分的內容了。。。。最近比較負能量。。。傷不起啊。。 上一篇說到了，在python的記憶體分配中兩個非常重要的方法：PyObject_Malloc和PyObject_Free 在具體的來這兩個方法之前，先要看看別的一些東西 //這裡用usedpool構成了一個雙

Redis原始碼分析-記憶體分配

本文轉載自Day Day Up部落格，文章對Redis的記憶體分配封裝庫進行了分析，描述了Redis在記憶體分配和使用統計方面的各種細節和技巧。 Redis中到處都會進行記憶體分配操作。為了遮蔽不同平臺之間的差異，以及統計記憶體佔用量等，Redis對記憶體分配函式進

VxWorks記憶體分配分析

記憶體顯示函式memPartShow static PART_ID  testMemoryPartId = NULL; void mem_test() {     char *memoryPool;     void * pMemory;     static con

android TV 系統記憶體使用情況分析（系統預設分配記憶體小）

系統記憶體申請分為預設記憶體和最大限度使用記憶體，一般沒有在AndroidMenifest中設定LargeHeap為true的話，使用的是預設記憶體，有些記憶體分配的很小比如48M，設定了之後就可以使用分配的最大記憶體空間了。下面是可以檢測記憶體使用量的計算方式。 // l

ART執行時為新建立物件分配記憶體的過程分析

        ART執行時和Dalvik虛擬機器一樣，在堆上為物件分配記憶體時都要解決記憶體碎片和記憶體不足問題。記憶體碎片問題可以使用dlmalloc技術解決。記憶體不足問題則通過垃圾回收和在允許範圍內增長堆大小解決。由於垃圾回收會影響程式，因此ART執行時採用力度從小到

dpdk 程式碼分析一 ： 記憶體初始化

一  前言 http://www.dpdk.org/  dpdk 是 intel 開發的x86晶片上用於高效能網路處理的基礎庫，業內比較常用的模式是linux-app模式，即 利用該基礎庫，在使用者層空間做資料包處理，有了這個基礎庫，可以方便地在寫應用層的網路包處理高