// To create function that does part of the job, create class that inherits

// this one, reimplements operator() and does part of the job based on

// thread_id_ and num_threads_

// Note: example implementations are in thread/kaldi-thread-test.cc

public:

virtual void operator() () = 0;

// Does the main function of the class

// Subclasses have to redefine this

virtual ~MultiThreadable();

// Optional destructor. Note: the destructor

// the object passed by the user will also be called, so

// watch out.

static void *run(void *m_in) {

MultiThreadable *m = static_cast<MultiThreadable*>(m_in);

(*m)(); // call operator () on it. This is a virtual

// function so the one in the child class will be called.

return NULL;

}

public:

// Do not redeclare thread_id_ and num_threads_ in derived classes.

int32 thread_id_; // 0 <= thread_id_ < num_threads_

int32 num_threads_;

private:

// Have additional member variables as needed.

public:

ExampleClass(int32 *foo); // Typically there will be an initializer that

// takes arguments.

ExampleClass(const ExampleClass &other); // A copy constructor is also needed;

// some example classes use the default version of this.

void operator() () {

// Does the main function of the class. This

// function will typically want to look at the values of the

// member variables thread_id_ and num_threads_, inherited

// from MultiThreadable.

}

~ExampleClass() {

// Optional destructor. Sometimes useful things happen here,

// for example summing up of certain quantities. See code

// that uses RunMultiThreaded for examples.

}

private:

// Have additional member variables as needed.

public:

MultiThreader(int32 num_threads,

const C &c_in):

threads_(new pthread_t[std::max<int32>(1, num_threads)]),

cvec_(std::max<int32>(1, num_threads), c_in) {

if (num_threads == 0) {

// This is a special case with num_threads == 0, which behaves like with

// num_threads == 1 but without creating extra threads. This can be

// useful in GPU computations where threads cannot be used.

KALDI_PTHREAD_PTR(threads_[0]) = 0;

cvec_[0].thread_id_ = 0;

cvec_[0].num_threads_ = 1;

(cvec_[0])();

} else {

pthread_attr_t pthread_attr;

pthread_attr_init(&pthread_attr);

for (int32 thread = 0; thread < num_threads; thread++) {

cvec_[thread].thread_id_ = thread;

cvec_[thread].num_threads_ = num_threads;

int32 ret;

if ((ret=pthread_create(&(threads_[thread]),

&pthread_attr, C::run, &(cvec_[thread])))) {

const char *c = strerror(ret);

if (c == NULL) { c = "[NULL]"; }

KALDI_ERR << "Error creating thread, errno was: " << c;

}

}

}

}

~MultiThreader() {

for (size_t thread = 0; thread < cvec_.size(); thread++)

if (KALDI_PTHREAD_PTR(threads_[thread]) != 0)

if (pthread_join(threads_[thread], NULL))

KALDI_ERR << "Error rejoining thread.";

delete [] threads_;

}

private:

pthread_t *threads_;

std::vector<C> cvec_;