Decrypt Go: empty struct

In Go, a normal struct typically occupies a block of memory. However, there’s a special case: if it’s an empty struct, its size is zero. How is this possible, and what is the use of an empty struct?

This article is first published in the medium MPP plan. If you are a medium user, please follow me in medium. Thank you very much.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


type Test struct {
    A int
    B string
}

func main() {
    fmt.Println(unsafe.Sizeof(new(Test)))
    fmt.Println(unsafe.Sizeof(struct{}{}))
}

/*
8
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 actually 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.

Example

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


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
// 0x58e360

The 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:

1
2
3
4
5
6
7


//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 special case when the empty struct is the last field; it triggers memory alignment.

Example

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24


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 next variable.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26


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. When you need a struct but don’t care about its contents, consider using an empty struct. Go’s core composite structures such as map, chan, and slice can all use struct{}.

`map` & `struct{}`

1
2
3
4
5
6


// 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.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


// 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, is struct{} absolutely 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, just 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.