odeint thrust slows down massively when using nested zip_iterators - thrust

Question

I am building an analysis tool on top of odeint and thrust. The tool solves a large number of initial condition problems. I have had success following the odeint and thrust tutorials / demos. Up until now, the systems I have been working with have had less than 5 state variables, but now I need to extend the system to be capable of handling more.
As mentioned in the tutorial, there is a small problem that thrust's tuples can only have up to 10 items. This problem can be solved by using nested zip_iterators.
Quoting from near the bottom of one of the tutorials:
"a small difficulty that Thrust's tuples have a maximal arity of 10. But this is only a small problem since we can create a zip iterator packed with zip iterators. So the top level zip iterator contains one zip iterator for the state, one normal iterator for the parameter, and one zip iterator for the derivative."
I have implemented this solution, and it works, but unfortunately with a massive loss in speed. For the same system (a two-variable system, simultaneously solving 8192 initial conditions), the original, simple but not-extensible to more than 5 variables solution runs in just over a second:
real 0m1.244s
user 0m0.798s
sys 0m0.356s
whereas the more complex, but extensible nested solution takes ~2000 times longer!
real 4m3.613s
user 2m15.124s
sys 1m47.363s
The only difference between the two programs is
inside the functor's operator(), where I refer to the state variables and derivatives, and
inside the functor's constructor, specifically the for_each command, where I create the zip_iterators and tuples.
Below I have included excerpts from these sections, for each program. I hope I am doing something wrong here, because this kind of speed loss is devastating! Any help would be much appreciated.
Excerpts for "SIMPLE" code (non-nested-iterators)
//////////////////////////////////////////////////////////
//// Inside ICFunctor's operator()
// getting the state variable
value_type X = thrust::get< 0 >( t );
// setting the derivative
thrust::get< 2 >( t ) = 0.5*A - 1.5*X;
//////////////////////////////////////////////////////////
//// the for_each statement that creates the zip_iterator
thrust::for_each(
//// START INDICES
thrust::make_zip_iterator( thrust::make_tuple(
// State-variables
boost::begin( x ) + 0*m_N,
boost::begin( x ) + 1*m_N,
// Derivatives
boost::begin( dxdt ) + 0*m_N,
boost::begin( dxdt ) + 1*m_N)) ,
//// END INDICES
thrust::make_zip_iterator( thrust::make_tuple(
// State-variables
boost::begin( x ) + 1*m_N,
boost::begin( x ) + 2*m_N,
// Derivatives
boost::begin( dxdt ) + 1*m_N,
boost::begin( dxdt ) + 2*m_N)) ,
ICFunctor() );
Excerpts for "EXTENSIBLE" code (nested-iterators)
//////////////////////////////////////////////////////////
//// Inside ICFunctor's operator()
// getting the state variable
const int STATE_VARIABLES = 0; // defined as a global constant
value_type X = thrust::get<0>(thrust::get<STATE_VARIABLES>( t ));
// setting the derivative
const int DERIVATIVES = 1; // defined as a global constant
thrust::get<0>(thrust::get<DERIVATIVES>( t )) = 0.5*A - 1.5*X;
//////////////////////////////////////////////////////////
//// the for_each statement that creates the zip_iterator
thrust::for_each(
//// START INDICES
thrust::make_zip_iterator( thrust::make_tuple(
// State variables
thrust::make_zip_iterator( thrust::make_tuple(
boost::begin( x ) + 0*m_N,
boost::begin( x ) + 1*m_N)),
// Derivatives
thrust::make_zip_iterator( thrust::make_tuple(
boost::begin( dxdt ) + 0*m_N,
boost::begin( dxdt ) + 1*m_N))
)),
//// END INDICES
thrust::make_zip_iterator( thrust::make_tuple(
// State variables
thrust::make_zip_iterator( thrust::make_tuple(
boost::begin( x ) + 1*m_N,
boost::begin( x ) + 2*m_N)),
// Derivatives
thrust::make_zip_iterator( thrust::make_tuple(
boost::begin( dxdt ) + 1*m_N,
boost::begin( dxdt ) + 2*m_N))
)),
ICFunctor() );