Checking disk and file space usage in linux
Here are some notes on the various ways to check disk space usage on linux:
Disk usage of all (non-hidden) files and folders
Using the du
command (disk use) with the -s
(summarize) and -h
(human-readable) options.
du -sh *
Prints a list of all files and folders in the current directory. Folder/directory sizes given includes all the subdirectories and any files they contain.
BONUS: You can add the -c
option to get the total size of all the files that this command lists. (I.e. du -sch *
)
Total disk usage including hidden files
This is useful, particularly if you are trying to get comparable outputs from the quota
command (see below). Hidden files are not included by default, so we have to use wildcard matching like so:
du -sch .[!.]* *
The first .
matches files beginning with a dot, but we want to exclude ..
, since this would match the directory above (as in when you do cd ..
etc.) and we don’t want to include that. To exclude that pattern we add [!.]
, in other words, match a single dot but not two in a row. The final asterisk is to match all the non-hidden files as before.
Another way to do this is to specify the -ahd1
set of options:
du -ahd1
However, this also includes the file .
, which refers to the current directory. If you add the -c
option to this
Sorted disk usage
The easiest way to do this is to just pipe the results into the sort command. To sort them numerically, we can just add the -n
flag to sort.
du -sch * | sort -n
This will sort them numerically in ascending order. Have a look at the sort manual pages for more sorting opttions.
Disk usage by file system
df
is a slightly different unix command which lists disk free space by file system. Typing it with no options will give a list of all mounted file systems, their total size available, how much space has been used, and their linux mount points. The -h
option gives a more human-readable form.
df -h
Disk quota information
On systems where you have an allocated disk quota, the quota
utility tells you how much of your quota has been used and how much you have available. The -s
option gives a nice summary of disk quota:
quota -s
Outputs:
Disk quotas for user bob (uid 123456):
Filesystem space quota limit grace files quota limit grace
mydomain:/disk/someserver/u1234//dvalters
2000M 15000M 15000M 12000 0 0
The space
output is sometimes replaced with blocks
, which is a slightly less helpful measure. On POSIX systems, 1 block is befined as 512 bytes. space
(or blocks
tells you how much you have used, quota
is your total quota allowance. If you are over the quota, an asterisk appears next to the number for space/blocks.
Other utilities
I have only covered the most common GNU/Linux utilities for monitoring/measuring disk usage. There are othe utilities available that have nicer outputs by default, such as: ncdu, freespace etc.
Generators or List comprehensions
Optimisations with python data structure generation
This post explores some of the differences in using list comprehensions and generator expressions to build lists in Python. We are going to look at the memory and CPU performance using various Python profiling tools and packages.
Firstly a list comprehension can be built in python using:
which constructs the list for every item in somedata
. The list comprehension may also be built out of a function that returns an item on return, e.g. [x for x in somefunc()]
. The important thing to note in list comprehensions is that the whole list is evaluated at once, this is in contrast to the generator expression which is “short-circuiting” and will exit early if the expression permits it so. Generators can be a useful alternative where an algorithm is likely to finish early if certain conditions are met. For example:
In the case of the list comprehension the entire list is evaluated first, and then run through the any()
function. In the generator case, the any()
test is evaluated every iteration of somefunc(), and if it returns true the any test can return early without having to build the entire list.
In theory then, generator expressions offer a potential performance benefit compared to their list comprehension counterparts. But how does it play out in practice?
Testing
We’re going to use an example that builds lists of random strings. Here’s a function that returns a random string:
Now we need a function that builds the lists using each method. First the list comprehension way:
And now a function that uses the generator approach:
Let’s also create some functions for testing ints, just to see if there is any difference with the data type.
timeit
Now we are going to test these methods with the timeit
command, built in to the python interpreter. Using IPython, this can be run using the command: %timit [FUNCTION_NAME(ARGS)]
. Help for this command is accessed with %timeit?
.
Using our integer list building methods:
So, it would appear at first approximation, the generator approach is slower, at least for building a list of integers this size.
Memory usage
Now let’s investigate the impact on memory use. Memory use is tricky to measure in Python, as objects can have a deeply nested structure, making it diffcult to fully trace the memory footprint of objects. The python interpreter also performs garbage collection atcertain intervals, meaning it can be difficult to reproduce tests of memory consumption.
First we’re going to use the built in sys.getsizeof()
Interestingly, the generator performs better in most cases, execpt for the smallest example with eight strings. With larger lists than this, the generator approach consistently outperforms the list comprehension method in terms of its memory footpring, when building lists of strings and measuring with the sys.getsizeof()
function.
pympler asizeof()
The pympler package is reportedly more accurate at deteriming the true memory footprint of a Python object. USing the asizeof()
method with the same tests as above, we get:
memory_profiler
Another option is the memory_profiler
package. This provides another IPython magic command: %memit
, which can be used like so:
Pympler’s asizeof()
says the list comprehension is bigger, memory_profiler
says the generator sees the bigger memory footprint…TBC
Initialising the WRF model with ECMWF ERA-20C reanalysis data
The Weather Research and Forecasting model (WRF) can be initialised with a range of input data sources for simulations. The initialisation step describes the setting of grid parameters within the model domain (pressure, surface variables, etc.) as well as defining the boundary conditions for the model. If you have followed the excellent WRF tutorial and run a few of the case studies with real data the input data is provided for you and is already tested to ensure it can be pre-processed relatively painlessly by the WPS (WRF pre-processing system). Datsets from North American providers are extenisvely tested with WRF, (i.e. GFS data (global), AWIP (North American continent area))
I’ve recently begun using ECMWF data to intialise WRF simulations and a few extra steps not shown in the standard tutorials were required to get the data pre-processed correctly by WPS. Certain ECWF datasets, such as reanalysis data, can be accessed and downloaded freely from their public data portal. Global reanalysis data is availble for the 20th century and interim data for the most recent years. In this example I’m using the ERA-20C global reanalysis dataset to set up a case study of some severe storm events over Great Britain in 2005. (The ERA-20C actually extends into the 21st century as well now).
The data come in several different sets; as a minimum for intialising the WRF model you will need some surface variable data, and then pressure level data (pressures at different heights in the atmosphere). You could also use model level data directly, but WRF can interpolate this for you from the pressure level data. There is one other data set you need, which is a land-sea surface mask. This is called invariant data, as it does not change over time, and is found under the ‘invariant’ tab on the ECMWF page. Technically, WRF already has invariant data bundled with it but I found I had to download the ECMWF land-sea mask separately for WPS to work correctly.
To summarise, you need three separate data files from the reanalysis data:
- Surface variable data
- Pressure level data (or model levels)
- Land-sea mask.
Downloading the data
You’ll be required to select which surface varibles you want to download, as well as which pressure levels, too. The land-sea mask is just a single file. Although probably not the most efficient method, I tend to just select all the surface variables for the surface data, (you don’t actually need all of them to intiailise the model, but I find it easier to just download everything in case it’s required later). Once you’ve selected the date range, and varaibles of interest, you can proceed directly to the download by clicking the GRIB or netCDF download buttons.
Downloading via Python script
ECMWF have provided a very handy python API for downloading data without necessarily having to use the web interface, which can save time if you already know exactly which data fields you want. The details of the Python API are here, it’s well explained so I will only summarise here what you need to do:
- Register on the ECMWF site
- Download an access key to placed on the computer or system you are downloading to.
- Install the ecmwfapi Python module.
- Either write your own python script using the API documentation above, or have the ECMWF web interface generate one for you. (Click the ‘view MARS request’ after making your selections, and then copy the Python script that is displayed. An example python script looks like this:
ECMWF provide the data in two different file formats, GRIB (gridded-binary) and netCDF (.nc files). WPS comes with the ungribber tool (ungrib.exe) so I’ve gone for the grib data format here. (Selected by default in the Python download script).
Important: Retrieveing the data in Gaussian gridded format
By default, the ECMWF site will download the data on a spherical harmonic grid, and the version of ungrib supplied in WPS v3.8.1 will not be able to decode this properly. (You may get the error Unknown ksec2(4): 50
in the ungrib error log, if you try this). Ungrib expects a regular Gaussian grid, and I couldn’t find a way to easily access this from the web portal interface. However, using the Python script above, you can easily request Gaussian gridded data by adding the parameter:
"grid": "160",
to the python download script, and your grib data will be supplied in Gaussian grid format. The CHANGEME
value is the name of the downloaded file and you should probably change it to something meaningful. The python script will download the grib file to the same directory it is run in. For the example in this post, I ended up with three python scripts, one for the surface data, one for pressure levels, and one for the land-sea mask. (You could of course bundle them all in to one script).
Ungribbing the data
Now we need to ‘ungrib’ data to convert into the WPS intermediate file format, before running metgrid. This has to be done in two stages - one for the surface and pressure level data, and one for the land-sea mask. This is because the land-sea mask has a ‘start date’ of 1900-01-01 if you try to run ungrib with the date of your case study, ungrib will fail, complaining that the dates specified could not be found. In the namelist.wps file, I set the the &ungrib
section to the following:
Link your land-sea mask to the WPS directory with the link_grib.sh
script and run ungrib. Repeat again for the surface and pressure data but with the following section in the namelist.wps file:
To be honest, you can use whatever file prefixes you like, but I like to use this naming convention.
Make sure you have linked the correct Vtable before running ungrib. The ECMWF Vtable supplied with WRF v3.8.1 worked fine without any modifications in this case. The Vtable can be found in WPS/ungrib/Variable_Tables/Vtable.ECMWF
Metgrid
Metgrid interpolates your ungribbed data files over the model domain. (I haven’t gone through the model domain generation stage with geogrid.exe as this blog post is only about prepping the input data.)
If you are using the sea surface temparatures field from the ECMWF data, you’ll need to make a few changes to the METGRID.TBL file for it to correctly interpolate and mask the sea surface temparatures around land. IN the METGRID.TBL file (located in WPS/metgrid/), change the entry of the SST field to the following:
The changes are to make the interp_mask use the LANDMASK mask instead of LANDSEA (the default), and to change the interpolation option slightly. Without the changes, I found that for my inner domain the sea surface temperatures were incorrectly masked, and had been interpolated over land as well. Although metgrid.exe did not complain when run, the met files generated caused an error when real.exe was run - generating an error message saying:
The changes to METGRID.TBL should remedy this error message.
Before running metgrid, there is one last change to make to the namelist.wps file:
This tells metgrid to use the invariant data we downloaded earlier as a constant field (i.e. the land-sea mask doesn’t change over time, so it doesn’t need to be interpolated for each period). Use whichever name you have used for this invariant file.
Now you can run metgrid. Hopefully it will produce all the input met files needed, and correctly interpolated. It’s a good idea before running real.exe and wrf.exe to check that the fields look reasonable. In particular, check the SST field if you are using sea-surface temperatures. Check the nested domains as well - I found that my SST field had been incorrectly interpolated in the inner domain, which required the change to the METGRID.TBL file above. ncview is a useful utility for checking the met files generated by metgrid.
Real and WRF
You are now set to run real.exe to generate the lateral boundary conditions and initialise the model, followed (finally) by wrf.exe to run the simulation.
Sources
The following discussion boards and mailing list answers were helpful in preparing this post:
Also two useful blogposts from NCAR: Analysis, Forecast, Reanalysis, What’s the difference?.
Array sum reductions in OpenMP 4.5
Some interesting new OpenMP functions in OpenMP 4.5, including the potentially useful reduction on arrays for C and C++ now (this was previously supported for Fortran only).
You can now perform summations of arrays using the reduction clause with OpenMP 4.5.
Reductions can be done on variables using syntax such as:
So each thread gets its own copy of total_sum, and at the end of the parallel for region, all the local copies of total_sum are summed up to get the grand total.
Suppose you have an array where you want to summation of each array element (not the entire array). Previously, you would have to implement this manually.
Whereas now in OpenMP 4.5 you can do
Outputs:
I compiled this with GCC 6.2. You can see which common compiler versions support the OpenMP 4.5 features here: http://www.openmp.org/resources/openmp-compilers/
Compiling WRF v3.8.1 on ARCHER (Cray XC system)
This post documents how to compile the latest release of WRF (version 3.8.1) on the ARCHER HPC service. There is already a compiled version available on archer that be accessed using the modules funciton (see this guide), but you will need to be able to compile from the source code if you are making any modifications to the code, or if you need to compile the idealised cases, or need to compile it with a different nesting set up. (The pre-compiled code is set up for basic nesting only).
Compilation with the default ARCHER compiler (Cray CCE)
This is relatively straightforward as the configure script already works as expected. However, compiling with the Cray compiler (usually the default loaded compiler when you login to ARCHER) can take upwards of 6-8 hours, depending on the options selected in configure, and the load on the login or serial nodes.
Setting up your ARCHER environment
First, check that you do actually have the Cray compiler environment loaded. You can look for PrgEnv-cray
in the output from running the module list
command, or you can do echo $PE_ENV
from a login session.
Because it takes so long to compile using the Cray compiler, you need to run the compilation task as a serial job on the serial nodes. If you attempt to run on the login nodes, the compilation process will time out well before completion.
So we are going to prepare three things:
- A ‘pre build’ script that will load the correct modules on ARCHER and set up the environment variables
- The configure.wrf file. This is prepared using the
configure
script, so you should not need to do anything different to the normal WRF compilation instructions for this part. - A compliation job submission (.pbs) script. This will be submitted as a serial node job to do the actual compilation bit.
The pre-build script
This is a shell script (of the bash flavour) that loads the relevant modules for WRF to compile.
pre-build.bash
NetCDF-4 is the default netcdf module on the ARCHER environment, so I am assuming you want to compile it with netcdf-4 (it has extra features like supporting file compression etc…)
I attempted this with the gcc/5.x.x module, but ran into compilation errors. Using GCC v6 seemed to fix them.
Note that you may need to switch a load
statement for a swap
statement in some places, depending on what default modules are loaded in your ARCHER environment. See your .profile
and .bashrc
scripts.
NOTE: .profile
(in the $HOME
directory is only loaded on the login shells. If you launch any other interactive shells (like an interactive job mode), then .bashrc
will get loaded.
pre-build.bash (continued)
Some things to note:
- You cannot compile WRF in parallel (it’s a bug in the Makefile, apparrently)
- There are some environment variables that are just set equal to some other environmnet variables, e.g.
NETCDF=$NETCDF_DIR
. This works because when you use themodule
system to load, say, netCDF, ARCHER will automatically set its own environment variables that we can use to initialise the WRF configure variables, e.g.$NETCDF
.
Run configure
For the CRAY compiler, this can be run as normal e.g. ./configure
from the WRFV3
directory.
Compilation job script
At this stage, you can either request an interactive mode job on the serial nodes, and then run compile in the usual way (after running the prebuild script and the configure commands), or you can submit a serial job with the PBS job scheduling system to run when a node becomes available. If you are going down the interactive job mode, be sure to request enough walltime as the Cray compiler takes a long time to compile everything. I would ask for 12 hours to be on the safe side.
If you want to submit a job to run without having to wait for an interactive-mode job, prepare the following job submission script:
Putting it all together.
-
Make sure the
pre-build.bash
script and thecompile.pbs
script are in a directory above/WRFV3
. I called itWRF_build381
-
Use qsub as normal to submit the compile.pbs script. E.g.
qsub compile.pbs
Your job should run and the compile logs will be written to compileCray.log (or whatever you named them in the compile.log
script above.
Compiling WRF using the GNU compilers on ARCHER
You may have reason to want to compile WRF with the GNU compilers on ARCHER or another Cray XC30 system. Unfortunately I found that the configure
script supplied with version 3.8.1 did not generate a correct configure.wrf
script for the GNU compilers in a Cray enviroment. Namely, it used compilation flags specific to the Cray compiler, rather than the gfortran compilation flags (which are incompatible). To rectify this you can either run the configure
script as normal, and then correct the compiler flags in the configure.wrf
output script that is generated. Or if you want a more re-usable soultion you can edit the file in the WRFV3/arch/configure_new.defaults
file.
I did this by opening the configure_new.defaults
file and adding a new entry. The purpose of the file is to generate the menu entries that you see when running the configure
script, and then populate the Makefile with the correct compilation options.
Find the CRAY CCE entry in the configure_new.defaults
file and insert a new entry below it called GNU on CRAY XC30 system
or similar. The entry should contain the following:
###########################################################
#ARCH Cray XE and XC CLE/Linux x86_64, GNU Compiler on Cray System # serial dmpar smpar dm+sm
# Use this when you are using the GNU programming environment on ARCHER (a Cray system)
DESCRIPTION = GNU on Cray system ($SFC/$SCC): Cray XE and XC
# OpenMP is enabled by default for Cray CCE compiler
# This turns it off
DMPARALLEL = # 1
OMPCPP = # -D_OPENMP
OMP = # -fopenmp
OMPCC = # -fopenmp
SFC = ftn
SCC = cc
CCOMP = gcc
DM_FC = ftn
DM_CC = cc
FC = CONFIGURE_FC
CC = CONFIGURE_CC
LD = $(FC)
RWORDSIZE = CONFIGURE_RWORDSIZE
PROMOTION = #-fdefault-real-8
ARCH_LOCAL = -DNONSTANDARD_SYSTEM_SUBR -DWRF_USE_CLM
CFLAGS_LOCAL = -O3
LDFLAGS_LOCAL =
CPLUSPLUSLIB =
ESMF_LDFLAG = $(CPLUSPLUSLIB)
FCOPTIM = -O2 -ftree-vectorize -funroll-loops
FCREDUCEDOPT = $(FCOPTIM)
FCNOOPT = -O0
FCDEBUG = # -g $(FCNOOPT) # -ggdb -fbacktrace -fcheck=bounds,do,mem,pointer -ffpe-trap=invalid,zero,overflow
FORMAT_FIXED = -ffixed-form
FORMAT_FREE = -ffree-form -ffree-line-length-none
FCSUFFIX =
BYTESWAPIO = -fconvert=big-endian -frecord-marker=4
FCBASEOPTS_NO_G = -w $(FORMAT_FREE) $(BYTESWAPIO)
FCBASEOPTS = $(FCBASEOPTS_NO_G) $(FCDEBUG)
FCBASEOPTS_NO_G = -N1023 $(FORMAT_FREE) $(BYTESWAPIO) #-ra
FCBASEOPTS = $(FCBASEOPTS_NO_G) $(FCDEBUG)
MODULE_SRCH_FLAG =
TRADFLAG = -traditional
CPP = /lib/cpp -P
AR = ar
ARFLAGS = ru
M4 = m4 -G
RANLIB = ranlib
RLFLAGS =
CC_TOOLS = gcc
###########################################################
You can run the configure script as normal once these changes have been made and you will get a configure.wrf
suitable for using the GNU compilers on ARCHER to build WRF v3.8.1.