前几天 Eran Yanay 在 Gophercon Israel 分享了一个讲座：Going Infinite, handling 1M websockets connections in Go, 介绍了使用Go实现支持百万连接的websocket服务器，引起了很大的反响。事实上，相关的技术在2017年的一篇技术中已经介绍： A Million WebSockets and Go, 这篇2017年文章的作者Sergey Kamardin也就是 Eran Yanay 项目中使用的ws库的作者。

第一篇百万 Go TCP 连接的思考: epoll方式减少资源占用
第二篇百万 Go TCP 连接的思考2: 百万连接的吞吐率和延迟
第三篇百万 Go TCP 连接的思考: 正常连接下的吞吐率和延迟

相关代码已发布到github上: 1m-go-tcp-server。

阅读全文

2019年02月22日

by smallnest

在Linux中查询CPU的核数

以一台Linux服务器为例。这台Linux包括两颗Intel(R) Xeon(R) CPU E5-2630 v4 @ 2.20GHz CPU, 单颗CPU包括 10 个 cpu core, 使用超线程包含20个逻辑cpu core，具体的官方介绍: E5-2630 V4。

下面让我们通过Linux的命令来查找对应的参数，看看是否符合官方的介绍, 主要是查看/proc/cpuinfo的信息获得。

阅读全文

2019年02月18日

by smallnest

从 io.Reader 中读数据

Go 的标准库提供了多个从 io.Reader 中读取数据的方法 (io、ioutil)，本文通过从 net.Conn中读取数据为例，演示各种方法已经应用场景。

阅读全文

2019年01月29日

by smallnest

Go Reflect 性能

Go reflect包提供了运行时获取对象的类型和值的能力，它可以帮助我们实现代码的抽象和简化，实现动态的数据获取和方法调用，提高开发效率和可读性，也弥补Go在缺乏泛型的情况下对数据的统一处理能力。

通过reflect，我们可以实现获取对象类型、对象字段、对象方法的能力，获取struct的tag信息，动态创建对象，对象是否实现特定的接口，对象的转换、对象值的获取和设置、Select分支动态调用等功能，看起来功能不错，但是大家也都知道一点: 使用reflect是有性能代价的!

阅读全文

2019年01月24日

by smallnest

cacheline 对 Go 程序的影响

首先来了解一下来自维基百科上关于CPU缓存的介绍。

在计算机系统中，CPU高速缓存（英语：CPU Cache，在本文中简称缓存）是用于减少处理器访问内存所需平均时间的部件。在金字塔式存储体系中它位于自顶向下的第二层，仅次于CPU寄存器。其容量远小于内存，但速度却可以接近处理器的频率。

当处理器发出内存访问请求时，会先查看缓存内是否有请求数据。如果存在（命中），则不经访问内存直接返回该数据；如果不存在（失效），则要先把内存中的相应数据载入缓存，再将其返回处理器。
缓存之所以有效，主要是因为程序运行时对内存的访问呈现局部性（Locality）特征。这种局部性既包括空间局部性（Spatial Locality），也包括时间局部性（Temporal Locality）。有效利用这种局部性，缓存可以达到极高的命中率。
在处理器看来，缓存是一个透明部件。因此，程序员通常无法直接干预对缓存的操作。但是，确实可以根据缓存的特点对程序代码实施特定优化，从而更好地利用缓存。

结构上，一个直接映射（Direct Mapped）缓存由若干缓存块（Cache Block，或Cache Line）构成。每个缓存块存储具有连续内存地址的若干个存储单元。在32位计算机上这通常是一个双字（dword），即四个字节。因此，每个双字具有唯一的块内偏移量。每个缓存块还可对应若干标志位，包括有效位（valid bit）、脏位（dirty bit）、使用位（use bit）等。这些位在保证正确性、排除冲突、优化性能等方面起着重要作用。

在并发编程中，经常会有共享数据被多个goroutine同时访问，所以如何有效的进行数据的设计，就是一个相当有技巧的操作。最常用的技巧就是Padding。现在大部分的CPU的cahceline是64字节，将变量补足为64字节可以保证它正好可以填充一个cacheline。

台湾的盧俊錡 Genchi Lu提供了一个很好的例子来比较pad和没有padding的性能(我稍微改了一下)。

package test

import (
	"sync/atomic"
	"testing"
)

type NoPad struct {
	a uint64
	b uint64
	c uint64
}

func (np *NoPad) Increase() {
	atomic.AddUint64(&np.a, 1)
	atomic.AddUint64(&np.b, 1)
	atomic.AddUint64(&np.c, 1)
}

type Pad struct {
	a   uint64
	_p1 [8]uint64
	b   uint64
	_p2 [8]uint64
	c   uint64
	_p3 [8]uint64
}

func (p *Pad) Increase() {
	atomic.AddUint64(&p.a, 1)
	atomic.AddUint64(&p.b, 1)
	atomic.AddUint64(&p.c, 1)
}

func BenchmarkPad_Increase(b *testing.B) {
	pad := &Pad{}

	b.RunParallel(func(pb *testing.PB) {
		for pb.Next() {
			pad.Increase()
		}
	})

}

func BenchmarkNoPad_Increase(b *testing.B) {
	nopad := &NoPad{}
	b.RunParallel(func(pb *testing.PB) {
		for pb.Next() {
			nopad.Increase()
		}
	})
}

运行结果:

go test -gcflags "-N -l" -bench .
goos: darwin
goarch: amd64
BenchmarkPad_Increase-4     	30000000	        56.4 ns/op
BenchmarkNoPad_Increase-4   	20000000	        91.4 ns/op

可能每次运行的结果不相同，但是基本上Padding后的数据结构要比没有padding的数据结构要好的多。

Java中知名的高性能的disruptor库中的设计中也采用了padding的方式避免伪共享。

你可以使用intel-go/cpuid获取CPU的cacheline的大小，官方库x/sys/cpu也提供了一个CacheLinePad struct用来padding,你只需要在你的struct定义的第一行增加_ CacheLinePad这么一行即可：

var X86 struct {
	_            CacheLinePad
	HasAES       bool // AES hardware implementation (AES NI)
    HasADX       bool // Multi-precision add-carry instruction extensions
    ......

一个完整的测试, 相关讨论#25203:

package test

import (
	"runtime"
	"sync"
	"testing"
)

type foo struct {
	x, y, z int64
}

type foo64Start struct {
	_       [64]byte
	x, y, z int64
}

type foo64StartEnd struct {
	_       [64]byte
	x, y, z int64
	_       [64]byte
}

type foo128Start struct {
	_       [128]byte
	x, y, z int64
}

type foo128StartEnd struct {
	_       [128]byte
	x, y, z int64
	_       [128]byte
}

type foo64StartEndAligned struct {
	_       [64]byte
	x, y, z int64
	_       [64 - 24]byte
}

type foo128StartEndAligned struct {
	_       [128]byte
	x, y, z int64
	_       [128 - 24]byte
}

const iter = (1 << 16)

func BenchmarkFalseSharing(b *testing.B) {
	var wg sync.WaitGroup

	b.Run("NoPad", func(b *testing.B) {
		arr := make([]foo, runtime.GOMAXPROCS(0))
		arrChan := make([]chan struct{}, runtime.GOMAXPROCS(0))
		for i := range arrChan {
			arrChan[i] = make(chan struct{})
		}

		for i := range arr {
			go func(i int) {
				for range arrChan[i] {
					for j := 0; j < iter; j++ {
						arr[i].x++
					}
					wg.Done()
				}

			}(i)
		}

		b.ResetTimer()

		for i := 0; i < b.N; i++ {
			wg.Add(runtime.GOMAXPROCS(0))
			for j := range arrChan {
				arrChan[j] <- struct{}{}
			}
			wg.Wait()
		}

		b.StopTimer()

		for i := range arrChan {
			close(arrChan[i])
		}
	})

	b.Run("Pad64Start", func(b *testing.B) {
		arr := make([]foo64Start, runtime.GOMAXPROCS(0))
		arrChan := make([]chan struct{}, runtime.GOMAXPROCS(0))
		for i := range arrChan {
			arrChan[i] = make(chan struct{})
		}

		for i := range arr {
			go func(i int) {
				for range arrChan[i] {
					for j := 0; j < iter; j++ {
						arr[i].x++
					}
					wg.Done()
				}

			}(i)
		}

		b.ResetTimer()

		for i := 0; i < b.N; i++ {
			wg.Add(runtime.GOMAXPROCS(0))
			for j := range arrChan {
				arrChan[j] <- struct{}{}
			}
			wg.Wait()
		}

		b.StopTimer()

		for i := range arrChan {
			close(arrChan[i])
		}
	})

	b.Run("Pad64StartEnd", func(b *testing.B) {
		arr := make([]foo64StartEnd, runtime.GOMAXPROCS(0))
		arrChan := make([]chan struct{}, runtime.GOMAXPROCS(0))
		for i := range arrChan {
			arrChan[i] = make(chan struct{})
		}

		for i := range arr {
			go func(i int) {
				for range arrChan[i] {
					for j := 0; j < iter; j++ {
						arr[i].x++
					}
					wg.Done()
				}

			}(i)
		}

		b.ResetTimer()

		for i := 0; i < b.N; i++ {
			wg.Add(runtime.GOMAXPROCS(0))
			for j := range arrChan {
				arrChan[j] <- struct{}{}
			}
			wg.Wait()
		}

		b.StopTimer()

		for i := range arrChan {
			close(arrChan[i])
		}
	})

	b.Run("Pad128Start", func(b *testing.B) {
		arr := make([]foo128Start, runtime.GOMAXPROCS(0))
		arrChan := make([]chan struct{}, runtime.GOMAXPROCS(0))
		for i := range arrChan {
			arrChan[i] = make(chan struct{})
		}

		for i := range arr {
			go func(i int) {
				for range arrChan[i] {
					for j := 0; j < iter; j++ {
						arr[i].x++
					}
					wg.Done()
				}

			}(i)
		}

		b.ResetTimer()

		for i := 0; i < b.N; i++ {
			wg.Add(runtime.GOMAXPROCS(0))
			for j := range arrChan {
				arrChan[j] <- struct{}{}
			}
			wg.Wait()
		}

		b.StopTimer()

		for i := range arrChan {
			close(arrChan[i])
		}
	})

	b.Run("Pad128StartEnd", func(b *testing.B) {
		arr := make([]foo128StartEnd, runtime.GOMAXPROCS(0))
		arrChan := make([]chan struct{}, runtime.GOMAXPROCS(0))
		for i := range arrChan {
			arrChan[i] = make(chan struct{})
		}

		for i := range arr {
			go func(i int) {
				for range arrChan[i] {
					for j := 0; j < iter; j++ {
						arr[i].x++
					}
					wg.Done()
				}

			}(i)
		}

		b.ResetTimer()

		for i := 0; i < b.N; i++ {
			wg.Add(runtime.GOMAXPROCS(0))
			for j := range arrChan {
				arrChan[j] <- struct{}{}
			}
			wg.Wait()
		}

		b.StopTimer()

		for i := range arrChan {
			close(arrChan[i])
		}
	})

	b.Run("Pad64StartEndAligned", func(b *testing.B) {
		arr := make([]foo64StartEndAligned, runtime.GOMAXPROCS(0))
		arrChan := make([]chan struct{}, runtime.GOMAXPROCS(0))
		for i := range arrChan {
			arrChan[i] = make(chan struct{})
		}

		for i := range arr {
			go func(i int) {
				for range arrChan[i] {
					for j := 0; j < iter; j++ {
						arr[i].x++
					}
					wg.Done()
				}

			}(i)
		}

		b.ResetTimer()

		for i := 0; i < b.N; i++ {
			wg.Add(runtime.GOMAXPROCS(0))
			for j := range arrChan {
				arrChan[j] <- struct{}{}
			}
			wg.Wait()
		}

		b.StopTimer()

		for i := range arrChan {
			close(arrChan[i])
		}
	})

	b.Run("Pad128StartEndAligned", func(b *testing.B) {
		arr := make([]foo128StartEndAligned, runtime.GOMAXPROCS(0))
		arrChan := make([]chan struct{}, runtime.GOMAXPROCS(0))
		for i := range arrChan {
			arrChan[i] = make(chan struct{})
		}

		for i := range arr {
			go func(i int) {
				for range arrChan[i] {
					for j := 0; j < iter; j++ {
						arr[i].x++
					}
					wg.Done()
				}

			}(i)
		}

		b.ResetTimer()

		for i := 0; i < b.N; i++ {
			wg.Add(runtime.GOMAXPROCS(0))
			for j := range arrChan {
				arrChan[j] <- struct{}{}
			}
			wg.Wait()
		}

		b.StopTimer()

		for i := range arrChan {
			close(arrChan[i])
		}
	})
}

func BenchmarkTrueSharing(b *testing.B) {
	var wg sync.WaitGroup

	b.Run("<64", func(b *testing.B) {
		arr := make([]foo, runtime.GOMAXPROCS(0)*iter)
		arrChan := make([]chan struct{}, runtime.GOMAXPROCS(0))
		for i := range arrChan {
			arrChan[i] = make(chan struct{})
		}

		for i := range arrChan {
			go func(i int) {
				for range arrChan[i] {
					for j := 0; j < iter; j++ {
						arr[(i*iter)+j].x++
					}
					wg.Done()
				}

			}(i)
		}

		b.ResetTimer()

		for i := 0; i < b.N; i++ {
			wg.Add(runtime.GOMAXPROCS(0))
			for j := range arrChan {
				arrChan[j] <- struct{}{}
			}
			wg.Wait()
		}

		b.StopTimer()

		for i := range arrChan {
			close(arrChan[i])
		}
	})

	b.Run(">64", func(b *testing.B) {
		arr := make([]foo64Start, runtime.GOMAXPROCS(0)*iter)
		arrChan := make([]chan struct{}, runtime.GOMAXPROCS(0))
		for i := range arrChan {
			arrChan[i] = make(chan struct{})
		}

		for i := range arrChan {
			go func(i int) {
				for range arrChan[i] {
					for j := 0; j < iter; j++ {
						arr[(i*iter)+j].x++
					}
					wg.Done()
				}

			}(i)
		}

		b.ResetTimer()

		for i := 0; i < b.N; i++ {
			wg.Add(runtime.GOMAXPROCS(0))
			for j := range arrChan {
				arrChan[j] <- struct{}{}
			}
			wg.Wait()
		}

		b.StopTimer()

		for i := range arrChan {
			close(arrChan[i])
		}
	})

	b.Run(">128", func(b *testing.B) {
		arr := make([]foo128Start, runtime.GOMAXPROCS(0)*iter)
		arrChan := make([]chan struct{}, runtime.GOMAXPROCS(0))
		for i := range arrChan {
			arrChan[i] = make(chan struct{})
		}

		for i := range arrChan {
			go func(i int) {
				for range arrChan[i] {
					for j := 0; j < iter; j++ {
						arr[(i*iter)+j].x++
					}
					wg.Done()
				}

			}(i)
		}

		b.ResetTimer()

		for i := 0; i < b.N; i++ {
			wg.Add(runtime.GOMAXPROCS(0))
			for j := range arrChan {
				arrChan[j] <- struct{}{}
			}
			wg.Wait()
		}

		b.StopTimer()

		for i := range arrChan {
			close(arrChan[i])
		}
	})
}

🪹鸟窝

[译]使用 Go 语言读写Redis协议

Go 生态圈的 K/V 数据库 benchmark

百万 Go TCP 连接的思考3: 正常连接下的吞吐率和延迟

百万 Go TCP 连接的思考2: 百万连接的吞吐率和延迟

[译]Go开发中一些有用的模式

百万 Go TCP 连接的思考: epoll方式减少资源占用

在Linux中查询CPU的核数

从 io.Reader 中读数据

Go Reflect 性能

cacheline 对 Go 程序的影响

参考资料