Update Documentation (#558)

* Update Documentation

* update keywords

* fix readme bug

Author: jan-janssen

README.md

@@ -23,25 +23,25 @@ with the [ProcessPoolExecutor](https://docs.python.org/3/library/concurrent.futu
 [ThreadPoolExecutor](https://docs.python.org/3/library/concurrent.futures.html#threadpoolexecutor) for parallel 
 execution of Python functions on a single computer. executorlib extends this functionality to distribute Python 
 functions over multiple computers within a high performance computing (HPC) cluster. This can be either achieved by 
-submitting each function as individual job to the HPC job scheduler - [HPC Submission Mode](https://executorlib.readthedocs.io/en/latest/2-hpc-submission.html) - 
-or by requesting a compute allocation of multiple nodes and then distribute the Python functions within this - allocation -
-[HPC Allocation Mode](https://executorlib.readthedocs.io/en/latest/3-hpc-allocation.html). Finally, to accelerate the 
-development process executorlib also provides a - [Local Mode](https://executorlib.readthedocs.io/en/latest/1-local.html) - 
-to use the executorlib functionality on a single workstation for testing. Starting with the [Local Mode](https://executorlib.readthedocs.io/en/latest/1-local.html) 
-set by setting the backend parameter to local - `backend="local"`:
+submitting each function as individual job to the HPC job scheduler with an [HPC Cluster Executor](https://executorlib.readthedocs.io/en/latest/2-hpc-cluster.html) - 
+or by requesting a job from the HPC cluster and then distribute the Python functions within this job with an
+[HPC Job Executor](https://executorlib.readthedocs.io/en/latest/3-hpc-job.html). Finally, to accelerate the 
+development process executorlib also provides a [Single Node Executor](https://executorlib.readthedocs.io/en/latest/1-single-node.html) - 
+to use the executorlib functionality on a laptop, workstation or single compute node for testing. Starting with the 
+[Single Node Executor](https://executorlib.readthedocs.io/en/latest/1-single-node.html):
 ```python
-from executorlib import Executor
+from executorlib import SingleNodeExecutor
 
 
-with Executor(backend="local") as exe:
+with SingleNodeExecutor() as exe:
     future_lst = [exe.submit(sum, [i, i]) for i in range(1, 5)]
     print([f.result() for f in future_lst])
 ```
 In the same way executorlib can also execute Python functions which use additional computing resources, like multiple 
 CPU cores, CPU threads or GPUs. For example if the Python function internally uses the Message Passing Interface (MPI) 
 via the [mpi4py](https://mpi4py.readthedocs.io) Python libary: 
 ```python
-from executorlib import Executor
+from executorlib import SingleNodeExecutor
 
 
 def calc(i):
@@ -52,7 +52,7 @@ def calc(i):
     return i, size, rank
 
 
-with Executor(backend="local") as exe:
+with SingleNodeExecutor() as exe:
     fs = exe.submit(calc, 3, resource_dict={"cores": 2})
     print(fs.result())
 ```
@@ -66,11 +66,11 @@ This flexibility to assign computing resources on a per-function-call basis simp
 Only the part of the Python functions which benefit from parallel execution are implemented as MPI parallel Python 
 funtions, while the rest of the program remains serial. 
 
-The same function can be submitted to the [SLURM](https://slurm.schedmd.com) queuing by just changing the `backend` 
-parameter to `slurm_submission`. The rest of the example remains the same, which highlights how executorlib accelerates
-the rapid prototyping and up-scaling of HPC Python programs. 
+The same function can be submitted to the [SLURM](https://slurm.schedmd.com) job scheduler by replacing the 
+`SingleNodeExecutor` with the `SlurmClusterExecutor`.  The rest of the example remains the same, which highlights how 
+executorlib accelerates the rapid prototyping and up-scaling of HPC Python programs. 
 ```python
-from executorlib import Executor
+from executorlib import SlurmClusterExecutor
 
 
 def calc(i):
@@ -81,16 +81,16 @@ def calc(i):
     return i, size, rank
 
 
-with Executor(backend="slurm_submission") as exe:
+with SlurmClusterExecutor() as exe:
     fs = exe.submit(calc, 3, resource_dict={"cores": 2})
     print(fs.result())
 ```
 In this case the [Python simple queuing system adapter (pysqa)](https://pysqa.readthedocs.io) is used to submit the 
 `calc()` function to the [SLURM](https://slurm.schedmd.com) job scheduler and request an allocation with two CPU cores 
-for the execution of the function - [HPC Submission Mode](https://executorlib.readthedocs.io/en/latest/2-hpc-submission.html). In the background the [sbatch](https://slurm.schedmd.com/sbatch.html) 
+for the execution of the function - [HPC Cluster Executor](https://executorlib.readthedocs.io/en/latest/2-hpc-submission.html). In the background the [sbatch](https://slurm.schedmd.com/sbatch.html) 
 command is used to request the allocation to execute the Python function. 
 
-Within a given [SLURM](https://slurm.schedmd.com) allocation executorlib can also be used to assign a subset of the 
+Within a given [SLURM](https://slurm.schedmd.com) job executorlib can also be used to assign a subset of the 
 available computing resources to execute a given Python function. In terms of the [SLURM](https://slurm.schedmd.com) 
 commands, this functionality internally uses the [srun](https://slurm.schedmd.com/srun.html) command to receive a subset
 of the resources of a given queuing system allocation. 
@@ -106,7 +106,7 @@ def calc(i):
     return i, size, rank
 
 
-with Executor(backend="slurm_allocation") as exe:
+with SlurmJobExecutor() as exe:
     fs = exe.submit(calc, 3, resource_dict={"cores": 2})
     print(fs.result())
 ```
@@ -116,29 +116,29 @@ In addition, to support for [SLURM](https://slurm.schedmd.com) executorlib also
 to address the needs for the up-coming generation of Exascale computers. Still even on traditional HPC clusters the 
 hierarchical approach of the [flux](http://flux-framework.org) is beneficial to distribute hundreds of tasks within a
 given allocation. Even when [SLURM](https://slurm.schedmd.com) is used as primary job scheduler of your HPC, it is 
-recommended to use [SLURM with flux](https://executorlib.readthedocs.io/en/latest/3-hpc-allocation.html#slurm-with-flux) 
+recommended to use [SLURM with flux](https://executorlib.readthedocs.io/en/latest/3-hpc-job.html#slurm-with-flux) 
 as hierarchical job scheduler within the allocations. 
 
 ## Documentation
 * [Installation](https://executorlib.readthedocs.io/en/latest/installation.html)
   * [Minimal](https://executorlib.readthedocs.io/en/latest/installation.html#minimal)
   * [MPI Support](https://executorlib.readthedocs.io/en/latest/installation.html#mpi-support)
   * [Caching](https://executorlib.readthedocs.io/en/latest/installation.html#caching)
-  * [HPC Submission Mode](https://executorlib.readthedocs.io/en/latest/installation.html#hpc-submission-mode)
-  * [HPC Allocation Mode](https://executorlib.readthedocs.io/en/latest/installation.html#hpc-allocation-mode)
+  * [HPC Cluster Executor](https://executorlib.readthedocs.io/en/latest/installation.html#hpc-cluster-executor)
+  * [HPC Job Executor](https://executorlib.readthedocs.io/en/latest/installation.html#hpc-job-executor)
   * [Visualisation](https://executorlib.readthedocs.io/en/latest/installation.html#visualisation)
   * [For Developers](https://executorlib.readthedocs.io/en/latest/installation.html#for-developers)
-* [Local Mode](https://executorlib.readthedocs.io/en/latest/1-local.html)
-  * [Basic Functionality](https://executorlib.readthedocs.io/en/latest/1-local.html#basic-functionality)
-  * [Parallel Functions](https://executorlib.readthedocs.io/en/latest/1-local.html#parallel-functions)
-  * [Performance Optimization](https://executorlib.readthedocs.io/en/latest/1-local.html#performance-optimization)
-* [HPC Submission Mode](https://executorlib.readthedocs.io/en/latest/2-hpc-submission.html)
-  * [SLURM](https://executorlib.readthedocs.io/en/latest/2-hpc-submission.html#slurm)
-  * [Flux](https://executorlib.readthedocs.io/en/latest/2-hpc-submission.html#flux)
-* [HPC Allocation Mode](https://executorlib.readthedocs.io/en/latest/3-hpc-allocation.html)
-  * [SLURM](https://executorlib.readthedocs.io/en/latest/3-hpc-allocation.html#slurm)
-  * [SLURM with Flux](https://executorlib.readthedocs.io/en/latest/3-hpc-allocation.html#slurm-with-flux)
-  * [Flux](https://executorlib.readthedocs.io/en/latest/3-hpc-allocation.html#flux)
+* [Single Node Executor](https://executorlib.readthedocs.io/en/latest/1-single-node.html)
+  * [Basic Functionality](https://executorlib.readthedocs.io/en/latest/1-single-node.html#basic-functionality)
+  * [Parallel Functions](https://executorlib.readthedocs.io/en/latest/1-single-node.html#parallel-functions)
+  * [Performance Optimization](https://executorlib.readthedocs.io/en/latest/1-single-node.html#performance-optimization)
+* [HPC Cluster Executor](https://executorlib.readthedocs.io/en/latest/2-hpc-cluster.html)
+  * [SLURM](https://executorlib.readthedocs.io/en/latest/2-hpc-cluster.html#slurm)
+  * [Flux](https://executorlib.readthedocs.io/en/latest/2-hpc-cluster.html#flux)
+* [HPC Job Executor](https://executorlib.readthedocs.io/en/latest/3-hpc-job.html)
+  * [SLURM](https://executorlib.readthedocs.io/en/latest/3-hpc-job.html#slurm)
+  * [SLURM with Flux](https://executorlib.readthedocs.io/en/latest/3-hpc-job.html#slurm-with-flux)
+  * [Flux](https://executorlib.readthedocs.io/en/latest/3-hpc-job.html#flux)
 * [Trouble Shooting](https://executorlib.readthedocs.io/en/latest/trouble_shooting.html)
   * [Filesystem Usage](https://executorlib.readthedocs.io/en/latest/trouble_shooting.html#filesystem-usage)
   * [Firewall Issues](https://executorlib.readthedocs.io/en/latest/trouble_shooting.html#firewall-issues)

docs/_toc.yml

@@ -2,9 +2,9 @@ format: jb-book
 root: README
 chapters:
 - file: installation.md
-- file: 1-local.ipynb
-- file: 2-hpc-submission.ipynb
-- file: 3-hpc-allocation.ipynb
+- file: 1-single-node.ipynb
+- file: 2-hpc-cluster.ipynb
+- file: 3-hpc-job.ipynb
 - file: trouble_shooting.md
 - file: 4-developer.ipynb
 - file: api.rst

docs/installation.md

@@ -33,10 +33,10 @@ used. The mpi4py documentation covers the [installation of mpi4py](https://mpi4p
 in more detail. 
 
 ## Caching 
-While the caching is an optional feature for [Local Mode](https://executorlib.readthedocs.io/en/latest/1-local.html) and 
-for the distribution of Python functions in a given allocation of an HPC job scheduler [HPC Allocation Mode](https://executorlib.readthedocs.io/en/latest/3-hpc-allocation.html), 
-it is required for the submission of individual functions to an HPC job scheduler [HPC Submission Mode](https://executorlib.readthedocs.io/en/latest/2-hpc-submission.html). 
-This is required as in [HPC Submission Mode](https://executorlib.readthedocs.io/en/latest/2-hpc-submission.html) the 
+While the caching is an optional feature for [Single Node Executor](https://executorlib.readthedocs.io/en/latest/1-single-node.html) and 
+for the distribution of Python functions in a given allocation of an HPC job scheduler [HPC Job Executors](https://executorlib.readthedocs.io/en/latest/3-hpc-job.html), 
+it is required for the submission of individual functions to an HPC job scheduler [HPC Cluster Executors](https://executorlib.readthedocs.io/en/latest/2-hpc-cluster.html). 
+This is required as in [HPC Cluster Executors](https://executorlib.readthedocs.io/en/latest/2-hpc-cluster.html) the 
 Python function is stored on the file system until the requested computing resources become available. The caching is 
 implemented based on the hierarchical data format (HDF5). The corresponding [h5py](https://www.h5py.org) package can be 
 installed using either the [Python package manager](https://pypi.org/project/h5py/):
@@ -51,12 +51,12 @@ Again, given the C++ bindings of the [h5py](https://www.h5py.org) package to the
 recommended. The h5py documentation covers the [installation of h5py](https://docs.h5py.org/en/latest/build.html) in 
 more detail. 
 
-## HPC Submission Mode
-[HPC Submission Mode] requires the [Python simple queuing system adatper (pysqa)](https://pysqa.readthedocs.io) to 
+## HPC Cluster Executor
+[HPC Cluster Executor](https://executorlib.readthedocs.io/en/latest/2-hpc-cluster.html) requires the [Python simple queuing system adatper (pysqa)](https://pysqa.readthedocs.io) to 
 interface with the job schedulers and [h5py](https://www.h5py.org) package to enable caching, as explained above. Both 
 can be installed via the [Python package manager](https://pypi.org/project/pysqa/):
 ```
-pip install executorlib[submission]
+pip install executorlib[cluster]
 ```
 Or alternatively using the [conda package manager](https://anaconda.org/conda-forge/pysqa):
 ```
@@ -67,8 +67,8 @@ dependencies, still at least for [SLURM](https://slurm.schedmd.com) no additiona
 documentation covers the [installation of pysqa](https://pysqa.readthedocs.io/en/latest/installation.html) in more 
 detail.
 
-## HPC Allocation Mode
-For optimal performance in [HPC Allocation Mode](https://executorlib.readthedocs.io/en/latest/3-hpc-allocation.html) the
+## HPC Job Executor
+For optimal performance in [HPC Allocation Mode](https://executorlib.readthedocs.io/en/latest/3-hpc-job.html) the
 [flux framework](https://flux-framework.org) is recommended as job scheduler. Even when the [Simple Linux Utility for Resource Management (SLURM)](https://slurm.schedmd.com) 
 or any other job scheduler is already installed on the HPC cluster. [flux framework](https://flux-framework.org) can be
 installed as a secondary job scheduler to leverage [flux framework](https://flux-framework.org) for the distribution of

docs/trouble_shooting.md

@@ -20,8 +20,8 @@ dependency. The installation of this and other optional dependencies is covered
 
 ## Missing Dependencies
 The default installation of executorlib only comes with a limited number of dependencies, especially the [zero message queue](https://zeromq.org)
-and [cloudpickle](https://github.com/cloudpipe/cloudpickle). Additional features like [caching](https://executorlib.readthedocs.io/en/latest/installation.html#caching), [HPC submission mode](https://executorlib.readthedocs.io/en/latest/installation.html#hpc-submission-mode) 
-and [HPC allocation mode](https://executorlib.readthedocs.io/en/latest/installation.html#hpc-allocation-mode) require additional dependencies. The dependencies are explained in more detail in the 
+and [cloudpickle](https://github.com/cloudpipe/cloudpickle). Additional features like [caching](https://executorlib.readthedocs.io/en/latest/installation.html#caching), [HPC submission mode](https://executorlib.readthedocs.io/en/latest/installation.html#hpc-cluster-executor) 
+and [HPC allocation mode](https://executorlib.readthedocs.io/en/latest/installation.html#hpc-job-executor) require additional dependencies. The dependencies are explained in more detail in the 
 [installation section](https://executorlib.readthedocs.io/en/latest/installation.html#).
 
 ## Python Version 
@@ -38,7 +38,7 @@ The resource dictionary parameter `resource_dict` can contain one or more of the
 * `openmpi_oversubscribe` (bool): adds the `--oversubscribe` command line flag (OpenMPI and SLURM only) - default False
 * `slurm_cmd_args` (list): Additional command line arguments for the srun call (SLURM only)
 
-For the special case of the [HPC allocation mode](https://executorlib.readthedocs.io/en/latest/3-hpc-allocation.html) 
+For the special case of the [HPC Job Executor](https://executorlib.readthedocs.io/en/latest/3-hpc-job.html) 
 the resource dictionary parameter `resource_dict` can also include additional parameters define in the submission script
 of the [Python simple queuing system adatper (pysqa)](https://pysqa.readthedocs.io) these include but are not limited to: 
 * `run_time_max` (int): the maximum time the execution of the submitted Python function is allowed to take in seconds.