Go语言中的SIMD加速：以矩阵加法为例

最新推荐文章于 2024-07-24 12:44:47 发布
最新推荐文章于 2024-07-24 12:44:47 发布
阅读量3 收藏
点赞数
文章标签： golang 矩阵 java linux 开发语言
原文链接：https://mp.weixin.qq.com/s?__biz=MzA4ODg0NDkzOA==&mid=2247510067&idx=1&sn=07ec1de9cffa3696e2a4ea3f1f23ff0e&chksm=911931fe1c3198c39252d9635226d1fdd7d1b7ef3a2405b1802b8b190681e7db5bfc978344cb&scene=126&sessionid=0
版权

前些日子，一些资深Gopher，比如fasthttp[1]的作者Aliaksandr Valialkin[2]因函数迭代器[3]加入Go 1.23版本[4]而抱怨Go的演进走错了方向：朝着增加复杂性和隐式代码执行的方向发展，而没有专注于Go语言的基本设计哲学——简单性、生产力和性能。Valialkin希望Go团队能专注于一些性能打磨和优化的环节，比如使用SIMD提升一些计算场景下Go代码的性能，避免Go的某些领地被以性能和安全性著称的Rust[5]抢去！

无独有偶，在Go项目issues中，我们也能看到很多有关希望Go支持SIMD指令的issue，比如近期的一个proposal[6]，就期望Go团队可以在标准库中添加simd包以支持高性能的SIMD计算，就像Rust std::simd那样。当然，早期这类issue也有很多，比如：issue 53171[7]、issue 58610[8]等。

那么什么是SIMD指令？在Go官方尚未支持simd包或SIMD计算的情况下，如何在Go中使用SIMD指令进行计算加速呢？在这篇文章中，我们就来做个入门版介绍，并以一个最简单的矩阵加法的示例来展示一下SIMD指令的加速效果。

1. SIMD指令简介

SIMD是“单指令多数据”(Single Instruction Multiple Data)的缩写。与之对应的则是SISD（Single Instruction, Single Data），即“单指令单数据”。

在大学学习汇编时，用于举例的汇编指令通常是SISD指令，比如常见的ADD、MOV、LEA、XCHG等。这些指令每执行一次，仅处理一个数据项。早期的x86架构下，SISD指令处理的数据仅限于8字节（64位）或更小的数据。随着处理器架构的发展，特别是x86-64架构的引入，SISD指令也能处理更大的数据项，使用更大的寄存器。但SISD指令每次仍然只处理一个数据项，即使这个数据项可能比较大。

相反，SIMD指令是一种特殊的指令集，它可以让处理器可以同时处理多个数据项，提高计算效率。我们可以用下面这个更为形象生动的比喻来体会SIMD和SISD的差别。

想象你是一个厨师，需要切100个苹果。普通的方式是一次切一个苹果，这就像普通的SISD处理器指令。而SIMD指令就像是你突然多了几双手，可以同时切4个或8个苹果。显然，多手同时工作会大大提高切苹果的速度。

cc6c90c8feb20efebcf561abd41347bb.png

具体来说，SIMD指令的优势在于以下几点：

  • 并行处理：一条指令可以同时对多个数据进行相同的操作。

  • 数据打包：将多个较小的数据(如32位浮点数)打包到一个较大的寄存器(如256位)中。

  • 提高数据吞吐量：每个时钟周期可以处理更多的数据。

这种并行处理方式特别适合于需要大量重复计算的任务，如图像处理、音频处理、科学计算等。通过使用SIMD指令，可以显著提高这些应用的性能。

主流的x86-64(amd64)和arm系列CPU都有对SIMD指令的支持。以x86-64为例，该CPU体系下支持的SIMD指令就包括MMX(MultiMedia eXtensions)、SSE (Streaming SIMD Extensions)、SSE2、SSE3、SSSE3、SSE4、AVX(Advanced Vector Extensions)、AVX2以及AVX-512等。ARM架构下也有对应的SIMD指令集，包括VFP (Vector Floating Point)、NEON (Advanced SIMD)、SVE (Scalable Vector Extension)、SVE2以及Helium (M-Profile Vector Extension, MVE)等。

注：在Linux上，你可以通过lscpu或cat /proc/cpuinfo来查看当前主机cpu支持的SIMD指令集的种类。注：Go在Go 1.11版本才开始支持AVX-512指令[9]。

每类SIMD指令集都有其特定的优势和应用场景，以x86-64下的SIMD指令集为例：

  • MMX主要用于早期的多媒体处理；

  • SSE系列逐步改进了浮点运算和整数运算能力，广泛应用于图形处理和音视频编码；

  • AVX系列大幅提高了并行处理能力，特别适合科学计算和高性能计算场景。

e6524cee03271a58e60795d0eca89a3f.png

x86-64下SIMD指令集演进

这些指令集的演进反映了处理器技术的发展和应用需求的变化。从支持64位计算的MMX到支持512位计算的AVX-512，SIMD指令的并行处理能力不断提升，更多更大的寄存器加入进来，为各种复杂的计算任务提供了强大的硬件支持。

注：SSE和AVX各自有16个寄存器，SSE的16个寄存器为XMM0-XMM15，XMM是128位寄存器，而YMM是256位寄存器。支持AVX的x86-64处理器包含16个256位大小的寄存器，从YMM0到YMM15。每个YMM寄存器的低128位是相对应的XMM寄存器。大多数AVX指令可以使用任何一个XMM或者YMM寄存器作为SIMD操作数。AVX512将每个AVXSIMD寄存器的大小从256位扩展到512位，称为ZMM寄存器；符合AVX512标准的处理器包含32个ZMM寄存器，从ZMM0~ZMM31。YMM和XMM寄存器分别对应于每个ZMM寄存器的低256位和低128位。

既然SIMD指令这么好，那么在Go中应该如何使用SIMD指令呢？接下来我们就来看看。

2. 在Go中如何使用SIMD指令

Go主要面向的是云计算领域、微服务领域，这些领域中对计算性能的要求相对没那么极致。以至于在一些对性能要求较高的场景，比如高性能计算、 图形学、数字信号处理等领域，很多gopher会遇到对Go计算性能进行优化的需求。

纯计算领域，怎么优化呢？此时此刻，Go官方并没有提供对SIMD提供支持的simd包。

一种想法是使用cgo机制在Go中调用更快的C或C++，但cgo的负担又不能不考虑，cgo不是go[10]，很多人不愿意引入cgo。

另外一种想法就是再向下一层，直接上汇编，在汇编中直接利用SIMD指令实现并行计算。但手写汇编难度是很高的，手写Plan9风格、资料甚少的Go汇编难度则更高。那么有什么方法避免直接手搓汇编呢？目前看大致有这么几种(如果有更好的方法，欢迎在评论区提出你的建议)：

  • 使用c2goasm[11](https://github.com/minio/c2goasm/)转换

我们可以先用c/c++实现对应的函数功能(可以利用类似intel提供的面向simd的intrisic functions[12])，然后生成汇编代码(基于clang)，再用c2goasm转换为go语言汇编。不过目前c2goasm已经public archive了，并且该方法应用受很多因素限制，比如clang版本和特定的编译选项啥的。亲测这种方法上手难度较高。

  • 使用uber工程师Michael McLoughlin开源的avo[13]来生成go汇编

avo(https://github.com/mmcloughlin/avo)是一个go包，它支持以一种相对高级一些的Go语法来编写汇编，至少你可以不必直面那些晦涩难懂的汇编代码。但使用avo编写汇编也不是很容易的事情，你仍然需要大致知道汇编的运作原理和基本的编写规则。此外avo与汇编的能力并非完全等价，其作者声明：avo也还处于实验阶段。

  • 使用goplus/llgo集成c/c++生态

在go中调用c的cgo机制不受待见，llgo[14]反其道而行之，将go、python、c/c++等代码统统转换为llvm中间代码进而通过clang编译和优化为可执行文件。这样就可以直接利用python、c/c++的生态，进而利用高性能的c/c++实现（比如支持SIMD指令）。目前llgo还不成熟，七牛云老板许式伟正在全力开发llgo，等llgo成熟后，这后续可能也是一种选择。

考虑到Go目前不直接支持intel intrisic functions for SIMD[15]，要在Go中使用SIMD只能直接使用汇编。而在手搓汇编难度太高的情况下，通过avo生成汇编便是一条可以尝试的路径，我们可以将一些计算的核心部分用avo生成的汇编来进行加速。

接下来，我们就来通过一个矩阵加法的示例看看SIMD指令的加速效果。基于SIMD指令的矩阵加法的汇编逻辑，我们采用avo实现。

3. 第一版SIMD优化(基于SSE)

我们使用avo先来实现一版基于SSE指令集的矩阵加法。前面说过avo是一个Go库，我们无需安装任何二进制程序，直接使用avo库中的类型和函数编写矩阵加法的实现即可：

// simd-in-go/matadd-sse/pkg/asm.go

//go:build ignore
// +build ignore

package main

import (
 "github.com/mmcloughlin/avo/attr"
 . "github.com/mmcloughlin/avo/build"
 . "github.com/mmcloughlin/avo/operand"
)

func main() {
 TEXT("MatrixAddSIMD", attr.NOSPLIT, "func(a, b, c []float32)")
 a := Mem{Base: Load(Param("a").Base(), GP64())}
 b := Mem{Base: Load(Param("b").Base(), GP64())}
 c := Mem{Base: Load(Param("c").Base(), GP64())}
 n := Load(Param("a").Len(), GP64())

 X0 := XMM()
 X1 := XMM()

 Label("loop")
 CMPQ(n, U32(4))
 JL(LabelRef("done"))

 MOVUPS(a.Offset(0), X0)
 MOVUPS(b.Offset(0), X1)
 ADDPS(X1, X0)
 MOVUPS(X0, c.Offset(0))

 ADDQ(U32(16), a.Base)
 ADDQ(U32(16), b.Base)
 ADDQ(U32(16), c.Base)
 SUBQ(U32(4), n)
 JMP(LabelRef("loop"))

 Label("done")
 RET()

 Generate()
}

第一次看上面这段代码，你是不是觉得即便使用avo来生成矩阵加法的代码，如果你不了解汇编的编写和运行模式，你也是无从下手的。简单说一下这段代码。

首先，该文件是用于生成矩阵加法的汇编代码的，因此该asm.go并不会编译到最终的可执行文件中或测试代码中，这里利用go编译器构建约束将该文件排除在外。

main函数的第一行的TEXT函数定义了一个名为MatrixAddSIMD的函数，使用attr.NOSPLIT属性表示不需要栈分割，函数签名是：

func(a, b, c []float32)

变量a, b, c分别表示输入矩阵a, b和输出矩阵c的内存地址，使用Load函数从参数中加载基地址到GP64返回的通用寄存器。n表示矩阵的长度，使用 Load函数从参数中加载长度到GP64返回的通用寄存器。

X0和X1定义了两个XMM寄存器，用于SIMD操作。

接下来定义了一个循环，在这个循环的循环体中，将通过SSE指令处理输入的矩阵数据：

  • MOVUPS(a.Offset(0), X0)：将矩阵a的前16字节（4 个float32）加载到XMM寄存器X0。

  • MOVUPS(b.Offset(0), X1)：将矩阵b的前16字节（4个float32）加载到XMM寄存器X1。

  • ADDPS(X1, X0)：将X1和X0中的数据相加，结果存入X0。

  • MOVUPS(X0, c.Offset(0))：将结果从X0存入矩阵c的前16字节。

  • ADDQ(U32(16), a.Base)：将矩阵a的基地址增加16字节（4个float32）。

  • ADDQ(U32(16), b.Base)：将矩阵b的基地址增加16字节（4个float32）。

  • ADDQ(U32(16), c.Base)：将矩阵c的基地址增加16字节（4个float32）。

  • SUBQ(U32(4), n)：将矩阵长度n减少4。

  • JMP(LabelRef("loop"))：无条件跳转到标签loop，继续循环。

最后调用Generate函数生成汇编代码。

下面我们就来运行该代码，生成相应的汇编代码以及stub函数：

$cd matadd-sse/pkg
$make
go run asm.go -out add.s -stubs stub.go

下面是生产的add.s的全部汇编代码：

// simd-in-go/matadd-sse/pkg/add.s

// Code generated by command: go run asm.go -out add.s -stubs stub.go. DO NOT EDIT.

#include "textflag.h"

// func MatrixAddSIMD(a []float32, b []float32, c []float32)
// Requires: SSE
TEXT ·MatrixAddSIMD(SB), NOSPLIT, $0-72
 MOVQ a_base+0(FP), AX
 MOVQ b_base+24(FP), CX
 MOVQ c_base+48(FP), DX
 MOVQ a_len+8(FP), BX

loop:
 CMPQ   BX, $0x00000004
 JL     done
 MOVUPS (AX), X0
 MOVUPS (CX), X1
 ADDPS  X1, X0
 MOVUPS X0, (DX)
 ADDQ   $0x00000010, AX
 ADDQ   $0x00000010, CX
 ADDQ   $0x00000010, DX
 SUBQ   $0x00000004, BX
 JMP    loop

done:
 RET

这里使用的ADDPS、MOVUPS和ADDQ都是SSE指令：

  • ADDPS (Add Packed Single-Precision Floating-Point Values)：这是一个SSE指令，用于对两个128位的XMM寄存器中的4个单精度浮点数进行并行加法运算。

  • MOVUPS (Move Unaligned Packed Single-Precision Floating-Point Values): 这也是一个SSE指令，用于在内存和XMM寄存器之间移动128位的单精度浮点数数据。与MOVAPS(Move Aligned Packed Single-Precision Floating-Point Values) 指令不同，MOVUPS不要求地址对齐，可以处理非对齐的数据。

除了生成汇编代码外，asm.go还生成了一个stub函数：MatrixAddSIMD，即上面汇编实现的那个函数。

// simd-in-go/matadd-sse/pkg/stub.go

// Code generated by command: go run asm.go -out add.s -stubs stub.go. DO NOT EDIT.

package pkg

func MatrixAddSIMD(a []float32, b []float32, c []float32)

在matadd-sse/pkg/add-no-simd.go中，我们放置了常规的矩阵加法的实现：

package pkg

func MatrixAddNonSIMD(a, b, c []float32) {
 n := len(a)
 for i := 0; i < n; i++ {
  c[i] = a[i] + b[i]
 }
}

接下来，我们编写一些单测代码，确保一下MatrixAddSIMD和MatrixAddNonSIMD的功能是正确的：

// simd-in-go/matadd-sse/matrix_add_test.go 
package main

import (
 "demo/pkg"
 "testing"
)

func TestMatrixAddNonSIMD(t *testing.T) {
 size := 1024
 a := make([]float32, size)
 b := make([]float32, size)
 c := make([]float32, size)
 expected := make([]float32, size)

 for i := 0; i < size; i++ {
  a[i] = float32(i)
  b[i] = float32(i)
  expected[i] = a[i] + b[i]
 }

 pkg.MatrixAddNonSIMD(a, b, c)

 for i := 0; i < size; i++ {
  if c[i] != expected[i] {
   t.Errorf("MatrixAddNonSIMD: expected %f, got %f at index %d", expected[i], c[i], i)
  }
 }
}

func TestMatrixAddSIMD(t *testing.T) {
 size := 1024
 a := make([]float32, size)
 b := make([]float32, size)
 c := make([]float32, size)
 expected := make([]float32, size)

 for i := 0; i < size; i++ {
  a[i] = float32(i)
  b[i] = float32(i)
  expected[i] = a[i] + b[i]
 }

 pkg.MatrixAddSIMD(a, b, c)

 for i := 0; i < size; i++ {
  if c[i] != expected[i] {
   t.Errorf("MatrixAddSIMD: expected %f, got %f at index %d", expected[i], c[i], i)
  }
 }
}

如我们预期的那样，上述单测代码可以顺利通过。接下来，我们再来做一下benchmark，看看使用SSE实现的矩阵加法性能到底提升了多少：

// simd-in-go/matadd-sse/benchmark_test.go 
package main

import (
 "demo/pkg"
 "testing"
)

func BenchmarkMatrixAddNonSIMD(tb *testing.B) {
 size := 1024
 a := make([]float32, size)
 b := make([]float32, size)
 c := make([]float32, size)

 for i := 0; i < size; i++ {
  a[i] = float32(i)
  b[i] = float32(i)
 }

 tb.ResetTimer()
 for i := 0; i < tb.N; i++ {
  pkg.MatrixAddNonSIMD(a, b, c)
 }
}

func BenchmarkMatrixAddSIMD(tb *testing.B) {
 size := 1024
 a := make([]float32, size)
 b := make([]float32, size)
 c := make([]float32, size)

 for i := 0; i < size; i++ {
  a[i] = float32(i)
  b[i] = float32(i)
 }

 tb.ResetTimer()
 for i := 0; i < tb.N; i++ {
  pkg.MatrixAddSIMD(a, b, c)
 }
}

运行这个benchmark，我们得到下面结果：

$go test -bench .
goos: darwin
goarch: amd64
pkg: demo
... ...
BenchmarkMatrixAddNonSIMD-8     2129426        554.4 ns/op
BenchmarkMatrixAddSIMD-8        3481318        357.4 ns/op
PASS
ok   demo 3.350s

我们看到SIMD实现的确性能优秀，几乎在非SIMD实现的基础上提升了一倍。但这似乎还并不足以说明SIMD的优秀。我们再来扩展一下并行处理的数据的数量和宽度，使用AVX指令再来实现一版矩阵加法，看是否还会有进一步的性能提升。

4. 第二版SIMD优化(基于AVX)

下面是基于avo使用AVX指令实现的Go代码：

// simd-in-go/matadd-avx/pkg/asm.go

//go:build ignore
// +build ignore

package main

import (
 "github.com/mmcloughlin/avo/attr"
 . "github.com/mmcloughlin/avo/build"
 . "github.com/mmcloughlin/avo/operand"
)

func main() {
 TEXT("MatrixAddSIMD", attr.NOSPLIT, "func(a, b, c []float32)")
 a := Mem{Base: Load(Param("a").Base(), GP64())}
 b := Mem{Base: Load(Param("b").Base(), GP64())}
 c := Mem{Base: Load(Param("c").Base(), GP64())}
 n := Load(Param("a").Len(), GP64())

 Y0 := YMM()
 Y1 := YMM()

 Label("loop")
 CMPQ(n, U32(8))
 JL(LabelRef("done"))

 VMOVUPS(a.Offset(0), Y0)
 VMOVUPS(b.Offset(0), Y1)
 VADDPS(Y1, Y0, Y0)
 VMOVUPS(Y0, c.Offset(0))

 ADDQ(U32(32), a.Base)
 ADDQ(U32(32), b.Base)
 ADDQ(U32(32), c.Base)
 SUBQ(U32(8), n)
 JMP(LabelRef("loop"))

 Label("done")
 RET()

 Generate()
}

这里的代码与上面sse实现的代码逻辑类似，只是指令换成了avx的指令，包括VMOVUPS、VADDPS等：

  • VADDPS (Vectorized Add Packed Single-Precision Floating-Point Values): 是AVX (Advanced Vector Extensions) 指令集中的一个指令，用于对两个256位的YMM寄存器中的8个单精度浮点数进行并行加法运算。

  • VMOVUPS (Vectorized Move Unaligned Packed Single-Precision Floating-Point Values): 这也是一个AVX指令，用于在内存和YMM寄存器之间移动256位的单精度浮点数数据。与MOVUPS指令相比，VMOVUPS可以处理更宽的256位SIMD数据。

由于在SSE实现的版本中做了详细说明，这里就不再赘述代码逻辑，其他单元测试与benchmark测试的代码也都完全相同，我们直接看benchmark的结果：

$go test -bench .
goos: darwin
goarch: amd64
pkg: demo
... ...
BenchmarkMatrixAddNonSIMD-8     2115284        566.6 ns/op
BenchmarkMatrixAddSIMD-8       10703102        111.5 ns/op
PASS
ok   demo 3.088s

我们看到AVX版的矩阵加法的性能是常规实现的5倍多，是SSE实现的性能的近3倍，在实际生产中，这将大大提升代码的执行效率。

也许还有更优化的实现，但我们已经达到了基于SIMD加速矩阵加法的目的，这里就不再做继续优化了，大家如果有什么新的想法和验证的结果，可以在评论区留言告诉我哦！

5. 小结

在这篇文章中，我们探讨了在Go语言中使用SIMD指令进行计算加速的方法。尽管Go官方目前还没有直接支持SIMD的包，但我们通过使用avo库生成汇编代码的方式，成功实现了基于SSE和AVX指令集的矩阵加法优化。

我们首先介绍了SIMD指令的基本概念和优势，然后讨论了在Go中使用SIMD指令的几种可能方法。接着，我们通过一个具体的矩阵加法示例，展示了如何使用avo库生成基于SSE和AVX指令集的汇编代码。

通过benchmark测试，我们看到基于SSE指令的实现相比常规实现提升了约1.5倍的性能，而基于AVX指令的实现则带来了约5倍的性能提升。这充分说明了SIMD指令在并行计算密集型任务中的强大优势。

虽然直接使用SIMD指令需要一定的汇编知识，增加了代码的复杂性，但在一些对性能要求极高的场景下，这种优化方法仍然是非常有价值的。我希望这篇文章能为Go开发者在进行性能优化时提供一些新的思路和参考。

当然，这里展示的只是SIMD优化的一个简单示例。在实际应用中，可能还需要考虑更多因素，如数据对齐、边界条件处理等。大家可以在此基础上进行更深入的探索和实践。

本文涉及的源码可以在这里[16]下载 - https://github.com/bigwhite/experiments/blob/master/simd-in-go

本文部分源代码由deepseek coder v2[17]实现。

6. 参考资料

  • Intel Intrinsics Guide[18] - https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html

  • Go Wiki: AVX512[19] - https://go.dev/wiki/AVX512

  • A Manual for the Plan 9 assembler[20] - http://doc.cat-v.org/plan_9/4th_edition/papers/asm

  • From slow to SIMD: A Go optimization story[21] - https://sourcegraph.com/blog/slow-to-simd

  • Efficient and performance-portable vector software[22] - https://github.com/google/highway

  • 并行处理-SIMD[23] - https://www.slidestalk.com/u231/simd_computer

  • 玩转SIMD指令编程[24] - https://zhuanlan.zhihu.com/p/591900754

参考资料

[1] 

fasthttp: https://tonybai.com/2021/04/25/server-side-performance-nethttp-vs-fasthttp

[2] 

Aliaksandr Valialkin: https://github.com/valyala

[3] 

函数迭代器: https://tonybai.com/2024/06/24/range-over-func-and-package-iter-in-go-1-23/

[4] 

Go 1.23版本: https://tonybai.com/2024/05/30/go-1-23-foresight/

[5] 

Rust: https://tonybai.com/tag/rust

[6] 

近期的一个proposal: https://github.com/golang/go/issues/67520

[7] 

issue 53171: https://github.com/golang/go/issues/53171

[8] 

issue 58610: https://github.com/golang/go/issues/58610

[9] 

Go 1.11版本才开始支持AVX-512指令: https://go.dev/wiki/AVX512

[10] 

cgo不是go: https://dave.cheney.net/2016/01/18/cgo-is-not-go

[11] 

c2goasm: https://github.com/minio/c2goasm/

[12] 

intrisic functions: https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html

[13] 

avo: https://github.com/mmcloughlin/avo

[14] 

llgo: https://github.com/goplus/llgo

[15] 

intel intrisic functions for SIMD: https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html

[16] 

这里: https://github.com/bigwhite/experiments/blob/master/simd-in-go

[17] 

deepseek coder v2: https://chat.deepseek.com/coder

[18] 

Intel Intrinsics Guide: https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html

[19] 

Go Wiki: AVX512: https://go.dev/wiki/AVX512

[20] 

A Manual for the Plan 9 assembler: http://doc.cat-v.org/plan_9/4th_edition/papers/asm

[21] 

From slow to SIMD: A Go optimization story: https://sourcegraph.com/blog/slow-to-simd

[22] 

Efficient and performance-portable vector software: https://github.com/google/highway

[23] 

并行处理-SIMD: https://www.slidestalk.com/u231/simd_computer

[24] 

玩转SIMD指令编程: https://zhuanlan.zhihu.com/p/591900754

[25] 

Gopher部落知识星球: https://public.zsxq.com/groups/51284458844544

[26] 

链接地址: https://m.do.co/c/bff6eed92687

- END -

推荐阅读:

6 个必须尝试的将代码转换为引人注目的图表的工具

Go 1.23新特性前瞻

Gopher的Rust第一课：第一个Rust程序

Go早期是如何在Google内部发展起来的

2024 Gopher Meetup 武汉站活动

go 中更加强大的 traces

「GoCN酷Go推荐」我用go写了魔兽世界登录器?

Go区不大，创造神话，科目三杀进来了

想要了解Go更多内容，欢迎扫描下方👇关注公众号，扫描 [实战群]二维码  ,即可进群和我们交流~

- 扫码即可加入实战群 -

7bbc8e682484d8830eb86329d2af7dd3.png

97e98b1ab82def0fcac88ee949d3f82c.png

分享、在看与点赞Go aad3f3a3af2579ad2edf3fb9c517d8a5.gif

Go中国
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Go汇编语法和MatrixOne使用介绍
licdn的专栏
04-19 329
MatrixOne是一个新一代超融合异构数据库，致力于打造单一架构处理TP、AP、流计算等多种负载的极简大数据引擎。MatrixOne由Go语言所开发，在MatrixOne已发布的性能报告中，与业界领先的OLAP数据库Clickhouse相比也不落下风。作为一款Go语言实现的数据库，可以达到C++实现的数据库一样的性能，其中一个很重要的优化就是利用Go语言自带的汇编能力，来通过调用SIMD指令进行硬件加速。本文就将对Go汇编及在MatrixOne的应用做详细介绍。
c 汇编语言用标准函数代替,GO汇编-汇编语言的为例
weixin_32568425的博客
05-18 189
汇编语言的为例汇编语言的真正威力来自两个维度：一是突破框架限制，实现看似不可能的任务；二是突破指令限制，通过高级指令挖掘极致的性能。对于第一个问题，我们将演示如何通过Go汇编语言直接访问系统调用，和直接调用C语言函数。对于第二个问题，我们将演示X64指令中AVX等高级指令的简单用法。系统调用系统调用是操作系统为外提供的公共接口。因为操作系统彻底接管了各种底层硬件设备，因此操作系统提供的系统调用成了...
2.3 大模型硬件基础：AI芯片（上篇） —— 《带你自学大语言模型》系列
陌北有棵树的博客
07-20 766
算力是AI发展的驱动力，大模型时代更要格外关注算力。目前的大模型是个重资产行业，底层竞争在于半导体产业，AI的发展离不开芯片，甚至可以说，整个信息时代的发展都离不开芯片。
漫谈SIMD、SSE指令集与ClickHouse向量化执行
LittleMagic's Blog
08-13 3888
前言 ClickHouse之所以会像闪电一样快（"blazing fast"），是多方面优化的结果，包括且不限于：高效且磁盘友好的列式存储，高效的数据压缩，精心设计的各类索引，并行分布式查询，运行时代码生成等。 另外，ClickHouse为了最大限度地压榨硬件——尤其是CPU——的性能，实现了向量化查询执行（vectorized query execution）机制。这个名词相对于上面的那些可能没...
变换和世界视图投影空间矩阵
游戏开发、游戏引擎开发、逆向破解爱好者
04-13 787
在本教程中，我们将学习矩阵，变换，世界/视图/投影空间矩阵以及每次绘制的常量缓冲区。 概述 在本教程中，我们将学习矩阵，变换，世界/视图/投影空间矩阵以及每次绘制的常量缓冲区。 矩阵 变换 世界/视图/投影空间 每次绘制的常量缓冲区 好吧，让我们从矩阵开始。 矩阵 矩阵是二维数组。 我们可以使用矩阵来表示包括平移，旋转和缩放的变换，以及包括世界（所有变换），视图和投影的空间。 在3D图形中，我们使用4x4矩阵，但是4x3矩阵可以用于蒙皮网格，将网格发送到GPU时可以节省一些带宽。 向量与.
POSEIDON: Privacy-Preserving Federated NeuralNetwork Learning
weixin_60335028的博客
05-27 827
POSEIDON: Privacy-Preserving Federated NeuralNetwork Learning阅读笔记
量化神经网络：QNN论文阅读笔记
热门推荐
weixin_40671425的博客
12-22 1万+
论文：《Quantized Neural Networks: Training Neural Networks with Low Precision Weights and Activations》 连接：https://arxiv.org/pdf/1609.07061v1.pdf 摘要 我们介绍一种训练量化神经网络（QNN）的方法，在运行时具有极低精度（例如1bit）权重和激...
二值化网络：BNN 论文阅读笔记
weixin_40671425的博客
12-22 2261
论文：《Binarized Neural Networks: Training Neural Networks with Weights and Activations Constrained to +1 or -1》 连接：https://arxiv.org/pdf/1602.02830.pdf 摘要 我们介绍了一种训练二进制神经网络（BNN）的方法-在运行时，神经网络具有二...
DD-AVX_v3:SIMD 加速的高精度稀疏矩阵运算库
05-31
DD-AVX 库：SIMD 加速的高精度稀疏矩阵运算库 关于 DD-AVX_v3 是 SIMD 加速简单接口高精度 BLAS Lv.1 和 Sparse BLAS 操作库。 这些操作可以通过组合双精度和双双精度来执行。 多线程(OpenMP) 和SIMD AVX / AVX2 /...
CMRF：可配置的矩阵寄存器文件，用于加速SIMD处理器上的矩阵操作
03-11
CMRF：可配置的矩阵寄存器文件，用于加速SIMD处理器上的矩阵操作
wasm-simd:通过 WebAssembly 演示 JavaScript 中的 SIMD 用法
05-30
WebAssembly SIMD 示例本示例通过 WebAssembly 演示了 JavaScript 中 SIMD 的用法。 它运行了 2 个大小为 10000 的数组相加的 100000 倍（有关更多详细信息，请参阅 ）。 第一个实现是通过 JavaScript 中的一个简单...
simd-adler32:SIMD加速的Adler-32滚动哈希算法实现
04-11
simd-adler32 SIMD加速的Adler-32滚动哈希算法实现。特征没有依赖关系支持no_std （具有default-features = false ） 运行时CPU功能检测（启用std ） 在尽可能多的目标（目前仅x86和x86_64）上实现快速性能当simd不...
嘈杂：SIMD加速产生噪音
02-04
在"noisy-master"这个压缩包中，可能包含了一个噪声生成库的源代码，该库可能使用了SIMD优化，以实现更高效的噪声生成。开发者可能通过查看和分析这些源代码，学习如何在Nim中使用SIMD技术，以及如何将其应用于噪声...
go--本地下载包
weixin_63566388的博客
07-23 344
下载完成后，你可以验证包是否已正确下载。下载并安装适合你操作系统的版本。：确保已经安装 Go。
Golang | Leetcode Golang题解之第282题给表达式添加运算符
weixin_66442839的博客
07-24 273
Golang | Leetcode Golang题解之第282题给表达式添加运算符
Windows安装go语言开发环境
doubiy的博客
07-20 475
然后重新安装这些插件（重新安装插件的触发方式：安装失败后有可能会重新在右下角弹出安装插件的提示；这些插件的作用是，对go语言代码的合法性检查以及提示（比如提示有哪些方法可以使用、保存时自动导入没有导入的包、去除没有使用的包（没有使用的包导入后会不合法）等等）这里安装插件时，由于需要使用国外的网络，可能会失败，那么最简单的解决方案就是设置go语言环境变量中的proxy为国内的代理地址。当我们用vscode写go语言代码时，会在vscode的右下角弹出安装相关插件的提示，那么全部安装即可。正常显示则安装完成。
protoc-gen-go-http: program not found or is not executable
lemonth的博客
07-19 362
1 先升级到最新版 sudo kratos upgrade #3 安装 protoc-gen-go-errors。
goland设置Gin框架中tmpl模板的语法提示的方法
最新发布
yonggeit的博客
07-24 214
在Gin中，我们要使用.tmpl结尾的模板文件，但是我们在new的时候，发现没有对应的文件，所以它就会被当成普通的文件来进行解析，因此也没有提示，这对我们使用goland来开发，是非常痛苦的事情。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值