Sign In Start Free Trial

Book Overview & Buying
Table Of Contents
Feedback & Rating

Hands-On High Performance with Go

By : Strecansky

3.6 (5)

Hands-On High Performance with Go

3.6 (5)

By: Strecansky

Overview of this book

Go is an easy-to-write language that is popular among developers thanks to its features such as concurrency, portability, and ability to reduce complexity. This Golang book will teach you how to construct idiomatic Go code that is reusable and highly performant. Starting with an introduction to performance concepts, you’ll understand the ideology behind Go’s performance. You’ll then learn how to effectively implement Go data structures and algorithms along with exploring data manipulation and organization to write programs for scalable software. This book covers channels and goroutines for parallelism and concurrency to write high-performance code for distributed systems. As you advance, you’ll learn how to manage memory effectively. You’ll explore the compute unified device architecture (CUDA) application programming interface (API), use containers to build Go code, and work with the Go build cache for quicker compilation. You’ll also get to grips with profiling and tracing Go code for detecting bottlenecks in your system. Finally, you’ll evaluate clusters and job queues for performance optimization and monitor the application for performance regression. By the end of this Go programming book, you’ll be able to improve existing code and fulfill customer requirements by writing efficient programs.

Preface

Preface

Who this book is for

What this book covers

To get the most out of this book

Get in touch

Section 1: Learning about Performance in Go

Section 1: Learning about Performance in Go

Free Chapter

Introduction to Performance in Go

Introduction to Performance in Go

Technical requirements

Understanding performance in computer science

A brief history of Go

The ideology behind Go performance

Summary

Data Structures and Algorithms

Data Structures and Algorithms

Understanding benchmarking

Introducing Big O notation

Understanding sort algorithms

Understanding search algorithms

Exploring trees

Exploring queues

Summary

Understanding Concurrency

Understanding Concurrency

Understanding closures

Exploring goroutines

Introducing channels

Introducing semaphores

Understanding WaitGroups

Iterators and the process of iteration

Briefing on generators

Summary

STL Algorithm Equivalents in Go

STL Algorithm Equivalents in Go

Understanding algorithms in the STL

Understanding containers

Understanding function objects

Summary

Matrix and Vector Computation in Go

Matrix and Vector Computation in Go

Introducing Gonum and the Sparse library

Introducing BLAS

Introducing vectors

Introducing matrices

Matrix operations

Understanding matrix structures

Summary

Section 2: Applying Performance Concepts in Go

Section 2: Applying Performance Concepts in Go

Composing Readable Go Code

Composing Readable Go Code

Maintaining simplicity in Go

Maintaining readability in Go

Exploring packaging in Go

Understanding naming in Go

Understanding formatting in Go

Briefing on interfaces in Go

Comprehending methods in Go

Comprehending inheritance in Go

Exploring reflection in Go

Summary

Template Programming in Go

Template Programming in Go

Understanding Go generate

The link toolchain

Introducing Cobra and Viper for configuration programming

Text templating

HTML templating

Exploring Sprig

Summary

Memory Management in Go

Memory Management in Go

Understanding Modern Computer Memory - A Primer

Allocating memory

Understanding memory utilization

Briefing on limited memory situations

Summary

GPU Parallelization in Go

GPU Parallelization in Go

Cgo – writing C in Go

GPU-accelerated computing – utilizing the hardware

CUDA on GCP

CUDA – powering the program

Summary

Compile Time Evaluations in Go

Compile Time Evaluations in Go

Exploring the Go runtime

Understanding functions

Summary

Section 3: Deploying, Monitoring, and Iterating on Go Programs with Performance in Mind

Section 3: Deploying, Monitoring, and Iterating on Go Programs with Performance in Mind

Building and Deploying Go Code

Building and Deploying Go Code

Building Go binaries

Go build – building your Go code

Go clean – cleaning your build directory

Retrieving package dependencies with go get and go mod

Go list

Go run – executing your packages

Go install – installing your binaries

Building Go binaries with Docker

Summary

Profiling Go Code

Profiling Go Code

Understanding profiling

Exploring instrumentation methodologies

Briefing on CPU profiling

Briefing on memory profiling

Extended capabilities with upstream pprof

Comparing multiple profiles

Interpreting flame graphs within pprof

Detecting memory leaks in Go

Summary

Tracing Go Code

Tracing Go Code

Implementing tracing instrumentation

Understanding the tracing format

Understanding trace collection

Exploring pprof-like traces

Go distributed tracing

Implementing OpenCensus for your application

Summary

Clusters and Job Queues

Clusters and Job Queues

Clustering in Go

Exploring job queues in Go

Summary

Comparing Code Quality Across Versions

Comparing Code Quality Across Versions

Go Prometheus exporter – exporting data from your Go application

APM – watching your distributed system performance

SLIs and SLOs – setting goals

Logging – keeping track of your data

Summary

Other Books You May Enjoy

Other Books You May Enjoy

Leave a review - let other readers know what you think

Customer Reviews

3.6 (5)

5 star

40%

4 star

20%

3 star

20%

2 star

0

1 star

20%

Allocating memory

The main memory that a computer has is used for many things. The Memory Management Unit (MMU) is a piece of computer hardware that translates between physical and virtual memory addresses. When a CPU performs an instruction that uses a memory address, the MMU takes that logical memory address and translates it to a physical memory address. These are handled in groupings of physical memory addresses called pages. Pages are usually handled in 4 kB segments, using a table called a page table. The MMU also has other functionality, including using buffers, such as the Translation Lookaside Buffer (TLB), to hold recently accessed translations.

Virtual memory is helpful because it does the following:

Allows hardware device memory to be mapped to an address space
Allows access permissions (rwx) for particular memory regions
Allows processes to have separate memory mappings...

Search

Your notes and bookmarks