Golang High-Performance Programming EP1: Empty Struct
The secret and application of the empty struct with a size of 0
The Mystery of the Empty Struct in Go: Understanding its Usage and Optimization
In Go, a regular struct typically occupies a block of memory. However, there’s a particular case: if it’s an empty struct, its size is zero. How is this possible, and what is the use of an empty struct?
type Test struct {
A int
B string
}
func main() {
fmt.Println(unsafe.Sizeof(Test{}))
fmt.Println(unsafe.Sizeof(struct{}{}))
}
/*
24
0
*/The Secret of the Empty Struct
Special Variable: zerobase
An empty struct is a struct with no memory size. This statement is correct, but to be more precise, it has a special starting point: the zerobase variable. This is a uintptr global variable that occupies 8 bytes. Whenever countless struct {} variables are defined, the compiler assigns the address of this zerobase variable. In other words, in Go, any memory allocation with a size of 0 uses the same address, &zerobase.
package main
import "fmt"
type emptyStruct struct {}
func main() {
a := struct{}{}
b := struct{}{}
c := emptyStruct{}
fmt.Printf("%p\n", &a)
fmt.Printf("%p\n", &b)
fmt.Printf("%p\n", &c)
}
// 0x58e360
// 0x58e360
// 0x58e360The memory addresses of variables of an empty struct are all the same. This is because the compiler assigns &zerobase during compilation when encountering this special type of memory allocation. This logic is in the mallocgc function:
//go:linkname mallocgc
func mallocgc(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
...
if size == 0 {
return unsafe.Pointer(&zerobase)
}
...This is the secret of the Empty struct. With this special variable, we can accomplish many functionalities.
Empty Struct and Memory Alignment
Typically, if an empty struct is part of a larger struct, it doesn’t occupy memory. However, there’s a particular case when the empty struct is the last field; it triggers memory alignment.
type A struct {
x int
y string
z struct{}
}
type B struct {
x int
z struct{}
y string
}
func main() {
println(unsafe.Alignof(A{}))
println(unsafe.Alignof(B{}))
println(unsafe.Sizeof(A{}))
println(unsafe.Sizeof(B{}))
}
/**
8
8
32
24
**/When a pointer to a field is present, the returned address may be outside the struct, potentially leading to memory leaks if the memory is not freed when the struct is released. Therefore, when an empty struct is the last field of another struct, additional memory is allocated for safety. If the empty struct is at the beginning or middle, its address is the same as the following variable.
type A struct {
x int
y string
z struct{}
}
type B struct {
x int
z struct{}
y string
}
func main() {
a := A{}
b := B{}
fmt.Printf("%p\n", &a.y)
fmt.Printf("%p\n", &a.z)
fmt.Printf("%p\n", &b.y)
fmt.Printf("%p\n", &b.z)
}
/**
0x1400012c008
0x1400012c018
0x1400012e008
0x1400012e008
**/Use Cases of the Empty Struct
The core reason for the existence of the empty struct struct{} is to save memory. Consider using an empty struct when you need a struct but don't care about its contents. Go's core composite structures, such as map, chan, and slice can all use struct{}.
map & struct{}
// Create map
m := make(map[int]struct{})
// Assign value
m[1] = struct{}{}
// Check if key exists
_, ok := m[1]chan & struct{}
A classic scenario combines channel and struct{}, where struct{} is often used as a signal without caring about its content. As analyzed in previous articles, the essential data structure of a channel is a management structure plus a ring buffer. The ring buffer is zero-allocated if struct{} is used as an element.
The only use of chan and struct{} together is for signal transmission since the empty struct itself cannot carry any value. Generally, it's used with no buffer channels.
// Create a signal channel
waitc := make(chan struct{})
// ...
goroutine 1:
// Send signal: push element
waitc <- struct{}{}
// Send signal: close
close(waitc)
goroutine 2:
select {
// Receive signal and perform corresponding actions
case <-waitc:
}In this scenario, it is struct{} necessary? Not really, and the memory saved is negligible. The key point is that the element value of chan is not cared about, hence struct{} is used.
Summary
- An empty struct is still a struct with a size of 0.
- All empty structs share the same address: the address of
zerobase. - We can leverage the empty struct’s non-memory-occupying feature to optimize code, such as using maps to implement sets and channels.
