runtime: store large map keys and values indirectly

When a map key or value exceeds 128 bytes, the bucket now stores a
pointer to separately allocated memory instead of the data inline. This
matches Go's MapMaxKeyBytes/MapMaxElemBytes threshold and prevents
bucket sizes from exploding for large key/value types.

For example, map[[256]byte]int previously used 2128 bytes per bucket
(16 header + 256*8 keys + 8*8 values); now it uses 144 bytes per bucket
(16 header + 8*8 pointers + 8*8 values).

The indirection is fully encapsulated in the runtime via helper
functions (hashmapKeySlotSize, hashmapValueSlotSize, hashmapSlotKeyData,
hashmapSlotValueData, hashmapStoreKey, hashmapStoreValue). No compiler
or reflect changes are needed.

Author: jakebailey

main_test.go

@@ -77,6 +77,7 @@ func TestBuild(t *testing.T) {
 		"interface.go",
 		"json.go",
 		"map.go",
+		"map_bigkey.go",
 		"math.go",
 		"oldgo/",
 		"print.go",
@@ -283,6 +284,11 @@ func runPlatTests(options compileopts.Options, tests []string, t *testing.T) {
 				// limited amount of memory.
 				continue
 
+			case "map_bigkey.go":
+				// Compiler generates many large stack temporaries for [256]byte
+				// map keys, overflowing the goroutine stack (384 bytes).
+				continue
+
 			case "gc.go":
 				// Does not pass due to high mark false positive rate.
 				continue

src/runtime/hashmap.go

@@ -16,13 +16,22 @@ type hashmap struct {
 	buckets    unsafe.Pointer // pointer to array of buckets
 	seed       uintptr
 	count      uintptr
-	keySize    uintptr // maybe this can store the key type as well? E.g. keysize == 5 means string?
+	keySize    uintptr
 	valueSize  uintptr
 	bucketBits uint8
+	flags      uint8
 	keyEqual   func(x, y unsafe.Pointer, n uintptr) bool
 	keyHash    func(key unsafe.Pointer, size, seed uintptr) uint32
 }
 
+const (
+	hashmapMaxKeySize   = 128
+	hashmapMaxValueSize = 128
+
+	hashmapFlagIndirectKey   = 1 << 0
+	hashmapFlagIndirectValue = 1 << 1
+)
+
 // A hashmap bucket. A bucket is a container of 8 key/value pairs: first the
 // following two entries, then the 8 keys, then the 8 values. This somewhat odd
 // ordering is to make sure the keys and values are well aligned when one of
@@ -40,6 +49,48 @@ type hashmapBucket struct {
 // like MIPS) are properly aligned in the bucket.
 const hashmapBucketHeaderSize = (unsafe.Sizeof(hashmapBucket{}) + 7) &^ 7
 
+// hashmapKeySlotSize returns the size of a key slot in the bucket. For indirect
+// keys, this is the pointer size; otherwise the actual key size.
+//
+//go:inline
+func hashmapKeySlotSize(m *hashmap) uintptr {
+	if m.flags&hashmapFlagIndirectKey != 0 {
+		return unsafe.Sizeof(unsafe.Pointer(nil))
+	}
+	return m.keySize
+}
+
+// hashmapValueSlotSize returns the size of a value slot in the bucket.
+//
+//go:inline
+func hashmapValueSlotSize(m *hashmap) uintptr {
+	if m.flags&hashmapFlagIndirectValue != 0 {
+		return unsafe.Sizeof(unsafe.Pointer(nil))
+	}
+	return m.valueSize
+}
+
+// hashmapSlotKeyData returns a pointer to the actual key data for a given slot.
+// For indirect keys, the slot contains a pointer that must be dereferenced.
+//
+//go:inline
+func hashmapSlotKeyData(m *hashmap, slotKey unsafe.Pointer) unsafe.Pointer {
+	if m.flags&hashmapFlagIndirectKey != 0 {
+		return *(*unsafe.Pointer)(slotKey)
+	}
+	return slotKey
+}
+
+// hashmapSlotValueData returns a pointer to the actual value data for a given slot.
+//
+//go:inline
+func hashmapSlotValueData(m *hashmap, slotValue unsafe.Pointer) unsafe.Pointer {
+	if m.flags&hashmapFlagIndirectValue != 0 {
+		return *(*unsafe.Pointer)(slotValue)
+	}
+	return slotValue
+}
+
 type hashmapIterator struct {
 	buckets      unsafe.Pointer // pointer to array of hashapBuckets
 	numBuckets   uintptr        // length of buckets array
@@ -72,7 +123,19 @@ func hashmapMake(keySize, valueSize uintptr, sizeHint uintptr, alg uint8) *hashm
 		bucketBits++
 	}
 
-	bucketBufSize := hashmapBucketHeaderSize + keySize*8 + valueSize*8
+	var flags uint8
+	keySlotSize := keySize
+	if keySize > hashmapMaxKeySize {
+		flags |= hashmapFlagIndirectKey
+		keySlotSize = unsafe.Sizeof(unsafe.Pointer(nil))
+	}
+	valueSlotSize := valueSize
+	if valueSize > hashmapMaxValueSize {
+		flags |= hashmapFlagIndirectValue
+		valueSlotSize = unsafe.Sizeof(unsafe.Pointer(nil))
+	}
+
+	bucketBufSize := hashmapBucketHeaderSize + keySlotSize*8 + valueSlotSize*8
 	buckets := alloc(bucketBufSize*(1<<bucketBits), nil)
 
 	keyHash := hashmapKeyHashAlg(tinygo.HashmapAlgorithm(alg))
@@ -84,6 +147,7 @@ func hashmapMake(keySize, valueSize uintptr, sizeHint uintptr, alg uint8) *hashm
 		keySize:    keySize,
 		valueSize:  valueSize,
 		bucketBits: bucketBits,
+		flags:      flags,
 		keyEqual:   keyEqual,
 		keyHash:    keyHash,
 	}
@@ -178,7 +242,7 @@ func hashmapLen(m *hashmap) int {
 
 //go:inline
 func hashmapBucketSize(m *hashmap) uintptr {
-	return hashmapBucketHeaderSize + uintptr(m.keySize)*8 + uintptr(m.valueSize)*8
+	return hashmapBucketHeaderSize + hashmapKeySlotSize(m)*8 + hashmapValueSlotSize(m)*8
 }
 
 //go:inline
@@ -197,16 +261,14 @@ func hashmapBucketAddrForHash(m *hashmap, hash uint32) *hashmapBucket {
 
 //go:inline
 func hashmapSlotKey(m *hashmap, bucket *hashmapBucket, slot uint8) unsafe.Pointer {
-	slotKeyOffset := hashmapBucketHeaderSize + uintptr(m.keySize)*uintptr(slot)
-	slotKey := unsafe.Add(unsafe.Pointer(bucket), slotKeyOffset)
-	return slotKey
+	slotKeyOffset := hashmapBucketHeaderSize + hashmapKeySlotSize(m)*uintptr(slot)
+	return unsafe.Add(unsafe.Pointer(bucket), slotKeyOffset)
 }
 
 //go:inline
 func hashmapSlotValue(m *hashmap, bucket *hashmapBucket, slot uint8) unsafe.Pointer {
-	slotValueOffset := hashmapBucketHeaderSize + uintptr(m.keySize)*8 + uintptr(m.valueSize)*uintptr(slot)
-	slotValue := unsafe.Add(unsafe.Pointer(bucket), slotValueOffset)
-	return slotValue
+	slotValueOffset := hashmapBucketHeaderSize + hashmapKeySlotSize(m)*8 + hashmapValueSlotSize(m)*uintptr(slot)
+	return unsafe.Add(unsafe.Pointer(bucket), slotValueOffset)
 }
 
 // Set a specified key to a given value. Grow the map if necessary.
@@ -240,9 +302,9 @@ func hashmapSet(m *hashmap, key unsafe.Pointer, value unsafe.Pointer, hash uint3
 			}
 			if bucket.tophash[i] == tophash {
 				// Could be an existing key that's the same.
-				if m.keyEqual(key, slotKey, m.keySize) {
-					// found same key, replace it
-					memcpy(slotValue, value, m.valueSize)
+				if m.keyEqual(key, hashmapSlotKeyData(m, slotKey), m.keySize) {
+					// found same key, replace the value
+					hashmapStoreValue(m, slotValue, value)
 					return
 				}
 			}
@@ -257,11 +319,45 @@ func hashmapSet(m *hashmap, key unsafe.Pointer, value unsafe.Pointer, hash uint3
 		return
 	}
 	m.count++
-	memcpy(emptySlotKey, key, m.keySize)
-	memcpy(emptySlotValue, value, m.valueSize)
+	hashmapStoreKey(m, emptySlotKey, key)
+	hashmapStoreValue(m, emptySlotValue, value)
 	*emptySlotTophash = tophash
 }
 
+// hashmapStoreKey stores a key into a bucket slot, allocating backing storage
+// if the key is indirect (first insert) or copying into it (shouldn't happen
+// for keys, but handles it correctly).
+//
+//go:inline
+func hashmapStoreKey(m *hashmap, slotKey, key unsafe.Pointer) {
+	if m.flags&hashmapFlagIndirectKey != 0 {
+		p := alloc(m.keySize, nil)
+		memcpy(p, key, m.keySize)
+		*(*unsafe.Pointer)(slotKey) = p
+	} else {
+		memcpy(slotKey, key, m.keySize)
+	}
+}
+
+// hashmapStoreValue stores a value into a bucket slot. For indirect values,
+// it allocates backing storage on first insert or copies into the existing
+// backing on overwrite.
+//
+//go:inline
+func hashmapStoreValue(m *hashmap, slotValue, value unsafe.Pointer) {
+	if m.flags&hashmapFlagIndirectValue != 0 {
+		p := *(*unsafe.Pointer)(slotValue)
+		if p == nil {
+			// First insert: allocate backing storage.
+			p = alloc(m.valueSize, nil)
+			*(*unsafe.Pointer)(slotValue) = p
+		}
+		memcpy(p, value, m.valueSize)
+	} else {
+		memcpy(slotValue, value, m.valueSize)
+	}
+}
+
 // hashmapInsertIntoNewBucket creates a new bucket, inserts the given key and
 // value into the bucket, and returns a pointer to this bucket.
 func hashmapInsertIntoNewBucket(m *hashmap, key, value unsafe.Pointer, tophash uint8) *hashmapBucket {
@@ -273,8 +369,8 @@ func hashmapInsertIntoNewBucket(m *hashmap, key, value unsafe.Pointer, tophash u
 	slotKey := hashmapSlotKey(m, bucket, 0)
 	slotValue := hashmapSlotValue(m, bucket, 0)
 	m.count++
-	memcpy(slotKey, key, m.keySize)
-	memcpy(slotValue, value, m.valueSize)
+	hashmapStoreKey(m, slotKey, key)
+	hashmapStoreValue(m, slotValue, value)
 	bucket.tophash[0] = tophash
 	return bucket
 }
@@ -337,12 +433,12 @@ func hashmapGet(m *hashmap, key, value unsafe.Pointer, valueSize uintptr, hash u
 	for bucket != nil {
 		for i := uint8(0); i < 8; i++ {
 			slotKey := hashmapSlotKey(m, bucket, i)
-			slotValue := hashmapSlotValue(m, bucket, i)
 			if bucket.tophash[i] == tophash {
 				// This could be the key we're looking for.
-				if m.keyEqual(key, slotKey, m.keySize) {
+				if m.keyEqual(key, hashmapSlotKeyData(m, slotKey), m.keySize) {
 					// Found the key, copy it.
-					memcpy(value, slotValue, m.valueSize)
+					slotValue := hashmapSlotValue(m, bucket, i)
+					memcpy(value, hashmapSlotValueData(m, slotValue), m.valueSize)
 					return true
 				}
 			}
@@ -376,13 +472,15 @@ func hashmapDelete(m *hashmap, key unsafe.Pointer, hash uint32) {
 			slotKey := hashmapSlotKey(m, bucket, i)
 			if bucket.tophash[i] == tophash {
 				// This could be the key we're looking for.
-				if m.keyEqual(key, slotKey, m.keySize) {
+				if m.keyEqual(key, hashmapSlotKeyData(m, slotKey), m.keySize) {
 					// Found the key, delete it.
 					bucket.tophash[i] = 0
-					// Zero out the key and value so garbage collector doesn't pin the allocations.
-					memzero(slotKey, m.keySize)
+					// Zero out the slot so the GC won't pin the allocations.
+					keySlotSize := hashmapKeySlotSize(m)
+					memzero(slotKey, keySlotSize)
 					slotValue := hashmapSlotValue(m, bucket, i)
-					memzero(slotValue, m.valueSize)
+					valueSlotSize := hashmapValueSlotSize(m)
+					memzero(slotValue, valueSlotSize)
 					m.count--
 					return
 				}
@@ -444,13 +542,13 @@ func hashmapNext(m *hashmap, it *hashmapIterator, key, value unsafe.Pointer) boo
 
 		// Found a key.
 		slotKey := hashmapSlotKey(m, it.bucket, it.bucketIndex)
-		memcpy(key, slotKey, m.keySize)
+		memcpy(key, hashmapSlotKeyData(m, slotKey), m.keySize)
 
 		if it.buckets == m.buckets {
 			// Our view of the buckets is the same as the parent map.
 			// Just copy the value we have
 			slotValue := hashmapSlotValue(m, it.bucket, it.bucketIndex)
-			memcpy(value, slotValue, m.valueSize)
+			memcpy(value, hashmapSlotValueData(m, slotValue), m.valueSize)
 			it.bucketIndex++
 		} else {
 			it.bucketIndex++
@@ -539,7 +637,19 @@ func hashmapMakeGeneric(keySize, valueSize uintptr, sizeHint uintptr,
 		bucketBits++
 	}
 
-	bucketBufSize := hashmapBucketHeaderSize + keySize*8 + valueSize*8
+	var flags uint8
+	keySlotSize := keySize
+	if keySize > hashmapMaxKeySize {
+		flags |= hashmapFlagIndirectKey
+		keySlotSize = unsafe.Sizeof(unsafe.Pointer(nil))
+	}
+	valueSlotSize := valueSize
+	if valueSize > hashmapMaxValueSize {
+		flags |= hashmapFlagIndirectValue
+		valueSlotSize = unsafe.Sizeof(unsafe.Pointer(nil))
+	}
+
+	bucketBufSize := hashmapBucketHeaderSize + keySlotSize*8 + valueSlotSize*8
 	buckets := alloc(bucketBufSize*(1<<bucketBits), nil)
 
 	return &hashmap{
@@ -548,6 +658,7 @@ func hashmapMakeGeneric(keySize, valueSize uintptr, sizeHint uintptr,
 		keySize:    keySize,
 		valueSize:  valueSize,
 		bucketBits: bucketBits,
+		flags:      flags,
 		keyEqual:   keyEqual,
 		keyHash:    keyHash,
 	}

testdata/map_bigkey.go

@@ -0,0 +1,63 @@
+package main
+
+// Test maps with keys and values larger than 128 bytes, which triggers
+// indirect storage in the bucket (pointers instead of inline data).
+//
+// This is a separate file from map.go because the compiler generates many
+// large stack temporaries for map operations on [256]byte keys, which
+// overflows the goroutine stack on AVR (384 bytes). AVR skips this test.
+
+type BigKey [256]byte
+type BigValue [256]byte
+
+func main() {
+	// Large key, small value.
+	m1 := make(map[BigKey]int)
+	var k1 BigKey
+	k1[0] = 1
+	k1[255] = 42
+	m1[k1] = 100
+
+	var k1same BigKey
+	k1same[0] = 1
+	k1same[255] = 42
+
+	var k1diff BigKey
+	k1diff[0] = 2
+
+	println("bigkey get:", m1[k1])
+	println("bigkey get same:", m1[k1same])
+	println("bigkey get diff:", m1[k1diff])
+
+	// Overwrite.
+	m1[k1] = 200
+	println("bigkey overwrite:", m1[k1])
+
+	// Small key, large value.
+	m2 := make(map[int]BigValue)
+	var v BigValue
+	v[0] = 7
+	v[255] = 99
+	m2[1] = v
+	got := m2[1]
+	println("bigval get:", got[0], got[255])
+
+	// Both large.
+	m3 := make(map[BigKey]BigValue)
+	m3[k1] = v
+	got3 := m3[k1]
+	println("bigboth get:", got3[0], got3[255])
+
+	// Delete.
+	delete(m3, k1)
+	got3 = m3[k1]
+	println("bigboth deleted:", got3[0])
+
+	// Iteration.
+	m1[k1diff] = 300
+	count := 0
+	for range m1 {
+		count++
+	}
+	println("bigkey len:", len(m1), "iterated:", count)
+}

testdata/map_bigkey.txt

@@ -0,0 +1,8 @@
+bigkey get: 100
+bigkey get same: 100
+bigkey get diff: 0
+bigkey overwrite: 200
+bigval get: 7 99
+bigboth get: 7 99
+bigboth deleted: 0
+bigkey len: 2 iterated: 2