MultiThreadOperations.h

Go to the documentation of this file.

// -*- c-basic-offset: 4 -*-
#ifndef _MULTITHREADOPERATIONS_H
#define _MULTITHREADOPERATIONS_H

#include <hugin_shared.h>
#include <hugin_utils/utils.h>

#include <vigra/windows.h>
#include <boost/thread.hpp>
#include <boost/bind.hpp>

#include <vigra/utilities.hxx>

namespace vigra_ext
{

class IMPEX ThreadManager
{

public:
    ThreadManager()
    {
        m_nThreads = 1;
    }

        virtual ~ThreadManager()
        {}

    static ThreadManager & get()
    {
        if (!m_instance) {
            m_instance = new ThreadManager();
        } 
        return *m_instance;
    }

    unsigned getNThreads() {
        return m_nThreads;
    }

    void setNThreads(unsigned n)
    {
        m_nThreads = n;
    }
private:
    unsigned m_nThreads;
    static ThreadManager * m_instance;
};

template <class SrcIter, class SrcAcc, class DestIter, class DestAcc, class Function>
void multithreadOperation (vigra::triple<SrcIter, SrcIter, SrcAcc> src,
                           vigra::pair<DestIter, DestAcc> dest,
                           Function op)
{
    // divide output image into multiple areas
    unsigned nThreads = ThreadManager::get().getNThreads();

    vigra::Diff2D srcSize = src.second - src.first;
    // limit amount of threads if only a few lines are given.
    if (srcSize.y < (int) nThreads) {
        nThreads = srcSize.y;
    }

    // just our thread
    if (nThreads == 1)
    {
        op(src,dest);
    }

    DEBUG_DEBUG("creating " << nThreads << " threads for transform");

    unsigned int chunkSize = srcSize.y / nThreads;
//    unsigned int lastChunkSize = srcSize.y - (nThreads-1) * chunkSize;

    // create threads to remap each area
    boost::thread_group threads;

    vigra::triple<SrcIter, SrcIter, SrcAcc> srcCurr(src);
    vigra::pair<DestIter, DestAcc> destCurr(dest);

    srcCurr.second.y -= srcSize.y - chunkSize;

    unsigned int i;
    for (i = 0; i < nThreads-1; ++i) {
        DEBUG_DEBUG("Starting thread " << i);
        threads.create_thread(boost::bind(op, srcCurr, destCurr));

        srcCurr.first.y += chunkSize;
        srcCurr.second.y += chunkSize;
        destCurr.first.y += chunkSize;
    }
    // last chunk
    srcCurr.second = src.second;
    // remap last chunk in current thread.
    op(src,dest);

    DEBUG_DEBUG("Waiting for threads to join");
    threads.join_all();
    DEBUG_DEBUG("Threads joined");
}


} // namespace

#endif // _MULTITHREADOPERATIONS_H

---