Multiprocessing JSBSim with Python

[sr71684]

When attempting to pass an FGFDMExec instance into a python processing pool, JSBSim returns the following error:

  File "stringsource", line 2, in jsbsim.FGFDMExec.__reduce_cython__
TypeError: no default __reduce__ due to non-trivial __cinit__

This happens because FGFDMExec can't be trivially pickled.

Does there exist a way to pickle FGFDMExec such that the above error is avoided?

Minimum working example:

import os
from multiprocessing import Pool

import jsbsim


def make_fdm():
    fdm = jsbsim.FGFDMExec(root_dir=os.path.abspath('/home/jsbsim'))
    fdm.set_debug_level(0)
    time_step = 0
    fdm.load_model("c172p")
    fdm.set_dt(1.0 / 6.0)
    return fdm


def run(fdm):
    # do fdm stuff here
    return fdm

if __name__ == "__main__":
    n_sims = 10
    n_threads = 4
    envs = [make_fdm() for id in range(n_sims)]

    p = Pool(n_threads)
    results = p.map(run, envs)

Environment

• OS: Ubuntu 20.04 LTS
• JSBSim version: v1.1.10
• Language: Python

[bcoconni]

Hi @sr71684,

Indeed Cython extension types can't be pickled when they contain the __cinit__ method.

So your best course of action is to create a new Python class that inherits from FGFDMExec and that implements the __reduce__ method:

class PickleFDMExec(jsbsim.FGFDMExec):
  def load_model(self, model_name):
    self.model_name = model_name  # Store a copy of the model name
    jsbsim.FGFDMExec.load_model(self, model_name)
  def __reduce__(self):
    return rebuild, (self.get_root_dir(), self.model_name, self.get_delta_t())

# Tells pickle how to rebuild the FDM from the reduced data.
def rebuild(root_dir, model_name, dt):
  fdm = jsbsim.FGFDMExec(root=root_dir)
  fdm.load_model(model_name)
  fdm.set_dt(dt)
  return fdm

[seanmcleod]

Great. Out of interest what are you doing with the multiple JSBSim instances in the thread pool? Is this for some sort of reinforcement learning?

Just an fyi, in terms of multiple instances of JSBSim running in a thread pool you can thank @bcoconni for enabling that a while back by modifying some code in JSBSim that used to maintain some static variable(s) which would cause havoc/crashes when used by multiple threads.

[bcoconni]

I've never done any pickling myself, so I'm sort of trying to make educated guesses.

So it looks like it's not seeing the implemented __reduce__ method you added to the wrapper class PickleFDMExec, maybe the following:

def rebuild(root_dir, model_name, dt):
    fdm = jsbsim.FGFDMExec(root_dir)

Should be changed to return the wrapper class object?

def rebuild(root_dir, model_name, dt):
    fdm = PickleFDMExec(root_dir)

Good to know. This requirement to return a PickleFDMExec instance seems to be specific to the multiprocessing library because the following test is working on my platform:

import jsbsim
import pickle

class PickleFGFDMExec(jsbsim.FGFDMExec):
     def load_model(self, model_name):
         self.model_name = model_name
         jsbsim.FGFDMExec.load_model(self, model_name)
     def __reduce__(self):
         return rebuild, (self.get_root_dir(), self.model_name, self.get_delta_t())

def rebuild(root_dir, model_name, dt):
     fdm = jsbsim.FGFDMExec(root_dir)
     fdm.load_model(model_name)
     fdm.set_dt(dt)
     return fdm

fdm = PickleFGFDMExec(None)  # Only works on JSBSim v1.1.10 and higher
fdm.load_model("c172p")

with open('fdm.pickle', 'wb') as f:
    pickle.dump(fdm, f, pickle.HIGHEST_PROTOCOL)

with open('fdm.pickle', 'rb') as f:
    fdm2 = pickle.load(f)

fdm2.run_ic()

Note that rebuild is returning an FGFDMExec instance instead of a PickleFGFDMExec instance.

[sinizu]

Great. Out of interest what are you doing with the multiple JSBSim instances in the thread pool? Is this for some sort of reinforcement learning?

Just an fyi, in terms of multiple instances of JSBSim running in a thread pool you can thank @bcoconni for enabling that a while back by modifying some code in JSBSim that used to maintain some static variable(s) which would cause havoc/crashes when used by multiple threads.

Yes, I use multiple processes to speed up the interaction of agents with the environment.

[seanmcleod]

@bcoconni so type(fdm) == PickleFGFDMExec but type(fdm2) == FGFDMExec right?

So if you now tried to pickle fdm2 via pickle.dump() I'm guessing you'll run into the issue @sinizu was seeing with multiprocessing. My guess is multiprocessing is trying re-prickle instances at some point.

[bcoconni]

@bcoconni so type(fdm) == PickleFGFDMExec but type(fdm2) == FGFDMExec right?

Correct.

So if you now tried to pickle fdm2 via pickle.dump() I'm guessing you'll run into the issue @sinizu was seeing with multiprocessing.

Correct.

My guess is multiprocessing is trying re-prickle instances at some point.

Most likely yes. There are a number of places in the docs of multiprocessing that require that objects must be "picklable". I was not expecting that unpickled objects could need to be re-pickled afterward so my test case was not representative of @sinizu's request.

[bcoconni]

This topic has been moved to JSBSim Discussions as per the issue template statement: Issues that are neither bug reports or feature requests will be transferred to [Discussions](https://github.com/JSBSim-Team/jsbsim/discussions) by the team and the issue will be locked and closed..

Support for this topic will therefore continue within this discussion. Thanks for your understanding.