Использование кэшей CPU: Максимальная производительность в Go

type User struct {
    Login   string
    Active  bool
    Icon    [128 * 128]byte // 16КБ данных
    Country string
}
 
// Функция подсчёта активных пользователей по странам
func CountryCount(users []User) map[string]int {
    counts := make(map[string]int)
    for _, u := range users {
        if !u.Active {
            continue
        }
        counts[u.Country]++
    }
    return counts
}

type Image []byte
 
type User struct {
    Login   string
    Active  bool
    Icon    Image    // Слайс вместо массива
    Country string
}

// AoS: Array of Structures
type UserAoS struct {
    Users []User
}
 
// SoA: Structure of Arrays
type UserSoA struct {
    Logins   []string
    Active   []bool
    Icons    []Image
    Countries []string
}

// Неоптимальное выравнивание
type Config struct {
    Flag  bool       // 1 байт + 7 байт padding
    Count int64      // 8 байт
    Name  string     // 16 байт (указатель + длина)
}
// Общий размер: 32 байта
 
// Оптимальное выравнивание
type Config struct {
    Name  string     // 16 байт
    Count int64      // 8 байт
    Flag  bool       // 1 байт + 7 байт padding
}
// Общий размер: 32 байта

// Вместо постепенного добавления элементов
data := make([]int, 0)
for i := 0; i < n; i++ {
    data = append(data, i) // Может вызывать перераспределение памяти
}
 
// Лучше предварительно выделить память
data := make([]int, 0, n) // Указываем емкость
for i := 0; i < n; i++ {
    data = append(data, i) // Не требует перераспределения
}

var bufferPool = sync.Pool{
    New: func() interface{} {
        return make([]byte, 4096)
    },
}
 
func ProcessData() {
    buffer := bufferPool.Get().([]byte)
    defer bufferPool.Put(buffer)
    
    // Использование буфера...
}

//go:noescape
func prefetch(addr unsafe.Pointer) 
 
func ProcessLargeArray(data []int) {
    for i := 0; i < len(data); i++ {
        if i+64 < len(data) {
            prefetch(unsafe.Pointer(&data[i+64]))
        }
        // Обработка текущего элемента...
    }
}

type Processor interface {
    Process(data []byte) error
}
 
func ProcessBatch(processors []Processor, batch [][]byte) {
    for _, proc := range processors {
        for _, data := range batch {
            proc.Process(data)  // Потенциальный кэш-промах при разрешении интерфейса
        }
    }
}

// Версия с использованием генериков
func ProcessBatchGeneric[P interface{ Process([]byte) error }](processors []P, batch [][]byte) {
    for _, proc := range processors {
        for _, data := range batch {
            proc.Process(data)  // Компилятор может оптимизировать вызов
        }
    }
}

func ParallelSum(data []int) int {
    cpus := runtime.NumCPU()
    var wg sync.WaitGroup
    results := make([]int, cpus)
    
    chunkSize := (len(data) + cpus - 1) / cpus
    for i := 0; i < cpus; i++ {
        wg.Add(1)
        go func(workerID int) {
            defer wg.Done()
            
            start := workerID * chunkSize
            end := start + chunkSize
            if end > len(data) {
                end = len(data)
            }
            
            localSum := 0
            for j := start; j < end; j++ {
                localSum += data[j]
            }
            
            results[workerID] = localSum
        }(i)
    }
    
    wg.Wait()
    
    totalSum := 0
    for _, sum := range results {
        totalSum += sum
    }
    
    return totalSum
}

type Counter struct {
    value uint64  // Должен быть выровнен на 8-байтовую границу для эффективных атомарных операций
    _     [56]byte  // Padding для предотвращения false sharing
}
 
func (c *Counter) Increment() {
    atomic.AddUint64(&c.value, 1)
}

// Неэффективный обход: кэш-промахи на каждой итерации по столбцам
for col := 0; col < width; col++ {
    for row := 0; row < height; row++ {
        process(image[row][col])
    }
}
 
// Эффективный обход: использует пространственную локальность
for row := 0; row < height; row++ {
    for col := 0; col < width; col++ {
        process(image[row][col])
    }
}

import "runtime/pprof"
 
f, _ := os.Create("cpu.prof")
pprof.StartCPUProfile(f)
// Код программы
pprof.StopCPUProfile()

func BenchmarkProcessing(b *testing.B) {
    data := prepareTestData()
    b.ResetTimer()
    for i := 0; i < b.N; i++ {
        result := processingFunction(data)
        // Предотвращаем оптимизацию неиспользуемого результата
        if result == nil {
            b.Fatal("Unexpected nil result")
        }
    }
}

// До оптимизации
data := make([]int, 0)
for i := 0; i < size; i++ {
    data = append(data, getValue(i))
}
 
// После оптимизации
data := make([]int, size)
for i := 0; i < size; i++ {
    data[i] = getValue(i)
}

type ShardedCounter struct {
    counters [256]uint64
}
 
func (sc *ShardedCounter) Increment(key uint64) {
    // Используем младшие 8 бит ключа для выбора шарда
    shard := key & 0xFF
    atomic.AddUint64(&sc.counters[shard], 1)
}

// Иерархическая структура (менее эффективная для кэша)
type Node struct {
    Value int
    Left  *Node
    Right *Node
}
 
// Плоская структура (более кэш-дружественная)
type FlatTree struct {
    Values []int
    Lefts  []int  // индексы левых потомков
    Rights []int  // индексы правых потомков
}

// До оптимизации
sum := 0
for i := 0; i < len(data); i++ {
    sum += data[i]
}
 
// После оптимизации
sum := 0
remainder := len(data) % 4
for i := 0; i < remainder; i++ {
    sum += data[i]
}
for i := remainder; i < len(data); i += 4 {
    sum += data[i] + data[i+1] + data[i+2] + data[i+3]
}

type Cache struct {
    mu    sync.RWMutex
    items map[string]cachedItem
}
 
type cachedItem struct {
    value      interface{}
    expiration time.Time
}
 
func (c *Cache) Get(key string, fetch func() (interface{}, error)) (interface{}, error) {
    c.mu.RLock()
    item, found := c.items[key]
    c.mu.RUnlock()
    
    if found && time.Now().Before(item.expiration) {
        return item.value, nil
    }
    
    // Ключа нет в кэше или он устарел - получаем новое значение
    value, err := fetch()
    if err != nil {
        return nil, err
    }
    
    // Сохраняем в кэше
    c.mu.Lock()
    c.items[key] = cachedItem{
        value:      value,
        expiration: time.Now().Add(c.ttl),
    }
    c.mu.Unlock()
    
    return value, nil
}

type DatabaseCache struct {
    l1     map[string]interface{} // Часто используемые данные в памяти
    l2     *lru.Cache            // Большой LRU-кэш для менее частых запросов
    db     Database              // Интерфейс к реальной базе данных
    mu     sync.RWMutex
}
 
func (c *DatabaseCache) Get(key string) (interface{}, error) {
    // Сначала проверяем L1-кэш для сверхбыстрого доступа
    c.mu.RLock()
    if val, ok := c.l1[key]; ok {
        c.mu.RUnlock()
        return val, nil
    }
    c.mu.RUnlock()
    
    // Проверяем L2-кэш
    if val, ok := c.l2.Get(key); ok {
        return val, nil
    }
    
    // Обращаемся к базе данных
    val, err := c.db.Query(key)
    if err != nil {
        return nil, err
    }
    
    // Обновляем L2-кэш
    c.l2.Add(key, val)
    return val, nil
}

// Вместо этого
items := make([]*Item, size)
for i := 0; i < size; i++ {
    items[i] = &Item{}  // Отдельная аллокация для каждого элемента
}
 
// Делайте так
itemsBlock := make([]Item, size)  // Одна аллокация для всех
items := make([]*Item, size)
for i := 0; i < size; i++ {
    items[i] = &itemsBlock[i]  // Указатели на существующие элементы
}

// Перед критически важной операцией
runtime.GC()  // Форсируем сборку мусора
setGCPercent := debug.SetGCPercent(-1)  // Временно отключаем GC
// Выполняем операцию, чувствительную к задержкам
debug.SetGCPercent(setGCPercent)  // Восстанавливаем настройки GC

type NodePool struct {
    pool sync.Pool
}
 
func NewNodePool() *NodePool {
    return &NodePool{
        pool: sync.Pool{
            New: func() interface{} {
                return &Node{}
            },
        },
    }
}
 
func (p *NodePool) Get() *Node {
    return p.pool.Get().(*Node)
}
 
func (p *NodePool) Put(node *Node) {
    // Сброс состояния перед возвратом в пул
    *node = Node{}
    p.pool.Put(node)
}

func CacheAwareQuickSort(data []int) {
    const l1CacheThreshold = 16 * 1024 / 8  // Примерный размер L1 в int64
    quickSortRecursive(data, 0, len(data)-1, l1CacheThreshold)
}
 
func quickSortRecursive(data []int, low, high, threshold int) {
    if high-low <= 0 {
        return
    }
    
    // Для маленьких подмассивов, умещающихся в кэш, используем простую сортировку вставками
    if high-low < threshold {
        insertionSort(data[low:high+1])
        return
    }
    
    // Обычный алгоритм быстрой сортировки для больших массивов
    pivot := partition(data, low, high)
    quickSortRecursive(data, low, pivot-1, threshold)
    quickSortRecursive(data, pivot+1, high, threshold)
}

// B-дерево: узел содержит несколько ключей и указателей на потомков
type BTreeNode struct {
    keys     [2*t-1]int  // t - минимальная степень дерева
    children [2*t]*BTreeNode
    n        int         // количество ключей
    leaf     bool
}

func init() {
    // Настраиваем количество процессоров и GC в соответствии с ограничениями контейнера
    if cpuLimit := os.Getenv("CPU_LIMIT"); cpuLimit != "" {
        if limit, err := strconv.Atoi(cpuLimit); err == nil {
            runtime.GOMAXPROCS(limit)
        }
    }
    
    // Агрессивнее собираем мусор в условиях ограниченной памяти
    if memLimit := os.Getenv("MEMORY_LIMIT_MB"); memLimit != "" {
        if limit, err := strconv.Atoi(memLimit); err == nil && limit < 1024 {
            debug.SetGCPercent(20)  // Более частая сборка мусора
        }
    }
}

func ProcessLargeArray(data []int) {
    done := make(chan struct{})
    prefetchDistance := 1024  // Расстояние опережения
    
    // Запускаем "разведчика"
    go func() {
        for i := 0; i < len(data); i += 64 {  // Шаг в размер кэш-линии
            if i+prefetchDistance < len(data) {
                _ = data[i+prefetchDistance]  // Просто прикасаемся к данным, чтобы они попали в кэш
            }
            
            select {
            case <-done:
                return
            default:
                // Продолжаем
            }
        }
    }()
    
    // Основной код обработки
    for i := 0; i < len(data); i++ {
        // Обработка data[i]
    }
    
    close(done)  // Сигнализируем разведчику о завершении
}

// Пример кода для сбора данных о доступе к памяти
type MemoryAccess struct {
    Address uintptr
    Count   int
}
 
var accessMap = make(map[uintptr]int)
var mapMutex sync.Mutex
 
func recordAccess(addr uintptr) {
    mapMutex.Lock()
    accessMap[addr]++
    mapMutex.Unlock()
}
 
// После сбора данных они визуализируются
// с помощью специальных инструментов

type CacheAwareAlgorithm struct {
    blockSize      int
    prefetchDistance int
    processingOrder []int
}
 
func NewAdaptiveAlgorithm() *CacheAwareAlgorithm {
    // Определяем характеристики кэша текущего CPU
    l1Size := detectL1CacheSize()
    l1LineSize := detectL1LineSize()
    
    return &CacheAwareAlgorithm{
        blockSize:      l1Size / 4, // Эвристика: блок составляет 1/4 размера L1
        prefetchDistance: l1Size / l1LineSize, // Дистанция предзагрузки
        processingOrder: determineOptimalOrder(),
    }
}

type MLPrefetcher struct {
    model      *ml.Model
    historyBuffer []memAccess
    predictions   chan uintptr
}
 
func (p *MLPrefetcher) RecordAccess(addr uintptr) {
    p.historyBuffer = append(p.historyBuffer, memAccess{addr: addr, time: time.Now()})
    if len(p.historyBuffer) > bufferSize {
        p.historyBuffer = p.historyBuffer[1:]
    }
    
    go p.generatePredictions()
}
 
func (p *MLPrefetcher) generatePredictions() {
    // Получаем предсказание следующих адресов на основе исторических данных
    nextAddrs := p.model.Predict(p.historyBuffer)
    
    // Отправляем предсказания для предзагрузки
    for _, addr := range nextAddrs {
        p.predictions <- addr
    }
}