[インデックス 1876] ファイルの概要
このコミットは、Goランタイムのメモリ管理における重要なリファクタリングを示しています。具体的には、ヒープマップ（heapmap）の実装が、汎用的なmalloc（メモリ割り当て）コードから分離され、64ビットポインタアドレスに特化した新しいファイル群（mheapmap64.cとmheapmap64.h）に移動されました。これにより、コードのモジュール性が向上し、将来的に32ビットシステム向けの異なるヒープマップ実装を容易に統合できるようになります。
コミット
commit 80f4ab47ee781a32368dcccd063c6482a97b159c
Author: Russ Cox <rsc@golang.org>
Date: Tue Mar 24 15:11:56 2009 -0700
split heapmap, which is specific to 64-bit pointer addresses,
out of malloc proper.
TBR=r
OCL=26689
CL=26689
GitHub上でのコミットページへのリンク
https://github.com/golang/go/commit/80f4ab47ee781a32368dcccd063c6482a97b159c
元コミット内容
このコミットの元の内容は、heapmapの実装をmallocの主要部分から分離することです。これは、heapmapが64ビットポインタアドレスに特化しているため、コードベースの整理と将来的な拡張性を考慮した変更です。
変更の背景
Goランタイムのメモリ管理は、効率的かつ堅牢である必要があります。その中で、heapmapは、特定のメモリページがどのMSpan（メモリ領域の管理単位）に属するかを迅速に特定するための重要なデータ構造です。当初、このheapmapの定義と関連関数は、src/runtime/malloc.hとsrc/runtime/mheap.cに直接組み込まれていました。
しかし、heapmapの実装、特にその内部構造（3レベルのラディックスツリー）は、64ビットシステムのアドレス空間の大きさに合わせて設計されていました。これは、32ビットシステムでは異なる最適化やデータ構造が必要になる可能性を示唆しています。
このコミットの背景には、以下の目的があったと考えられます。
- モジュール性の向上: 64ビットに特化したコードを分離することで、
mallocのコアロジックとheapmapの実装を明確に区別し、コードの可読性と保守性を向上させる。 - プラットフォーム依存性の管理: 将来的に32ビットシステム向けの
heapmap実装を導入する際に、既存の64ビット実装に影響を与えることなく、容易に切り替えや追加ができるようにする。 - コードの整理: 特定のアーキテクチャに依存する部分を独立したファイルにまとめることで、コードベース全体の構造をより論理的にする。
前提知識の解説
このコミットを理解するためには、以下の概念について基本的な知識が必要です。
- Goランタイム: Goプログラムの実行を管理する低レベルのシステム。ガベージコレクション、スケジューリング、メモリ管理などが含まれます。
- メモリ管理: プログラムがメモリをどのように取得し、使用し、解放するかを管理するプロセス。Goランタイムは独自のメモリマネージャを持っています。
- ヒープ (Heap): プログラムが動的にメモリを割り当てる領域。Goでは、
makeやnewで作成されたオブジェクトはヒープに割り当てられます。 - ページ (Page): オペレーティングシステムがメモリを管理する最小単位。通常、4KBなどの固定サイズです。
- MSpan: Goランタイムのメモリ管理における重要なデータ構造。連続したメモリページのブロックを表し、特定のサイズのオブジェクトを割り当てるために使用されます。
MSpanは、ガベージコレクタがオブジェクトをスキャンしたり、メモリを解放したりする際に利用されます。 - ラディックスツリー (Radix Tree): キー（この場合はページ番号）に基づいてデータを効率的に検索するためのツリーベースのデータ構造。メモリ管理では、仮想アドレスから物理アドレスへのマッピングや、特定のページがどのメモリ領域に属するかを検索するために使用されることがあります。このコミットでは、ページ番号から
MSpanへのマッピングを管理するために3レベルのラディックスツリーが使用されています。- 3レベルラディックスツリー: ページ番号を複数のビットフィールドに分割し、それぞれのビットフィールドがツリーの各レベルのインデックスとして機能します。これにより、広大なアドレス空間を効率的にマッピングできます。
- ポインタアドレス (Pointer Address): メモリ上の特定の位置を指す数値。64ビットシステムでは64ビットのポインタアドレスを使用し、32ビットシステムでは32ビットのポインタアドレスを使用します。これにより、アクセス可能なメモリ空間の大きさが異なります。
malloc: 一般的なプログラミングにおいて、動的にメモリを割り当てるための関数。Goランタイムの内部でも、低レベルのメモリ割り当てのために同様の概念が使用されます。PageID: メモリページの識別子。通常、ページのアドレスをページサイズで割った値です。MHeapMapCache:MHeapMapへの高コストなルックアップを避けるために、ページ番号からサイズクラスへの変換をキャッシュするシンプルな直接マップキャッシュ。
技術的詳細
このコミットの核心は、Goランタイムのメモリ管理におけるMHeapMapの実装の分離です。
MHeapMapは、Free(v)（メモリ解放）操作において、与えられたアドレスvを含むMSpanを特定するために使用されます。これは、ページ番号をMSpanにマッピングする3レベルのラディックスツリーとして実装されています。
元のコードでは、MHeapMapの構造体定義、関連する列挙型（MHeapMap_Level1Bitsなど）、および関数（MHeapMap_Init, MHeapMap_Get, MHeapMap_Set, MHeapMap_Preallocate）がsrc/runtime/malloc.hとsrc/runtime/mheap.cに分散して存在していました。
このコミットでは、以下の変更が行われました。
-
malloc.hからのMHeapMap関連定義の削除:MHeapMapNode2,MHeapMapNode3構造体定義。MHeapMap_Level1Bits,MHeapMap_Level2Bits,MHeapMap_Level3Bits,MHeapMap_TotalBitsなどのビットマスクとシフト値の定義。これらは64ビットアドレス空間を52ビット（64ビットアドレス - 12ビットページサイズ）でマッピングするために設計されています。MHeapMap構造体定義。MHeapMap_Init,MHeapMap_Preallocate,MHeapMap_Get,MHeapMap_GetMaybe,MHeapMap_Set関数のプロトタイプ宣言。MHeapMapCache関連の定義とマクロ。
-
mheap.cからのMHeapMap関連関数の実装の削除:MHeapMap_Init,MHeapMap_Get,MHeapMap_GetMaybe,MHeapMap_Set,MHeapMap_Preallocate関数の実装が完全に削除されました。
-
新しいファイル
src/runtime/mheapmap64.hの作成:malloc.hから削除されたMHeapMap関連の構造体、列挙型、関数プロトタイプ宣言がこの新しいヘッダーファイルに移動されました。- このファイルには、
MHeapMapが64ビットポインタアドレスに特化していること、および32ビットプラットフォームでは異なる実装が可能であることに関するコメントが含まれています。特に、3レベルツリーのメモリフットプリントに関する考察（1MB/ノード、最小3MB）や、4レベルツリーによるフットプリント削減の可能性についても言及されています。
-
新しいファイル
src/runtime/mheapmap64.cの作成:mheap.cから削除されたMHeapMap関連関数の実装がこの新しいソースファイルに移動されました。- このファイルには、
runtime.hとmalloc.hがインクルードされています。
-
malloc.hへのmheapmap64.hのインクルード:src/runtime/malloc.hの変更点として、削除されたMHeapMap関連の定義の代わりに、新しく作成されたmheapmap64.hがインクルードされるようになりました。これにより、malloc.hを使用する他のファイルは、引き続きMHeapMapの定義と関数プロトタイプにアクセスできますが、その実装は64ビットに特化したファイルにカプセル化されます。
この変更により、Goランタイムのメモリ管理コードは、アーキテクチャ固有のロジックと汎用的なロジックがより明確に分離され、コードベースの整理と将来的な拡張性が向上しました。特に、32ビットシステム向けのMHeapMap実装が必要になった場合でも、既存の64ビット実装に影響を与えることなく、新しいmheapmap32.hやmheapmap32.cのようなファイルを追加するだけで対応できるようになります。
コアとなるコードの変更箇所
このコミットによる主要な変更は以下の4つのファイルにわたります。
-
src/runtime/malloc.h:MHeapMap、MHeapMapNode2、MHeapMapNode3構造体定義の削除。MHeapMap_Level1Bitsなどのビット定義の削除。MHeapMap_Initなどの関数プロトタイプ宣言の削除。MHeapMapCache関連の定義とマクロの削除。#include "mheapmap64.h"の追加。
-
src/runtime/mheap.c:MHeapMap_Init、MHeapMap_Get、MHeapMap_GetMaybe、MHeapMap_Set、MHeapMap_Preallocate関数の実装の削除。
-
src/runtime/mheapmap64.c(新規ファイル):mheap.cから移動されたMHeapMap_Init、MHeapMap_Get、MHeapMap_GetMaybe、MHeapMap_Set、MHeapMap_Preallocate関数の実装。- ファイル冒頭にライセンス情報とコメントが追加されています。
-
src/runtime/mheapmap64.h(新規ファイル):malloc.hから移動されたMHeapMap、MHeapMapNode2、MHeapMapNode3構造体定義。MHeapMap_Level1Bitsなどのビット定義。MHeapMap_Initなどの関数プロトタイプ宣言。MHeapMapCache関連の定義とマクロ。- ファイル冒頭にライセンス情報とコメントが追加されています。
コアとなるコードの解説
src/runtime/malloc.h の変更
--- a/src/runtime/malloc.h
+++ b/src/runtime/malloc.h
@@ -253,100 +253,7 @@ void MCentral_Init(MCentral *c, int32 sizeclass);
int32 MCentral_AllocList(MCentral *c, int32 n, MLink **first);
void MCentral_FreeList(MCentral *c, int32 n, MLink *first);
--
-// Free(v) must be able to determine the MSpan containing v.
-// The MHeapMap is a 3-level radix tree mapping page numbers to MSpans.
-//
-// NOTE(rsc): On a 32-bit platform (= 20-bit page numbers),
-// we can swap in a 2-level radix tree.
-//
-// NOTE(rsc): We use a 3-level tree because tcmalloc does, but
-// having only three levels requires approximately 1 MB per node
-// in the tree, making the minimum map footprint 3 MB.
-// Using a 4-level tree would cut the minimum footprint to 256 kB.
-// On the other hand, it\'s just virtual address space: most of
-// the memory is never going to be touched, thus never paged in.
-
-typedef struct MHeapMapNode2 MHeapMapNode2;
-typedef struct MHeapMapNode3 MHeapMapNode3;
-
-enum
-{
- // 64 bit address - 12 bit page size = 52 bits to map
- MHeapMap_Level1Bits = 18,
- MHeapMap_Level2Bits = 18,
- MHeapMap_Level3Bits = 16,
-
- MHeapMap_TotalBits =
- MHeapMap_Level1Bits +
- MHeapMap_Level2Bits +
- MHeapMap_Level3Bits,
-
- MHeapMap_Level1Mask = (1<<MHeapMap_Level1Bits) - 1,
- MHeapMap_Level2Mask = (1<<MHeapMap_Level2Bits) - 1,
- MHeapMap_Level3Mask = (1<<MHeapMap_Level3Bits) - 1,
-};
-
-struct MHeapMap
-{
- void *(*allocator)(uintptr);
- MHeapMapNode2 *p[1<<MHeapMap_Level1Bits];
-};
-
-struct MHeapMapNode2
-{
- MHeapMapNode3 *p[1<<MHeapMap_Level2Bits];
-};
-
-struct MHeapMapNode3
-{
- MSpan *s[1<<MHeapMap_Level3Bits];
-};
-
-void MHeapMap_Init(MHeapMap *m, void *(*allocator)(uintptr));
-bool MHeapMap_Preallocate(MHeapMap *m, PageID k, uintptr npages);
-MSpan* MHeapMap_Get(MHeapMap *m, PageID k);
-MSpan* MHeapMap_GetMaybe(MHeapMap *m, PageID k);
-void MHeapMap_Set(MHeapMap *m, PageID k, MSpan *v);
-
-
-// Much of the time, free(v) needs to know only the size class for v,
-// not which span it came from. The MHeapMap finds the size class
-// by looking up the span.
-//
-// An MHeapMapCache is a simple direct-mapped cache translating
-// page numbers to size classes. It avoids the expensive MHeapMap
-// lookup for hot pages.
-//
-// The cache entries are 64 bits, with the page number in the low part
-// and the value at the top.
-//
-// NOTE(rsc): On a machine with 32-bit addresses (= 20-bit page numbers),
-// we can use a 16-bit cache entry by not storing the redundant 12 bits
-// of the key that are used as the entry index. Here in 64-bit land,
-// that trick won\'t work unless the hash table has 2^28 entries.
-enum
-{
- MHeapMapCache_HashBits = 12
-};
-
-struct MHeapMapCache
-{
- uintptr array[1<<MHeapMapCache_HashBits];
-};
-
-// All macros for speed (sorry).
-#define HMASK ((1<<MHeapMapCache_HashBits)-1)
-#define KBITS MHeapMap_TotalBits
-#define KMASK ((1LL<<KBITS)-1)
-
-#define MHeapMapCache_SET(cache, key, value) \
- ((cache)->array[(key) & HMASK] = (key) | ((uintptr)(value) << KBITS))
-
-#define MHeapMapCache_GET(cache, key, tmp) \
- (tmp = (cache)->array[(key) & HMASK], \
- (tmp & KMASK) == (key) ? (tmp >> KBITS) : 0)
-
+#include "mheapmap64.h"
この差分は、malloc.hからMHeapMapとMHeapMapCacheに関するすべての定義とプロトタイプ宣言が削除され、代わりにmheapmap64.hがインクルードされるようになったことを示しています。これにより、malloc.hはより汎用的なメモリ割り当てのインターフェースに特化し、アーキテクチャ固有のheapmapの詳細は別のファイルに委譲されます。
src/runtime/mheap.c の変更
--- a/src/runtime/mheap.c
+++ b/src/runtime/mheap.c
@@ -281,113 +281,6 @@ MHeap_FreeLocked(MHeap *h, MSpan *s)
// TODO(rsc): IncrementalScavenge() to return memory to OS.
}
-// 3-level radix tree mapping page ids to Span*.
-void
-MHeapMap_Init(MHeapMap *m, void *(*allocator)(size_t))
-{
- m->allocator = allocator;
-}
-
-MSpan*
-MHeapMap_Get(MHeapMap *m, PageID k)
-{
- int32 i1, i2, i3;
-
- i3 = k & MHeapMap_Level3Mask;
- k >>= MHeapMap_Level3Bits;
- i2 = k & MHeapMap_Level2Mask;
- k >>= MHeapMap_Level2Bits;
- i1 = k & MHeapMap_Level1Mask;
- k >>= MHeapMap_Level1Bits;
- if(k != 0)
- throw("MHeapMap_Get");
-
- return m->p[i1]->p[i2]->s[i3];
-}
-
-MSpan*
-MHeapMap_GetMaybe(MHeapMap *m, PageID k)
-{
- int32 i1, i2, i3;
- MHeapMapNode2 *p2;
- MHeapMapNode3 *p3;
-
- i3 = k & MHeapMap_Level3Mask;
- k >>= MHeapMap_Level3Bits;
- i2 = k & MHeapMap_Level2Mask;
- k >>= MHeapMap_Level2Bits;
- i1 = k & MHeapMap_Level1Mask;
- k >>= MHeapMap_Level1Bits;
- if(k != 0)
- throw("MHeapMap_Get");
-
- p2 = m->p[i1];
- if(p2 == nil)
- return nil;
- p3 = p2->p[i2];
- if(p3 == nil)
- return nil;
- return p3->s[i3];
-}
-
-void
-MHeapMap_Set(MHeapMap *m, PageID k, MSpan *s)
-{
- int32 i1, i2, i3;
-
- i3 = k & MHeapMap_Level3Mask;
- k >>= MHeapMap_Level3Bits;
- i2 = k & MHeapMap_Level2Mask;
- k >>= MHeapMap_Level2Bits;
- i1 = k & MHeapMap_Level1Mask;
- k >>= MHeapMap_Level1Bits;
- if(k != 0)
- throw("MHeapMap_Set");
-
- m->p[i1]->p[i2]->s[i3] = s;
-}
-
-// Allocate the storage required for entries [k, k+1, ..., k+len-1]
-// so that Get and Set calls need not check for nil pointers.
-bool
-MHeapMap_Preallocate(MHeapMap *m, PageID k, uintptr len)
-{
- uintptr end;
- int32 i1, i2;
- MHeapMapNode2 *p2;
- MHeapMapNode3 *p3;
-
- end = k+len;
- while(k < end) {
- if((k >> MHeapMap_TotalBits) != 0)
- return false;
- i2 = (k >> MHeapMap_Level3Bits) & MHeapMap_Level2Mask;
- i1 = (k >> (MHeapMap_Level3Bits + MHeapMap_Level2Bits)) & MHeapMap_Level1Mask;
-
- // first-level pointer
- if((p2 = m->p[i1]) == nil) {
- p2 = m->allocator(sizeof *p2);
- if(p2 == nil)
- return false;
- sys_memclr((byte*)p2, sizeof *p2);
- m->p[i1] = p2;
- }
-
- // second-level pointer
- if(p2->p[i2] == nil) {
- p3 = m->allocator(sizeof *p3);
- if(p3 == nil)
- return false;
- sys_memclr((byte*)p3, sizeof *p3);
- p2->p[i2] = p3;
- }
-
- // advance key past this leaf node
- k = ((k >> MHeapMap_Level3Bits) + 1) << MHeapMap_Level3Bits;
- }
- return true;
-}
-
// Initialize a new span with the given start and npages.
void
MSpan_Init(MSpan *span, PageID start, uintptr npages)
この差分は、mheap.cからMHeapMap関連の関数の実装がすべて削除されたことを示しています。これにより、mheap.cはMHeapMapの具体的な実装詳細から解放され、より高レベルのヒープ管理ロジックに集中できるようになります。
src/runtime/mheapmap64.c (新規ファイル)
// Copyright 2009 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
// Heap map, 64-bit version
// See malloc.h and mheap.c for overview.
#include "runtime.h"
#include "malloc.h"
// 3-level radix tree mapping page ids to Span*.
void
MHeapMap_Init(MHeapMap *m, void *(*allocator)(size_t))
{
m->allocator = allocator;
}
MSpan*
MHeapMap_Get(MHeapMap *m, PageID k)
{
int32 i1, i2, i3;
i3 = k & MHeapMap_Level3Mask;
k >>= MHeapMap_Level3Bits;
i2 = k & MHeapMap_Level2Mask;
k >>= MHeapMap_Level2Bits;
i1 = k & MHeapMap_Level1Mask;
k >>= MHeapMap_Level1Bits;
if(k != 0)
throw("MHeapMap_Get");
return m->p[i1]->p[i2]->s[i3];
}
MSpan*
MHeapMap_GetMaybe(MHeapMap *m, PageID k)
{
int32 i1, i2, i3;
MHeapMapNode2 *p2;
MHeapMapNode3 *p3;
i3 = k & MHeapMap_Level3Mask;
k >>= MHeapMap_Level3Bits;
i2 = k & MHeapMap_Level2Mask;
k >>= MHeapMap_Level2Bits;
i1 = k & MHeapMap_Level1Mask;
k >>= MHeapMap_Level1Bits;
if(k != 0)
throw("MHeapMap_Get");
p2 = m->p[i1];
if(p2 == nil)
return nil;
p3 = p2->p[i2];
if(p3 == nil)
return nil;
return p3->s[i3];
}
void
MHeapMap_Set(MHeapMap *m, PageID k, MSpan *s)
{
int32 i1, i2, i3;
i3 = k & MHeapMap_Level3Mask;
k >>= MHeapMap_Level3Bits;
i2 = k & MHeapMap_Level2Mask;
k >>= MHeapMap_Level2Bits;
i1 = k & MHeapMap_Level1Mask;
k >>= MHeapMap_Level1Bits;
if(k != 0)
throw("MHeapMap_Set");
m->p[i1]->p[i2]->s[i3] = s;
}
// Allocate the storage required for entries [k, k+1, ..., k+len-1]
// so that Get and Set calls need not check for nil pointers.
bool
MHeapMap_Preallocate(MHeapMap *m, PageID k, uintptr len)
{
uintptr end;
int32 i1, i2;
MHeapMapNode2 *p2;
MHeapMapNode3 *p3;
end = k+len;
while(k < end) {
if((k >> MHeapMap_TotalBits) != 0)
return false;
i2 = (k >> MHeapMap_Level3Bits) & MHeapMap_Level2Mask;
i1 = (k >> (MHeapMap_Level3Bits + MHeapMap_Level2Bits)) & MHeapMap_Level1Mask;
// first-level pointer
if((p2 = m->p[i1]) == nil) {
p2 = m->allocator(sizeof *p2);
if(p2 == nil)
return false;
sys_memclr((byte*)p2, sizeof *p2);
m->p[i1] = p2;
}
// second-level pointer
if(p2->p[i2] == nil) {
p3 = m->allocator(sizeof *p3);
if(p3 == nil)
return false;
sys_memclr((byte*)p3, sizeof *p3);
p2->p[i2] = p3;
}
// advance key past this leaf node
k = ((k >> MHeapMap_Level3Bits) + 1) << MHeapMap_Level3Bits;
}
return true;
}
このファイルは、mheap.cから移動されたMHeapMap関連の関数の実装をすべて含んでいます。これらの関数は、ページIDからMSpanへのマッピングを管理する3レベルのラディックスツリーの操作（初期化、取得、設定、事前割り当て）を行います。
src/runtime/mheapmap64.h (新規ファイル)
// Copyright 2009 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
// Free(v) must be able to determine the MSpan containing v.
// The MHeapMap is a 3-level radix tree mapping page numbers to MSpans.
//
// NOTE(rsc): On a 32-bit platform (= 20-bit page numbers),
// we can swap in a 2-level radix tree.
//
// NOTE(rsc): We use a 3-level tree because tcmalloc does, but
// having only three levels requires approximately 1 MB per node
// in the tree, making the minimum map footprint 3 MB.
// Using a 4-level tree would cut the minimum footprint to 256 kB.
// On the other hand, it\'s just virtual address space: most of
// the memory is never going to be touched, thus never paged in.
typedef struct MHeapMapNode2 MHeapMapNode2;
typedef struct MHeapMapNode3 MHeapMapNode3;
enum
{
// 64 bit address - 12 bit page size = 52 bits to map
MHeapMap_Level1Bits = 18,
MHeapMap_Level2Bits = 18,
MHeapMap_Level3Bits = 16,
MHeapMap_TotalBits =
MHeapMap_Level1Bits +
MHeapMap_Level2Bits +
MHeapMap_Level3Bits,
MHeapMap_Level1Mask = (1<<MHeapMap_Level1Bits) - 1,
MHeapMap_Level2Mask = (1<<MHeapMap_Level2Bits) - 1,
MHeapMap_Level3Mask = (1<<MHeapMap_Level3Bits) - 1,
};
struct MHeapMap
{
void *(*allocator)(uintptr);
MHeapMapNode2 *p[1<<MHeapMap_Level1Bits];
};
struct MHeapMapNode2
{
MHeapMapNode3 *p[1<<MHeapMap_Level2Bits];
};
struct MHeapMapNode3
{
MSpan *s[1<<MHeapMap_Level3Bits];
};
void MHeapMap_Init(MHeapMap *m, void *(*allocator)(uintptr));
bool MHeapMap_Preallocate(MHeapMap *m, PageID k, uintptr npages);
MSpan* MHeapMap_Get(MHeapMap *m, PageID k);
MSpan* MHeapMap_GetMaybe(MHeapMap *m, PageID k);
void MHeapMap_Set(MHeapMap *m, PageID k, MSpan *v);
// Much of the time, free(v) needs to know only the size class for v,
// not which span it came from. The MHeapMap finds the size class
// by looking up the span.
//
// An MHeapMapCache is a simple direct-mapped cache translating
// page numbers to size classes. It avoids the expensive MHeapMap
// lookup for hot pages.
//
// The cache entries are 64 bits, with the page number in the low part
// and the value at the top.
//
// NOTE(rsc): On a machine with 32-bit addresses (= 20-bit page numbers),
// we can use a 16-bit cache entry by not storing the redundant 12 bits
// of the key that are used as the entry index. Here in 64-bit land,
// that trick won\'t work unless the hash table has 2^28 entries.
enum
{
MHeapMapCache_HashBits = 12
};
struct MHeapMapCache
{
uintptr array[1<<MHeapMapCache_HashBits];
};
// All macros for speed (sorry).
#define HMASK ((1<<MHeapMapCache_HashBits)-1)
#define KBITS MHeapMap_TotalBits
#define KMASK ((1LL<<KBITS)-1)
#define MHeapMapCache_SET(cache, key, value) \
((cache)->array[(key) & HMASK] = (key) | ((uintptr)(value) << KBITS))
#define MHeapMapCache_GET(cache, key, tmp) \
(tmp = (cache)->array[(key) & HMASK], \
(tmp & KMASK) == (key) ? (tmp >> KBITS) : 0)
このヘッダーファイルは、MHeapMapとMHeapMapCacheのすべての構造体定義、列挙型、および関数プロトタイプ宣言を含んでいます。特に、64ビットアドレス空間をマッピングするためのビット分割（MHeapMap_Level1Bitsなど）が明確に定義されており、32ビットシステムとの違いに関するコメントも含まれています。これにより、MHeapMapのインターフェースと64ビット固有の実装詳細がこのファイルにカプセル化されます。
関連リンク
- Go言語のメモリ管理に関する公式ドキュメントやブログ記事（当時のものがあれば）
- tcmallocのドキュメント（
MHeapMapの設計がtcmallocに影響を受けているため）
参考にした情報源リンク
- Go言語のソースコード（特に
src/runtime/ディレクトリ） - Go言語のコミット履歴
- tcmallocのドキュメント (GoogleのPerftoolsの一部)
- ラディックスツリーに関する一般的なデータ構造の解説