multiprocdiv.h

基于OpenCV的计算机视觉技术实现.rar

#ifndef __MULTYPROCDIV_H__
#define __MULTYPROCDIV_H__

#include <winbase.h>
#include <crtdbg.h>

#ifdef _DEBUG
    #define thrWriteToTrace0(mac_param0,mac_param1)                                               \
            _RPT0(mac_param0,mac_param1)
    #define thrWriteToTrace1(mac_param0,mac_param1,mac_param2)                                    \
            _RPT1(mac_param0,mac_param1,mac_param2)
    #define thrWriteToTrace2(mac_param0,mac_param1,mac_param2,mac_param3)                         \
            _RPT2(mac_param0,mac_param1,mac_param2,mac_param3)
    #define thrWriteToTrace3(mac_param0,mac_param1,mac_param2,mac_param3,mac_param4)              \
            _RPT3(mac_param0,mac_param1,mac_param2,mac_param3,mac_param4)
    #define thrWriteToTrace4(mac_param0,mac_param1,mac_param2,mac_param3,mac_param4,mac_param5)   \
            _RPT4(mac_param0,mac_param1,mac_param2,mac_param3,mac_param4,mac_param5)
#else
    #define thrWriteToTrace0(mac_param0,mac_param1)
    #define thrWriteToTrace1(mac_param0,mac_param1,mac_param2)
    #define thrWriteToTrace2(mac_param0,mac_param1,mac_param2,mac_param3)
    #define thrWriteToTrace3(mac_param0,mac_param1,mac_param2,mac_param3,mac_param4)
    #define thrWriteToTrace4(mac_param0,mac_param1,mac_param2,mac_param3,mac_param4,mac_param5)
#endif

#define NONE_FINISH_WORK -1
#define BRAKE_WORK -2

#define SET_CHILD_THREAD_PRIORITY(mac_handle)                                      \
    SetThreadPriority( mac_handle, THREAD_PRIORITY_BELOW_NORMAL )

#if(_WIN32_WINNT >= 0x0400)
    #define SET_CHILD_THREAD_AFFINITY_MASK(mac_handle,mac_mask)                    \
        SetThreadAffinityMask( mac_handle, mac_mask )
    #define SET_CHILD_THREAD_IDEAL_PROCESSOR(mac_handle,mac_number)                \
        SetThreadIdealProcessor( mac_handle, (DWORD)mac_number )
#else
    #define SET_CHILD_THREAD_AFFINITY_MASK(mac_handle,mac_mask)
    #define SET_CHILD_THREAD_IDEAL_PROCESSOR(mac_handle,mac_number)
#endif

#define COMMON_GLOBAL_VARS(mac_functionName,mac_inputStructType)                   \
CRITICAL_SECTION mac_functionName##CritSect;                                       \
HANDLE mac_functionName##Event;                                                    \
volatile int mac_functionName##Message;                                            \
HANDLE mac_functionName##ThreadHandle;                                             \
mac_inputStructType mac_functionName##InputStruct


#define IS_THREAD_STILL_WORKING(mac_functionName)                                  \
    ( mac_functionName##ThreadHandle ? true : false )

#define INPUT_STRUCT_COMMON_PARAMS()                                               \
    int threadNum;                                                                 \
    bool doNext;                                                                   \
    HANDLE hThread;                                                                \
    bool working

#define ENTER_THREAD_CRITICAL_SECTION()                                            \
    EnterCriticalSection( criticalSection )

#define LEAVE_THREAD_CRITICAL_SECTION()                                            \
    LeaveCriticalSection( criticalSection )

#define childParams (thrParams[thrTaskNum])

#define INIT_CHILD_THREAD_PARAMS(mac_inputStructType,mac_threadMessage)            \
    mac_inputStructType* params = (mac_inputStructType*)param;                     \
    int threadNum = params->threadNum;                                             \
    CRITICAL_SECTION* criticalSect;                                                \
    HANDLE event;                                                                  \
    int* thrMessage = (int*)&mac_threadMessage;                                    \
    bool anotherThreadBlocksVar

#define BEGIN_CHILD_THREAD_FUNCTION(mac_functionName,mac_inputStructTypeForChild)  \
DWORD mac_functionName##_child( LPVOID param )                                     \
{                                                                                  \
    INIT_CHILD_THREAD_PARAMS( mac_inputStructTypeForChild,                         \
        mac_functionName##Message );                                               \
    criticalSect = &mac_functionName##CritSect;                                    \
    event = mac_functionName##Event;                                               \
    thrWriteToTrace1( _CRT_WARN, "Thread #%d begins\n", threadNum )

#define BEGIN_CHILD_THREAD_CORE()                                                  \
    InterlockedExchange( (long*)&(params->working), (long)true );                  \
    while( params->doNext )                                                        \
    {                                                                              \
        thrWriteToTrace1( _CRT_WARN, "Thread #%d core begins\n", threadNum )

#define END_CHILD_THREAD_CORE()                                                    \
        if( !params->doNext ) {                                                    \
            break;                                                                 \
        }                                                                          \
        thrWriteToTrace1( _CRT_WARN, "Thread #%d core ends\n", threadNum );        \
        EnterCriticalSection( criticalSect );                                      \
            params->doNext = false;                                                \
            anotherThreadBlocksVar = true;                                         \
            while( anotherThreadBlocksVar )                                        \
            {                                                                      \
                if( *thrMessage == NONE_FINISH_WORK ) {                            \
                    *thrMessage = threadNum;                                       \
                    anotherThreadBlocksVar = false;                                \
                }                                                                  \
                else {                                                             \
                    LeaveCriticalSection( criticalSect );                          \
                        Sleep(0);                                                  \
                    EnterCriticalSection( criticalSect );                          \
                }                                                                  \
            }                                                                      \
            thrWriteToTrace1( _CRT_WARN, "Thread #%d sends message\n", threadNum );\
            SetEvent( event );                                                     \
        LeaveCriticalSection( criticalSect );                                      \
        thrWriteToTrace1( _CRT_WARN, "Thread #%d suspends\n", threadNum );         \
        SuspendThread( params->hThread );                                          \
        Sleep(0);                                                                  \
        thrWriteToTrace1( _CRT_WARN, "Thread #%d resumes\n", threadNum );          \
    }

#define END_CHILD_THREAD_FUNCTION()                                                \
    thrWriteToTrace1( _CRT_WARN, "Thread #%d finishes\n", threadNum );             \
    InterlockedExchange( (long*)&(params->working), (long)false );                 \
    return 0;                                                                      \
}                                                                                  
                                                                                   
#define EXIT_CTRL_THREAD(mac_threadHandle)                                         \
    thrWriteToTrace0( _CRT_WARN, "Control thread exits\n" );                       \
    if( eraseFunction ) {                                                          \
        eraseFunction(params);                                                     \
    }                                                                              \
    CloseHandle( *event );                                                         \
    DeleteCriticalSection( criticalSect );                                         \
    mac_threadHandle = 0;                                                          \
    return 0;                                                                      
                                                                                   
#define WAIT_SINGLE_OBJECT_CTRL()                                                  \
WaitForSingleObject( *event, INFINITE );                                           \
if( *thrMessage == BRAKE_WORK ) {                                                  \
    int j;                                                                         \
    thrWriteToTrace0( _CRT_WARN, "Control thread got exit message" );              \
    for( j = 0; j < numProc; j ++ )                                                \
    {                                                                              \
        if( thrParams[j].working == true ) {                                       \
            thrParams[j].doNext = false;                                           \
            ResumeThread( hThread[j] );                                            \
        }                                                                          \
    }                                                                              \
    Sleep( 5000 );                                                                 \
    for( j = 0; j < numProc; j ++ )                                                \
    {                                                                              \
        int termRes;                                                               \
        if( thrParams[j].working == true )                                         \
        {                                                                          \
            char buf[256];                                                         \
            if( termRes = TerminateThread( hThread[j], 1 ) )                       \
            {                                                                      \
                FormatMessage( FORMAT_MESSAGE_FROM_SYSTEM, 0, GetLastError(), 0,   \
                    buf, 256, 0 );                                                 \
                thrWriteToTrace1( _CRT_WARN, "TerminateThread returned: %s\n",     \
                    buf );                                                         \
            }                                                                      \
            else {                                                                 \
                FormatMessage( FORMAT_MESSAGE_FROM_SYSTEM, 0, GetLastError(), 0,   \
                    buf, 256, 0 );                                                 \
                thrWriteToTrace1( _CRT_WARN, "TerminateThread returned: %s\n",     \
                    buf );                                                         \
            }                                                                      \
            WaitForSingleObject( hThread[j], 1000 );                               \
        }                                                                          \
    }                                                                              \
    EXIT_CTRL_THREAD(*thisThreadHandle);                                           \