Intel Threading Building Blocks

Automata: Implementation

Automata are implemented as a mixture of managed and unmanaged C++. The user interface is entirely in managed code, with the calculation engine being a mixture of both.

The abstract class Evolution (Example 11-16) serves as a base class for the two implementations, SequentialEvolution (Example 11-17) and ParallelEvolution (Example 11-18). The actual generational calculations are performed by iterative calls to the Cell class, found in Cell.h and Cell.cpp.

The sequential calculation loop can be found in SequentialEvolution::Step(), shown in Example 11-13.

Example 11-13. Automaton: SequentialEvolution step

// SequentialEvolution::Step() - overrideof step method
void SequentialEvolution::Step()
{
  Cell cell;

  for (int i=0; i<m_size; i++) {
    *(m_dest+i) = cell.CalculateState(
                      m_matrix->data,   // pointer to source data block
                      m_matrix->width,  // logical width of field
                      m_matrix->height, // logical height of field
                      i                 // number of cell position to examine
                      );
  }
}

This loop calls cell.CalculateState() for each cell in the source grid, and puts the resultant state in the same cell location in the destination grid. The corresponding parallel calculation can be found in ParallelEvolution::Step(), as shown in Example 11-14.

Example 11-14. Automaton: ParallelEvolution step

// // ParallelEvolution::Step() - override of Step method // void ParallelEvolution::Step() { size_t begin = 0; // beginning cell position size_t end = m_size-1; // ending cell position size_t grainSize = 4000; // ...