Results for “kernel”

Develop or port CPU kernels, the low-level calculation routines used by MNN. Follow staged implementation guidance, check data layout agreements, register functions, and verify correctness across processor instruction sets and numerical precision settings.

• Implementing or porting an MNN CPU kernel
• Adding support for a processor instruction set
• Changing packed data layouts or tile sizes

Add a CUDA/C++ GPU operation to sgl-kernel using AOT, meaning compilation before use. Follow the implementation through PyTorch registration, Python API exposure, SGLang integration, correctness tests, and benchmarks that account for cache reuse.

• Adding a CUDA/C++ operation to sgl-kernel
• Registering an operation with PyTorch and exposing a Python API
• Testing numerical results and invalid inputs

Run TVM's TIRx compiler tests alongside tirx-kernels import and correctness checks. It verifies the local build, selects GPUs, runs parallel tests, saves full logs, and guides failure investigation and result reporting.

• Testing TIRx compiler and kernel changes
• Checking tirx-kernels imports and registry entries
• Running parallel tests across selected GPUs

Provides guidance for writing and benchmarking optimized CUDA kernels for NVIDIA GPUs (H100, A100, T4) targeting HuggingFace diffusers and transformers libraries. Kernels must be kernel-builder/ABI3-compliant: no pybind11, no setup.py, TORCH_LIBRARY_EXPAND bindings only. Supports models like LTX-Video, Stable Diffusion, LLaMA, Mistral, and Qwen. Includes integration with HuggingFace Kernels Hub (get_kernel) for loading pre-compiled kernels. Includes benchmarking scripts to compare kernel performance against baseline implementations.

The English summary is being prepared. Showing the original description.

Improve MNN inference on OpenCL by measuring bottlenecks and refining GPU kernels, the code that performs calculations. The skill guides baseline measurements, correctness checks, Android device benchmarks, and integration of new OpenCL features with compatibility fallbacks.

• Find bottlenecks in a model's GPU inference
• Optimize a specific operator's GPU kernels
• Integrate an OpenCL extension with a fallback

Organize SGLang GPU operations when adding or moving code. It guides API placement, operation registration, test organization, and migration checks to preserve existing behavior, references, and continuous integration coverage.

• Choose where to place a new GPU operation
• Split or move existing operation files
• Review API registration and test placement

Find the right workflow for MNN CPU work, from investigating slow execution to implementing calculation routines and planning tests. Compare ARM, x86_64, and RISC-V backend structures before choosing the relevant guidance.

• Choosing where to start an MNN CPU performance investigation
• Finding guidance for CPU kernel implementation
• Comparing ARM, x86_64, and RISC-V backend structures

Guide reviews of Linux Kernel patches for memory safety, Terraform plans for costly resource changes, and Kubernetes configurations for restricted permissions. A separately installed tool and configured AI model produce advisory findings and candidate manifests for validation.

• Review Linux Kernel patches for memory safety issues
• Check Terraform plans for potentially costly resource changes
• Draft Kubernetes permission settings from security requirements

Build, update, explain, or review Microsoft Agent Framework applications in .NET or Python. The skill guides agent and workflow design using current official documentation and supports migration from Semantic Kernel or AutoGen.

• Build an agent application in .NET or Python
• Review agent and workflow design
• Migrate from Semantic Kernel or AutoGen

Investigate Linux kernel rootkits, malware that hides inside the operating system's core. Analyze memory dumps with Volatility3, compare system views, and run live scans to identify hidden modules, altered calls, and suspicious inconsistencies.

• Investigate suspected Linux rootkit infections
• Find hidden kernel modules in memory dumps
• Compare module lists for signs of concealment

Guide MNN Metal backend development and optimization, from finding performance bottlenecks to changing GPU computation, combining operators, and adjusting execution scheduling. A task-based document index directs work toward relevant implementation rules, benchmarks, and correctness checks.

• Finding bottlenecks in Metal inference
• Adding or modifying Metal kernels
• Combining operators into one GPU dispatch

Use when benchmarking, profiling, or A/B-testing CUDA kernels or end-to-end perf in the imp inference engine on RTX 5090 (sm_120), including refreshing tests/perf_baseline.json or publishing numbers to docs/BENCHMARKS.md and the README. Triggers on "benchmark kernel", "profile cuda", "ncu", "nsys", "kernel timing", "kernel sum", "occupancy", "bandwidth bound", "compute bound", "roofline", "perf baseline", "is this regression real", "decode dropped", "aggregate throughput", "two-image A/B", "prefill kernel A/B". Do NOT use for writing/optimizing kernel code (sm120-cuda-expert) or output-quality checks (check-degeneration).

The English summary is being prepared. Showing the original description.

Examine container isolation in a CTF sandbox, a controlled security challenge environment. The skill checks kernel and runtime conditions, verifies whether an exploit crosses into host context, and preserves a minimal reproducible chain with evidence.

• Review container isolation settings in a CTF environment
• Check kernel exploit prerequisites
• Verify whether a trigger crosses the container boundary

Review and improve .NET/C# code against project conventions. Cover public API documentation, dependency injection for supplying services to classes, asynchronous operations, tests, configuration, logging, and input validation, including guidance for Semantic Kernel integrations.

• Review C# code against project conventions
• Improve XML documentation for public APIs
• Review asynchronous operations and dependency injection

Develop lightweight CUDA operations for SGLang using JIT, which compiles code on first use. A tensor-scaling example explains implementation conventions, input validation, memory access helpers, and when to choose this approach.

• Add a lightweight CUDA operation to SGLang
• Choose between JIT and ahead-of-time compilation
• Validate tensor inputs in a kernel launcher

Acquire Linux memory with LiME and examine it using Volatility 3. Extract processes, network connections, command history, loaded kernel modules, and signs of injected code to support investigations of compromised Linux systems.

• Acquiring memory from a compromised Linux system
• Comparing process lists to investigate hidden processes
• Reviewing command history and network connections

Find why MNN CPU inference is slow by examining threads, scheduling, memory layout, and the processor instruction path actually used. Operator-level measurements and comparisons with other inference frameworks help identify which layer needs improvement across ARM, x86_64, and RISC-V.

• Investigate slow CPU operators or LLM inference
• Diagnose thread count and memory usage anomalies
• Locate the cause of a performance regression

Use this skill when the user is doing hands-on DOCA GPUNetIO programming — wiring a CUDA kernel on an NVIDIA GPU to a doca-eth queue via doca_gpu_eth_rxq / doca_gpu_eth_txq, standing up the per-CUDA-device doca_gpu context, designing the persistent CUDA kernel that drains the GPU-visible queue, running the dual capability check (DOCA cap-query plus cudaGetDeviceProperties), registering cudaMalloc pools via doca_buf_arr_create_*, or debugging DOCA_ERROR_* returns from the GPUNetIO API. Trigger even when the user does not explicitly mention "DOCA GPUNetIO" or "persistent kernel" — typical implicit phrasings include "CUDA kernel reading packets directly from the NIC", "GPU-initiated networking on BlueField", "DOCA_ERROR_DRIVER on doca_gpu_create", "nvidia_peermem not loaded", "kernel-per-packet is too slow", or "which GPU supports GPU-side packet I/O". Refuse and route elsewhere for general CUDA programming, DOCA Ethernet queue bring-up, DOCA DPA, or DOCA install — those belong to other skills.

The English summary is being prepared. Showing the original description.

Use this skill when the user is doing hands-on DOCA DPA host-side work on a BlueField — creating the `doca_dpa` Core context, loading a DPACC-compiled DPA app image (`doca_dpa_app`), creating DPA threads, launching kernels via `doca_dpa_kernel_launch_update_*`, draining `doca_dpa_completion`, running `doca_dpa_cap_*` discovery, choosing between the DPA comm component (inter-DPA messaging) and the DPA verbs component (in-kernel RDMA), or debugging `DOCA_ERROR_*` from `doca_dpa_*`. Trigger even without "DOCA DPA" or "Data-Path Accelerator": "run compute on the DPA from my host", "DPA kernel hangs, no completion", "DOCA_ERROR_DRIVER on launch", "DOCA/DPACC version skew", or "does this BlueField expose a DPA". Route elsewhere for DPA-side kernel programming itself, DPACC compiler internals, host↔DPU messaging (doca-comch), host-side RDMA (doca-rdma), and GPU-initiated networking (doca-gpunetio).

The English summary is being prepared. Showing the original description.

Provides guidance for writing, optimizing, and benchmarking Triton kernels for Intel XPU GPUs (Battlemage/Arc Pro B50) using the Xe-Forge optimization framework. Includes an LLM-driven trial-loop workflow (analyze, validate, benchmark, profile, finalize), XPU-specific patterns (tensor descriptors, GRF mode, tile swizzling), KernelBench fused kernels, and Flash Attention.

The English summary is being prepared. Showing the original description.

Provides guidance for writing, optimizing, and benchmarking C++ CPU kernels with SIMD intrinsics (AVX2/AVX512) for the Hugging Face kernels ecosystem. Includes a two-phase workflow: Phase 1 correctness (generic → AVX2) and Phase 2 performance exploration (AVX512 with branching trial loop), runtime CPU dispatch, OpenMP threading, and brgemm integration for GEMM-heavy kernels.

The English summary is being prepared. Showing the original description.

Mine a per-kernel optimization trace — a git repository capturing successive versions of one kernel being optimized — into structured, gate-validated optimization-experience records for the GPU kernel wiki. Use when asked to distill an optimization run, a kernel_opt trace directory or a version ladder into wiki records; to report what such a run actually achieved; to build, extend, re-run or validate the staging store behind those records; or to explain how a trace-derived record's number, snippet or provenance was established.

The English summary is being prepared. Showing the original description.

Step-by-step tutorial for adding a new lightweight SYCL JIT kernel for Intel XPU to sgl-kernel-xpu's python/sgl_kernel/jit module (SYCL source + Python wrapper + tests + benchmark)

The English summary is being prepared. Showing the original description.

Investigate TOCTOU flaws: race conditions where a checked property changes before an action uses it. The skill covers filesystem, kernel, web, and container testing, helping identify vulnerable sequences, reproduce timing issues, and document observed impact.

• Reviewing file checks before privileged operations
• Testing access revocation during long-running requests
• Investigating duplicate payments from concurrent requests