GNU Parallel is a tool for executing shell jobs in parallel using one or more computers. Jobs can consist of single commands or of scripts and they are executed on lists of files, hosts, users or other items.

This package provides a library for parallel programming.

This package provides utility functions that enhance the parallel package and support the built-in parallel backends of the future package. For example, availableCores gives the number of CPU cores available to your R process as given by R options and environment variables, including those set by job schedulers on high-performance compute clusters. If none is set, it will fall back to parallel::detectCores. Another example is makeClusterPSOCK, which is backward compatible with parallel::makePSOCKcluster while doing a better job in setting up remote cluster workers without the need for configuring the firewall to do port-forwarding to your local computer.

Xyce is a SPICE-compatible, high-performance analog circuit simulator, capable of solving extremely large circuit problems by supporting large-scale parallel computing platforms. It also supports serial execution.

Parallel allows you to run any code in parallel Processes (to use all CPUs) or Threads(to speedup blocking operations). It is best suited for map-reduce or e.g. parallel downloads/uploads.

This package provides a unified parallelization framework for multiple backends. This package is designed for internal package and interactive usage. The main operation is parallel mapping over lists. It supports local, multicore, mpi and BatchJobs mode. It allows tagging of the parallel operation with a level name that can be later selected by the user to switch on parallel execution for exactly this operation.

Application of the Partitioning-Around-Medoids (PAM) clustering algorithm described in Schubert, E. and Rousseeuw, P.J.: "Fast and eager k-medoids clustering: O(k) runtime improvement of the PAM, CLARA, and CLARANS algorithms." Information Systems, vol. 101, p. 101804, (2021). <doi:10.1016/j.is.2021.101804>. It uses a binary format for storing and retrieval of matrices developed for the jmatrix package but the functionality of jmatrix is included here, so you do not need to install it. Also, it is used by package scellpam', so if you have installed it, you do not need to install this package. PAM can be applied to sets of data whose dissimilarity matrix can be very big. It has been tested with up to 100.000 points. It does this with the help of the code developed for other package, jmatrix', which allows the matrix not to be loaded in R memory (which would force it to be of double type) but it gets from disk, which allows using float (or even smaller data types). Moreover, the dissimilarity matrix is calculated in parallel if the computer has several cores so it can open many threads. The initial part of the PAM algorithm can be done with the BUILD or LAB algorithms; the BUILD algorithm has been implemented in parallel. The optimization phase implements the FastPAM1 algorithm, also in parallel. Finally, calculation of silhouette is available and also implemented in parallel.

Create a parallel coordinates plot, using `htmlwidgets` package and `d3.js`.

This package provides a fast parallelized alternative to R's native dist function to calculate distance matrices for continuous, binary, and multi-dimensional input matrices, which supports a broad variety of predefined distance functions from other R packages, as well as user- defined functions written in C++. For ease of use, the parDist function extends the signature of the dist function and uses the same parameter naming conventions as distance methods of existing R packages.

This package provides two functions: Group_function() and Parallel_Tree(). Group_function() applies a given function (e.g., mean()) to input variable(s) by group across levels of a multilevel data structure, with additional data management options. Parallel_Tree() uses ggplot2 to create parallel coordinate plots (technically a facsimile of parallel coordinate plots in a Cartesian coordinate system). Used in combination, these functions can create parallel tree plots, a variant of parallel coordinate plots useful for visualizing multilevel data.

Parallel Python module (PP) provides an easy and efficient way to create parallel-enabled applications for SMP computers and clusters. PP module features cross-platform portability and dynamic load balancing. Thus applications written with PP will parallelize efficiently even on heterogeneous and multi-platform clusters (including clusters running other applications with variable CPU loads).

Support for parallel computation with progress bar, and option to stop or proceed on errors. Also provides logging to console and disk, and the logging persists in the parallel threads. Additional functions support function call automation with delayed execution (e.g. for executing functions in parallel).

This package provides a parallel environment which allows two potentially different texts to be typeset in two columns, while maintaining alignment. The two columns may be on the same page, or on facing pages. This arrangement of text is commonly used when typesetting translations, but it can have value when comparing any two texts.

parallel-hashmap provides a family of header-only, very fast and memory-friendly hashmap and btree containers for C++11 and above.

It has the following characteristics:

• Drop-in replacement for std::unordered_map, std::unordered_set, std::map, and std::set with better performance.

• Requires C++11 compiler support and provides C++14 and C++17 APIs, including features like try_emplace.

• Highly efficent and faster than standard unordered containers, Boost implementations, or sparsepp alternatives.

• Memory-friendly: maintains low memory usage with a slight increase compared to sparsepp.

• Heterogeneous lookup support.

• Dump/load feature: for flat hash maps storing std::trivially_copyable data, the entire table can be dumped to disk and restored as a single array efficiently without hash computations. This is about 10 times faster than element-wise serialization but uses 10% to 60% extra disk space.

• Automatic support for boost::hash_value() and default hash functions for std::pair and std::tuple.

Run an array of functions in parallel

Run an array of functions in parallel

Simulation from an mrgsolve <https://cran.r-project.org/package=mrgsolve> model using a parallel backend. Input data sets are split (chunked) and simulated in parallel using mclapply() or future_lapply() <https://cran.r-project.org/package=future.apply>.

This package defines classes of monads that can perform multiple executions in parallel and combine their results. For any monad that's an instance of the class, the package re-implements a subset of the Control.Monad interface, but with parallel execution.

This package can speed up Test::Unit, RSpec, Cucumber, and Spinach tests by running them concurrently across multiple CPU cores.

The doctest program checks examples in source code comments. It is modeled after doctest for Python (<https://docs.python.org/3/library/doctest.html>). . Documentation is at <https://github.com/martijnbastiaan/doctest-parallel#readme>.

The h5py package provides both a high- and low-level interface to the HDF5 library from Python. The low-level interface is intended to be a complete wrapping of the HDF5 API, while the high-level component supports access to HDF5 files, datasets and groups using established Python and NumPy concepts.

HDF5 is a suite that makes possible the management of extremely large and complex data collections.

See Miroshnikov and Conlon (2014) <doi:10.1371/journal.pone.0108425>. Recent Bayesian Markov chain Monto Carlo (MCMC) methods have been developed for big data sets that are too large to be analyzed using traditional statistical methods. These methods partition the data into non-overlapping subsets, and perform parallel independent Bayesian MCMC analyses on the data subsets, creating independent subposterior samples for each data subset. These independent subposterior samples are combined through four functions in this package, including averaging across subset samples, weighted averaging across subsets samples, and kernel smoothing across subset samples. The four functions assume the user has previously run the Bayesian analysis and has produced the independent subposterior samples outside of the package; the functions use as input the array of subposterior samples. The methods have been demonstrated to be useful for Bayesian MCMC models including Bayesian logistic regression, Bayesian Gaussian mixture models and Bayesian hierarchical Poisson-Gamma models. The methods are appropriate for Bayesian hierarchical models with hyperparameters, as long as data values in a single level of the hierarchy are not split into subsets.