Glossary¶

This page defines the terms and abbreviations used throughout the cookbook. All entries are highlighted with tooltips wherever they appear. Hover over a term on any page to see its definition.

BLAS — Basic Linear Algebra Subprograms: A standard interface for low-level linear algebra routines (matrix multiply, dot products, etc.). NumPy and SciPy delegate heavy math to a BLAS implementation (OpenBLAS or Intel MKL) that runs in native threads, bypassing Python's GIL. Control thread count with OMP_NUM_THREADS.
CI/CD — Continuous Integration / Continuous Deployment: Automated build, test, and deployment pipelines.
Compute Node: A node dedicated to running jobs — where your code actually executes.
Core: A general-purpose processor. A modern CPU contains many cores, each capable of running work independently. In HPC contexts (and throughout this cookbook), "CPU" and "core" are used interchangeably to mean one unit of processing power. When you request "4 CPUs" for a job, you're asking for 4 cores.
CPU — Central Processing Unit: A general-purpose processor. A modern CPU contains many cores, each capable of running work independently. In HPC contexts (and throughout this cookbook), "CPU" and "core" are used interchangeably to mean one unit of processing power. When you request "4 CPUs" for a job, you're asking for 4 cores.
CUDA — Compute Unified Device Architecture: NVIDIA's GPU programming toolkit.
Dependency: Something your program depends on. This could be a Python package (like numpy), a shared library (like GDAL), or anything else that exists outside your own source code. If something works on your computer, but not on a different computer (like an HPC system), it's most likely because of a missing or mismatched dependency.
Distributed Memory: An architecture where many nodes each have private memory, communicating over a high-speed network.
Embarrassingly Parallel: A type of problem where the work can be divided into completely independent tasks that require no communication or coordination between them. Processing 1,000 images with the same filter is a classic example: each image can be handled separately without any information from the others.
GSSAPI — Generic Security Services Application Program Interface: An authentication mechanism that works with institutional credentials to enable passwordless logins to HPC systems. Some clusters use SSH keys instead.
GPU — Graphics Processing Unit: Used for parallel computation and AI/ML.
Headless: A system with no physical display attached. Cluster nodes are headless, which is why graphical applications need a remote display path, typically a web portal like Open OnDemand, X11 forwarding, or saving figures to files.
Host: A computer on a network, identified by its hostname. When you're logged into an HPC cluster, the hostname in your shell prompt tells you which host you're on.
HPC — High-Performance Computing: The practice of aggregating computing power for large-scale workloads.
Lmod: A Lua-based module system for managing software environments on HPC clusters. Lmod provides commands like module load, module avail, and module list to load and switch between software versions.
MGHPCC — Massachusetts Green High Performance Computing Center: A data center in Holyoke, MA that hosts shared HPC infrastructure for a consortium of universities, including the Unity cluster.
I/O — Input/Output: Abbreviation for data input and output processes, like reading/writing to a file or database.
JIT — Just-In-Time compilation: A technique where code is compiled to machine instructions at runtime rather than ahead of time. Numba uses JIT compilation to turn Python functions into fast native code on first call.
Joblib: A Python library for lightweight pipelining and parallel execution. scikit-learn uses Joblib internally when you set n_jobs on an estimator. Its default backend (loky) spawns worker processes similar to multiprocessing.
Job: A unit of work that a user submits to a scheduler. A job script specifies what to run and what resources are needed.
LAPACK — Linear Algebra PACKage: A library of routines for solving systems of linear equations, eigenvalue problems, and singular value decompositions. NumPy and SciPy call LAPACK through the BLAS implementation (OpenBLAS or MKL) for operations like np.linalg.svd() and np.linalg.eig().
LAPACK — Linear Algebra PACKage: A library of routines for solving systems of linear equations, eigenvalue problems, and singular value decompositions. NumPy and SciPy call LAPACK through the BLAS implementation (OpenBLAS or MKL) for operations like np.linalg.svd() and np.linalg.eig().
Login Node: The node you connect to via SSH — used for preparing and submitting jobs, not running them.
Memory: The fast but volatile working memory (RAM) available to a node, used by running processes to hold data and code while a job executes. Memory is different from storage because it is cleared when power is removed, but is much faster to access for the CPU or GPU.
MPI — Message Passing Interface: A standard for writing programs that run as many simultaneous processes spread across multiple nodes, communicating by sending messages over the network. Each process has its own private memory and a unique integer ID called a rank. Open MPI is the most common implementation on HPC clusters.
MKL — Intel Math Kernel Library: Intel's optimized implementation of BLAS and LAPACK, used by NumPy and SciPy on systems with Intel CPUs. Thread count is controlled by MKL_NUM_THREADS.
Open Mpi: A widely used open-source implementation of the MPI standard, available on Unity. Provides the mpicc compiler wrapper (which links the MPI libraries into your program) and the mpirun launcher (which starts your processes across allocated nodes).
Rank: A unique integer ID assigned to each process in an MPI job, starting at 0. If you launch 8 MPI processes, they are numbered rank 0 through 7. Rank 0 is conventionally used as the "root" for coordination tasks like gathering results from all other ranks.
Node: An individual machine within a cluster. Each node has its own CPUs, memory, and (sometimes) GPUs.
OOD — Open OnDemand: Web portal for cluster access.
OOM — Out of Memory: When a job exceeds its allocated memory.
Openblas: An open-source implementation of BLAS and LAPACK, commonly used as the linear algebra backend for NumPy on Linux. Thread count is controlled by OPENBLAS_NUM_THREADS.
Partition: A logical grouping of nodes, often organized by hardware type or intended use (e.g., standard CPU nodes, GPU nodes).
PBS — Portable Batch System: A legacy job scheduler (this site uses Slurm).
Pickle: Python's built-in serialization format for converting objects to a byte stream and back. The multiprocessing module uses pickle to send functions and data to worker processes. Lambdas, nested functions, and some complex objects can't be pickled, which causes PicklingError when used with multiprocessing or concurrent.futures.
Process: A running instance of a program, with its own process ID (PID) and memory. A single program can spawn multiple processes — for example, an MPI job launches one process per rank.
Netid: A unique campus username assigned to each member of the Dartmouth community, used for authentication across university systems including HPC.
QOS — Quality of Service: Slurm mechanism for priority and limits.
Quota: A limit on how much storage space a user or directory can consume. Quotas prevent any one user or program from using more than their fair share of shared storage resources.
Scheduler: A program that receives job submissions from users, keeps track of the cluster's available resources, and decides when and where each job should run. This site's cluster uses Slurm.
Shared Memory: An architecture where all processors share a single pool of RAM, like in a regular laptop computer.
SIF — Singularity Image Format: Container image format used by Apptainer.
SLURM — Simple Linux Utility for Resource Management: The job scheduler used on the Unity cluster.
Slurm — Simple Linux Utility for Resource Management: The job scheduler used on the Unity cluster.
SSH — Secure Shell: Encrypted protocol for remote access.
Scratch: High-speed temporary storage on the cluster, optimized for the heavy read/write patterns of running jobs. Files on scratch are not backed up and may be purged automatically after a period of inactivity.
Scratch Storage: High-speed temporary storage on the cluster, optimized for the heavy read/write patterns of running jobs. Files on scratch are not backed up and may be purged automatically after a period of inactivity.
Storage: The persistent, non-volatile data repositories that jobs read from and write to. This includes parallel file systems (e.g., Lustre, GPFS) shared across many nodes, local scratch disks on individual nodes, and longer-term archives. Unlike memory, storage retains its contents after power is removed.
Home Directory: A small, persistent, backed-up personal directory on the cluster (typically accessed as ~). Intended for scripts, configuration files, and small personal files — not for large datasets or heavy job I/O.
VPN — Virtual Private Network: Software that creates a secure, encrypted connection to a campus network from an off-campus location, enabling access to resources that are restricted to on-campus use.
venv — Python virtual environment: A bundle of Python packages of specific versions.
Huggingface Hub: The online model registry at huggingface.co where researchers publish pre-trained model weights, tokenizers, and datasets. The transformers library downloads from the Hub on first use and caches the files locally under $HF_HOME.
Device_Map: An accelerate feature that automatically partitions a model's layers across all available GPUs (and CPU/disk if needed) so that large models exceeding a single GPU's memory can still run. Enabled by passing device_map="auto" to AutoModel.from_pretrained().
Accelerate: A HuggingFace library that abstracts multi-GPU and mixed-precision training and inference. Required for device_map="auto" in transformers.
Amdahl'S Law: A formula predicting the maximum speedup from parallelizing a program: S = 1 / (1 − P + P/n), where P is the fraction that can be parallelized and n is the number of processors. The serial portion of your code sets a hard ceiling on how much faster you can go, no matter how many processors you add.
Concurrency: Executing multiple tasks in overlapping time periods, potentially on a single processor. Tasks make progress by interleaving — not necessarily by running simultaneously. Useful for I/O-bound workloads where tasks spend time waiting for external resources.
Coroutine: A function that can pause its execution (yield control) and resume later. Used in async/concurrent programming to allow cooperative multitasking within a single thread.
Cpu-Bound: A workload whose execution time is dominated by computation rather than waiting for I/O. CPU-bound tasks benefit from parallel execution on multiple cores.
Event Loop: A programming construct that waits for tasks to become ready and dispatches them for execution. The core mechanism behind concurrent/async programming — it switches between tasks when one begins waiting for I/O, keeping the processor busy.
GIL — Global Interpreter Lock: A mutex in CPython that allows only one thread to execute Python bytecode at a time. This limits the effectiveness of thread-based parallelism for CPU-bound Python code; use multiple processes instead.
I/O-Bound: A workload whose execution time is dominated by waiting for input/output operations (network requests, disk reads, database queries) rather than computation. I/O-bound tasks benefit from concurrent execution.
Message Passing: A communication model where processes exchange data by explicitly sending and receiving messages rather than sharing memory. MPI is the dominant standard for message passing in HPC.
Oversubscription: Running more processes or threads than available physical CPU cores, forcing the operating system to time-share them. Can degrade performance due to context-switching overhead.
Parallelism: Executing multiple tasks at the exact same time on separate physical processors. Unlike concurrency (which interleaves tasks on one core), parallelism requires multi-core or multi-node hardware.
Race Condition: A bug that occurs when multiple threads or processes access shared data simultaneously and the outcome depends on the unpredictable timing of their execution. Avoiding race conditions is a central challenge in shared-memory parallel programming.
Speedup: The ratio of sequential execution time to parallel execution time. A speedup of 4× means the parallel version runs four times faster than the sequential one.
Thread: An execution flow within a process that shares the parent process's memory space. Threads are lightweight to create and destroy, but concurrent access to shared memory introduces the risk of race conditions.