by smallnest

Go Reflect 性能

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

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

阅读全文

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的性能(我稍微改了一下)。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
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()
		}
	})
}

运行结果:

1
2
3
4
5
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这么一行即可：

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

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
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])
		}
	})
}

参考资料

  1. https://zh.wikipedia.org/wiki/CPU缓存
  2. https://medium.com/@genchilu/whats-false-sharing-and-how-to-solve-it-using-golang-as-example-ef978a305e10
  3. https://github.com/golang/go/issues/14980
  4. https://github.com/klauspost/cpuid
  5. https://segment.com/blog/allocation-efficiency-in-high-performance-go-services/
  6. https://luciotato.svbtle.com/golangs-duffs-devices
  7. https://stackoverflow.com/questions/14707803/line-size-of-l1-and-l2-caches
  8. https://luciotato.svbtle.com/golangs-duffs-devices
  9. https://github.com/golang/go/issues/25203
by smallnest

Cookie是指网站为了辨别用户身份而储存于客户端的数据，由网景公司的前雇员卢·蒙特利在1993年3月发明。最初定义于RFC 2109, 以及后续的规范 RFC 2965、RFC 6265。

服务器可以设置或读取Cookies中包含信息，借此维护用户跟服务器会话中的状态，并且可以基于Cookie实现Session,用来在服务器端存储用户的数据。

现在，几乎所有的商业网站都会使用Cookie技术用来标示浏览的用户，比如电子商务中的购物车、广告追踪系统等，并且涉及到一系列的安全问题和隐私问题。

Go的标准库中提供了Cookie的操作，并且第三方的库提供了Session的实现，所以在使用Go开发web应用中，我们可以很方便的实现session的管理，但是也有一些安全方面的设置需要注意。

本文介绍了使用Go语言开发web应用的时候，服务器端Cookie和Session的使用。

阅读全文

by smallnest

图像相似性比较实践

2008年TinEye上线了图片搜索，开始是注册制，后来逐步放开。2011年， Google也上线了相似图片搜索，通过用户上传的图片，可以搜索相似的图片。
参考文档中提供了一些介绍图像搜索的一些文章， 尤其是阮一峰2011年和2013年两篇普及性的文章，可以帮助你了解图像相似搜索的原理。

图像相似性搜索应用广泛、除了使用搜索引擎搜索类似图片外，像淘宝可以让顾客直接拍照搜索类似的商品信息、应用在商品购物上。也可以应用物体识别比如拍图识花等领域。目前我在调研图片鉴权的方案，通过一张图片和图片库中的图片进行比对，来确定这张图片是否侵权，或者退一步讲，图片库中是否包含和这张图片类似。 这个需求和目前深度学习应用中的图像识别还不一样， 图像识别是需要将图像中的物体识别出来， 猫啊狗啊什么的，而我所要做的就是一个查找相似图片的东西。

Neal Krawetz博士看到了一些关于TinEye原理的询问， 虽然他并不知道TinEye是怎么实现的，但是根据搜索结果，他判断是基于感知哈希算法(Perceptual hash algorithm)的变种，他于2011年5月写了一篇文章，介绍相关的技术。

阅读全文

by smallnest

C和Go相互调用

C可以调用Go，并且Go可以调用C， 如果更进一步呢， C-->Go-->C 或者 Go-->C-->Go的调用如何实现？

本文通过两个简单的例子帮助你了解这两种复杂的调用关系。本文不涉及两者之间的复杂的数据转换，官方文章C? Go? Cgo!、wiki/cgo和cmd/cgo有一些介绍。

阅读全文