Difference between revisions of "Best practices on Lustre parallel file systems"
(→Try to use local scratch for serial jobs)
|Line 63:||Line 63:|
===Try to use local scratch for serial jobs===
===Try to use local scratch for serial jobs===
If your data set fits into local scratch (
If your data set fits into local scratch (300 GB), then try to use local scratch instead of Lustre as it will be faster in almost all cases.
Revision as of 06:40, 13 February 2019
- 1 Introduction
- 2 Lustre architecture
- 3 Best practices
- 3.1 Avoid unnecessary I/O operations
- 3.2 Limit repetitive Open/Close operations
- 3.3 Limit repetitive "stat" operations
- 3.4 Directory listings: ls vs. ls -l vs. ls --color
- 3.5 Use subdirectories instead of storing all files in a single directory
- 3.6 Try to use local scratch for serial jobs
- 3.7 Use other storage locations for small files
- 3.8 Avoid reading the same region of a file from many processes at the same time
- 4 Working with stripes (advanced users)
On the Euler and the Leonhard cluster, the global scratch and work directories
are hosted on Lustre file systems. The are optimized especially for parallel I/O and large files. Those file systems are shared among many users. If you are
- working with a large number of small files
- running thousands of unnecessary I/O operations per second (running Open/Close in a loop)
- accessing the same file with hundreds of processes
then this will not only slow down your jobs. It can overload the entire file system affecting all users. Therefore please carefully read our best practices guide before using /cluster/work and/or /cluster/scratch.
Lustre is a parallel distributed file system. Files are distributed across multiple servers, and then striped across multiple disks.
A Lustre file system has three major functional units:
- Metadata servers (MDS) that stores namespace metadata, such as filenames, directories, access permissions, and file layout.
- Object storage server (OSS) nodes that store file data on one or more object storage target (OST) devices.
- Client(s) that access and use the data.
When a client accesses a file, it performs a filename lookup on the MDS. When the MDS filename lookup is complete and the user and client have permission to access the file, then the layout of the file is returned.
For read or write operations, the client then interprets the file layout, which maps the file logical offset and size to one or more objects, each residing on a separate OST. The client then locks the file range being operated on and executes one or more parallel read or write operations directly to the OSS nodes.
After the initial lookup of the file layout, the MDS is not normally involved in file IO operations since all block allocation and data IO is managed internally by the OST. Clients do not directly modify the objects or data on the OST filesystems, but instead delegate this task to OSS nodes.
Avoid unnecessary I/O operations
In many programs, there are options to control I/O to make them more or less verbose. In general I/O operations are slowing down your computation, because during I/O operations the CPU is waiting and doing nothing. Therefore only do I/O if it is required and provides an added value to your computation. Otherwise try to avoid unneccessary I/O operations whenever possible.
Limit repetitive Open/Close operations
If you need to write a lot of values into a file as part of a loop, then there are multiple ways of achieving this task. Please make sure that you never put the open and close statements inside the loop as shown in this Python example:
for i in range(1000): f=open('test2.txt', 'a') f.write(some_data) f.close()
This will cause that the same file is opened and closed 1000 times, which causes a total of 2000 I/O operations and 1998 of them are unnecessary. It is sufficient to open the file once, then write all values to it and close it at the end, resulting in only 2 I/O operations
f=open('test1.txt', 'w') for i in range(1000): f.write(some_data) f.close()
Limit repetitive "stat" operations
If you are running a code that needs at some point to wait until a certain file is created, it is sufficient to check for this every 5-10 seconds. Checking this without any delay in a loop can cause more than 1000 checks per second create a lot of unnecessary file stat calls.
Directory listings: ls vs. ls -l vs. ls --color
If you run the ls command for listing a file or a directory, then it will query the MDS for this information. But when running the command with the -l option, it will also need to access the OSSes to look up the file size, which creates additional load on the storage system.
- Use ls if you would like to list files and directories
- Only use ls -l if you also need to know about the file size
- Unset the default color option for ls (ls --color) if you need to do ls on Lustre directories with many files: ls --color=never or to permanently disable it during your session $ \ls
Use subdirectories instead of storing all files in a single directory
When a file is accessed, Lustre puts a lock on the parent directory. If many files are opened in the same directory, then this will cause contention. To minimize contention, distribute your files into a subdirectory structure. This way your files are also organized and easier to handle.
If you accidentally run an ls -l instead of just ls, then it also makes a difference if the directory contains 20 or 100'000 files.
Try to use local scratch for serial jobs
If your data set fits into local scratch (≤ 300 GB), then try to use local scratch instead of Lustre as it will be faster in almost all cases.
A typical workflow could be to copy your files from Lustre to local scratch at the beginning of a job, then process the files and copy back the results of the job from local scratch to Lustre.
Jobs working with many small files might be improved by a huge factor with the latency reduction provided by local scratch.
Use other storage locations for small files
Avoid reading the same region of a file from many processes at the same time
If you are running a series of jobs in parallel that are all accessing the same region of a file, then this will cause performance problems. It might be better to either split the file into parts that can be used by individual jobs, or to work on multiple copies of the same file. Each job could for instance copy the file to local scratch in order to avoid contention.
Working with stripes (advanced users)
Lustre will always try to distribute your data across all OSTs. The striping parameters can be tuned per file or directory.
How to display the current striping settings
The default stripe setting of a file or directory can be shown with the command lfs getstripe. It is configured by default to 1:
[sfux@eu-login-24-ng ~]$ lfs getstripe $SCRATCH/__USAGE_RULES__ /cluster/scratch/sfux/__USAGE_RULES__ lmm_stripe_count: 1 lmm_stripe_size: 1048576 lmm_pattern: 1 lmm_layout_gen: 0 lmm_stripe_offset: 3 obdidx objid objid group 3 619261 0x972fd 0 [sfux@eu-login-24-ng ~]$
- stripe_count = 1 : Use the filesystem default stripe count
- stripe_size = 1048576 : Use 1 MiB stripe/chunk size
- stripe_offset = -1: Let Lustre choose the next OST (you shouldn't change this)
Hints for proper striping count
The best stripping count depends mostly on the IO pattern access, the file size and the number of nodes used to access a file. As a rule of thumb we could provide the following general hints:
- If only one processor will access the file (single threaded pattern) let the default striping count (1)
- If it's a single shared file for many cores:
* Files smaller than 1GB should be left with the default striping (1) * Between 1GB and 10GB a small stripe should be used (2) * 10 - 100GB : use medium striping (2 to 4) * Above 100GB: use maximum striping (-c -1)
Do not use the maximum stripe option by default on directories (-c -1). This could add unnecessary overhead to the filesystem. Use only this option with individual files that you know they will be above 100GB or with a highly parallelized access.
How to change stripe settings
The stripe setting of a directory can be changed with the command lfs setstripe.
- Changing the default stripe on directories is highly discouraged: this could unnecessarily overload the storage system if many files are created on this directory
- You can not change the striping of existing files
- You can always change the striping parameters for new files with the lfs command
- A subdirectory inherits all stripe parameters from its parent directory (if not changed via lfs setstripe)
[sfux@eu-login-02-ng test]$ lfs setstripe -c 4 my_new_file
The file will be precreated with zero bytes size and preallocated on 4 stripes.
Change the stripe size of a file:
- Create and empty file with the preferred stripe settings
- Copy the original file into the new one
- Move the new one to the original file name
[sfux@eu-login-02-ng test]$ pwd /cluster/scratch/sfux/test [sfux@eu-login-02-ng test]$ ls DFT.tar.gz [sfux@eu-login-02-ng test]$ lfs getstripe DFT.tar.gz DFT.tar.gz lmm_stripe_count: 1 lmm_stripe_size: 1048576 lmm_pattern: 1 lmm_layout_gen: 0 lmm_stripe_offset: 3 obdidx objid objid group 3 218244665 0xd022639 0
The original file has a stripe count of 1. Now it is changed to the maximal stripe count (-1 sets it to the maximal stripe count):
[sfux@eu-login-02-ng test]$ lfs setstripe -c -1 DFT.tar.gz_tmp [sfux@eu-login-02-ng test]$ cp -a DFT.tar.gz DFT.tar.gz_tmp [sfux@eu-login-02-ng test]$ mv DFT.tar.gz_tmp DFT.tar.gz [sfux@eu-login-02-ng test]$ lfs getstripe DFT.tar.gz DFT.tar.gz lmm_stripe_count: 8 lmm_stripe_size: 1048576 lmm_pattern: 1 lmm_layout_gen: 0 lmm_stripe_offset: 7 obdidx objid objid group 7 216514949 0xce7c185 0 2 218076805 0xcff9685 0 0 216705136 0xceaa870 0 5 217632135 0xcf8cd87 0 6 218497608 0xd060248 0 3 218248704 0xd023600 0 1 217278204 0xcf366fc 0 4 217634916 0xcf8d864 0