Contact & Support
OLCF User Assistance Center
Authentication Support
OLCF Office Hours
Communication to Users
Accounts and Projects
Request a New Allocation
What are the differences between project types?
What happens after a project request is approved?
Guidance on Frontier Allocation Requests
Applying for a user account
Checking the status of your application
Get access to additional projects
Frequently Asked Questions
How do I apply for an account?
What is the status of my application?
How should I acknowledge the OLCF in my publications and presentations?
What is a subproject?
I no longer need my account. Who should I inform and what should I do with my OLCF issued RSA SecurID token?
My SecurID token is broken/expired. What should I do?
Getting Help
Additional Resources
Documents and Forms
Forms for Requesting a Project Allocation
Forms for Requesting an Account
Forms to Request Changes to Computers, Jobs, or Accounts
Report Templates
Miscellaneous Forms
OLCF Policy Guides
OLCF Acknowledgement
Software Requests
Special Requests and Policy Exemptions
Computing Policy
Computer Use
Data Use
Software Use
User Accountability
Data Management Policy
Introduction
Data Retention, Purge, & Quotas
Data Prohibitions & Safeguards
Software
Security Policy
Scope
Personal Use
Accessing OLCF Computational Resources
Data Management
Sensitive Data
Data Transfer
INCITE Allocation Under-utilization Policy
Project Reporting Policy
Non-proprietary Institutional User Agreement Policy
Access
Rules and Regulations
Safety and Health
Intent to Publish
Export Control
Intellectual Property
HIPAA/ITAR Project Rules of Behavior Policy
User-Managed Software (UMS) Policy
Purpose
Policies
Glossary
Additional Resources
Connecting
Connecting for the first time
Activating a new SecurID fob
PINs, Passcodes, and Tokencodes
X11 Forwarding
Systems Available to All Projects
OLCF System Hostnames
Starting a Tmux Session
Checking System Availability
Systems
Frontier User Guide
System Overview
Frontier Compute Nodes
Node Types
System Interconnect
File Systems
Operating System
GPUs
Connecting
Data and Storage
Transition from Alpine to Orion
LFS setstripe wrapper
NFS Filesystem
Lustre Filesystem
Kronos Archival Storage
NVMe
NVMe Usage
Using Globus to Move Data to and from Orion
AMD GPUs
AMD vs NVIDIA Terminology
Blocks (workgroups), Threads (work items), Grids, Wavefronts
The Compute Unit
HIP
Things To Remember When Programming for AMD GPUs
Programming Environment
Environment Modules (Lmod)
Compilers
MPI
RCCL
Compiling
Compilers
MPI
OpenMP
OpenMP GPU Offload
OpenACC
HIP
HIP + OpenMP CPU Threading
SYCL
Running Jobs
Login vs Compute Nodes
Simplified Node Layout
Slurm
Batch Scripts
Interactive Jobs
Common Slurm Options
OLCF Custom Slurm Plugins
Slurm Environment Variables
Job States
Job Reason Codes
Scheduling Policy
Job Dependencies
Monitoring and Modifying Batch Jobs
Srun
Process and Thread Mapping Examples
Ensemble Jobs
Tips for Launching at Scale
Software
Containers
Jupyter
Debugging
Linaro DDT
GDB
Valgrind4hpc
Profiling Applications
Getting Started with the HPE Performance Analysis Tools (PAT)
Getting Started with HPCToolkit
Getting Started with the ROCm Profiler
Roofline Profiling with the ROCm Profiler
ROCm Compute Profiler (formerly Omniperf)
Omnistat - A lightweight ROCm system profiler
Tips and Tricks
Using reduced precision (FP16 and BF16 datatypes)
Enabling GPU Page Migration
Floating-Point (FP) Atomic Operations and Coarse/Fine Grained Memory Allocations
Performance considerations for LDS FP atomicAdd()
Library considerations with atomic operations
GPU inter-process communication (IPC) considerations
Useful MPI Environment Variables
System Updates
2026-09-15
2026-08-25
2026-07-01
2026-05-26
2026-04-07
2026-02-10
2025-10-21
2025-07-29
2025-06-17
2025-05-13
2025-04-01
2025-02-18
2025-01-14
2024-11-12
2024-09-03
2024-08-20
2024-07-16
2024-04-17
2024-03-19
2024-01-23
2023-12-05
2023-10-03
2023-09-19
2023-07-18
2023-05-09
Known Issues
Open Issues
Open Issues w/Workaround
Resolved Issues
Citadel User Guide
What is Citadel
Citadel (SPI) Documentation
Riker User Guide
System Overview
Riker Nodes
System Interconnect
File Systems
GPUs
Connecting
Data and Storage
NFS Filesystem
Lustre Filesystem
Programming Environment
Environment Modules (Lmod)
Compiling
Compilers
MPI
OpenMP
Running Jobs
Slurm Workload Manager
General information for Node-sharing on Riker
Sharing Batch (CPU) nodes
Sharing GPU nodes
Queues on Riker
Process and Thread Mapping
Job Accounting on Riker
Visualization tools
Container Usage
Build and Run Workflow
Getting Help
Known Issues
Interactive jobs hanging when allocation expires
Andes User Guide
System Overview
Compute Nodes
Login Nodes
File Systems
LFS setstripe Wrapper
Shell and Programming Environments
Default shell
Environment Management with lmod
Installed Software
Compiling
Available Compilers
Changing Compilers
Compiler Wrappers
Compiling Threaded Codes
Compiling CUDA Codes
Running Jobs
Login vs Compute Nodes on Commodity Clusters
Slurm
Interactive Batch Jobs on Commodity Clusters
Common Batch Options to Slurm
Batch Environment Variables
Modifying Batch Jobs
Monitoring Batch Jobs
Job Execution
Batch Queues on Andes
Job Accounting on Andes
Debugging
Linaro DDT
GDB
Valgrind
Visualization tools
ParaView
VisIt
Remote Visualization using VNC (non-GPU)
Remote Visualization using VNC (GPU nodes)
Remote Visualization using Nice DCV (GPU nodes only)
Container Usage
Examples for Building and Running Containers
Building a Simple Container Image
Running a Simple Container Through a Batch Job
Running an MPI Application within a Container
Lux User Guide
System Overview
Lux Compute Nodes
Lux HPC User Guide
HPC Node Overview
Node Types
System Interconnect
File Systems
Operating System
GPUs
Connecting
Data and Storage
Orion
NFS Filesystem
Lustre Filesystem
Kronos Archival Storage
NVMe
NVMe Usage
Using Globus to Move Data to and from Orion
AMD GPUs
The Compute Unit
HIP
Programming Environment
Environment Modules (Lmod)
Compilers
MPI
RCCL
Compiling
Compilers
MPI
OpenMP
OpenMP GPU Offload
HIP
HIP + OpenMP CPU Threading
Running Jobs
Login vs Compute Nodes
Slurm
General information for Node-sharing on Lux
Queues on Lux
Batch Scripts
Interactive Jobs
Common Slurm Options
Slurm Environment Variables
Job States
Job Reason Codes
Job Dependencies
Monitoring and Modifying Batch Jobs
srun
: Run Jobs/Steps
Process and Thread Mapping Examples
Ensemble Jobs
Tips for Launching at Scale
Debugging
GDB
Profiling
Getting Started with the ROCm Profiler
Tips and Tricks
Running with MPI
Lux Kubernetes User Guide
Setting up the kubectl commandline tool
Create a new namespace
Some Kubernetes Basics
Setting the default namespace
Pods
Deployment
Services
Jobs
Port Forwarding (To View Your Application’s Output)
Example Application
GPU Usage on Kubernetes
Requesting and Using Multiple GPUs
Storage
Using PersistentVolumeClaims (PVCs) for Persistent Storage
Temporary Storage
Accessing your Application
HTTPRoutes for Accessing your App via the Browser
Home
System Overview
Access & Connecting
Usage
Acceptable Tasks
Unacceptable Tasks
Data Transfer Nodes (DTNs)
System Overview
Interactive Access
Access From Globus Online
Batch Queue (Slurm)
Queue Policy
Submitting jobs to Frontier
Odo
System Overview
File Systems
Obtaining Access to Odo
Logging In to Odo
Legacy Systems
Crusher Quick-Start Guide
System Overview
Crusher Compute Nodes
System Interconnect
File Systems
GPUs
Connecting
Data and Storage
NFS Filesystem
Lustre Filesystem
Programming Environment
Environment Modules (Lmod)
Compilers
MPI
Compiling
MPI
OpenMP
OpenMP GPU Offload
HIP
HIP + OpenMP CPU Threading
SYCL
Running Jobs
Slurm Workload Manager
Slurm Compute Node Partitions
Process and Thread Mapping
NVMe Usage
Tips for Launching at Scale
Profiling Applications
Getting Started with the HPE Performance Analysis Tools (PAT)
Getting Started with HPCToolkit
Getting Started with the ROCm Profiler
Roofline Profiling with the ROCm Profiler
Omnitrace
Omniperf
Notable Differences between Summit and Crusher
Using reduced precision (FP16 and BF16 datatypes)
Enabling GPU Page Migration
Floating-Point (FP) Atomic Operations and Coarse/Fine Grained Memory Allocations
Performance considerations for LDS FP atomicAdd()
System Updates
2024-03-19
2024-01-23
2023-12-05
2023-10-03
2023-09-19
2023-07-18
2023-04-05
2022-12-29
Getting Help
Spock Quick-Start Guide
System Overview
Spock Compute Nodes
System Interconnect
File Systems
GPUs
Connecting
Data and Storage
NFS
GPFS
Programming Environment
Environment Modules (Lmod)
Compilers
MPI
Compiling
MPI
OpenMP
OpenMP GPU Offload
HIP
Running Jobs
Slurm Workload Manager
Slurm Compute Node Partitions
Process and Thread Mapping
NVMe Usage
Getting Help
Summit User Guide
Summit Documentation Resources
System Overview
Summit Nodes
Node Types
System Interconnect
File Systems
Operating System
Hardware Threads
GPUs
Connecting
Data and Storage
Software
Shell & Programming Environments
Default Shell
Environment Management with Lmod
Compiling
Compilers
Linking in Libraries
Running Jobs
Login, Launch, and Compute Nodes
Batch Scripts
Interactive Jobs
Common bsub Options
Batch Environment Variables
Job States
Scheduling Policy
Job Dependencies
Job Launcher (jsrun)
Launching a Job with jsrun
Jsrun Examples
Using Multithreading in a Job
Launching Multiple Jsruns
CUDA-Aware MPI
Monitoring Jobs
Interacting With Jobs
Other LSF Commands
PBS/Torque/MOAB-to-LSF Translation
Easy Mode vs. Expert Mode
System Service Core Isolation
Job Accounting on Summit
Other Notes
Debugging
Linaro DDT
GDB
Valgrind
Optimizing and Profiling
Profiling GPU Code with NVIDIA Developer Tools
Score-P
Vampir
HPCToolkit
NVIDIA V100 GPUs
NVIDIA V100 SM
HBM2
NVIDIA NVLink
Volta Multi-Process Service
Unified Memory
Independent Thread Scheduling
Tensor Cores
Tesla V100 Specifications
Further Reading
Burst Buffer
NVMe (XFS)
Current NVMe Usage
Interactive Jobs Using the NVMe
NVMe Usage Example
Spectral Library
Known Issues
Open Issues
Resolved Issues
CUDA 10.1 Known Issues
Scalable Protected Infrastructure (SPI)
Training System (Ascent)
File Systems
Obtaining Access to Ascent
Logging In to Ascent
Preparing For Frontier
HIP
Using HIP on Summit
Learning to Program with HIP
Previous Frontier Training Events
Ascent User Guide
System Overview
Services and Applications
Slate
Overview
What is Slate?
Marble Cluster
Onyx Cluster
What is Kubernetes?
What is OpenShift?
Getting Started
Requesting A Slate Project Allocation
Logging in
Slate Namespaces
Install the OC tool
Test login with OC Tool
Guided Tutorial
Creating your project
Guided Web GUI Tutorial
Adding a Pod to your Project
Guided Tutorial: CLI
Adding a Pod to your Project
Image Building
Build Types
Docker
S2I
Examples
Building From Git Repository in GUI
Creating a BuildConfig from the CLI
Using A Dockerfile
Using a Local Image
Logging into the Registry Externally
Workloads
Pods
Running a Container in a Pod with the CLI
Running a Container in a Pod with the Web Console
More Information
Deployments
Creating a Deployment
Creating Deployments
Web Interface
Deployment Strategies
Rolling Strategy
Recreate Strategy
More Advanced Deployment Strategies with Routes
Blue-Green Deployment
A/B Deployment
More information
Networking
Services
Creating Services
CLI
Accessing Services from Outside the Cluster
Route
NodePort
NodePorts
Configuring a Service NodePort
CLI
Routes
Why Routes
Creating Routes
CLI
Web Interface Configuration
Routes with NCCS Authentication
Requirements
Optional Application Authentication
How
Exemptions
Internet-facing Services
Labelling Routes
Advanced Routes
Multiple Services
Network Policies
Isolation Explanation
Creating a Network Policy
In the GUI
Using the CLI
Quick Access from Outside Slate
Access to the Web UI and CLI
Access to Internal Resources
Persistent Storage
Creating A Persistent Volume Claim
Using The CLI
Using the web GUI
Adding PVC To Pod
Adding PVC To Pod Using Web GUI
Backups
VolumeSnapshots
Cloning
Workflows
Workflows Overview
CI/CD Workflows
GitOps Workflows
Scientific Workflows
OpenShift GitOps
Resources
Installation
Configuration
Multiple Project Management
Application Deployment
Directory Structure
kustomization.yaml
ArgoCD and kustomize
OpenShift Pipelines
Application Deployment Examples
Build and Deploy Simple Website
Creating the BuildConfig
Create the Image
Deploy the Image
Next Steps
Teardown
Deploy MongoDB
Prerequisites
Deploy MongoDB
Deploy Mongoku (Management UI)
Expose MongoDB outside of the cluster
Teardown
Deploy NGINX with Hello World
GitLab Runners
References
Registration Token
Installation and Configuration
Removing a GitLab Runner
Deploy Packages with Helm
Install MySQL with Helm
Setting Values
After Installation
Finding New Charts
Writing Charts
Helm Prerequisites
Establish a project/namespace on Onyx or Marble
Install Helm
MinIO Object Store (On an NCCS Filesystem)
Getting Started
Configure Your Deployment
Create the MinIO Application’s Secret Tokens
Installing the MinIO Standalone Application
Use the MinIO Standalone Application
Deleting the MinIO Standalone Application
Access OLCF Resources From Containers
Batch Job Submission
Mount OLCF Filesystems
Schedule Other Slate Resources
GPUs
Pod Example
Caveats
Upstream documentation
OLCF-Provided Applications on Slate
Troubleshooting
Fix Container Image Permissions
Mount an EmptyDir Volume
Build a New Image
Debugging
Debug a pod in CrashLoopBackoff
Get a shell inside a pod
YAML Object Quick Reference
CronJobs
Basic Cronjob
Deployments and Stateful Sets
Basic Deployment
Basic Stateful Set
Pods
Basic Pod you can create and get a shell in
Pod that mounts a volume named test-pod-pvc
Roles and Rolebindings
Role
Rolebinding
Routes, Services and Nodeports
Route
Service
NodePort
Persistent Volume Claims
Basic PVC
Basic VolumeSnapshot
Glossary
myOLCF
Overview
What is myOLCF?
What can it do?
Can I suggest a feature?
Authenticating
OLCF Moderate Accounts
OLCF Open Accounts
What You Might See During Login
Troubleshooting
Project Pages
Project Context
Switching Project Contexts
Available Pages
Account Pages
Account Context
Available Pages
Processing Project Membership Requests
Jupyter
Overview
Jupyter at OLCF
JupyterLab
Jupyter Hub
Access
CPU vs. GPU JupyterLab (Available Resources)
Hardware Resources
Software and Libraries
Working within Lustre and NFS (Launching a Notebook)
Conda Environments and Custom Notebooks
Example: Creating a Conda Environment on Jupyter
Manually Stopping Your JupyterLab Session
Things to Be Aware Of
Example Jupyter Notebooks
Data Publication (Constellation)
Constellation Overview
Infrastructure
Authentication and Account Setup
Preparing and Submitting Data
Preparing Your Dataset
Data Review and Release
Reserving a Draft DOI
Removal of Dataset Drafts
Adding Data and Documentation
Review States
Data Curation
Reusing Constellation Data
S3M
Overview
What is S3M (OLCF API)?
S3M Use Cases
Token Policy
Get a Token
Generate a Token
Manage Existing Tokens
Token Management
Immediately Revoke Tokens if Exposed!
Never Save Token Directly in Code
Avoid Command-Line Arguments
Verify Secret Files are Ignored
Principle of Least Privilege
Secure Storage of Tokens
Example: Using Header Files Securely
Set Up Your Project
Contact Us
API Reference
Status
List All Resources
Get Specific Resource
List Current Downtimes
List Upcoming Downtimes
Tokens
Revoke a Token
Introspect a Token
Token Structure
Compute
Available Resources
Ping Resource
List Partitions
Submit a Job
Get Job Status
List All Jobs
Cancel a Job
List Nodes
List Reservations
Scheduler Diagnostics
References
Streaming
Available Backends
Cluster Lifecycle
List Available Backends
S3M - Streaming: RabbitMQ
S3M - Streaming: Redis
OLCF Inference Service Documentation
Requesting OLCF Inference Service Access
Authentication
Endpoint URL
Available Models
Multi-Modal Inputs
Usage Examples
Querying gpt-oss-120b
Querying nemotron-nano-fp8
Computer Vision
Simple Text Files
Core API Endpoints
Chat Completions
Standard Completions
List Models
Embeddings
Responses
Additional Resources
Data Storage and Transfers
Summary of Storage Areas
Notes on User-Centric Data Storage
Notes on Project-Centric Data Storage
Data Policies
Information
Special Requests
Data Retention
Orion Lustre HPE ClusterStor Filesystem
Orion Performance Tiers and File Striping Policy
I/O Patterns that Benefit from File Striping
LFS setstripe wrapper
Lustre File Locking Tips
Darshan-runtime and I/O Profiling
Purge
HPSS Data Archival System
Kronos Nearline Archival Storage System
Access / Data Transfer
Directory Structure
Project Quotas
Kronos and HPSS Comparison
Transferring Data
Globus
Command-Line/Terminal Tools
Software
OLCF Software Catalog
Software News
Frontier: Default Core Update (September 15, 2026)
Frontier: profiling daemon enabled (August 25, 2026)
Frontier: Software Changes (July 1, 2026)
Frontier: ROCm/5.x removal date announced (May 13, 2026)
Frontier: Core Module (May 11, 2026)
Frontier: ROCm/5.x removal notice (April 7, 2026)
Frontier: Core Module (March 18, 2025)
Frontier: System Software Update (February 18, 2025)
Frontier: Updated Modules for cpe/23.12 (October 16 2024)
Frontier: Core Module (October 15, 2024)
Frontier: System Software Update (July 16, 2024)
Frontier: User Environment Changes (July 9, 2024)
ML/DL & Data Analytics
Apache Spark
Overview
Getting Started
PyTorch on Frontier
Table of Contents:
Installing PyTorch
Optional: Install mpi4py
Example Usage
Best Practices
Master Address and Sockets
Torchrun and Other Distributed PyTorch Launchers
Environment Location
RCCL Network Plugin
Alternative Rendezvous Protocol
RCCL Environment Variables
Manual RCCL Network Plugin Configuration (Not Recommended)
PyTorch Geometric
Flash Attention
Troubleshooting
MPICH mpi4py Errors
Proxy Settings
c10d Socket Warnings
Dataset Cache
Additional Resources
JAX
Setting up the environment
Installing JAX
Testing JAX
Additional Resources
Python on OLCF Systems
Overview
OLCF Python Guides
Conda Basics
Overview
Inspecting and Setting Up an Environment
Creating a New Environment
Installing Packages
Installing with pip
Installing with Conda Commands
Testing Your New Environment
Additional Tips
Quick-Reference Commands
Additional Resources
Installing mpi4py and h5py
Overview
Parallel HDF5
Setting Up the Environment
Installing mpi4py
Installing h5py
Testing parallel h5py
Additional Resources
Installing CuPy
Overview
CuPy
Installing CuPy
Getting Started With CuPy
Additional Resources
Sbcast Conda Environments
Installing Conda-Pack
Example Usage on Frontier
Jupyter Visibility
Making your Environment Visible to Jupyter
PyTorch on Frontier
Table of Contents:
Installing PyTorch
Optional: Install mpi4py
Example Usage
Best Practices
Master Address and Sockets
Torchrun and Other Distributed PyTorch Launchers
Environment Location
RCCL Network Plugin
Alternative Rendezvous Protocol
RCCL Environment Variables
Manual RCCL Network Plugin Configuration (Not Recommended)
PyTorch Geometric
Flash Attention
Troubleshooting
MPICH mpi4py Errors
Proxy Settings
c10d Socket Warnings
Dataset Cache
Additional Resources
JAX
Setting up the environment
Installing JAX
Testing JAX
Additional Resources
Module Usage
Base Environment
Custom Environments
How to Run
Frontier / Andes
Batch Script - Frontier / Andes
Interactive Job - Frontier / Andes
Best Practices
Additional Resources
Profiling Tools
Score-P
Overview
Usage
Instrumentation
CMake / Autotools Instrumentation
Makefile Instrumentation
Measurement
Profiling
Tracing
Manual Instrumentation
Score-P and Vampir Demo
Tuning and Analysis Utilities (TAU)
Enabling TAU at OLCF
Profile and trace using “tau_exec exe”
Profiling the execution
Tracing the execution
Automatic source instrumentation using compiler wrappers
Selective Instrumentation
Manual source instrumentation
Run-Time Environment Variables
Compile-Time Environment Variables
References
Vampir
Overview
Usage
Vampir on a Login Node
Vampir on Login Node Using VampirServer
Vampir Tunneling from Local Machine to VampirServer
Vampir GUI Demo
Linaro
Overview
Usage
Performance Reports
Linaro MAP
Loading a MAP Profile
Linaro Demo
Darshan
Overview
Usage
Runtime Configuration
Analysis
Darshan-util
PyDarshan
DXT-Explorer
Common Issues
Static Analysis Tools and Code Formatters
Overview
Clang-format (for C, C++)
Clang-tidy (for C++)
Using the Clang tools
Codee Formatter (for Fortran)
Codee Analyzer (for C, C++, Fortran)
Using Codee
User-Managed Software
Introduction
Currently Available User-Managed Software
Usage
Policies
Writing UMS Modulefiles
Workflows
Running Workflows on OLCF Resources
Workflow Systems
Ensemble Toolkit (EnTK)
Overview
Prerequisites
Hello world!
Parsl
Overview
Prerequisites
Hello world!
Swift/T
Overview
Prerequisites
Hello world!
Cross Facility Workflow
Radical Pilot (RP)
Overview
Introduction
INSTALLATION OF THE RADICAL-PILOT TOOL
APPLICATIONS
Visualization Tools
VisIt
Overview
Installing and Setting Up Visit
Creating ORNL/OLCF Host Profiles
Modifying Host Profiles
Remote GUI Usage
Command Line Example
Troubleshooting
Riker: Unable to use the ANARI VisRTX backend
SSH error after accepting passcode (duplicate host profile bug)
VisIt launch continues indefinitely after entering passcode
VisIt keeps asking for your password.
VisIt will not connect when you try to draw an image.
Fatal Python error when launching the CLI
VisIt never asks for passcode then hangs
Additional Resources
ParaView
Overview
Installing and Setting Up ParaView
Remote GUI Usage
Creating a Python Trace
Command Line Example
Troubleshooting
Riker: Unable to use more than 1 core per MPI task
Riker: Hangs on GPU partition with specific filters
Riker: Loading the NVIDIA IndeX plugin crashes ParaView
Process failed to start connection issue (or DISPLAY not set)
Additional Resources
VMD
Overview
Setting Up VMD
GUI Usage
Interactive Molecular Dynamics
Additional Resources
Remote Desktop Tools
Overview
Remote Visualization using VNC
Step 1 (local system)
Step 2 (terminal 1)
Step 3 (terminal 2)
Step 4 (local system)
Jupyter on Frontier
Access
Launching a Notebook
Accessing Files on Orion
Closing a Notebook
API Token
VSCode Example
Example PyTorch Jupyter Notebook
Containers on Frontier
Examples for Building and Running Containers
Building and running a container image from a base Linux distribution for MPI
Pushing your Apptainer image to an OCI Registry supporting ORAS (e.g. DockerHub)
Building an image on top of an existing image (local, docker image, OCI artifact)
Using Podman to build images and converting them to Apptainer
OLCF Base Images & Apptainer Modules
Base Images
Apptainer Modules
Example Workflow
Sample Applications
AMD DockerHub AI/ML Workload Containers on Frontier
Building and Running the AMD DockerHub AI/ML Images on Frontier
Debugging Applications Running in Apptainer
Using gdbserver to debug a single MPI task
Using Linaro Forge to attach to an already running MPI application running from containers
Some Restrictions and Tips
Debugging
Linaro Forge DDT
Client Setup and Usage
Download
Installation
Configuration
GNU GDB
Valgrind
Quantum Chemistry and Materials Science Software
CP2K
Overview
Package Details
Usage
Beginner’s Guide
0. Prepare a working directory.
1. Prepare the input file (
input.in
).
2. Prepare the basis sets and pseudopotentials.
3. Prepare the job submission script.
4. Submit the job to the queue with
sbatch
.
Helpful Links
Quantum ESPRESSO
Overview
Package Details
Usage
Beginner’s Guide
0. Prepare a working directory.
1. Prepare the input file (
input.in
).
2. Prepare the pseudopotentials.
3. Prepare the job submission script.
4. Submit the job to the queue with
sbatch
.
Helpful Links
VASP
Overview
Package Details
Usage
Beginner’s Guide
0. Prepare a working directory.
1. Prepare the input files.
2. Prepare the pseudopotentials.
3. Prepare the job submission script.
4. Submit the job to the queue with
sbatch
.
Helpful Links
Training
OLCF Training Calendar
OLCF Tutorials
OLCF Training Archive
OLCF GPU Hackathons
FacultyHack
OLCF Vimeo Channel
New User Quick Start
Quantum
Quantum Computing User Program (QCUP) Access
QCUP Priorities
Project Allocations
What happens after a project request is approved?
Credit Allocation Requests
Project Renewals
Closeout Reports
User Accounts
Checking the status of your application
Accessing Quantum Resources
IBM Quantum Computing
Quantinuum
IonQ
IQM
Data Retention Policy
Publication Citations
Quantum Systems
IBM Quantum
Overview
Connecting
Cloud Access
Locally via Qiskit
Running Jobs & Queue Policies
Fair-Share Queue Policy
Allocations & Usage Limits
The 28-day rolling cycle
Submitting Jobs
Sessions
Checking System Availability & Capability
Software
Additional Resources
Quantinuum
Overview
Features
Connecting
Cloud Access
Quantinuum Nexus
OLCF JupyterHub
Locally
Running Jobs & Queue Policies
Default Quotas
Allocation Policies & Credit Usage
Software
Additional Resources
IonQ
Overview
IonQ systems
Connecting
Cloud Access
IonQ API
Quantum SDKs
API Keys
Running Jobs & Queue Policies
Allocations & Credit Usage
Checking System Availability & Capability
Additional Resources
IQM
Overview
Available Systems
Connecting
Running Jobs & Queue Policies
Project/Team Roles
Allocations & Usage Limits
IQM API
API Keys
Submitting Jobs
Checking System Availability
Software
Additional Resources
Quantum Software
Quantum Software on HPC Systems
Overview
Qiskit
IBM Quantum
Qiskit IonQ Provider
IQM Qiskit Plugin
PennyLane
Guppy
Batch Jobs
Hello QCUP Scripts
Overview
IBM Quantum
Quantinuum
IonQ
IQM
Frequently Asked Questions
How do quantum computers differ from classical computers?
What is a qubit?
How do I access the OLCF quantum computing resources?
What happens after I apply for access to QCUP?
I formerly had access to quantum resources, but my backends/lattices/etc. have disappeared, what do I do?
I applied to a quantum computing resource via the vendor website, but don’t have access; what do I do?
It says I have 0 credits, how do I get credits to run on the actual quantum hardware?
How should I acknowledge OLCF quantum computing resources in a publication?
Scalable Protected Infrastructure (SPI)
What is SPI
What is Citadel
New User QuickStart
Notable Differences
Allocations and User Accounts
Allocations (Projects)
User Accounts
Available Resources
Compute
File Systems
Data Transfer
IP Whitelisting
Whitelisting an IP or range
Finding your IP
Citadel
Login Nodes
Connecting
Building Software
Running Batch Jobs
File Systems
Data Transfer
Advanced Computing Ecosystem Testbed (ACE)
Defiant Quick-Start Guide
System Overview
Defiant Nodes
System Interconnect
File Systems
GPUs
Connecting
Data and Storage
NFS Filesystem
Lustre Filesystem (Polis)
Programming Environment
Environment Modules (Lmod)
Compilers
MPI
Compiling
MPI
OpenMP
OpenMP GPU Offload
Running Jobs
Slurm Workload Manager
Slurm Compute Node Partitions
GPU Partition
Process and Thread Mapping
NVMe Usage
Container Usage
Build and Run Workflow
Getting Help
Known Issues
Contributing to these docs
Submitting suggestions
Authoring content
Setup authoring environment
Edit the docs
Resources
GitHub Guidelines
OLCF User Documentation
Quantum
Quantum Systems
Edit on GitHub
Quantum Systems
IBM Quantum
Overview
Connecting
Running Jobs & Queue Policies
Checking System Availability & Capability
Software
Additional Resources
Quantinuum
Overview
Connecting
Running Jobs & Queue Policies
Default Quotas
Allocation Policies & Credit Usage
Software
Additional Resources
IonQ
Overview
IonQ systems
Connecting
Running Jobs & Queue Policies
Allocations & Credit Usage
Checking System Availability & Capability
Additional Resources
IQM
Overview
Available Systems
Connecting
Running Jobs & Queue Policies
Checking System Availability
Software
Additional Resources