UT/UT_ThreadedAlgorithm.h File Reference

#include "UT_API.h"
#include "UT_Thread.h"
#include "UT_Lock.h"
#include "UT_Functor.h"
#include <boost/tuple/tuple.hpp>

Go to the source code of this file.

Classes

class  UT_ThreadedAlgorithm
class  UT_JobInfo
class  UT_AutoJobInfoLock

Defines

#define THREADED_METHOD_INTERNAL(ISCONST, CLASSNAME, DOMULTI, METHOD)
#define THREADED_METHOD1_INTERNAL(ISCONST, CLASSNAME, DOMULTI, METHOD, PARMTYPE1, PARMNAME1)
#define THREADED_METHOD2_INTERNAL(ISCONST, CLASSNAME, DOMULTI, METHOD, PARMTYPE1, PARMNAME1, PARMTYPE2, PARMNAME2)
#define THREADED_METHOD3_INTERNAL(ISCONST, CLASSNAME, DOMULTI, METHOD, PARMTYPE1, PARMNAME1, PARMTYPE2, PARMNAME2, PARMTYPE3, PARMNAME3)
#define THREADED_METHOD4_INTERNAL(ISCONST, CLASSNAME, DOMULTI, METHOD, PARMTYPE1, PARMNAME1, PARMTYPE2, PARMNAME2, PARMTYPE3, PARMNAME3, PARMTYPE4, PARMNAME4)
#define THREADED_METHOD5_INTERNAL(ISCONST, CLASSNAME, DOMULTI, METHOD, PARMTYPE1, PARMNAME1, PARMTYPE2, PARMNAME2, PARMTYPE3, PARMNAME3, PARMTYPE4, PARMNAME4, PARMTYPE5, PARMNAME5)
#define THREADED_METHOD6_INTERNAL(ISCONST, CLASSNAME, DOMULTI, METHOD, PARMTYPE1, PARMNAME1, PARMTYPE2, PARMNAME2, PARMTYPE3, PARMNAME3, PARMTYPE4, PARMNAME4, PARMTYPE5, PARMNAME5, PARMTYPE6, PARMNAME6)
#define THREADED_METHOD7_INTERNAL(ISCONST, CLASSNAME, DOMULTI, METHOD, PARMTYPE1, PARMNAME1, PARMTYPE2, PARMNAME2, PARMTYPE3, PARMNAME3, PARMTYPE4, PARMNAME4, PARMTYPE5, PARMNAME5, PARMTYPE6, PARMNAME6, PARMTYPE7, PARMNAME7)
#define THREADED_METHOD8_INTERNAL(ISCONST, CLASSNAME, DOMULTI, METHOD, PARMTYPE1, PARMNAME1, PARMTYPE2, PARMNAME2, PARMTYPE3, PARMNAME3, PARMTYPE4, PARMNAME4, PARMTYPE5, PARMNAME5, PARMTYPE6, PARMNAME6, PARMTYPE7, PARMNAME7, PARMTYPE8, PARMNAME8)
#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)

Detailed Description

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: 

 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;
   }
 }

The suffix number is the number of parameters the function should take - THREADED_METHOD#(). The parameters to the macro are:

 THREADED_METHOD#(CLASSNAME, DOMULTI, METHOD, PARMTYPE1, PARMNAME1, ...);

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 

    void functionPartial(parameterlist, const &UT_JobInfo)
which does all the real work (see above).

Automatically created by the THREADED_METHOD macro are: 

   void function(parameterlist)          <- what users can invoke
   void functionNoThread(parameterlist)   <- unthreaded version
   int  functionInvokeParital(...)        <- marshalling function.

Definition in file UT_ThreadedAlgorithm.h.

Define Documentation

#define THREADED_METHOD ( CLASSNAME,
DOMULTI,
METHOD   )     THREADED_METHOD_INTERNAL( , CLASSNAME, DOMULTI, METHOD)

Definition at line 590 of file UT_ThreadedAlgorithm.h.

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

Definition at line 595 of file UT_ThreadedAlgorithm.h.

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

Definition at line 597 of file UT_ThreadedAlgorithm.h.

#define THREADED_METHOD1_INTERNAL ( ISCONST,
CLASSNAME,
DOMULTI,
METHOD,
PARMTYPE1,
PARMNAME1   ) 

Value:

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; \
}

Definition at line 352 of file UT_ThreadedAlgorithm.h.

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

Definition at line 600 of file UT_ThreadedAlgorithm.h.

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

Definition at line 602 of file UT_ThreadedAlgorithm.h.

#define THREADED_METHOD2_INTERNAL ( ISCONST,
CLASSNAME,
DOMULTI,
METHOD,
PARMTYPE1,
PARMNAME1,
PARMTYPE2,
PARMNAME2   ) 

Value:

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; \
}

Definition at line 381 of file UT_ThreadedAlgorithm.h.

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

Definition at line 605 of file UT_ThreadedAlgorithm.h.

#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)

Definition at line 607 of file UT_ThreadedAlgorithm.h.

#define THREADED_METHOD3_INTERNAL ( ISCONST,
CLASSNAME,
DOMULTI,
METHOD,
PARMTYPE1,
PARMNAME1,
PARMTYPE2,
PARMNAME2,
PARMTYPE3,
PARMNAME3   ) 

Value:

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; \
}

Definition at line 410 of file UT_ThreadedAlgorithm.h.

#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)

Definition at line 610 of file UT_ThreadedAlgorithm.h.

#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)

Definition at line 612 of file UT_ThreadedAlgorithm.h.

#define THREADED_METHOD4_INTERNAL ( ISCONST,
CLASSNAME,
DOMULTI,
METHOD,
PARMTYPE1,
PARMNAME1,
PARMTYPE2,
PARMNAME2,
PARMTYPE3,
PARMNAME3,
PARMTYPE4,
PARMNAME4   ) 

Value:

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; \
}

Definition at line 439 of file UT_ThreadedAlgorithm.h.

#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)

Definition at line 615 of file UT_ThreadedAlgorithm.h.

#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)

Definition at line 617 of file UT_ThreadedAlgorithm.h.

#define THREADED_METHOD5_INTERNAL ( ISCONST,
CLASSNAME,
DOMULTI,
METHOD,
PARMTYPE1,
PARMNAME1,
PARMTYPE2,
PARMNAME2,
PARMTYPE3,
PARMNAME3,
PARMTYPE4,
PARMNAME4,
PARMTYPE5,
PARMNAME5   ) 

Value:

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; \
}

Definition at line 469 of file UT_ThreadedAlgorithm.h.

#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)

Definition at line 620 of file UT_ThreadedAlgorithm.h.

#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)

Definition at line 622 of file UT_ThreadedAlgorithm.h.

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

Value:

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; \
}

Definition at line 499 of file UT_ThreadedAlgorithm.h.

#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)

Definition at line 625 of file UT_ThreadedAlgorithm.h.

#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)

Definition at line 627 of file UT_ThreadedAlgorithm.h.

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

Value:

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; \
}

Definition at line 528 of file UT_ThreadedAlgorithm.h.

#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)

Definition at line 630 of file UT_ThreadedAlgorithm.h.

#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)

Definition at line 632 of file UT_ThreadedAlgorithm.h.

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

Value:

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; \
}

Definition at line 557 of file UT_ThreadedAlgorithm.h.

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

Definition at line 592 of file UT_ThreadedAlgorithm.h.

#define THREADED_METHOD_INTERNAL ( ISCONST,
CLASSNAME,
DOMULTI,
METHOD   ) 

Value:

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; \
}

Definition at line 323 of file UT_ThreadedAlgorithm.h.

Generated on Thu May 24 00:09:05 2012 for HDK by  doxygen 1.5.9