clausecker / pospop Goto Github PK
View Code? Open in Web Editor NEWPositional Population Count for Go
License: BSD 2-Clause "Simplified" License
Positional Population Count for Go
License: BSD 2-Clause "Simplified" License
High-performance vectorised positional popcount routines for Go =============================================================== This repository contains implementations of the positional population count functions for Go. Details on the algorithms used will be published in a future research paper. To use this library, import it as follows: import "github.com/clausecker/pospop" You can then count populations using the Count8, Count16, Count32, and Count64 functions: var counts [8]int pospop.Count8(&counts, buf) The positional population count for buf is added to the contents of counts. Supported Platforms ------------------- The kernels works on a block size of 240 or 480 bytes (depending on whether AVX2 is available or not). A buffer size that is a multiple of 480 bytes and at least 10 kB in size is recommended. Implementations are provided for the following SIMD extensions: * AVX-512 F/BW (amd64) * AVX2 (amd64, 386) * SSE2 (amd64, 386) * NEON (arm64) * generic kernel (all architectures) The three kernels for amd64 correspond to the v4, v3, and v1 values of the upcoming GOAMD64 environment variable. Due to some required improvements in the assembler, the NEON kernel will only be available on Go 1.16 or newer. When building with earlier versions of the tool chain, only the generic kernel is available. The library automatically chooses the fastest available kernel for the system it is running on. Performance ----------- As all functions (Count8, Count16, Count32, Count64) of one set are based on the same kernel with a different accumulation function, they all perform equally well. This does not apply to the generic implementations whose performance is therefore given for every function individually. The following performance table is grouped by the instruction set used and the architecture it runs on. A buffer size of 100 kB was used to find these results. amd64 386 arm64 arm avx512 82.1 GB/s --- --- --- avx2 34.8 GB/s 31.6 GB/s --- --- sse2 16.0 GB/s 15.6 GB/s --- --- neon --- --- 36.9 GB/s --- generic8 1.02 GB/s 297 MB/s 1.68 GB/s 49.0 MB/s generic16 1.71 GB/s 1.36 GB/s 3.03 GB/s 67.1 MB/s generic32 2.66 GB/s 2.21 GB/s 3.83 GB/s 105 MB/s generic64 3.43 GB/s 1.89 GB/s 6.56 GB/s 82.9 MB/s The following systems were used for benchmarks, all using Go 1.16: * amd64, 386: Intel(R) Xeon(R) Gold 6138 CPU @ 2.00GHz * arm64: Apple M1 * arm: ARM Cortex-A72 r0p3 (Raspberry Pi 4B) Remaining Work -------------- * provide assembly kernels for arm, ppcle, and others (hardware donations appreciated for further targets) * provide variants of Count16, Count32, and Count64 working on byte arrays (c) 2020--2024 Robert Clausecker <[email protected]>. All Rights Reserved. This code is published under a 2-clause BSD license. See the file COPYING for details.
Hi Robert,
Thanks for persisting optimizing this great package.
I found that bit matrix transpositions slows down counting (100K buffer and others) since d24d616b (Add new count8 variant using bit matrix transpositions). I know you're creating a general framework to port to other platform, a little performance reduction may be tolerated.
I add some tests with few bytes, which I use in my cases.
Current version: d6e39e5
BenchmarkCount8/avx2/32-16 74935256 15.5 ns/op 2066.51 MB/s
BenchmarkCount8/avx2/64-16 55956423 20.3 ns/op 3153.58 MB/s
BenchmarkCount8/avx2/128-16 37906530 29.8 ns/op 4302.12 MB/s
BenchmarkCount8/avx2/256-16 24502731 50.8 ns/op 5038.58 MB/s
BenchmarkCount8/avx2/512-16 31988312 37.8 ns/op 13560.77 MB/s
BenchmarkCount8/avx2/1000-16 20510130 61.9 ns/op 16148.71 MB/s
BenchmarkCount8/avx2/10000-16 2245747 524 ns/op 19087.36 MB/s
BenchmarkCount8/avx2/100000-16 248845 4595 ns/op 21761.87 MB/s
Starting using bit matrix transpositions: 41dbbc5 (speedup after d24d616b)
BenchmarkCount8/avx2/32-16 100472971 13.2 ns/op 2431.84 MB/s
BenchmarkCount8/avx2/64-16 66744648 17.9 ns/op 3568.20 MB/s
BenchmarkCount8/avx2/128-16 42810946 28.3 ns/op 4530.39 MB/s
BenchmarkCount8/avx2/256-16 20535319 56.7 ns/op 4516.74 MB/s
BenchmarkCount8/avx2/512-16 33010789 37.1 ns/op 13811.14 MB/s
BenchmarkCount8/avx2/1000-16 21271256 56.3 ns/op 17774.12 MB/s
BenchmarkCount8/avx2/10000-16 2517070 447 ns/op 22377.79 MB/s
BenchmarkCount8/avx2/100000-16 296733 4059 ns/op 24637.18 MB/s
Old but fast way:
677120e
BenchmarkCount8/avx2/32-16 181525946 7.16 ns/op 4466.72 MB/s
BenchmarkCount8/avx2/64-16 112528216 10.5 ns/op 6069.95 MB/s
BenchmarkCount8/avx2/128-16 63801217 18.7 ns/op 6836.36 MB/s
BenchmarkCount8/avx2/256-16 40247318 29.1 ns/op 8795.27 MB/s
BenchmarkCount8/avx2/512-16 38962676 28.7 ns/op 17869.65 MB/s
BenchmarkCount8/avx2/1000-16 20517376 57.8 ns/op 17289.99 MB/s
BenchmarkCount8/avx2/10000-16 2644093 432 ns/op 23135.55 MB/s
BenchmarkCount8/avx2/100000-16 295675 3913 ns/op 25554.00 MB/s
Consider:
// B:A = A+B+C
#define CSA(A, B, C, D) \
MOVOA A, D \
PAND B, D \
PXOR B, A \
MOVOA A, B \
PAND C, B \
PXOR C, A \
POR D, B
vs
// B:A = A+B+C
#define CSA(A, B, C) \
PXOR C, B \
PXOR A, C \
PXOR B, A \
POR C, B \
PXOR A, B
The C
input must be ready 1 cycle earlier.
This is mainly for SSE2 platforms. AVX2/NEON instructions have non-destructive 3-operand forms.
Some architectures have "free" "mov elimination" which makes this change hard to benchmark.
IIRC, a problem I was having before was about how the compiler was merging a load with an xor instruction...
xor r1, [mem]
vs
load r2, [mem]
xor r1, r2
Not sure if this would be an issue with GoLang Assembly.
======
This issue is not important, feel free to close this out, just one of my pet projects.
A declarative, efficient, and flexible JavaScript library for building user interfaces.
๐ Vue.js is a progressive, incrementally-adoptable JavaScript framework for building UI on the web.
TypeScript is a superset of JavaScript that compiles to clean JavaScript output.
An Open Source Machine Learning Framework for Everyone
The Web framework for perfectionists with deadlines.
A PHP framework for web artisans
Bring data to life with SVG, Canvas and HTML. ๐๐๐
JavaScript (JS) is a lightweight interpreted programming language with first-class functions.
Some thing interesting about web. New door for the world.
A server is a program made to process requests and deliver data to clients.
Machine learning is a way of modeling and interpreting data that allows a piece of software to respond intelligently.
Some thing interesting about visualization, use data art
Some thing interesting about game, make everyone happy.
We are working to build community through open source technology. NB: members must have two-factor auth.
Open source projects and samples from Microsoft.
Google โค๏ธ Open Source for everyone.
Alibaba Open Source for everyone
Data-Driven Documents codes.
China tencent open source team.