numpy-memory

cuba6112's avatarfrom cuba6112

Deep dive into memory layout, including strides, C vs Fortran order, and zero-copy view generation via stride tricks. Triggers: strides, C-order, Fortran-order, memory locality, stride_tricks.

⭐0stars🔀0forks📁View on GitHub🕐Updated Dec 26, 2025
[Developer Tools]

When & Why to Use This Skill

This Claude skill provides a comprehensive toolkit for mastering NumPy memory management and performance optimization. It enables developers to analyze array strides, manage C and Fortran memory orders, and implement zero-copy view generation using advanced stride tricks to maximize CPU cache efficiency and minimize memory overhead.

Use Cases

  • Optimizing high-performance computing (HPC) tasks by improving CPU cache locality through detailed stride and memory layout analysis.
  • Implementing memory-efficient sliding window algorithms for signal processing or image manipulation without duplicating underlying data.
  • Ensuring seamless compatibility when interfacing Python code with low-level C or Fortran libraries (such as BLAS) that require specific memory layouts.
  • Reducing memory footprint in large-scale data processing by leveraging zero-copy transpositions and metadata-only array reshapes.
namenumpy-memory
descriptionDeep dive into memory layout, including strides, C vs Fortran order, and zero-copy view generation via stride tricks. Triggers: strides, C-order, Fortran-order, memory locality, stride_tricks.

Overview

NumPy memory management revolves around the concept of "strides." Strides define the number of bytes to skip in a flat 1D buffer to move to the next element in an N-dimensional space. Understanding this allows for zero-copy operations like transposition and complex sliding windows.

When to Use

  • Optimizing high-performance code for CPU cache locality.
  • Creating overlapping sliding windows for signal processing without duplicating data.
  • Interfacing with libraries that require specific memory orders (e.g., BLAS/Fortran).
  • Manipulating array logic without incurring the cost of data copying.

Decision Tree

  1. Need to optimize for row-wise processing?
    • Use C-order (row-major). Smallest stride is on the last axis.
  2. Interfacing with legacy Fortran or BLAS?
    • Use Fortran-order (column-major). Smallest stride is on the first axis.
  3. Want to create a sliding window view?
    • Use np.lib.stride_tricks.as_strided. (Use with caution).

Workflows

  1. Analyzing Memory Locality

    • Check arr.strides and arr.itemsize.
    • Identify the axis with the smallest stride (fastest changing in memory).
    • Reorder loops or axes to ensure data access follows the smallest stride for cache efficiency.

  2. Zero-Copy Transposition

    • Call arr.T or arr.transpose().
    • Inspect the strides of the result.
    • Note that the underlying data buffer remains identical; only the stride metadata was swapped.

  3. Creating Sliding Windows without Copies

    • Identify an array segment.
    • Use np.lib.stride_tricks.as_strided with a custom stride tuple to create overlapping windows.
    • Perform vectorized operations on the windowed view (warning: values may overlap).

Non-Obvious Insights

  • Metadata Logic: Changing an array's shape or transposing it often changes only the strides and shape metadata, leaving the data buffer untouched.
  • Cache Performance: Iterating over an axis with a large stride is slow because elements are spaced far apart in memory, causing CPU cache misses.
  • Strides Modification: Directly setting arr.strides is unsafe and discouraged; as_strided is the preferred, safer interface for advanced memory manipulation.

Evidence

  • "The strides of an array tell us how many bytes we have to skip in memory to move to the next position along a certain axis." Source
  • "The shape of the array can be changed very easily without changing anything in the data buffer or any data copying at all." Source

Scripts

  • scripts/numpy-memory_tool.py: Tools for stride analysis and zero-copy window creation.
  • scripts/numpy-memory_tool.js: Simulated byte-offset calculator.

Dependencies

  • numpy (Python)

References