Table of Contents
Who This Course Is For
This course is designed for absolute beginners to High-Performance Computing (HPC), including:
- Students or researchers who have never used a computing cluster before
- Engineers and scientists who currently run simulations or analyses on laptops/workstations and are hitting performance limits
- Developers who want a first exposure to parallel and high-performance environments
- Anyone curious about how modern supercomputers are structured and used
You are not expected to:
- Know Linux or any specific programming language well
- Have prior experience with clusters, schedulers, or parallel programming
- Understand performance optimization techniques in advance
Some basic familiarity with programming (in any language) and the command line will help, but is not strictly required.
What You Will Learn
By the end of this course, you should be able to:
- Explain what HPC is and where it is used in practice
- Log in to a typical HPC cluster and navigate the Linux environment
- Understand, at a conceptual level, how modern processors, memory, storage, and networks shape HPC system design
- Submit, monitor, and manage jobs using a batch scheduler on a cluster
- Distinguish between shared-memory, distributed-memory, and GPU-based parallelism
- Run and experiment with basic parallel programs (OpenMP, MPI, and GPU examples)
- Use common tools: modules, compilers, build systems, performance profilers, and debuggers at an introductory level
- Apply simple performance analysis ideas to understand why a program is slow
- Use numerical libraries and pre-installed software stacks rather than reinventing everything yourself
- Handle data and I/O in a way that respects the constraints of HPC systems
- Follow best practices for reproducible, efficient, and responsible use of shared HPC resources
- Recognize current and emerging trends in HPC and how they might affect your work
You will not become an expert HPC performance engineer in one course, but you will gain a solid, practical foundation and a roadmap for deeper learning.
How the Course Is Structured
The course is organized into thematic modules that move from concepts to practice:
- Conceptual foundations
- What HPC is, why it exists, and where it is used
- High-level computer architecture ideas relevant to performance
- The HPC environment and infrastructure
- Working in Linux, as it is the dominant OS in HPC
- Understanding what a cluster is and what its main components are
- How schedulers manage shared access to powerful systems
- Parallel programming models
- Conceptual models of parallelism and scalability
- Shared-memory programming, distributed-memory programming, and hybrids
- Accelerator (GPU) computing ideas and introductory tools
- Tools, performance, and software stacks
- Compilers, build systems, and numerical libraries
- Performance analysis and optimization concepts
- Data management and I/O patterns used in HPC
- Good practices and real-world context
- Reproducibility, software environments, and containers
- Debugging and testing parallel programs
- Ethics, sustainability, and future directions
- Final project and hands-on exercises
- A small, integrated project where you design, run, and analyze a simple HPC workload, tying together what you learned
Each bullet in the outline you saw corresponds to its own chapter, where concepts are introduced in more depth and with practical examples.
Learning Approach and Expectations
This course emphasizes:
- Conceptual clarity first
You will see diagrams, mental models, and analogies to understand what is happening under the hood before diving into commands or code. - Hands-on practice
You will repeatedly: - Log into a (real or simulated) cluster
- Navigate the filesystem
- Load software via environment modules
- Submit and inspect jobs
- Build and run small example programs
- Incremental complexity
- Early sections assume no prior exposure to Linux or clusters.
- Later sections introduce more advanced parallel programming and optimization ideas, building on the earlier material.
- HPC as a tool, not an end in itself
The goal is to enable you to use HPC effectively in real workflows, not just to memorize terminology. Examples will be motivated by common scientific and engineering tasks.
By the end, you should be comfortable enough with the environment and concepts to:
- Read HPC documentation without being lost in jargon
- Ask meaningful questions of system administrators or experienced users
- Start adapting your own codes or workflows to run on a cluster
Prerequisites and Recommended Background
Formal prerequisites are minimal, but the following will help:
- Basic programming experience
Being able to read and modify simple programs in C, C++, Fortran, Python, or a similar language will make the later programming-focused material more meaningful. - Comfort with basic computing tasks
Things like editing text files, working with directories, and installing software on your own machine are useful skills that transfer directly to HPC work.
If you lack experience in these areas, you can still follow the conceptual parts of the course; the hands-on code examples may just take more time.
How to Use This Course
To get the most out of the material:
- Follow the sequence
Early chapters introduce terminology and mental models that later chapters rely on. Skipping ahead will likely be confusing. - Practice as you go
Whenever you see a new command, concept, or workflow, try it immediately on a system you have access to, even if it is just a local Linux installation or a virtual machine. - Connect to your own domain
- Think about which parts of your current or future work are computationally heavy.
- Consider where larger datasets, longer simulations, or more complex models could benefit from HPC.
- Treat this as a starting point
The course deliberately stays at an introductory level while showing you where deeper material exists. Use the topics as a map for further learning once you know what is relevant to you.
How This Course Relates to Real HPC Systems
Although the course uses generic examples, it is designed so that:
- The concepts apply to most academic, governmental, and industrial clusters.
- The tools and workflows you learn (Linux commands, job submission patterns, modules, common schedulers) map closely to real environments.
- You can adapt the examples to your institution’s specific cluster configuration with only minor changes.
You should finish the course feeling ready to:
- Request an account on an HPC system,
- Log in, orient yourself, and understand the basic architecture,
- Run test jobs responsibly,
- Grow from “absolute beginner” to “competent new user” as you gain experience.
What You Will Not Find in This Course
To set expectations clearly, this course does not aim to:
- Cover advanced algorithm design or numerical methods in depth
- Teach full-scale software engineering practices for very large HPC codes
- Provide exhaustive coverage of any single technology (e.g., a full CUDA or MPI specialization)
Instead, it focuses on giving you:
- A coherent big-picture view of the HPC landscape
- The essential skills and vocabulary to participate in HPC projects
- Enough hands-on experience to continue learning independently or under the guidance of more experienced colleagues