UT/UT_ThreadedAlgorithm.h

Go to the documentation of this file.

/*
 * PROPRIETARY INFORMATION.  This software is proprietary to
 * Side Effects Software Inc., and is not to be reproduced,
 * transmitted, or disclosed in any way without written permission.
 *
 * Produced by:
 *      Jeff Lait
 *      Side Effects Software Inc
 *      123 Front Street West, Suite 1401
 *      Toronto, Ontario
 *      Canada   M5J 2M2
 *      416-504-9876
 *
 * NAME:        UT_ThreadedAlgorithm.h ( SIM Library, C++)
 *
 * COMMENTS:
 */

#ifndef __UT_ThreadedAlgorithm__
#define __UT_ThreadedAlgorithm__

#include "UT_API.h"

class UT_JobInfo;

#include "UT_Thread.h"
#include "UT_Lock.h"
#include "UT_Functor.h"

#if !defined(GAMEOS)
#include <boost/tuple/tuple.hpp>
#endif

///
/// UT_ThreadedAlgorithm takes care of all the thread administration that a
/// threaded algorithm requires.  
/// 
/// Its features are:
/// 1) it executes work in the main thread as well
/// 2) it assumes that the work can be divided into N parts and sends off 
///    exactly N calls to threadfunc() (jobs). (N depends on the # of 
///    installed processors and the maxthreads parm). 
///
/// Your callback function is called with several
/// useful parameters:
///
///   void * data    - the userdata pointer you provide to run()
///   int  jobindex  - there are N jobs, this is which job you're running
///                    (0 to N-1).
///   int  maxindex  - the total number of jobs farmed (N)
///   UT_Lock &lock  - a lock that you can use to lock other jobs out while
///                    you work on something non-threadsafe. Accepts NULL.
///
/// If your machine is a single proc, this will work exactly as a call to
/// threadfunc().
///
/// In addition to the traditional threadfunc() callback, you can pass
/// in a UT_Functor1 which takes a UT_JobInfo parameter to specify the
/// job to be performed (see below).  In this case, you may be better off
/// with the THREADED_METHOD macros detailed later.
///
class UT_API UT_ThreadedAlgorithm
{
public:
    UT_ThreadedAlgorithm(int maxthreads = -1);
    ~UT_ThreadedAlgorithm();

    /// Starts the jobs, and waits until all are finished. This can be called
    /// multiple times. The optional lock parm allows you to use your own
    /// lock; if not specified, this class's lock will be used.
    void        run(void (*threadfunc)(void *, int, int, UT_Lock &),
                    void *userdata,
                    UT_Lock *lock = 0);

    /// Starts the jobs and waits until all are finished.
    /// Since this uses a functor, you are expected to use BindFirst
    /// to hide any user data you may have
    /// While a return type is specified, it is not used.  This is because
    /// compiler bugs prohibit a Functor2 that returns null.
    void        run(UT_Functor1<int, const UT_JobInfo &> functor,
                    UT_Lock *lock = 0);

    /// If not currently inside a multithreaded algorithm, returns
    /// a UT_ThreadedAlgorithm with a thread per-processor.
    /// If inside a mulithreaded algorithm, returns a single-processor
    /// version.  This avoids accidental fork bombs.
    /// You must call release with the result of each lock.
    static UT_ThreadedAlgorithm *lockThreadedAlgorithm();
    static void  releaseThreadedAlgorithm(UT_ThreadedAlgorithm *alg);

private:
    static void * algorithmStart(void *data);
    
    UT_Lock     *myLock;
    int          myThreadCount;
    UT_Thread  **myThreads;

    static UT_ThreadedAlgorithm *ourThreadedAlgorithm;
    static bool                  ourThreadedAlgorithmInUse;
    static UT_Lock               ourThreadedAlgorithmLock;
};

///
/// Defines the work required for each invocation of *Partial
/// to complete.
///
class UT_API UT_JobInfo
{
public:
    UT_JobInfo(int jobidx, int numjobs, UT_Lock *lock)
    {
        myJob = jobidx;
        myNumJobs = numjobs;
        myLock = lock;
    }
    
    int          job() const     { return myJob; }
    int          numJobs() const { return myNumJobs; }

    /// Given "units" work, report which units you are responsible
    /// for with this JobInfo.  The resulting interval is [start, end),
    ///  Appropriate for loop:
    /// for (info.divideWork(total, i, end); i < end; i++)
    void         divideWork(int units, int &start, int &end) const;
    
    void        lock() const
                {
                    if (myLock)
                        myLock->lockLW();
                }
    void        unlock() const
                {
                    if (myLock)
                        myLock->unlock();
                }

protected:
    int          myJob, myNumJobs;
    UT_Lock     *myLock;
};

class UT_API UT_AutoJobInfoLock
{
public:
     UT_AutoJobInfoLock(const UT_JobInfo &lock)
         : myLock(lock)
        { lock.lock(); }
    
    ~UT_AutoJobInfoLock() { myLock.unlock(); }
    
private:
    const UT_JobInfo    &myLock;
};


///
/// @file
/// These macros automatically create all the wrapper functions
/// required to set up a multithreaded function call that can
/// be invoked transparently.
///
/// An example of use:
/// @code
/// class Foobar
/// {
///   ...
///   THREADED_METHOD2(Foobar, gdp->points().entries() > 100, 
///                    translate,
///                   GU_Detail *, gdp,
///                   const UT_Vector3 &, delta)
///
///   void translatePartial(GU_Detail *gdp, const UT_Vector3 &delta,
///                         const UT_JobInfo &info);
///   ...
/// }
///
/// void
/// Foobar::translatePartial(GU_Detail *gdp, const UT_Vector3 &delta,
///                          const UT_JobInfo &info)
/// {
///   int               i, n;
///   
///   for (info.divideWork(gdp->points().entries, i, n); i < n; i++)
///   {
///       gdp->points()(i).getPos() += delta;
///   }
/// }
/// @endcode
///
/// The suffix number is the number of parameters the function
/// should take - THREADED_METHOD#(). The parameters to the macro are:
///
/// @code
/// THREADED_METHOD#(CLASSNAME, DOMULTI, METHOD, PARMTYPE1, PARMNAME1, ...);
/// @endcode
///
/// The DOMULTI is a boolean value (which may be a function returning
/// such) which determines if multithreading should be performed.
/// This lets you disable the multithreading for small batches.
/// Note it executes inside of METHOD, so has access to the parameters
/// in the CLASS. For threaded methods with parameters, you need to
/// specify both the PARMTYPE and the PARMNAME for each parameter.
///
/// The user must both prototype & implement a
/// @code
///    void functionPartial(parameterlist, const &UT_JobInfo)
/// @endcode
/// which does all the real work (see above).
///
/// Automatically created by the THREADED_METHOD macro are:
/// @code
///   void function(parameterlist)          <- what users can invoke
///   void functionNoThread(parameterlist)   <- unthreaded version
///   int  functionInvokeParital(...)        <- marshalling function.
/// @endcode
///

// The linux ia64 compiler doesn't like functors very much, so
// we hide them from it.
#if defined(IA64) || defined(GAMEOS)

#define THREADED_METHOD_INTERNAL(ISCONST, CLASSNAME, DOMULTI, METHOD) \
void METHOD() ISCONST \
{ \
    METHOD ## NoThread(); \
} \
 \
void METHOD ## NoThread() ISCONST \
{ \
    METHOD ## Partial(UT_JobInfo(0, 1, 0)); \
}

#define THREADED_METHOD1_INTERNAL(ISCONST, CLASSNAME, DOMULTI, METHOD, PARMTYPE1, PARMNAME1) \
void METHOD(PARMTYPE1 PARMNAME1) ISCONST \
{ \
    METHOD ## NoThread(PARMNAME1); \
} \
 \
void METHOD ## NoThread(PARMTYPE1 PARMNAME1) ISCONST \
{ \
    METHOD ## Partial(PARMNAME1, UT_JobInfo(0, 1, 0)); \
}

#define THREADED_METHOD2_INTERNAL(ISCONST, CLASSNAME, DOMULTI, METHOD, PARMTYPE1, PARMNAME1, PARMTYPE2, PARMNAME2) \
void METHOD(PARMTYPE1 PARMNAME1, PARMTYPE2 PARMNAME2) ISCONST \
{ \
    METHOD ## NoThread(PARMNAME1, PARMNAME2); \
} \
 \
void METHOD ## NoThread(PARMTYPE1 PARMNAME1, PARMTYPE2 PARMNAME2) ISCONST \
{ \
    METHOD ## Partial(PARMNAME1, PARMNAME2, UT_JobInfo(0, 1, 0)); \
}

#define THREADED_METHOD3_INTERNAL(ISCONST, CLASSNAME, DOMULTI, METHOD, PARMTYPE1, PARMNAME1, PARMTYPE2, PARMNAME2, PARMTYPE3, PARMNAME3) \
void METHOD(PARMTYPE1 PARMNAME1, PARMTYPE2 PARMNAME2, PARMTYPE3 PARMNAME3) ISCONST \
{ \
    METHOD ## NoThread(PARMNAME1, PARMNAME2, PARMNAME3); \
} \
 \
void METHOD ## NoThread(PARMTYPE1 PARMNAME1, PARMTYPE2 PARMNAME2, PARMTYPE3 PARMNAME3) ISCONST \
{ \
    METHOD ## Partial(PARMNAME1, PARMNAME2, PARMNAME3, UT_JobInfo(0, 1, 0)); \
}

#define THREADED_METHOD4_INTERNAL(ISCONST, CLASSNAME, DOMULTI, METHOD, PARMTYPE1, PARMNAME1, PARMTYPE2, PARMNAME2, PARMTYPE3, PARMNAME3, PARMTYPE4, PARMNAME4) \
void METHOD(PARMTYPE1 PARMNAME1, PARMTYPE2 PARMNAME2, PARMTYPE3 PARMNAME3, PARMTYPE4 PARMNAME4) ISCONST \
{ \
    METHOD ## NoThread(PARMNAME1, PARMNAME2, PARMNAME3, PARMNAME4); \
} \
 \
void METHOD ## NoThread(PARMTYPE1 PARMNAME1, PARMTYPE2 PARMNAME2, PARMTYPE3 PARMNAME3, PARMTYPE4 PARMNAME4) ISCONST \
{ \
    METHOD ## Partial(PARMNAME1, PARMNAME2, PARMNAME3, PARMNAME4, UT_JobInfo(0, 1, 0)); \
}

#define THREADED_METHOD5_INTERNAL(ISCONST, CLASSNAME, DOMULTI, METHOD, PARMTYPE1, PARMNAME1, PARMTYPE2, PARMNAME2, PARMTYPE3, PARMNAME3, PARMTYPE4, PARMNAME4, PARMTYPE5, PARMNAME5) \
void METHOD(PARMTYPE1 PARMNAME1, PARMTYPE2 PARMNAME2, PARMTYPE3 PARMNAME3, PARMTYPE4 PARMNAME4, PARMTYPE5 PARMNAME5) ISCONST \
{ \
    METHOD ## NoThread(PARMNAME1, PARMNAME2, PARMNAME3, PARMNAME4, PARMNAME5); \
} \
 \
void METHOD ## NoThread(PARMTYPE1 PARMNAME1, PARMTYPE2 PARMNAME2, PARMTYPE3 PARMNAME3, PARMTYPE4 PARMNAME4, PARMTYPE5 PARMNAME5) ISCONST \
{ \
    METHOD ## Partial(PARMNAME1, PARMNAME2, PARMNAME3, PARMNAME4, PARMNAME5, UT_JobInfo(0, 1, 0)); \
}

#define THREADED_METHOD6_INTERNAL(ISCONST, CLASSNAME, DOMULTI, METHOD, PARMTYPE1, PARMNAME1, PARMTYPE2, PARMNAME2, PARMTYPE3, PARMNAME3, PARMTYPE4, PARMNAME4, PARMTYPE5, PARMNAME5, PARMTYPE6, PARMNAME6) \
void METHOD(PARMTYPE1 PARMNAME1, PARMTYPE2 PARMNAME2, PARMTYPE3 PARMNAME3, PARMTYPE4 PARMNAME4, PARMTYPE5 PARMNAME5, PARMTYPE6 PARMNAME6) ISCONST \
{ \
    METHOD ## NoThread(PARMNAME1, PARMNAME2, PARMNAME3, PARMNAME4, PARMNAME5, PARMNAME6); \
} \
 \
void METHOD ## NoThread(PARMTYPE1 PARMNAME1, PARMTYPE2 PARMNAME2, PARMTYPE3 PARMNAME3, PARMTYPE4 PARMNAME4, PARMTYPE5 PARMNAME5, PARMTYPE6 PARMNAME6) ISCONST \
{ \
    METHOD ## Partial(PARMNAME1, PARMNAME2, PARMNAME3, PARMNAME4, PARMNAME5, PARMNAME6, UT_JobInfo(0, 1, 0)); \
}

#define THREADED_METHOD7_INTERNAL(ISCONST, CLASSNAME, DOMULTI, METHOD, PARMTYPE1, PARMNAME1, PARMTYPE2, PARMNAME2, PARMTYPE3, PARMNAME3, PARMTYPE4, PARMNAME4, PARMTYPE5, PARMNAME5, PARMTYPE6, PARMNAME6, PARMTYPE7, PARMNAME7) \
void METHOD(PARMTYPE1 PARMNAME1, PARMTYPE2 PARMNAME2, PARMTYPE3 PARMNAME3, PARMTYPE4 PARMNAME4, PARMTYPE5 PARMNAME5, PARMTYPE6 PARMNAME6, PARMTYPE7 PARMNAME7) ISCONST \
{ \
    METHOD ## NoThread(PARMNAME1, PARMNAME2, PARMNAME3, PARMNAME4, PARMNAME5, PARMNAME6, PARMNAME7); \
} \
 \
void METHOD ## NoThread(PARMTYPE1 PARMNAME1, PARMTYPE2 PARMNAME2, PARMTYPE3 PARMNAME3, PARMTYPE4 PARMNAME4, PARMTYPE5 PARMNAME5, PARMTYPE6 PARMNAME6, PARMTYPE7 PARMNAME7) ISCONST \
{ \
    METHOD ## Partial(PARMNAME1, PARMNAME2, PARMNAME3, PARMNAME4, PARMNAME5, PARMNAME6, PARMNAME7, UT_JobInfo(0, 1, 0)); \
}

#define THREADED_METHOD8_INTERNAL(ISCONST, CLASSNAME, DOMULTI, METHOD, PARMTYPE1, PARMNAME1, PARMTYPE2, PARMNAME2, PARMTYPE3, PARMNAME3, PARMTYPE4, PARMNAME4, PARMTYPE5, PARMNAME5, PARMTYPE6, PARMNAME6, PARMTYPE7, PARMNAME7, PARMTYPE8, PARMNAME8) \
void METHOD(PARMTYPE1 PARMNAME1, PARMTYPE2 PARMNAME2, PARMTYPE3 PARMNAME3, PARMTYPE4 PARMNAME4, PARMTYPE5 PARMNAME5, PARMTYPE6 PARMNAME6, PARMTYPE7 PARMNAME7, PARMTYPE8 PARMNAME8) ISCONST \
{ \
    METHOD ## NoThread(PARMNAME1, PARMNAME2, PARMNAME3, PARMNAME4, PARMNAME5, PARMNAME6, PARMNAME7, PARMNAME8); \
} \
 \
void METHOD ## NoThread(PARMTYPE1 PARMNAME1, PARMTYPE2 PARMNAME2, PARMTYPE3 PARMNAME3, PARMTYPE4 PARMNAME4, PARMTYPE5 PARMNAME5, PARMTYPE6 PARMNAME6, PARMTYPE7 PARMNAME7, PARMTYPE8 PARMNAME8) ISCONST \
{ \
    METHOD ## Partial(PARMNAME1, PARMNAME2, PARMNAME3, PARMNAME4, PARMNAME5, PARMNAME6, PARMNAME7, PARMNAME8, UT_JobInfo(0, 1, 0)); \
}

#else

#define THREADED_METHOD_INTERNAL(ISCONST, CLASSNAME, DOMULTI, METHOD) \
void METHOD() ISCONST \
{ \
    if (!(DOMULTI)) \
    { \
        METHOD ## NoThread(); \
        return; \
    } \
     \
    UT_Functor1<int, const UT_JobInfo &> functor( \
            this, &CLASSNAME::METHOD ## InvokePartial); \
    UT_ThreadedAlgorithm *alg = UT_ThreadedAlgorithm::lockThreadedAlgorithm(); \
 \
    alg ->run(functor); \
     \
    UT_ThreadedAlgorithm::releaseThreadedAlgorithm(alg); \
} \
 \
void METHOD ## NoThread() ISCONST \
{ \
    METHOD ## Partial(UT_JobInfo(0, 1, 0)); \
} \
 \
int METHOD ## InvokePartial(const UT_JobInfo &info) ISCONST \
{ \
    METHOD ## Partial(info); \
    return 0; \
}

#define THREADED_METHOD1_INTERNAL(ISCONST, CLASSNAME, DOMULTI, METHOD, PARMTYPE1, PARMNAME1) \
void METHOD(PARMTYPE1 PARMNAME1) ISCONST \
{ \
    if (!(DOMULTI)) \
    { \
        METHOD ## NoThread(PARMNAME1); \
        return; \
    } \
     \
    UT_Functor2<int, PARMTYPE1, const UT_JobInfo &> functor( \
            this, &CLASSNAME::METHOD ## InvokePartial); \
    UT_ThreadedAlgorithm *alg = UT_ThreadedAlgorithm::lockThreadedAlgorithm(); \
 \
    alg ->run(UT_BindFirst1(functor, PARMNAME1)); \
     \
    UT_ThreadedAlgorithm::releaseThreadedAlgorithm(alg); \
} \
 \
void METHOD ## NoThread(PARMTYPE1 PARMNAME1) ISCONST \
{ \
    METHOD ## Partial(PARMNAME1, UT_JobInfo(0, 1, 0)); \
} \
 \
int METHOD ## InvokePartial(PARMTYPE1 PARMNAME1, const UT_JobInfo &info) ISCONST \
{ \
    METHOD ## Partial(PARMNAME1, info); \
    return 0; \
}

#define THREADED_METHOD2_INTERNAL(ISCONST, CLASSNAME, DOMULTI, METHOD, PARMTYPE1, PARMNAME1, PARMTYPE2, PARMNAME2) \
void METHOD(PARMTYPE1 PARMNAME1, PARMTYPE2 PARMNAME2) ISCONST \
{ \
    if (!(DOMULTI)) \
    { \
        METHOD ## NoThread(PARMNAME1, PARMNAME2); \
        return; \
    } \
     \
    UT_Functor2<int, boost::tuple<PARMTYPE1,PARMTYPE2 >, const UT_JobInfo &> functor( \
            this, &CLASSNAME::METHOD ## InvokePartial); \
    UT_ThreadedAlgorithm *alg = UT_ThreadedAlgorithm::lockThreadedAlgorithm(); \
 \
    alg ->run(UT_BindFirst1(functor, boost::tuple<PARMTYPE1, PARMTYPE2 >(PARMNAME1,PARMNAME2))); \
     \
    UT_ThreadedAlgorithm::releaseThreadedAlgorithm(alg); \
} \
 \
void METHOD ## NoThread(PARMTYPE1 PARMNAME1, PARMTYPE2 PARMNAME2) ISCONST \
{ \
    METHOD ## Partial(PARMNAME1, PARMNAME2, UT_JobInfo(0, 1, 0)); \
} \
 \
int METHOD ## InvokePartial(boost::tuple<PARMTYPE1, PARMTYPE2 > tuple, const UT_JobInfo &info) ISCONST \
{ \
    METHOD ## Partial(boost::get<0>(tuple), boost::get<1>(tuple), info); \
    return 0; \
}

#define THREADED_METHOD3_INTERNAL(ISCONST, CLASSNAME, DOMULTI, METHOD, PARMTYPE1, PARMNAME1, PARMTYPE2, PARMNAME2, PARMTYPE3, PARMNAME3) \
void METHOD(PARMTYPE1 PARMNAME1, PARMTYPE2 PARMNAME2, PARMTYPE3 PARMNAME3) ISCONST \
{ \
    if (!(DOMULTI)) \
    { \
        METHOD ## NoThread(PARMNAME1, PARMNAME2, PARMNAME3); \
        return; \
    } \
     \
    UT_Functor2<int, boost::tuple<PARMTYPE1,PARMTYPE2,PARMTYPE3 >, const UT_JobInfo &> functor( \
            this, &CLASSNAME::METHOD ## InvokePartial); \
    UT_ThreadedAlgorithm *alg = UT_ThreadedAlgorithm::lockThreadedAlgorithm(); \
 \
    alg ->run(UT_BindFirst1(functor, boost::tuple<PARMTYPE1,PARMTYPE2,PARMTYPE3 >(PARMNAME1, PARMNAME2, PARMNAME3))); \
     \
    UT_ThreadedAlgorithm::releaseThreadedAlgorithm(alg); \
} \
 \
void METHOD ## NoThread(PARMTYPE1 PARMNAME1, PARMTYPE2 PARMNAME2, PARMTYPE3 PARMNAME3) ISCONST \
{ \
    METHOD ## Partial(PARMNAME1, PARMNAME2, PARMNAME3, UT_JobInfo(0, 1, 0)); \
} \
 \
int METHOD ## InvokePartial(boost::tuple<PARMTYPE1, PARMTYPE2, PARMTYPE3 > tuple, const UT_JobInfo &info) ISCONST \
{ \
    METHOD ## Partial(boost::get<0>(tuple), boost::get<1>(tuple), boost::get<2>(tuple), info); \
    return 0; \
}

#define THREADED_METHOD4_INTERNAL(ISCONST, CLASSNAME, DOMULTI, METHOD, PARMTYPE1, PARMNAME1, PARMTYPE2, PARMNAME2, PARMTYPE3, PARMNAME3, PARMTYPE4, PARMNAME4) \
void METHOD(PARMTYPE1 PARMNAME1, PARMTYPE2 PARMNAME2, PARMTYPE3 PARMNAME3, PARMTYPE4 PARMNAME4) ISCONST \
{ \
    if (!(DOMULTI)) \
    { \
        METHOD ## NoThread(PARMNAME1, PARMNAME2, PARMNAME3, PARMNAME4); \
        return; \
    } \
     \
    UT_Functor2<int, boost::tuple<PARMTYPE1,PARMTYPE2,PARMTYPE3,PARMTYPE4 >, const UT_JobInfo &> functor( \
            this, &CLASSNAME::METHOD ## InvokePartial); \
    UT_ThreadedAlgorithm *alg = UT_ThreadedAlgorithm::lockThreadedAlgorithm(); \
 \
    alg ->run(UT_BindFirst1(functor, boost::tuple<PARMTYPE1,PARMTYPE2,PARMTYPE3,PARMTYPE4 >(PARMNAME1, PARMNAME2, PARMNAME3, PARMNAME4))); \
     \
    UT_ThreadedAlgorithm::releaseThreadedAlgorithm(alg); \
} \
 \
void METHOD ## NoThread(PARMTYPE1 PARMNAME1, PARMTYPE2 PARMNAME2, PARMTYPE3 PARMNAME3, PARMTYPE4 PARMNAME4) ISCONST \
{ \
    METHOD ## Partial(PARMNAME1, PARMNAME2, PARMNAME3, PARMNAME4, UT_JobInfo(0, 1, 0)); \
} \
 \
int METHOD ## InvokePartial(boost::tuple<PARMTYPE1, PARMTYPE2, PARMTYPE3, PARMTYPE4 > tuple, const UT_JobInfo &info) ISCONST \
{ \
    METHOD ## Partial(boost::get<0>(tuple), boost::get<1>(tuple), boost::get<2>(tuple), boost::get<3>(tuple), info); \
    return 0; \
}


#define THREADED_METHOD5_INTERNAL(ISCONST, CLASSNAME, DOMULTI, METHOD, PARMTYPE1, PARMNAME1, PARMTYPE2, PARMNAME2, PARMTYPE3, PARMNAME3, PARMTYPE4, PARMNAME4, PARMTYPE5, PARMNAME5) \
void METHOD(PARMTYPE1 PARMNAME1, PARMTYPE2 PARMNAME2, PARMTYPE3 PARMNAME3, PARMTYPE4 PARMNAME4, PARMTYPE5 PARMNAME5) ISCONST \
{ \
    if (!(DOMULTI)) \
    { \
        METHOD ## NoThread(PARMNAME1, PARMNAME2, PARMNAME3, PARMNAME4, PARMNAME5); \
        return; \
    } \
     \
    UT_Functor2<int, boost::tuple<PARMTYPE1,PARMTYPE2,PARMTYPE3,PARMTYPE4,PARMTYPE5 >, const UT_JobInfo &> functor( \
            this, &CLASSNAME::METHOD ## InvokePartial); \
    UT_ThreadedAlgorithm *alg = UT_ThreadedAlgorithm::lockThreadedAlgorithm(); \
 \
    alg ->run(UT_BindFirst1(functor, boost::tuple<PARMTYPE1,PARMTYPE2,PARMTYPE3,PARMTYPE4,PARMTYPE5 >(PARMNAME1, PARMNAME2, PARMNAME3, PARMNAME4, PARMNAME5))); \
     \
    UT_ThreadedAlgorithm::releaseThreadedAlgorithm(alg); \
} \
 \
void METHOD ## NoThread(PARMTYPE1 PARMNAME1, PARMTYPE2 PARMNAME2, PARMTYPE3 PARMNAME3, PARMTYPE4 PARMNAME4, PARMTYPE5 PARMNAME5) ISCONST \
{ \
    METHOD ## Partial(PARMNAME1, PARMNAME2, PARMNAME3, PARMNAME4, PARMNAME5, UT_JobInfo(0, 1, 0)); \
} \
 \
int METHOD ## InvokePartial(boost::tuple<PARMTYPE1, PARMTYPE2, PARMTYPE3, PARMTYPE4, PARMTYPE5 > tuple, const UT_JobInfo &info) ISCONST \
{ \
    METHOD ## Partial(boost::get<0>(tuple), boost::get<1>(tuple), boost::get<2>(tuple), boost::get<3>(tuple), boost::get<4>(tuple), info); \
    return 0; \
}


#define THREADED_METHOD6_INTERNAL(ISCONST, CLASSNAME, DOMULTI, METHOD, PARMTYPE1, PARMNAME1, PARMTYPE2, PARMNAME2, PARMTYPE3, PARMNAME3, PARMTYPE4, PARMNAME4, PARMTYPE5, PARMNAME5, PARMTYPE6, PARMNAME6) \
void METHOD(PARMTYPE1 PARMNAME1, PARMTYPE2 PARMNAME2, PARMTYPE3 PARMNAME3, PARMTYPE4 PARMNAME4, PARMTYPE5 PARMNAME5, PARMTYPE6 PARMNAME6) ISCONST \
{ \
    if (!(DOMULTI)) \
    { \
        METHOD ## NoThread(PARMNAME1, PARMNAME2, PARMNAME3, PARMNAME4, PARMNAME5, PARMNAME6); \
        return; \
    } \
     \
    UT_Functor2<int, boost::tuple<PARMTYPE1,PARMTYPE2,PARMTYPE3,PARMTYPE4,PARMTYPE5,PARMTYPE6 >, const UT_JobInfo &> functor( \
            this, &CLASSNAME::METHOD ## InvokePartial); \
    UT_ThreadedAlgorithm *alg = UT_ThreadedAlgorithm::lockThreadedAlgorithm(); \
 \
    alg ->run(UT_BindFirst1(functor, boost::tuple<PARMTYPE1,PARMTYPE2,PARMTYPE3,PARMTYPE4,PARMTYPE5,PARMTYPE6 >(PARMNAME1, PARMNAME2, PARMNAME3, PARMNAME4, PARMNAME5, PARMNAME6))); \
     \
    UT_ThreadedAlgorithm::releaseThreadedAlgorithm(alg); \
} \
 \
void METHOD ## NoThread(PARMTYPE1 PARMNAME1, PARMTYPE2 PARMNAME2, PARMTYPE3 PARMNAME3, PARMTYPE4 PARMNAME4, PARMTYPE5 PARMNAME5, PARMTYPE6 PARMNAME6) ISCONST \
{ \
    METHOD ## Partial(PARMNAME1, PARMNAME2, PARMNAME3, PARMNAME4, PARMNAME5, PARMNAME6, UT_JobInfo(0, 1, 0)); \
} \
 \
int METHOD ## InvokePartial(boost::tuple<PARMTYPE1, PARMTYPE2, PARMTYPE3, PARMTYPE4, PARMTYPE5, PARMTYPE6 > tuple, const UT_JobInfo &info) ISCONST \
{ \
    METHOD ## Partial(boost::get<0>(tuple), boost::get<1>(tuple), boost::get<2>(tuple), boost::get<3>(tuple), boost::get<4>(tuple), boost::get<5>(tuple), info); \
    return 0; \
}

#define THREADED_METHOD7_INTERNAL(ISCONST, CLASSNAME, DOMULTI, METHOD, PARMTYPE1, PARMNAME1, PARMTYPE2, PARMNAME2, PARMTYPE3, PARMNAME3, PARMTYPE4, PARMNAME4, PARMTYPE5, PARMNAME5, PARMTYPE6, PARMNAME6, PARMTYPE7, PARMNAME7) \
void METHOD(PARMTYPE1 PARMNAME1, PARMTYPE2 PARMNAME2, PARMTYPE3 PARMNAME3, PARMTYPE4 PARMNAME4, PARMTYPE5 PARMNAME5, PARMTYPE6 PARMNAME6, PARMTYPE7 PARMNAME7) ISCONST \
{ \
    if (!(DOMULTI)) \
    { \
        METHOD ## NoThread(PARMNAME1, PARMNAME2, PARMNAME3, PARMNAME4, PARMNAME5, PARMNAME6, PARMNAME7); \
        return; \
    } \
     \
    UT_Functor2<int, boost::tuple<PARMTYPE1,PARMTYPE2,PARMTYPE3,PARMTYPE4,PARMTYPE5,PARMTYPE6,PARMTYPE7 >, const UT_JobInfo &> functor( \
            this, &CLASSNAME::METHOD ## InvokePartial); \
    UT_ThreadedAlgorithm *alg = UT_ThreadedAlgorithm::lockThreadedAlgorithm(); \
 \
    alg ->run(UT_BindFirst1(functor, boost::tuple<PARMTYPE1,PARMTYPE2,PARMTYPE3,PARMTYPE4,PARMTYPE5,PARMTYPE6,PARMTYPE7 >(PARMNAME1, PARMNAME2, PARMNAME3, PARMNAME4, PARMNAME5, PARMNAME6, PARMNAME7))); \
     \
    UT_ThreadedAlgorithm::releaseThreadedAlgorithm(alg); \
} \
 \
void METHOD ## NoThread(PARMTYPE1 PARMNAME1, PARMTYPE2 PARMNAME2, PARMTYPE3 PARMNAME3, PARMTYPE4 PARMNAME4, PARMTYPE5 PARMNAME5, PARMTYPE6 PARMNAME6, PARMTYPE7 PARMNAME7) ISCONST \
{ \
    METHOD ## Partial(PARMNAME1, PARMNAME2, PARMNAME3, PARMNAME4, PARMNAME5, PARMNAME6, PARMNAME7, UT_JobInfo(0, 1, 0)); \
} \
 \
int METHOD ## InvokePartial(boost::tuple<PARMTYPE1, PARMTYPE2, PARMTYPE3, PARMTYPE4, PARMTYPE5, PARMTYPE6, PARMTYPE7 > tuple, const UT_JobInfo &info) ISCONST \
{ \
    METHOD ## Partial(boost::get<0>(tuple), boost::get<1>(tuple), boost::get<2>(tuple), boost::get<3>(tuple), boost::get<4>(tuple), boost::get<5>(tuple), boost::get<6>(tuple), info); \
    return 0; \
}

#define THREADED_METHOD8_INTERNAL(ISCONST, CLASSNAME, DOMULTI, METHOD, PARMTYPE1, PARMNAME1, PARMTYPE2, PARMNAME2, PARMTYPE3, PARMNAME3, PARMTYPE4, PARMNAME4, PARMTYPE5, PARMNAME5, PARMTYPE6, PARMNAME6, PARMTYPE7, PARMNAME7, PARMTYPE8, PARMNAME8) \
void METHOD(PARMTYPE1 PARMNAME1, PARMTYPE2 PARMNAME2, PARMTYPE3 PARMNAME3, PARMTYPE4 PARMNAME4, PARMTYPE5 PARMNAME5, PARMTYPE6 PARMNAME6, PARMTYPE7 PARMNAME7, PARMTYPE8 PARMNAME8) ISCONST \
{ \
    if (!(DOMULTI)) \
    { \
        METHOD ## NoThread(PARMNAME1, PARMNAME2, PARMNAME3, PARMNAME4, PARMNAME5, PARMNAME6, PARMNAME7, PARMNAME8); \
        return; \
    } \
     \
    UT_Functor2<int, boost::tuple<PARMTYPE1,PARMTYPE2,PARMTYPE3,PARMTYPE4,PARMTYPE5,PARMTYPE6,PARMTYPE7,PARMTYPE8 >, const UT_JobInfo &> functor( \
            this, &CLASSNAME::METHOD ## InvokePartial); \
    UT_ThreadedAlgorithm *alg = UT_ThreadedAlgorithm::lockThreadedAlgorithm(); \
 \
    alg ->run(UT_BindFirst1(functor, boost::tuple<PARMTYPE1,PARMTYPE2,PARMTYPE3,PARMTYPE4,PARMTYPE5,PARMTYPE6,PARMTYPE7,PARMTYPE8 >(PARMNAME1, PARMNAME2, PARMNAME3, PARMNAME4, PARMNAME5, PARMNAME6, PARMNAME7, PARMNAME8))); \
     \
    UT_ThreadedAlgorithm::releaseThreadedAlgorithm(alg); \
} \
 \
void METHOD ## NoThread(PARMTYPE1 PARMNAME1, PARMTYPE2 PARMNAME2, PARMTYPE3 PARMNAME3, PARMTYPE4 PARMNAME4, PARMTYPE5 PARMNAME5, PARMTYPE6 PARMNAME6, PARMTYPE7 PARMNAME7, PARMTYPE8 PARMNAME8) ISCONST \
{ \
    METHOD ## Partial(PARMNAME1, PARMNAME2, PARMNAME3, PARMNAME4, PARMNAME5, PARMNAME6, PARMNAME7, PARMNAME8, UT_JobInfo(0, 1, 0)); \
} \
 \
int METHOD ## InvokePartial(boost::tuple<PARMTYPE1, PARMTYPE2, PARMTYPE3, PARMTYPE4, PARMTYPE5, PARMTYPE6, PARMTYPE7, PARMTYPE8 > tuple, const UT_JobInfo &info) ISCONST \
{ \
    METHOD ## Partial(boost::get<0>(tuple), boost::get<1>(tuple), boost::get<2>(tuple), boost::get<3>(tuple), boost::get<4>(tuple), boost::get<5>(tuple), boost::get<6>(tuple), boost::get<7>(tuple), info); \
    return 0; \
}



#endif  // Switch if we allow functors.

#define THREADED_METHOD(CLASSNAME, DOMULTI, METHOD) \
    THREADED_METHOD_INTERNAL( , CLASSNAME, DOMULTI, METHOD)
#define THREADED_METHOD_CONST(CLASSNAME, DOMULTI, METHOD) \
    THREADED_METHOD_INTERNAL(const , CLASSNAME, DOMULTI, METHOD)

#define THREADED_METHOD1(CLASSNAME, DOMULTI, METHOD, PARMTYPE1, PARMNAME1) \
    THREADED_METHOD1_INTERNAL( , CLASSNAME, DOMULTI, METHOD, PARMTYPE1, PARMNAME1)
#define THREADED_METHOD1_CONST(CLASSNAME, DOMULTI, METHOD, PARMTYPE1, PARMNAME1) \
    THREADED_METHOD1_INTERNAL(const , CLASSNAME, DOMULTI, METHOD, PARMTYPE1, PARMNAME1)

#define THREADED_METHOD2(CLASSNAME, DOMULTI, METHOD, PARMTYPE1, PARMNAME1, PARMTYPE2, PARMNAME2) \
    THREADED_METHOD2_INTERNAL( , CLASSNAME, DOMULTI, METHOD, PARMTYPE1, PARMNAME1, PARMTYPE2, PARMNAME2)
#define THREADED_METHOD2_CONST(CLASSNAME, DOMULTI, METHOD, PARMTYPE1, PARMNAME1, PARMTYPE2, PARMNAME2) \
    THREADED_METHOD2_INTERNAL(const , CLASSNAME, DOMULTI, METHOD, PARMTYPE1, PARMNAME1, PARMTYPE2, PARMNAME2)

#define THREADED_METHOD3(CLASSNAME, DOMULTI, METHOD, PARMTYPE1, PARMNAME1, PARMTYPE2, PARMNAME2, PARMTYPE3, PARMNAME3) \
    THREADED_METHOD3_INTERNAL( , CLASSNAME, DOMULTI, METHOD, PARMTYPE1, PARMNAME1, PARMTYPE2, PARMNAME2, PARMTYPE3, PARMNAME3)
#define THREADED_METHOD3_CONST(CLASSNAME, DOMULTI, METHOD, PARMTYPE1, PARMNAME1, PARMTYPE2, PARMNAME2, PARMTYPE3, PARMNAME3) \
    THREADED_METHOD3_INTERNAL(const , CLASSNAME, DOMULTI, METHOD, PARMTYPE1, PARMNAME1, PARMTYPE2, PARMNAME2, PARMTYPE3, PARMNAME3)

#define THREADED_METHOD4(CLASSNAME, DOMULTI, METHOD, PARMTYPE1, PARMNAME1, PARMTYPE2, PARMNAME2, PARMTYPE3, PARMNAME3, PARMTYPE4, PARMNAME4) \
    THREADED_METHOD4_INTERNAL( , CLASSNAME, DOMULTI, METHOD, PARMTYPE1, PARMNAME1, PARMTYPE2, PARMNAME2, PARMTYPE3, PARMNAME3, PARMTYPE4, PARMNAME4)
#define THREADED_METHOD4_CONST(CLASSNAME, DOMULTI, METHOD, PARMTYPE1, PARMNAME1, PARMTYPE2, PARMNAME2, PARMTYPE3, PARMNAME3, PARMTYPE4, PARMNAME4) \
    THREADED_METHOD4_INTERNAL(const , CLASSNAME, DOMULTI, METHOD, PARMTYPE1, PARMNAME1, PARMTYPE2, PARMNAME2, PARMTYPE3, PARMNAME3, PARMTYPE4, PARMNAME4)

#define THREADED_METHOD5(CLASSNAME, DOMULTI, METHOD, PARMTYPE1, PARMNAME1, PARMTYPE2, PARMNAME2, PARMTYPE3, PARMNAME3, PARMTYPE4, PARMNAME4, PARMTYPE5, PARMNAME5) \
    THREADED_METHOD5_INTERNAL( , CLASSNAME, DOMULTI, METHOD, PARMTYPE1, PARMNAME1, PARMTYPE2, PARMNAME2, PARMTYPE3, PARMNAME3, PARMTYPE4, PARMNAME4, PARMTYPE5, PARMNAME5)
#define THREADED_METHOD5_CONST(CLASSNAME, DOMULTI, METHOD, PARMTYPE1, PARMNAME1, PARMTYPE2, PARMNAME2, PARMTYPE3, PARMNAME3, PARMTYPE4, PARMNAME4, PARMTYPE5, PARMNAME5) \
    THREADED_METHOD5_INTERNAL(const , CLASSNAME, DOMULTI, METHOD, PARMTYPE1, PARMNAME1, PARMTYPE2, PARMNAME2, PARMTYPE3, PARMNAME3, PARMTYPE4, PARMNAME4, PARMTYPE5, PARMNAME5)

#define THREADED_METHOD6(CLASSNAME, DOMULTI, METHOD, PARMTYPE1, PARMNAME1, PARMTYPE2, PARMNAME2, PARMTYPE3, PARMNAME3, PARMTYPE4, PARMNAME4, PARMTYPE5, PARMNAME5, PARMTYPE6, PARMNAME6) \
    THREADED_METHOD6_INTERNAL( , CLASSNAME, DOMULTI, METHOD, PARMTYPE1, PARMNAME1, PARMTYPE2, PARMNAME2, PARMTYPE3, PARMNAME3, PARMTYPE4, PARMNAME4, PARMTYPE5, PARMNAME5, PARMTYPE6, PARMNAME6)
#define THREADED_METHOD6_CONST(CLASSNAME, DOMULTI, METHOD, PARMTYPE1, PARMNAME1, PARMTYPE2, PARMNAME2, PARMTYPE3, PARMNAME3, PARMTYPE4, PARMNAME4, PARMTYPE5, PARMNAME5, PARMTYPE6, PARMNAME6) \
    THREADED_METHOD6_INTERNAL(const , CLASSNAME, DOMULTI, METHOD, PARMTYPE1, PARMNAME1, PARMTYPE2, PARMNAME2, PARMTYPE3, PARMNAME3, PARMTYPE4, PARMNAME4, PARMTYPE5, PARMNAME5, PARMTYPE6, PARMNAME6)

#define THREADED_METHOD7(CLASSNAME, DOMULTI, METHOD, PARMTYPE1, PARMNAME1, PARMTYPE2, PARMNAME2, PARMTYPE3, PARMNAME3, PARMTYPE4, PARMNAME4, PARMTYPE5, PARMNAME5, PARMTYPE6, PARMNAME6, PARMTYPE7, PARMNAME7) \
    THREADED_METHOD7_INTERNAL( , CLASSNAME, DOMULTI, METHOD, PARMTYPE1, PARMNAME1, PARMTYPE2, PARMNAME2, PARMTYPE3, PARMNAME3, PARMTYPE4, PARMNAME4, PARMTYPE5, PARMNAME5, PARMTYPE6, PARMNAME6, PARMTYPE7, PARMNAME7)
#define THREADED_METHOD7_CONST(CLASSNAME, DOMULTI, METHOD, PARMTYPE1, PARMNAME1, PARMTYPE2, PARMNAME2, PARMTYPE3, PARMNAME3, PARMTYPE4, PARMNAME4, PARMTYPE5, PARMNAME5, PARMTYPE6, PARMNAME6, PARMTYPE7, PARMNAME7) \
    THREADED_METHOD7_INTERNAL(const , CLASSNAME, DOMULTI, METHOD, PARMTYPE1, PARMNAME1, PARMTYPE2, PARMNAME2, PARMTYPE3, PARMNAME3, PARMTYPE4, PARMNAME4, PARMTYPE5, PARMNAME5, PARMTYPE6, PARMNAME6, PARMTYPE7, PARMNAME7)

#define THREADED_METHOD8(CLASSNAME, DOMULTI, METHOD, PARMTYPE1, PARMNAME1, PARMTYPE2, PARMNAME2, PARMTYPE3, PARMNAME3, PARMTYPE4, PARMNAME4, PARMTYPE5, PARMNAME5, PARMTYPE6, PARMNAME6, PARMTYPE7, PARMNAME7, PARMTYPE8, PARMNAME8) \
    THREADED_METHOD8_INTERNAL( , CLASSNAME, DOMULTI, METHOD, PARMTYPE1, PARMNAME1, PARMTYPE2, PARMNAME2, PARMTYPE3, PARMNAME3, PARMTYPE4, PARMNAME4, PARMTYPE5, PARMNAME5, PARMTYPE6, PARMNAME6, PARMTYPE7, PARMNAME7, PARMTYPE8, PARMNAME8)
#define THREADED_METHOD8_CONST(CLASSNAME, DOMULTI, METHOD, PARMTYPE1, PARMNAME1, PARMTYPE2, PARMNAME2, PARMTYPE3, PARMNAME3, PARMTYPE4, PARMNAME4, PARMTYPE5, PARMNAME5, PARMTYPE6, PARMNAME6, PARMTYPE7, PARMNAME7, PARMTYPE8, PARMNAME8) \
    THREADED_METHOD8_INTERNAL(const , CLASSNAME, DOMULTI, METHOD, PARMTYPE1, PARMNAME1, PARMTYPE2, PARMNAME2, PARMTYPE3, PARMNAME3, PARMTYPE4, PARMNAME4, PARMTYPE5, PARMNAME5, PARMTYPE6, PARMNAME6, PARMTYPE7, PARMNAME7, PARMTYPE8, PARMNAME8)

#endif

---