Bryan Boreham

The Go regexp package is an extremely competent piece of engineering, with attractive features such as being guaranteed to run in time linear in the size of the input. However, it can be made to go faster.

This talk will describe:

• how Go regexp works
• five changes that improve regexp performance
• the basic profiling techniques used to identify these optimisations
• further opportunities for optimisation, including via Generics.

A tour of the internals of Weave Net, one of the most popular container networks: design challenges and lessons learned from five years in the wild. Including Kubernetes integration and how CNI was born.

Weave Net is written in Go, using many Linux kernel features such as veths, bridges and iptables. Aimed at developers rather than network engineers, Weave Net tries to be self-configuring and find the best available transport between nodes. The control plane operates via gossip, with no central point of control.

The Go runtime has a garbage collector (GC) which is famously simple and lacking in tuning parameters compared to, say, a JVM.

However there are controls, and in this talk we shall look at what they do and when you might use them. We will also look at how to understand what GC is doing and how much that work might be costing your program.

Primarily we will look at the GOGC environment variable, and how it can be used to increase or decrease the rate of garbage collection, or turn it off completely.

We will show how garbage-collection activity can be observed via metrics, e.g. using Prometheus, or in more low-level detail via the GODEBUG environment variable.

We will also look at the evolution of GC performance in Go over the last five years, and new controls being added in the next version of Go.

A lightning-fast introduction to Grafanalib, a small Python library that lets you create dashboards as code.

Target audience for the library is people using and amending Grafana dashboards, but the underlying idea is of interest to anyone doing Ops or DevOps.

Grafanalib is an Open Source Python library that lets you create dashboards as code.

Once your dashboards are code you can check them in, PR them and have a CI/CD pipeline - GitOps!

Talk will cover:

• Basic primitives in the library - YAxis, Graph, Tooltip and so on
• Higher-level components such as QPSGraph
• Build your own components such as a LatencyGraph or a REDRow.
• How to deploy dashboards created using Grafanalib

This talk will preset a set of techniques to make your Go programs run faster.

Starting with CPU profiling, moving through memory allocation profiling, to escape analysis, we will point out some less-well-known corners of the runtime, how they impact performance, and how to mitigate this impact.

Often, the single biggest drain on performance in a Go program is the garbage collector. Each release of the Go runtime comes with a slightly faster collector, but you can make much bigger performance improvements by not creating garbage in the first place: if you can rework your code to make fewer heap allocations, then the garbage collector will run less often and have less work to do.

Examples will be drawn from real-world experience optimising the Open Source container visualisation project Weave Cortex.

Describing the design and function of Weave Network Policy Controller, which uses iptables and ipsets to govern which Linux containers can talk to which other containers, under control of Kubernetes. The code is all written in Go, and available on GitHub under Apache Licence.

Kubernetes Network Policy is an abstract specification to define which connections are to be allowed within a Kubernetes cluster. Weave Network Policy Controller (weave-npc) is an implementation of this specification in Go, under the Apache Licence. This talk will describe the design of weave-npc; how it was built from existing components in Linux, Kubernetes and the wider Go ecosystem, how it integrates with the Linux network stack, and how it can be used to tighten security on a typical Cloud application.