免费在 GitHub 公开

dotnet-simd

Vectorize hot loops in C#/.NET the right way — reach for System.Numerics.Tensors (TensorPrimitives) first, then System.Runtime.Intrinsics (Vector128/256/512) for hand-written algorithms, hardware intrinsics only as a last resort. USE FOR: choosing between TensorPrimitives, Vector<T>, Vector128/256/512, and X86/Arm/Wasm intrinsics; MemoryMarshal/LoadUnsafe/StoreUnsafe span-to-vector patterns; hardware-acceleration checks (IsHardwareAccelerated, IsSupported); widest-vector-first code paths with scalar/small-input fallbacks; masked remainder handling for non-idempotent vs idempotent ops; lane-crossing pitfalls with Vector256/512 horizontal reductions; eliminating bounds checks/branches in scalar/remainder code; multi-core parallelization via Parallel.Invoke chunking over TensorPrimitives calls; testing SIMD paths via DOTNET_Enable* env vars and .runsettings; benchmarking with BenchmarkDotNet job configs. DO NOT USE FOR: GPU compute (CUDA/TorchSharp); SIMD in non-.NET languages.

中文简介正在准备中。当前显示原文说明。

NetFabric/NetFabric.Numerics星标 36(GitHub 36 + cccskills 0)

实测评分未实测

查看安装方法

包含的文件（7）

SKILL.md4.7 KB
references/hardware-intrinsics.md1.9 KB
references/performance-optimization-ladder.md5.0 KB
references/tensor-primitives.md2.7 KB
references/testing-and-benchmarking.md4.2 KB
references/vector-t-and-fixed-shape.md2.7 KB
references/vector128-vectorization.md8.1 KB

SKILL.md（原文）

安装前可以查看交给 AI 代理的指令内容。

.NET SIMD & Vectorization

Requires using System.Numerics; / using System.Runtime.Intrinsics; / using System.Numerics.Tensors; (TensorPrimitives, package System.Numerics.Tensors) depending on the step below.

Decision Ladder

Only escalate to the next step when a benchmark shows the current one doesn't cover your case — most code should stop at step 1.

Step	API	When
1	`TensorPrimitives` (tensor-primitives.md)	Default choice — ~200 ready-made vectorized span operations (arithmetic, math functions, reductions, cosine similarity, ...). Don't hand-roll what's already optimized and tested.
2	`Vector128<T>`/`Vector256<T>`/`Vector512<T>` (vector128-vectorization.md)	No `TensorPrimitives` overload covers your exact operation. Recommended starting point for hand-written vectorization — broadest hardware support, fine-grained control.
3	`Vector<T>` (vector-t-and-fixed-shape.md)	A quick, simple portable loop where per-width control isn't worth the complexity. Simpler to write than step 2, but less control.
4	Platform intrinsics — `System.Runtime.Intrinsics.X86`/`.Arm`/`.Wasm` (hardware-intrinsics.md)	A specific processor instruction measurably beats what Vector128/256 generate, on a proven hot path.

Steps 1–2 handle almost everything. General CPU-level techniques for the scalar/remainder code inside a hand-written algorithm (bounds-check elimination, branch removal, multi-accumulator unrolling) and multi-core chunking live in performance-optimization-ladder.md.

Quick Pattern: Reach for TensorPrimitives First

public static float[] MultiplyAdd(float[] left, float[] right, float[] addend)
{
    var result = new float[left.Length];
    TensorPrimitives.Multiply(left, right, result);   // result = left * right
    TensorPrimitives.Add(result, addend, result);     // result += addend (in-place)
    return result;
}

Only drop to hand-written Vector128<T> (see vector128-vectorization.md) when no TensorPrimitives overload exists for your exact operation:

public static T Sum<T>(ReadOnlySpan<T> buffer) where T : unmanaged, INumberBase<T>
{
    if (Vector128.IsHardwareAccelerated && Vector128<T>.IsSupported)
        return buffer.Length >= Vector128<T>.Count ? SumVector128(buffer) : SumVectorSmall(buffer);
    return SumScalar(buffer);
}

Reference Files

File	Load When
references/tensor-primitives.md	Using `TensorPrimitives`/`Tensor<T>`; deciding when it's not enough
references/vector128-vectorization.md	Hand-writing `Vector128`/`256`/`512` code, hardware-acceleration checks, remainder handling, lane-crossing pitfalls, safe load/store
references/hardware-intrinsics.md	Platform-specific `X86`/`Arm`/`Wasm` intrinsics as a last resort
references/vector-t-and-fixed-shape.md	`Vector<T>` portable vectorization; `Vector2`/`Vector3`/`Vector4`/`Matrix`/`Quaternion` graphics types
references/performance-optimization-ladder.md	Bounds-check elimination, branch removal, loop unrolling, multi-core chunking recipes
references/testing-and-benchmarking.md	Testing across Scalar/Vector128/256/512; `.runsettings`; BenchmarkDotNet job configs

评价

还没有评价。欢迎分享你的使用感受。

无需登录即可发表。欢迎分享使用感受、提问，或说明在哪些环境下无法运行。

还没有评论。来写第一条吧。

同一仓库的技能

3d-rotation-theory

免费

Abstract math for 3D rotation representations and conversions. USE FOR: understanding axis-angle representation; Euler angles (yaw/pitch/roll, convention choices); rotation matrices (SO(3)); quaternion-based rotation; converting between representations; identifying and avoiding gimbal lock; composing rotations; half-angle formula; right-hand rule. DO NOT USE FOR: quaternion arithmetic details (use quaternion-algebra); slerp/lerp interpolation (use interpolation-on-manifolds); coordinate system definitions (use coordinate-system-conversions).

中文简介正在准备中。当前显示原文说明。