Разделить функцию i/o на потоки, где число сокетов больше 64

typedef struct _WAIT_THREAD_INFORMATION
{
DWORD dwWaitObjectCount;
PHANDLE pWaitHandles;
DWORD dwWaitMSeconds;
DWORD step;
} WAIT_THREAD_INFORMATION, *PWAIT_THREAD_INFORMATION;


//static
DWORD WINAPI WaitForMultipleObjectsThread(LPVOID lpParameter = NULL)
//
// Thread routine which calls WaitForMultipleObjects
// This is used to wait for more than MAXIMUM_WAIT_OBJECTS objects
//
{
    if (!lpParameter) return 0;
    DWORD u32_Res = 0;
    PWAIT_THREAD_INFORMATION pThreadInformation = NULL;
    assert( lpParameter != NULL ); 
    pThreadInformation = ( PWAIT_THREAD_INFORMATION )lpParameter;
    assert(pThreadInformation->dwWaitObjectCount <= MAXIMUM_WAIT_OBJECTS );
    assert(pThreadInformation->pWaitHandles != NULL );
    u32_Res=WaitForMultipleObjects(pThreadInformation->dwWaitObjectCount,
                                pThreadInformation->pWaitHandles,
                                FALSE,
                               pThreadInformation->dwWaitMSeconds);
    return (u32_Res)+(MAXIMUM_WAIT_OBJECTS*pThreadInformation->step);
}


DWORD TCP::cSocket::WSAWaitForMultipleEventsEx2(DWORD   dwWaitHandleCount,  WSAEVENT*  pWaitHandles,DWORD     dwMaxWaitMSeconds)
{
    HANDLE *                  pThreadWaitHandles    = NULL;
    WAIT_THREAD_INFORMATION * pWaitInformationArray = NULL;

    DWORD                     dwThreadCount         = 0;
    DWORD                     dwLastWaitCount       = 0;
    DWORD                     dwWaitHandleIndex     = 0;
    DWORD                     dwMaximumWaitObjects  = MAXIMUM_WAIT_OBJECTS;

    if( dwWaitHandleCount    <=  0 ) return 0;
    if( pWaitHandles         == NULL ) return 0;
    if ( dwMaxWaitMSeconds    < 1000 ) return 0;
    if( dwMaximumWaitObjects < MAXIMUM_WAIT_OBJECTS ) return 0;

    DWORD u32_Res = 0;    
    {
        //
        // Create separate threads to wait on maximum wait objects
        // and then make this thread wait on thread handles
        //
        dwThreadCount   = dwWaitHandleCount / dwMaximumWaitObjects;
        dwLastWaitCount = dwWaitHandleCount % dwMaximumWaitObjects;

        if( dwLastWaitCount > 0 )
        {
            dwThreadCount++;
        }
       
        //
        // This function can handle a maximum of
        // MAXIMUM_WAIT_OBJECTS * MAXIMUM_WAIT_OBJECT handles
        //
        if( dwThreadCount > dwMaximumWaitObjects )
        {
            dwThreadCount     = dwMaximumWaitObjects;
            dwLastWaitCount   = 0;
        }

        pThreadWaitHandles    = new HANDLE[ dwThreadCount ];
        memset(pThreadWaitHandles,0,sizeof(HANDLE)*dwThreadCount);
        pWaitInformationArray = new WAIT_THREAD_INFORMATION[ dwThreadCount ];
        memset(pWaitInformationArray,0,sizeof(WAIT_THREAD_INFORMATION)*dwThreadCount);

        if( pThreadWaitHandles == NULL || pWaitInformationArray == NULL )
        {
            //
            // Failure
            //
            goto Finished;
        }

        for( DWORD count = 0; count < dwThreadCount; count++)
        {
            //
            // Set information for the thread
            //
            pWaitInformationArray[ count ].dwWaitMSeconds =  dwMaxWaitMSeconds;
            pWaitInformationArray[ count ].pWaitHandles =  &pWaitHandles[ dwWaitHandleIndex ];
            pWaitInformationArray[ count ].step = count;
            if( count != dwThreadCount - 1 || dwLastWaitCount == 0 )
            {
                pWaitInformationArray[ count ].dwWaitObjectCount =   dwMaximumWaitObjects;
                dwWaitHandleIndex += dwMaximumWaitObjects;
            }
            else
            {
                pWaitInformationArray[count].dwWaitObjectCount =   dwLastWaitCount;
                dwWaitHandleIndex += dwLastWaitCount;
            }

            pThreadWaitHandles[ count ] =
                CreateThread( NULL,
                              0,
                              WaitForMultipleObjectsThread,
                              &pWaitInformationArray[ count ],
                              0,
                              NULL );
            if( pThreadWaitHandles[ count ] == NULL )
            {
                dwThreadCount = count;
                break;
            }
        }
       for(DWORD i = 0,j = dwThreadCount; i < j; ++i)
        {
            DWORD result = WaitForSingleObject(pThreadWaitHandles[i], dwMaxWaitMSeconds);
            if (result == WAIT_OBJECT_0)
            {
                DWORD exitcode=0;
                BOOL rc = GetExitCodeThread(pThreadWaitHandles[i], &exitcode);
                if (!rc)
                {
                    // handle error from GetExitCodeThread()...
                    u32_Res = 0;
                    goto Finished;
                }else
                {
                    return exitcode;
                }
            }
            else
                continue;

        }
    }

Finished:

    if( pThreadWaitHandles != NULL )
    {
        for( DWORD count = 0; count < dwThreadCount; count++)
        {
            if( pThreadWaitHandles[ count ] != NULL )
            {
                CloseHandle( pThreadWaitHandles[ count ] );
                pThreadWaitHandles[ count ] = NULL;
            }
        }

        delete [] pThreadWaitHandles;
        pThreadWaitHandles = NULL;
    }

    if( pWaitInformationArray != NULL )
    {
        delete [] pWaitInformationArray;
        pWaitInformationArray = NULL;
    }

    return u32_Res;
}