Fortran中向BLAS传递数组片段的安全性及临时数组排查问询

Great question—this is a super common pain point when modernizing old Fortran code that interfaces with BLAS/LAPACK, so let’s break this down clearly.

Is passing array sections like dx(start:) good practice and safe? #

Short answer: Absolutely—this is a huge improvement over the old dx(start) approach, and it’s aligned with modern Fortran best practices. Here’s why:

• Compiler safety checks: With an explicit interface for BLAS/LAPACK, the compiler can validate that you’re passing an array (not a scalar or mismatched type) and that the array section is logically valid (many compilers will warn if start is out of bounds when enabled). The old dx(start) trick bypasses all this—you’re essentially passing a scalar’s memory address and trusting the BLAS routine to read n consecutive elements, with no compiler guardrails to catch mistakes.
• Clarity: dx(start:) makes it explicit that you’re passing a contiguous subarray starting at start, which is far more readable than the ambiguous dx(start) syntax. Other developers (or future you) will immediately understand what’s intended.
• Memory behavior matches BLAS expectations: When you pass a contiguous array section (like start: with stride 1), the compiler passes the starting memory address of dx(start) directly to BLAS—just like the old dx(start) method. There’s no change in how BLAS accesses memory, but you get all the compiler’s safety benefits on top.

How to check/guarantee no temporary arrays are created? #

For contiguous array sections (like dx(start:) with stride 1), modern Fortran compilers will almost never create a temporary array—they can pass the section’s starting address directly to BLAS. Here’s how to confirm and enforce this:

• Enable compiler warnings for temporary arrays:
  • For GFortran: Use flags like -Wall -Wextra -Warray-temporaries—this will emit a warning if the compiler has to create a temporary array for the argument.
  • For Intel Fortran: Use -warn all -check all -warn array-temps to get similar diagnostics.
  • For NVIDIA HPC SDK: Add -Wall -Warray-temporaries to your compile flags.
• Check compiler optimization reports:
  • Intel Fortran: Use -qopt-report=5 to generate a detailed optimization report that explicitly notes when temporary arrays are created (or not).
  • GFortran: Use -fopt-info-all to get verbose optimization info, including temporary array details.
• Inspect assembly output: Compile with -S (works for most compilers) and look for memcpy or similar memory-copy instructions. If you don’t see them for the daxpy call, no temporary array was created.

Note: Temporary arrays are only a concern if you pass non-contiguous sections (like dx(1:n:2) with stride 2). BLAS routines expect contiguous memory, so the compiler will have to copy the non-contiguous elements into a temporary contiguous array to satisfy the interface. But in your case, start: is fully contiguous, so this isn’t an issue.

内容的提问来源于stack exchange，提问作者gnikit