Version 5.9.0, 5.9.1, 5.10.1, 5.11.2 of the pvserver and pvbatch OSMesa server tools (binary-install) is installed on the CSF.<\/p>\n
How ParaView runs on the CSF and your PC<\/h3>\n
On CSF4 two methods of running paraview are supported:<\/p>\n
- \n
- Client\/server mode – the
paraview<\/code> GUI app runs on your<\/em> PC or laptop – not<\/em> the CSF. It connects topvserver<\/code> processes running in a batch job on the CSF. These do the hard work of processing and rendering your data. The final rendered image is sent back to your PC\/laptop to be displayed in the ParaView GUI. The advantage of this is that you DO NOT need to download your data from the CSF.<\/li>\n- In purely batch mode –
pvbatch<\/code> processes are run in a batch job on the CSF to process a ParaView script. No GUI is used. A final rendered image, movie or some other dataset may be generated and stored in new files on the CSF.<\/li>\n<\/ol>\nNote that it is not<\/strong> possible to run the Paraview GUI (
paraview<\/code>) directly on the CSF – it is not even installed! The client\/server method is by far the most efficient method of using Paraview on the CSF and allows you to easily visualize huge datasets without needing to download the data to your PC and you also do not need a fancy GPU in your PC.<\/p>\nThe remainder of this page describes the above two methods in detail. Firstly we cover the client\/server method for interactive use of the ParaView GUI.<\/p>\n
Summary of the Client \/ Server method<\/h3>\n
The first method (the client\/server method) is the most common – you will use this to interactively examine your datasets.<\/p>\n
It is a little more complicated to set up, and requires you to install the ParaView GUI app on your PC\/laptop, but then allows you to visualize huge datasets stored on the CSF without<\/em> needing a powerful local PC\/workstation.<\/p>\n
This is a four-step process. Detailed instructions are provided further down on this page, but a summary of the steps is as follows:<\/p>\n
- \n
- Firstly, you<\/em> must install and run the ParaView GUI (
paraview<\/code>) on your local PC\/laptop<\/strong> (see below for more details.) Please note: If you need help installing ParaView on a campus desktop or your laptop, please contact the Support Centre<\/a> and they will arrange for this to be done. The Research Infrastructure team that look after the CSF cannot<\/em> arrange this.<\/li>\n- Then you run the parallel processing and rendering part of ParaView (
pvserver<\/code> processes) on the CSF in a batch job.<\/li>\n- Then you create an SSH<\/em> (secure shell) tunnel from your PC to the CSF batch job running the
pvserver<\/code> processes.<\/li>\n- Then you run
paraview<\/code> on your PC\/laptop and it will connect to the CSF, via the SSH tunnel, and use thepvserver<\/code> processes. This is efficient because only<\/em> the rendered images are sent to your PC over the network to be displayed in the paraview render window. Your datasets (which could be huge) are stored and processed entirely<\/em> on the CSF.<\/li>\n<\/ol>\nWhile this may seem like a lot of steps, it is actually reasonably straight-forward and we provide complete instructions below. It is worth doing – using this method allows you to visualize very large datasets on the CSF from the comfort of your PC\/laptop, without having to download those large datasets to your PC\/laptop.<\/p>\n
Note that the
pvserver<\/code> (orpvbatch<\/code>) applications will not<\/em> use any GPU hardware in the CSF. Instead all processing and rendering is performed in software on the compute nodes.<\/p>\nRemember, theparaview<\/code> GUI app is not<\/em> available on the CSF. You will need to install it on your PC\/laptop and connect it to apvserver<\/code> job running in batch on the CSF. Complete instructions are given below.<\/div>\nRestrictions on use<\/h2>\n
There are no restrictions on accessing the software on the CSF. The software is released under a BSD style license and all users should ensure they adhere to the terms of that license<\/a>.<\/p>\n
<\/a><\/p>\n
Installing ParaView on your local PC<\/h2>\n
You are going to run the
paraview<\/code> GUI on your PC\/laptop<\/em> and connect it to the CSF. <\/p>\nIf using a University “public cluster” PC then ParaView might already be installed – check the Start Menu.<\/p>\n
To install ParaView on your PC \/ laptop, please either<\/p>\n
- \n
- Check the University “Software Centre” app running on managed Windows laptops \/ desktops – at the time of writing version 5.10.1 is available for install.<\/li>\n
- Or, download ParaView with the same version number you will be using on the CSF<\/strong> from the ParaView Download page<\/a> for your platform (versions are available for Windows, MacOS and Linux – choose whatever your PC\/laptop runs). Please note that on Windows you should NOT download the “MPI” version – ignore the downloads that have “-MPI-” in their name.<\/li>\n<\/ul>\n
If you need help installing ParaView on a campus desktop or your laptop, please contact the Support Centre<\/a> and they will arrange for this to be done. The Research Infrastructure team that look after the CSF cannot<\/em> arrange this.<\/p>\n
Once installed on your PC, do not run ParaView just yet<\/strong>. You first need to start the
pvserver<\/code> job on the CSF and then set up an SSH tunnel on your PC. Full instructions are given below.<\/p>\nRunning
pvserver<\/code> in batch on the CSF<\/h2>\nYou will now submit a batch job (just like any other batch job) to the CSF batch system to run ParaView’s
pvserver<\/code> app.<\/p>\nThis is an application to perform processing and rendering as instructed by the ParaView GUI. For example, if you use the ParaView GUI to set up a pipeline that reads a data-file and then performs volume rendering, it is the
pvserver<\/code> processes running on the CSF that will do the actual file reading and volume rendering. The rendered image generated will be sent back to your ParaView GUI so that you can see it in the GUI.<\/p>\nThe
pvserver<\/code> app can be run as a large CSF job, across multiple compute nodes, or as a smaller job on a few CPU cores in a single compute node. Examples of both types of jobs are given below.<\/p>\nWhether you submit a smaller single-node job or a much larger multi-node job mainly depends on how much data you will be loading in to paraview. Typically each
pvserver<\/code> process has access to approximately 4GB of RAM. So you may be able to estimate how manypvserver<\/code> processes (and hence CPU cores) your job will need to be able to load and process your datasets. You may need to experiment – try submitting a smaller single-node job (e.g., 4 cores) to begin with. If your job runs out of memory, submit a new job with more CPU cores.<\/p>\nWe now recommend loading modulefiles within your jobscript so that you have a full record of how the job was run. See the example jobscripts below for how to do this. Load the following modulefile:<\/p>\n
\r\n# Note: The version of paraview installed on your PC must<\/em> be the same as that used on the CSF.\r\n# Load one<\/em> of the following:\r\nmodule load paraview\/5.11.2\r\nmodule load paraview\/5.10.1\r\nmodule load paraview\/5.9.1\r\nmodule load paraview\/5.9.0\r\n<\/pre>\n
Small single-node (multicore) pvserver job<\/h3>\n
Create the following jobscript (e.g., naming it
pvserver.sh<\/code>). NOTE<\/strong>: the--force-offscreen-rendering<\/code> rendering flag is required<\/strong>.<\/p>\n\r\n#!\/bin\/bash --login\r\n#SBATCH -p multicore # A single-node multicore job\r\n#SBATCH -n 8 # (or --ntasks=8) number of cores - can be 2--40.\r\n\r\n# We now recommend loading the modulefile in the jobscript\r\nmodule purge\r\nmodule load paraview\/5.10.1\r\n\r\n# mpiexec knows to use the number of cores requested above\r\nmpiexec pvserver --system-mpi --force-offscreen-rendering\r\n #\r\n # Note: This is specific to the CSF4 (it isn't used on CSF3)\r\n<\/pre>\n
Then submit the above jobscript using<\/p>\n
\r\nsbatch jobscript<\/em>\r\n<\/pre>\n
where jobscript<\/em> is the name of your file (e.g.,
pvserver.sh<\/code>)<\/p>\nLarge multi-node (multicore) pvserver job<\/h3>\n
Create the following jobscript (e.g., naming it
pvserver-ib.sh<\/code>). NOTE<\/strong>: the--force-offscreen-rendering<\/code> rendering flag is required<\/strong>.<\/p>\n\r\n#!\/bin\/bash --login\r\n#SBATCH -p multinode # A multi-node job\r\n#SBATCH -n 80 # (or --ntasks=80) number of cores, minimum is 80, must be in multiples of 40.\r\n\r\n# We now recommend loading the modulefile in the jobscript\r\nmodule load paraview\/5.10.1\r\n\r\n# mpiexec knows to use the number of cores requested above\r\nmpiexec pvserver --system-mpi --force-offscreen-rendering\r\n #\r\n # Note: This is specific to the CSF4 (it isn't used on CSF3)\r\n<\/pre>\n
Then submit the above jobscript using<\/p>\n
\r\nsbatch jobscript<\/em>\r\n<\/pre>\n
where jobscript<\/em> is the name of your file (e.g.,
pvserver-ib.sh<\/code>)<\/p>\nFind where the pvserver batch job runs<\/h3>\n
You must now wait<\/strong> until the
pvserver<\/code> job is running. Usesbatch<\/code> to check your job queue. Once thestate<\/code> reported bysbatch<\/code> has changed fromPD<\/code> toR<\/code> you will see something like:<\/p>\n\r\nJOBID PRIORITY PARTITION NAME USER ACC ST SUBMIT_TIME START_TIME TIME NODES CPUS NODELIST(REA\r\n24914 0.021350 multinode pvser... uname<\/em> xy01<\/em> R<\/strong> 08\/12\/21... 08\/12\/21... 5:21 2 80 node[056<\/strong>-057]\r\n<\/pre>\n
Make a note of the NODELIST(REASON)<\/strong> value (yes really, please make a note if it – you need this info later), specifically the first<\/strong> node (if a range of node numbers is given) – e.g.,
node[<\/em>056<\/strong>-057<\/em>]<\/code>. In this example we seenode056<\/code><\/strong> is the first<\/em> node in the list of nodes your job is running on.<\/p>\n\nIf you’ve submitted a large, multi-node pvserver job, you only need to make a note of the first<\/em> node in the list of nodes on which the job is running.<\/p>\nIn the above example, the job is running on
node[056-057]<\/code> so we make a note ofnode056<\/code>.\n<\/div>\nYou should now check in the job output that
pvserver<\/code> is waiting for you to connect to it:<\/p>\n\r\n# Go to where you submit the job from. For example:\r\ncd ~\/scratch\/data\r\n\r\n# Check the end of the job output file for a message from paraview:\r\ncat slurm-24914.out\r\n\r\n# You should see something similar to\r\nWaiting for client...\r\nConnection URL: cs:\/\/node056<\/strong>.csf4.local:11111\r\nAccepting connection(s): node056<\/strong>.csf4.local:11111\r\n\r\n# If the above message is not visible, wait a minute and run\r\n# the 'cat' command again. This shows that pvserver is ready\r\n# for you to connect your paraview GUI to it.\r\n<\/pre>\n
It may take a minute or two before the
pvserver<\/code> job displays the above message in theslurm-NNNNNN.out<\/code> file. Please wait until you see this message from the job.<\/p>\nAssuming you can see a message similar to the above, we are now going to do some steps on your local PC\/laptop to run the
paraview<\/code> GUI there and connect it to thepvserver<\/code> batch job.<\/p>\nSetting up the SSH tunnel from your PC to the CSF<\/h2>\n
We will now set up the SSH tunnel to the CSF from your PC\/laptop.<\/p>\n
This allows the ParaView GUI on your<\/em> PC to communicate directly with your CSF batch job running the
pvserver<\/code> processes. The method used is very similar to how you log in to the CSF, just with some extra command-line flags, so don’t be put off about doing this step. You will<\/em> need the information from thesqueue<\/code> command that we noted above.<\/p>\nSeparate instructions are given for Windows and Linux\/MacOS.<\/p>\n
At this stage you must<\/strong> have ParaView installed on your<\/em> local PC\/laptop (see above<\/a>). It doesn’t matter if the ParaView GUI is running or not yet on your PC.<\/p>\n
SSH Tunnel on Linux or MacOS<\/h3>\n
In a shell (Terminal) window on your<\/strong> PC\/laptop, create a tunnel<\/em> between your local port 11111 and the CSF backend node’s port 11111 where the
pvserver<\/code> job is running. This will go via the CSF login node. In this example we assume thepvserver<\/code> job is running on nodenode056<\/code><\/strong>.<\/p>\n\r\nssh -L 11111:node056<\/strong>:11111 username<\/em>@csf4.itservices.manchester.ac.uk\r\n # #\r\n # # Use your<\/em> UoM username\r\n #\r\n # Use the node number that you made a note of earlier (see squeue output)\r\n\r\n# Enter your University IT password when prompted and respond to any DUO prompt if shown.\r\n<\/pre>\n
where username<\/em> is your<\/em> CSF username and node056<\/em> is the node where your<\/em>
pvserver<\/code> job is running (usesqueue<\/code> on the CSF to find out). Do not close this shell<\/strong>. This connection must remain open to use ParaView. You do not<\/strong> need to type any commands in to this shell.<\/p>\nSSH Tunnel on Windows<\/h3>\n
You must have an SSH client, such as MobaXterm (or PuTTY), installed. Note that we are going to run a locally-installed Windows version of the ParaView GUI. The SSH application is just to set up the SSH tunnel. <\/p>\n
If using MobaXTerm, start MobaXTerm on your PC then simply copy the
ssh<\/code> command given in the Linux instructions above in to the black MobaXTerm window (don’t forget to use the appropriate node name – e.g.,node056<\/code> – appropriate to your job). For example:<\/p>\n\r\nssh -L 11111:node056<\/strong>:11111 username<\/em>@csf4.itservices.manchester.ac.uk\r\n # #\r\n # # Use your<\/em> UoM username\r\n #\r\n # Use the node number that you made a note of earlier (see squeue output)\r\n\r\n# Enter your University IT password when prompted and respond to any DUO prompt if shown.\r\n<\/pre>\n
PuTTY instructions coming soon…<\/p>\n
Run the Paraview GUI on your PC\/laptop<\/h2>\n
Now start your local installation of
paraview<\/code> on your<\/em> PC\/laptop:<\/p>\n- \n
- Linux or MacOS: Run the following command in a Terminal<\/em> (aka Shell<\/em>) window:\n
\r\nparaview --server-url=cs:\/\/localhost:11111<\/pre>\n
ParaView will connect to the
pvserver<\/code> processes through your local port11111<\/code>. This has been tunnelled to the CSF backend node where the processes are actually running. You can now jump to Render Settings<\/a> to ensure everything is working correctly.<\/li>\n- Windows: Run
paraview<\/code> by selecting it from the Start menu (or desktop icon if you have one). Then follow the steps below.<\/li>\n<\/ul>\nConnecting the ParaView GUI to your CSF job<\/h3>\n
Note that Linux and MacOS users do not need to do these steps if you ran paraview on your PC\/laptop using:<\/p>\n
\r\nparaview --server-url=cs:\/\/localhost:11111<\/pre>\n
because that command will have achieved what the following steps will do. The steps below are mostly for Windows users who will need to do the steps using the ParaView GUI.<\/p>\n
Once the ParaView GUI has appeared, do the following:<\/p>\n
- \n
- Go to File<\/em> > Connect<\/em><\/li>\n
- In the Choose Server Configuration<\/em> window that pops up, select Add Server<\/strong><\/li>\n
- \n
![\"Paraview](\"http:\/\/ri.itservices.manchester.ac.uk\/csf-apps\/wp-content\/uploads\/pv-connect02.png\")
<\/a><\/li>\n<\/ul>\n- Fill in the form to connect to your local port 1111 using the following then hit Configure<\/strong>:<\/li>\n
- \n
- Name:
localhost<\/code><\/li>\n- Server Type:
Client \/ Server<\/code><\/li>\n- Host:
localhost<\/code><\/li>\n- Port:
11111<\/code><\/li>\n<\/ul>\n- \n
![\"Paraview](\"http:\/\/ri.itservices.manchester.ac.uk\/csf-apps\/wp-content\/uploads\/pv-connect03.png\")
<\/a><\/li>\n<\/ul>\n- In the Server Launch Configuration<\/em> window ensure Manual<\/strong> is selected and hit Save<\/strong><\/li>\n
- \n
![\"ParaView](\"http:\/\/ri.itservices.manchester.ac.uk\/csf-apps\/wp-content\/uploads\/pv-connect04.png\")
<\/a><\/li>\n<\/ul>\n- Now select your saved configuration and hit Connect<\/strong><\/li>\n
- \n
![\"ParaView](\"http:\/\/ri.itservices.manchester.ac.uk\/csf-apps\/wp-content\/uploads\/pv-connect05.png\")
<\/a><\/li>\n<\/ul>\n<\/ol>\nParaView will connect to the
pvserver<\/code> processes through your local port 11111. This has been tunnelled to the CSF backend node where the processes are actually running.<\/p>\nNow jump to Render Settings<\/a> to ensure everything is working correctly.<\/p>\n
<\/a><\/p>\n
Render Settings<\/h2>\n
To ensure your local
paraview<\/code> client does no rendering work<\/em> you should change the render settings inparaview<\/code>. The default is to have your PC do a little bit of rendering work. We don’t want it to do any rendering otherwise it would have to transfer more data from the CSF to your PC. <\/p>\n- \n
- In the
paraview<\/code> GUI go to Edit<\/em> > Settings…<\/em><\/li>\n- In the Render View<\/em> tab, type in a zero
0<\/code> in the Remote Render Threshold<\/em> box, as shown below.<\/li>\n![\"ParaView](\"http:\/\/ri.itservices.manchester.ac.uk\/csf3\/wp-content\/uploads\/render-view-settings-red.png\")
<\/a><\/li>\n<\/ol>\nThis will ensure all<\/em> geometry data and rendering tasks remain on the CSF and only the final rendered image is delivered to your PC.<\/p>\n
Testing the Connection to the CSF<\/h2>\n
A useful way of checking what the remote
pvserver<\/code> processes are doing is to load a standard ParaView geometry (e.g., a sphere), or one of your own datasets, and then colour the data according to the processor ID<\/em> on which the data is residing (ParaView distributes the gemetry amongst thepvserver<\/code> processes). Hence you will see different colours for eachpvserver<\/code> used in the CSF batch job:<\/p>\n- \n
- Go to the Sources<\/em> > Geometric<\/em> > Sphere<\/em> menu item to add a sphere to your pipeline.
\n![\"Paraview](\"http:\/\/ri.itservices.manchester.ac.uk\/csf3\/wp-content\/uploads\/sphere-filter-red.png\")
<\/a><\/li>\n- Hit the Apply<\/em> button to display the sphere. The sphere’s geometry data will exist on the CSF (in the
pvserver<\/code> processes and be rendered by those processes. The final image of the sphere is then being sent back to your PC to be displayed in the ParaView GUI. - Hit the Apply<\/em> button to display the sphere. The sphere’s geometry data will exist on the CSF (in the
- In the Render View<\/em> tab, type in a zero
- In the
- Now select your saved configuration and hit Connect<\/strong><\/li>\n
- In the Server Launch Configuration<\/em> window ensure Manual<\/strong> is selected and hit Save<\/strong><\/li>\n
- Server Type:
- Fill in the form to connect to your local port 1111 using the following then hit Configure<\/strong>:<\/li>\n
- In the Choose Server Configuration<\/em> window that pops up, select Add Server<\/strong><\/li>\n
- Windows: Run
- Linux or MacOS: Run the following command in a Terminal<\/em> (aka Shell<\/em>) window:\n
- Then you run the parallel processing and rendering part of ParaView (
- In purely batch mode –