Prev Next a11c_bthread.cpp

@(@\newcommand{\W}[1]{ \; #1 \; } \newcommand{\R}[1]{ {\rm #1} } \newcommand{\B}[1]{ {\bf #1} } \newcommand{\D}[2]{ \frac{\partial #1}{\partial #2} } \newcommand{\DD}[3]{ \frac{\partial^2 #1}{\partial #2 \partial #3} } \newcommand{\Dpow}[2]{ \frac{\partial^{#1}}{\partial {#2}^{#1}} } \newcommand{\dpow}[2]{ \frac{ {\rm d}^{#1}}{{\rm d}\, {#2}^{#1}} }@)@
A Simple Boost Thread Example and Test

Purpose
This example just demonstrates Boost threads and does not use CppAD at all.

Source Code

# include <boost/thread.hpp>
# include <limits>
# include <cmath>
# include <cassert>
# define NUMBER_THREADS 4

namespace { // Begin empty namespace
     class worker_t
     {
     private:
          int    n_;
          float* a_;
          float* b_;
     public:
          void setup(size_t n, float* a, float* b)
          {     n_ = static_cast<int>(n);
               a_ = a;
               b_ = b;
          }
          // Beginning of Example A.1.1.1c of OpenMP 2.5 standard document
          void a1(int n, float *a, float *b)
          {     int i;
               // for some reason this function is missing on some systems
               // assert( bthread_is_multithreaded_np() > 0 );
               for(i = 1; i < n; i++)
                    b[i] = (a[i] + a[i-1]) / 2.0f;
               return;
          }
          // End of Example A.1.1.1c of OpenMP 2.5 standard document
          void operator()()
          {     a1(n_, a_, b_); }
     };
}

bool a11c(void)
{     bool ok = true;

     // Test setup
     size_t i, j, n_total = 10;
     float *a = new float[n_total];
     float *b = new float[n_total];
     for(i = 0; i < n_total; i++)
          a[i] = float(i);

     // number of threads
     size_t number_threads = NUMBER_THREADS;

     // set of workers
     worker_t worker[NUMBER_THREADS];
     // threads for each worker
     boost::thread* bthread[NUMBER_THREADS];

     // Break the work up into sub work for each thread
     size_t  n     = n_total / number_threads;
     size_t  n_tmp = n;
     float*  a_tmp = a;
     float*  b_tmp = b;
     worker[0].setup(n_tmp, a_tmp, b_tmp);
     for(j = 1; j < number_threads; j++)
     {     n_tmp = n + 1;
          a_tmp = a_tmp + n - 1;
          b_tmp = b_tmp + n - 1;
          if( j == (number_threads - 1) )
               n_tmp = n_total - j * n + 1;

          worker[j].setup(n_tmp, a_tmp, b_tmp);

          // create this thread
          bthread[j] = new boost::thread(worker[j]);
     }

     // do this threads protion of the work
     worker[0]();

     // wait for other threads to finish
     for(j = 1; j < number_threads; j++)
     {     bthread[j]->join();
          delete bthread[j];
     }

     // check the result
     float eps = 100.f * std::numeric_limits<float>::epsilon();
     for(i = 1; i < n ; i++)
          ok &= std::fabs( (2. * b[i] - a[i] - a[i-1]) / b[i] ) <= eps;

     delete [] a;
     delete [] b;

     return ok;
}

Input File: example/multi_thread/bthread/a11c_bthread.cpp