Further Reading: GPU Computing

GPU programming is unusually compiler- and hardware-specific, so the primary sources — the OpenACC specification and NVIDIA's own documentation — matter more here than in most chapters, and they are the place to confirm any syntax detail this book states but could not compile. Sources are tagged Tier 1 (works we are confident exist and recommend) and Tier 2 (real and worth seeking; verify the current edition or URL yourself). Because the field moves quickly, always check that a guide matches your compiler version.

The books

• Gregory Ruetsch and Massimiliano Fatica, CUDA Fortran for Scientists and Engineers (Morgan Kaufmann/Elsevier). The definitive book on CUDA Fortran specifically — kernels, device memory, launch configuration, atomics, and reductions, all in Fortran rather than C. If §35.3 left you wanting the whole story, this is it. Tier 1 (verify the current edition).
• David B. Kirk and Wen-mei W. Hwu, Programming Massively Parallel Processors (Morgan Kaufmann). The canonical text on how GPUs actually work — warps, memory coalescing, occupancy, divergence, and the tree reductions Case Study 2 gestured at. Its code is CUDA C, but the concepts are exactly those of §35.1 and §35.5 and transfer directly to CUDA Fortran. Tier 1.
• Milan Curcic, Modern Fortran: Building Efficient Parallel Applications (Manning). Carries the parallel Fortran of this whole part — including accelerator ideas — in a modern, example-driven style; the natural continuation of Chapters 31–35. Tier 1.
• Sunita Chandrasekaran and Guido Juckeland (eds.), OpenACC for Programmers: Concepts and Strategies (Addison-Wesley). A focused treatment of the directive path — parallel/kernels regions, data management, and the performance thinking of §35.4 — with worked case studies. Tier 2 (verify the citation).

Primary sources — the specifications and compiler docs

• The OpenACC specification (openacc.org). The authoritative definition of every !$acc directive and clause used in §35.2 and §35.4 — parallel loop, data, copyin/copyout/copy/create/present, update, reduction, collapse. Skim the "Getting Started" guides first, then use the spec as the reference. Tier 1.
• The NVIDIA HPC SDK documentation, including the CUDA Fortran Programming Guide (docs.nvidia.com). The primary source for nvfortran, the device/global/value attributes, the <<<>>> launch syntax, the one-based thread indexing of §35.3, and the -acc/-cuda/-Minfo=accel flags. When a CUDA Fortran detail in this chapter needs confirming, confirm it here. Tier 1.
• The GCC/gfortran OpenACC documentation (gcc.gnu.org, the OpenACC wiki). The reference for gfortran's -fopenacc support — the portable, no-NVIDIA-required way to compile the OpenACC examples, useful for learning the directives even without an NVIDIA GPU. Tier 1.

Free and online

• fortran-lang.org — parallel and GPU tutorials, and the Discourse forum. Community-maintained, current introductions to offloading from Fortran (OpenACC, do concurrent offload, !$omp target), and the best place to ask a compiler-specific GPU question. Tier 1.
• The OpenMP specification (openmp.org), the target directives. OpenMP grew its own accelerator-offload model (!$omp target, map clauses) closely paralleling OpenACC; worth knowing as the standardized alternative, and a natural bridge from the OpenMP of Chapter 33. Tier 1.
• NVIDIA Developer blog — CUDA Fortran and OpenACC posts. Short, practical articles (many by the CUDA Fortran book's authors) on specific techniques — managed memory, multi-GPU with MPI, profiling an offload. Tier 2 (blog posts; verify against current tooling).

Suggested order

1. Start with the OpenACC "Getting Started" guide and compile the §35.2 examples with gfortran -fopenacc (no GPU required) to make the directives concrete.
2. Read Kirk & Hwu's early chapters for why a GPU is shaped the way it is — it makes §35.4 and §35.5 click into place.
3. When you need explicit kernels, work through Ruetsch & Fatica alongside the NVIDIA CUDA Fortran Programming Guide, the two together being the authoritative pair for §35.3.
4. Keep Curcic and fortran-lang.org at hand as you fold the GPU offload into the running project and toward the Chapter 38 capstone.