Strings in Go — Professional Level¶

const a = "hello"
const b = "hello"
// a and b share the same .rodata bytes; their Data pointers are equal

s := strings.Repeat("a", 100) // backing array is a *[100]byte on heap

// GC metadata for the backing array:
// - type: []byte internally (no pointer fields — GC skips it)
// - This means string backing arrays are cheap for the GC

m := map[string]int{"hello": 1}
b := []byte("hello")
_ = m[string(b)] // compiler emits a map lookup using b directly, no heap allocation

s := a + b + c

for i, r := range s { ... }

// concatstring2 — concatenate two strings
func concatstring2(buf *tmpBuf, a, b string) string

// slicebytetostring — convert []byte to string
func slicebytetostring(buf *tmpBuf, ptr *byte, n int) (str string)

// stringtoslicebyte — convert string to []byte
func stringtoslicebyte(buf *tmpBuf, s string) []byte

// The buf *tmpBuf allows small allocations to avoid heap for short strings

type tmpBuf [tmpStringBufSize]byte
const tmpStringBufSize = 32

// rawstring allocates a new string of length n
func rawstring(size int) (s string, b []byte)

// rawbyteslice allocates a new []byte of length n
func rawbyteslice(size int) (b []byte)

// mallocgc for string backing arrays uses noscan=true
// This means the GC does not trace into the backing array
// Result: string backing arrays are cheaper for the GC than pointer-containing types

import (
    "reflect"
    "unsafe"
)

func bytesToString(b []byte) string {
    bh := (*reflect.SliceHeader)(unsafe.Pointer(&b))
    sh := reflect.StringHeader{
        Data: bh.Data,
        Len:  bh.Len,
    }
    return *(*string)(unsafe.Pointer(&sh))
}

import "unsafe"

func bytesToString(b []byte) string {
    if len(b) == 0 {
        return ""
    }
    return unsafe.String(unsafe.SliceData(b), len(b))
}

func stringToBytes(s string) []byte {
    if len(s) == 0 {
        return nil
    }
    return unsafe.Slice(unsafe.StringData(s), len(s))
}

// runtime/alg.go
func strequal(p, q unsafe.Pointer) bool {
    a := *(*string)(p)
    b := *(*string)(q)
    return a == b
}

// Which compiles to:
// 1. Compare lengths — if different, return false immediately
// 2. Compare Data pointers — if same, return true (same backing array)
// 3. Fall through to memequal for byte-by-byte comparison

// runtime/hash_amd64.s
// aeshashstr: AES-based string hash
// Falls back to wyhash on non-AES CPUs

// src/strings/builder.go
type Builder struct {
    addr *Builder // self-pointer for copy detection
    buf  []byte   // internal buffer
}

func (b *Builder) copyCheck() {
    if b.addr == nil {
        b.addr = (*Builder)(noescape(unsafe.Pointer(b)))
    } else if b.addr != b {
        panic("strings: illegal use of non-zero Builder copied by value")
    }
}

// WriteString appends to buf using append()
func (b *Builder) WriteString(s string) (int, error) {
    b.copyCheck()
    b.buf = append(b.buf, s...)
    return len(s), nil
}

// String shares the Builder's internal buffer — zero-copy
func (b *Builder) String() string {
    return unsafe.String(unsafe.SliceData(b.buf), len(b.buf))
}

// Case 1: Does not escape — stack string
func f() int {
    s := "hello"       // .rodata pointer, no allocation
    return len(s)
}

// Case 2: Escapes to heap — assigned to interface
func g() interface{} {
    s := "hello"
    return s           // s's StringHeader copies to heap for the interface
}

// Case 3: []byte -> string -> escape
func h() string {
    b := []byte("hello") // escapes: returned string holds reference
    return string(b)
}

package main

import (
    "os"
    "runtime/pprof"
    "strings"
)

func main() {
    f, _ := os.Create("cpu.prof")
    pprof.StartCPUProfile(f)
    defer pprof.StopCPUProfile()

    // Your string-heavy workload
    for i := 0; i < 1000000; i++ {
        _ = strings.Repeat("abc", 10)
    }
}
// Then: go tool pprof cpu.prof
// Look for: runtime.mallocgc, runtime.concatstrings