vectorization skill | PlugMCP

vectorization

dotnet5.9kstars

1---2name: vectorization3description: >4---56# plugins/dotnet-advanced/skills/vectorization/SKILL.md

SKILL.mdAgent skill

Transport: File
Status: Listed

SKILL.md

Install

The skill file stays in the publisher's repository.

Paste the copied command in a terminal. It installs this SKILL.md into that agent.

shterminal

1npx skills add dotnet/skills --skill vectorization -a cursor -y

Paste the copied command in a terminal. It installs this SKILL.md into that agent.

shterminal

1npx skills add dotnet/skills --skill vectorization -a claude-code -y

Paste the copied command in a terminal. It installs this SKILL.md into that agent.

shterminal

1npx skills add dotnet/skills --skill vectorization -a codex -y

Paste the copied command in a terminal. It installs this SKILL.md into that agent.

shterminal

1npx skills add dotnet/skills --skill vectorization -a grok -y

Send the copied message in a Grok Bot chat. The Bot fetches this SKILL.md from GitHub and adds it to the skills all your Bots share.

txtGrok Bot chat

1Install this skill: https://github.com/dotnet/skills/tree/HEAD/plugins/dotnet-advanced/skills/vectorization

Download skill plugins/dotnet-advanced/skills/vectorization/SKILL.md on GitHub

plugins/dotnet-advanced/skills/vectorization/SKILL.mdMarkdown · UTF-8

Skill facts

Agent skill

File: plugins/dotnet-advanced/skills/vectorization/SKILL.md
Publisher: dotnet
Hosting

FAQ

Questions

From the publisher

SKILL.md

name: vectorization
description: Design, implement, optimize, and review SIMD code in .NET. USE FOR: vectorizing scalar loops with TensorPrimitives, Vector64/128/256/512, or platform hardware intrinsics; reviewing existing SIMD code, including the generic Vector type, for contract equivalence, tail handling, memory safety, portability, fallbacks, and measured performance. DO NOT USE FOR: performance work unrelated to SIMD or vectorization.
license: MIT

.NET SIMD vectorization

Produce a portable optimization that preserves the scalar contract, remains memory-safe at every length, and earns its complexity with measured results. Read the official SIMD and hardware-intrinsics guidance first and follow its comprehensive implementation templates. In particular, use its self-contained per-width dispatch, dedicated small-input handling, loop, and remainder shapes rather than reducing them to a chain of width checks. This skill supplies the decision rules and validation checks to apply while changing real code.

Inputs and prerequisites

Discover these from the repository before asking the user:

Input	Required	What to establish
Scalar implementation and tests	Yes	Existing contract, representative call sites, and supported overlap
Target frameworks and platforms	Yes	Available SIMD APIs and architectures that must behave consistently
Build and test workflow	Yes	The repository's normal commands and how to launch separate test processes
Representative workload or benchmark	For optimization	Typical input sizes and the baseline to beat

Do not add a package merely because an API exists there. First check the target framework and the project's existing dependency/versioning policy.

Core rules

Use the highest-level API that matches the contract, then stop. Span<T> and string operations, TensorPrimitives, and tensor types already accelerate many operations. LINQ reductions such as Sum, Min, Max, and Average can also accelerate when the source exposes its underlying span. Verify empty-input and floating-point behavior rather than assuming similarly named operations are interchangeable. Once an existing API preserves the contract, use it instead of continuing into handwritten SIMD. Before writing an explicit loop, name the framework APIs considered and why none applies. Fixed-shape types remain appropriate for graphics and similar domains.

System.Numerics

Contract: identify behavior for empty and short inputs, overlap, overflow, NaN, signed zero, ordering, and exceptions before changing the implementation.
Framework gate: inspect the target framework and existing package references, then compile or probe the highest-level candidate API with the required edge cases. A small contract adapter, such as preserving special empty-input behavior, does not justify reimplementing the operation. If the API preserves the contract, use it and stop; do not claim it is unavailable without checking.
Structure: for new explicit SIMD, implement Vector128<T> and scalar first. Only after measurements justify wider paths, check Vector512<T>, then Vector256<T>, optional Vector<T>, Vector128<T>, and finally scalar. Omit paths the implementation does not need. Each outer fixed-width guard checks only its IsHardwareAccelerated property and, for generic element types, IsSupported. Inside that block, run the width-specific helper when the input has at least Count elements; otherwise run a dedicated small-input helper, then return. Do not put the length check in the outer guard and fall through to repeat dispatch at narrower widths. Keeping each supported-width block self-contained lets the JIT remove unsupported blocks and avoids redundant work on common small inputs.
Loads and stores: prefer span-based Vector128.Create(span) and CopyTo; the JIT keeps them efficient and they require no pinning or reference arithmetic. Unsafe loads and stores are largely unnecessary. When a path genuinely must walk a buffer by managed reference, use the element-offset LoadUnsafe(ref T, nuint) and StoreUnsafe overloads rather than pointers or manually advanced references.
Empty inputs: in a reference-based path, obtain the starting reference with MemoryMarshal.GetReference(span) or MemoryMarshal.GetArrayDataReference(array), not by indexing element 0.
Unsupported element types: the fixed-width vectors support primitive numeric element types, not char or bool. Reinterpret with MemoryMarshal.Cast or As<TFrom, TTo>; reinterpretation changes only the type, not the bits. Keep Boolean data as 0 or 1 and characters as valid UTF-16, normalizing results before storing when necessary.
Offsets: prove the input contains a full vector before subtracting Count or converting an index to nuint; otherwise a negative value becomes a huge unsigned offset.
Managed references: do not form references before the start or past the end of a span, including a one-past-end reference. The runtime permits a non-dereferenced managed pointer exactly one past an object or array, but this guidance intentionally prohibits the pattern because it is fragile and easy to misuse. Keep the base reference in range and express traversal with an element offset.
Remainders: cover every length, including 0, Count - 1, Count, Count + 1, and nonmultiples of each width. Once the input contains a full vector, keep the tail vectorized by reprocessing the last full vector. An idempotent operation can fold that overlap in directly. A non-idempotent operation must use ConditionalSelect to replace repeated lanes with the operation's identity before folding them in. This is the JIT-recognized general pattern; it can reduce a zero-identity selection to a bitwise mask while retaining broader optimization opportunities. For in-place transforms, preserve the original tail values before overlapping stores and write only valid results.
Buffer overlap: choose a traversal direction or staging strategy that prevents stores from corrupting values not yet loaded.
Numeric behavior: account for floating-point reassociation, NaN and signed-zero semantics, checked or unchecked integer overflow, and endianness where the algorithm depends on byte order. Native and Estimate operations can intentionally relax precision or IEEE edge-case behavior; use them only when the contract permits it and measurements justify them.

Span<int> tail = data.Slice(data.Length - Vector128<int>.Count);
Vector128<int> end = Vector128.Create<int>(tail);
Span<int> remaining = data;

while (remaining.Length >= Vector128<int>.Count)
{
    Vector128<int> values = Vector128.Create<int>(remaining);
    Transform(values).CopyTo(remaining);
    remaining = remaining.Slice(Vector128<int>.Count);
}

if (!remaining.IsEmpty)
{
    Transform(end).CopyTo(tail);
}

vectorization

Install

Skill facts

Questions

How do I install vectorization?

Where does vectorization live?

Which agents can use vectorization?

SKILL.md

.NET SIMD vectorization

Inputs and prerequisites

Core rules

Authoring checklist

Testing checklist

Benchmarking

Completion contract

Review checklist