# parallel-util

Simple implementation of `parallel_for` and `parallel_map` using C++11.

This library is based on multi-threading on CPU (`std::thread`) and the default concurrency is set to the hardware concurrency (`std::thread::hardware_concurrency()`).

## Usage of `parallel_for`

Suppose that you have a callable function that can be stored by an instance of `std::function<void(int)>`, for example, defined by C++11 lambda expression:
```
auto process = [](int i) { ... };
```
and want to parallelize the following for-loop procedure:
```
for (int i = 0; i < n; ++ i) { process(i); }
```
By using parallel-util, this can be easily parallelized by
```
parallelutil::parallel_for(n, process);
```

## Usage of `parallel_map`

Suppose that you have a callable function that takes an instance of `T1` as input and returns an instance of `T2` as output, and thus can be stored by an instance of `std::function<T2(T1)>`. For example,
```
auto square = [](double x) { return x * x; };
```
In this case, `T1` = `T2` = `double`. Also suppose that you have an array of `T1` and want to obtain an array of `T2` by applying the function to each array element. For example, you have an array:
```
std::vector<double> input_array = { 0.2, 0.9, - 0.4, 0.5, 0.3 };
```
and want to their squares. By using parallel-util, this can be easily parallelized by
```
auto output_array = parallelutil::parallel_map(input_array, square);
```
where `output_array` is an array: `{ 0.04, 0.81, 0.16, 0.25, 0.09 }`.

If you are using C++17 Parallel STL, `std::transform` has similar functionality.

## Installation

`parallel-util` is a header-only, single-file library. It can be used by just copying `parallel-util.hpp` and pasting it into your project.

Alternatively, it can be installed using `cmake`. If your project is also managed using `cmake`, `ExternalProject` or `add_subdirectory` commands are useful for including `parallel-util` to your project.

If you want to install `parallel-util` to your system, use the typical `cmake` cycle:
```
git clone https://github.com/yuki-koyama/parallel-util.git
mkdir build
cd build
cmake ../parallel-util
make install
```

## Dependencies

- C++ Standard Library; Thread support library (require `-pthread`)

## Persuing Further Performance

Please consider to use other complex libraries such as Intel(R) Threading Building Blocks.

## Projects using parallel-util

- Unblending <https://github.com/yuki-koyama/unblending>
- OptiMo <https://github.com/yuki-koyama/optimo>
- Sequential Line Search <https://github.com/yuki-koyama/sequential-line-search>
- SelPh <https://github.com/yuki-koyama/selph>

## LICENSING

MIT License.