# Multiprocessing in standalone mode

**URL:** <https://brian.discourse.group/t/multiprocessing-in-standalone-mode/142>\
**Category:** Support\
**Created:** [13 September 2020 13:11 UTC](https://brian.discourse.group/t/multiprocessing-in-standalone-mode/142 "2020-09-13T13:11:32Z")\
**Posts on this page:** 1\
**Showing post:** 2

<div class="post-metadata">

**Author:** ![denisalevi](https://yyz2.discourse-cdn.com/free1/user_avatar/brian.discourse.group/denisalevi/32/24_2.png) [@denisalevi](https://brian.discourse.group/u/denisalevi)\
**Post date:** [13 September 2020 21:18 UTC](https://brian.discourse.group/t/multiprocessing-in-standalone-mode/142/2 "2020-09-13T21:18:11Z")

</div>

There are a few problems in your code:

1. You need to move the `set_device` line into your run function. This line initialises the C++ Standalone Device that keeps track of wether your network has been build or run before. As it is right now, all processes work on the same C++ Standalone Device in parallel. The second process that tries to build the network throws your error as the first process already started running it (but hasn’t reached the `device.reinit()` line yet). By moving the `set_device` line into your parallelised function, you create one C++ Standalone Device per process.
2. You don’t need the `build_on_run=False` and `device.build` calls since you have only one `run` call in your simulations.
3. You are calling `device.reinit()` before you access the monitor values and by that resetting them before you use them. This will give you a `NotImplementedError`, saying that you can’t access variables in standalone mode before the network has been run. To fix that, first store the monitor values, then reinit the device. You still need to reinit the device if you are running multiple simulations per process (you have 10 tau values and `num_proc = 4`).

Here is a corrected version of your parallelised function:

```python
def run_sim(tau):

    set_device('cpp_standalone', directory=None)
    pid = os.getpid()
    print(f'RUNNING {pid}')

    G = NeuronGroup(1, 'dv/dt = -v/tau : 1', method='euler')
    G.v = 1

    mon = StateMonitor(G, 'v', record=0)
    net = Network()
    net.add(G, mon)
    net.run(100 * ms)

    res = (mon.t/ms, mon.v[0])
    device.reinit()

    print(f'FINISHED {pid}')
    return res

```

And just as a hint: If you haven’t come across it yet, there is also an option to run a single Brian2 simulation on multiple threads using OpenMP. The speedup you get is not linear in the number of threads you use (using 2 threads does not necessarily half the runtime since not all the aspects of spiking neural network simulations can be parallelised). So when you want to run many simulations with different parameters (as in your example), it is more efficient to use each of your available threads for one Brian2 simulation as you have done here. But if you just want to speed up a single simulation, check out Brian’s MPI option: [https://brian2.readthedocs.io/en/2.4/user/computation.html#multi-threading-with-openmp](https://brian2.readthedocs.io/en/2.4/user/computation.html#multi-threading-with-openmp)

---

_[View the full topic](https://brian.discourse.group/t/multiprocessing-in-standalone-mode/142)._