//! Pack/Unpack selected RNGs. This Pack/Unpack method (re-)creates the full RNG //! stack since it needs to (re-)bind function pointers on different processing //! elements. Therefore we circumvent Charm's usual pack/unpack for this type, //! and thus sizing does not make sense: sizing is a no-op. We could initialize //! the stack in RNGTestDriver's constructor and let this function re-create the //! stack only when unpacking, but that leads to repeating the same code twice: //! once in RNGTestDriver's constructor, once here. Another option is to use //! this pack/unpack routine to both initially create (when packing) and to //! re-create (when unpacking) the stack, which eliminates the need for //! pre-creating the object in RNGTestDriver's constructor and therefore //! eliminates the repeated code. This explains the guard for sizing: the code //! below is called for packing only (in serial) and packing and unpacking (in //! parallel). inline void operator|( PUP::er& p, std::map< tk::ctr::RawRNGType, tk::RNG >& rng ) { if (!p.isSizing()) { tk::RNGStack stack( #ifdef HAS_MKL g_inputdeck.get< tag::param, tag::rngmkl >(), #endif g_inputdeck.get< tag::param, tag::rngsse >() ); rng = stack.selected( g_inputdeck.get< tag::selected, tag::rng >() ); } }
//! Pack/Unpack test runner. This Pack/Unpack method (re-)creates the //! test runner singleton on all processing elements. Therefore we circumvent //! Charm's usual pack/unpack for this type, and thus sizing does not make //! sense: sizing is a no-op. We could initialize the stack in UnitTestDriver's //! constructor and let this function re-create the runner only when unpacking, //! but that leads to repeating the same code twice: once in UnitTestDriver's //! constructor, once here. Another option is to use this pack/unpack routine to //! both initially create (when packing) and to re-create (when unpacking) the //! runner, which eliminates the need for pre-creating the object in //! UnitTestDriver's constructor and therefore eliminates the repeated code. //! This explains the guard for sizing: the code below is called for packing //! only (in serial) and packing and unpacking (in parallel). inline void operator|( PUP::er& p, tut::test_runner_singleton& runner ) { if (!p.isSizing()) runner = tut::test_runner_singleton(); }
//! Pack/Unpack selected partial differential equations. This Pack/Unpack method //! (re-)creates the PDE factory since it needs to (re-)bind function //! pointers on different processing elements. Therefore we circumvent Charm's //! usual pack/unpack for this type, and thus sizing does not make sense: sizing //! is a no-op. We could initialize the factory in InciterDriver's constructor //! and let this function re-create the stack only when unpacking, but that //! leads to repeating the same code twice: once in InciterDriver's constructor, //! once here. Another option is to use this pack/unpack routine to both //! initially create (when packing) and to re-create (when unpacking) the //! factory, which eliminates the need for pre-creating the object in //! InciterDriver's constructor and therefore eliminates the repeated code. This //! explains the guard for sizing: the code below is called for packing only (in //! serial) and packing and unpacking (in parallel). inline void operator|( PUP::er& p, std::vector< PDE >& eqs ) { if (!p.isSizing()) eqs = PDEStack().selected(); }
//! Pack/Unpack test stack. This Pack/Unpack method (re-)creates the full test //! stack since it needs to (re-)bind function pointers on different processing //! elements. Therefore we circumvent Charm's usual pack/unpack for this type, //! and thus sizing does not make sense: sizing is a no-op. We could initialize //! the stack in RNGTestDriver's constructor and let this function re-create the //! stack only when unpacking, but that leads to repeating the same code twice: //! once in RNGTestDriver's constructor, once here. Another option is to use //! this pack/unpack routine to both initially create (when packing) and to //! re-create (when unpacking) the stack, which eliminates the need for //! pre-creating the object in RNGTestDriver's constructor and therefore //! eliminates the repeated code. This explains the guard for sizing: the code //! below is called for packing only (in serial) and packing and unpacking (in //! parallel). inline void operator|( PUP::er& p, TestStack& stack ) { if (!p.isSizing()) stack = TestStack(); }