Frontpage
Back

Navigation

  • IO500
  • SC24 – Bursting at the Seams
  • Keras: Getting Started with AI
  • KISS – Adding a New User
  • TUI Tools for Containers
  • HPCCM with Docker and Podman
  • Podman for Non-Root Docker
  • Update on Containers in HPC
  • ISC 2024 from a Distance
  • Desktop Blades (of Glory)
  • Really Useful Linux Commands for HPC Admins
  • Write Your Own Admin Tools
  • Tools to Manage Storage
  • AlmaLinux and HPC
  • Linux Local and Network Filesystems
  • Linux Software RAID
  • Managing Storage with LVM
  • Proprietary and Open Source Storage Options
  • Where Does Job Output Go?
  • Getting Data Into and Out of the Cluster
  • (Re)Installing Python
  • Saving Storage Space with Reduced Precision
  • Updates and Upgrades in HPC
  • Warewulf 4 – Python and Jupyter Notebooks
  • Warewulf 4 – Environment Modules
  • Warewulf 4 – GPUs
  • Warewulf 4 – Time and Resource Management
  • Warewulf 4
  • Analyzing Logs
  • Log Management
  • Parallel I/O Chases Amdahl Away
  • Rocky Reaches for a Role in HPC
  • Sharing a Linux Terminal Over the Web
  • Sharing Linux Terminals
  • Performance Health Check
  • Distributed Linear Algebra with Mahout
  • Extended File Attributes
  • What Is an Inode?
  • Working with the Lustre Filesystem
  • What is an IOPS Really?
  • Mounting Compressed Archives as a User
  • Parallel and Encrypted Compression
  • File Compression for HPC
  • Processor Affinity for OpenMP and MPI
  • Processor and Memory Affinity Tools
  • Darshan I/O Analysis for Deep Learning Frameworks
  • Prolog and Epilog Scripts
  • Run One Program at any Scale with Legate
  • When I/O Workloads Don’t Perform
  • Preload Trick
  • New Monitoring Tools
  • Desktop Supercomputers: Past, Present, and Future
  • Rethinking RAID (on Linux)
  • How Linux and Beowulf Drove Desktop Supercomputing
  • A Brief History of Supercomputers
  • Remora – Resource Monitoring for Users
  • mpi4py – High-Performance Distributed Python
  • Why Good Applications Don’t Scale
  • SSHFS for Shared Storage
  • SMART Devices
  • Caching with CacheFS
  • Bashtop, a Gorgeous Top-like Tool
  • Tips and Tricks for Containers
  • Pymp – OpenMP-like Python Programming
  • MPI Apps with Singularity and Docker
  • Tuning ZFS for Speed on Linux
  • More Best Practices for HPC Containers
  • Container Best Practices
  • Creating Virtual SSDs
  • Profiling Python Code
  • Linux Writecache
  • Porting CUDA to HIP
  • High-Performance Python 4
  • High-Performance Python 3
  • High-Performance Python 2
  • High-Performance Python 1
  • OpenMP – Coding Habits and GPUs
  • OpenMP – Loops and Data Control
  • OpenMP – Parallelizing Loops
  • OpenACC – Porting Code
  • OpenACC – Data Management
  • OpenACC – Parallelizing Loops
  • GUI or Text-Based Interface?
  • Resource Management with Slurm
  • Symbolic Mathematics with Python's SymPy Library
  • Shared Storage with NFS and SSHFS
  • Environment Modules Using Lmod
  • pdsh Parallel Shell
  • HPC Container Maker
  • pyamgx – Accelerated Python Library
  • User File Recovery
  • Linux I/O Schedulers
  • What to Do with System Data: Think Like a Vegan
  • System Logging for Data-Based Answers
  • Selecting Compilers for a Supercomputer
  • More Small Tools for HPC Admins
  • AMD’s Greg Stoner on ROCm
  • Discovering ROCm
  • Small Tools for Managing HPC
  • REMORA
  • Multicore Processing in Python
  • ClusterHAT
  • Read-only File Compression with SquashFS
  • HDF5 and Parallel I/O
  • How Old is That Data?
  • HDF5 with Python and Fortran
  • Introduction to HDF5
  • Modern Fortran – Part 3
  • Modern Fortran – Part 2
  • GlusterFS Storage Pools
  • Modern Fortran – Part 1
  • NVDIMM Persistent Memory
  • Let the Editor Wars Begin!
  • Useful NFS Options for Tuning and Management
  • Getting Ready for the New Ceph Object Store
  • Singularity – A Container for HPC
  • Interview with Gregory Kurtzer, Developer of Singularity
  • Memory Errors
  • Determining CPU Utilization
  • Persistent Memory
  • Improved Performance with Parallel I/O
  • Compiler Directives for Parallel Processing
  • Lmod 6.0: Exploring the Latest Edition of the Powerful Environment Module System
  • Building an HPC Cluster
  • Safe Files
  • Benchmarks Don’t Have to Be Evil
  • Nmon: All-Purpose Admin Tool
  • Stat-like Tools for Admins
  • I/O Profiling at the Block Level
  • HPC Data Analytics
  • Graphite: Collect and Visualize Numeric Data
  • The Meson Build System
  • Parallel Shells: Run Commands on Multiple Nodes
  • Understanding the Status of Your Filesystem
  • Ceph and OpenStack Join Forces
  • Combining Directories on a Single Mountpoint
  • Hadoop for Small-to-Medium-Sized Businesses
  • Sharing Data with SSHFS
  • Parallel Python with Joblib
  • Data Analysis with Panda
  • Process, Network, and Disk Metrics
  • Processor and Memory Metrics
  • The Lua Scripting Language
  • HPC Monitoring: What Should You Monitor?
  • Tuning I/O Patterns in Python
  • Tuning I/O Patterns in Fortran 90
  • HPC Cloud Storage
  • Predicting Drive Doom
  • Moore's Law Continues its Unwavering March
  • Finding Memory Bottlenecks with Stream
  • HPC Software Road Gets a Bit Smoother
  • Parallel Versions of Familiar Serial Tools
  • Ceph Maintenance
  • Tuning I/O Patterns in C
  • The New Hadoop
  • Failure to Scale
  • The Road to End-of-Scale
  • Getting Started with HPC Clusters
  • Moving Your Data – It’s Not Always Pleasant
  • Is Hadoop the New HPC?
  • The Cloud’s Role in HPC
  • CephX Encryption
  • Monitoring NFS Storage with nfsiostat
  • Monitoring Storage with iostat
  • Managing Cluster Software Packages
  • Lmod – Alternative Environment Modules
  • What's New at OpenMP
  • StarCluster Toolkit: Virtualization Meets HPC
  • Matlab-Like Tools for HPC
  • Profiling Is the Key to Survival
  • Living with Many and Multiple Cores
  • Parallel Programming with OpenMP
  • Managing the Build Environment with Environment Modules
  • RADOS and Ceph: Part 2
  • Moving HPC to the Cloud
  • openlava – Hot Resource Manager
  • Grid Engine: Running on All Four Cylinders
  • Gathering Data on Environment Modules
  • Warewulf 4 Code
  • Warewulf Cluster Manager – Administration and Monitoring
  • Julia Distributed Arrays
  • Warewulf Cluster Manager – Development and Run Time
  • Exploring the Linux Tuning Guide for AMD Opteron 6200 Series Processors
  • Parallel Julia – Jumping Right In
  • Warewulf Cluster Manager – Completing the Environment
  • Julia: A New Language For Technical Computing
  • Warewulf Cluster Manager – Master and Compute Nodes
  • Cluster Documentation Project
  • The RADOS Object Store and Ceph Filesystem
  • Interview: Hardware or Cloudware?
  • Five HPC Pitfalls – Part 2
  • Monitor Your Nodes with collectl
  • GlusterFS
  • Five HPC Pitfalls (Part 1)
  • MapReduce and Hadoop
  • Environment Modules
  • The History of Cluster HPC
  • Magellan Report on Cloud Computing
  • HPC Storage – I/O Profiling
  • Top Three HPC Roadblocks
  • Co-Design Approach to Supercomputing
  • Look for Bottlenecks with Open|SpeedShop
  • What's Ahead for OpenMP?
  • AMD Rolls Out Opteron 4200 and 6200 Series Processor
  • Programming with OpenMP
  • hwloc: Which Processor Is Running Your Service?
  • Get Started with Parallel CPython
  • Parallel Programming with OpenCL
  • Exploring the HPC Toolbox
  • Interview: AMD’s John Fruehe, Director of Server Product Marketing
  • GNU Parallel: Multicore at the Command Line with GNU Parallel
  • Real-World HPC: Setting Up an HPC Cluster

Articles

Linux device mapper writecache  

Kicking write I/O operations into overdrive with the Linux device mapper writecache.

Porting CUDA to HIP  

Give your proprietary CUDA code new life with an open platform for HPC.

High-Performance Python – Distributed Python  

Scale Python GPU code to distributed systems and your laptop.

High-Performance Python – GPUs  

Python finally has interoperable tools for programming the GPU – with or without CUDA.

High-Performance Python – Compiled Code and Fortran Interface  

Fortran functions called from Python bring complex computations to a scriptable language.

High-Performance Python – Compiled Code and C Interface  

Although Python is a popular language, in the high-performance world, it is not known for being fast. A number of tactics have been employed to make Python faster. We look at three: Numba, Cython, and ctypes.

OpenMP – Coding Habits and GPUs  

In this third and last article on OpenMP, we look at good OpenMP coding habits and present a short introduction to employing OpenMP with GPUs.

In the Loop  

Diving deeper into OpenMP loop directives for parallel code.

OpenMP  

The powerful OpenMP parallel do directive creates parallel code for your loops.

Porting Code to OpenACC  

OpenACC directives can improve performance if you know how to find where parallel code will make the greatest difference.

« Previous Next » 1 2 3 4 5 6 7 8 9 10 11 12 13 14 ...22

Copyright © 2011 eZ Systems AS (except where otherwise noted). All rights reserved.
Visit: mobile site | full site