C / C++ / MFC

• Takes BigStep (the address of the array of const MyStep structs).
• Casts it to struct Mystep * (hence discarding the const constraint).
• Assigns the result to step (that is probably defined as struct MyStep *).

Ebe72 wrote:

step = (struct MyStep*)BigStep
given,
typedef struct MyStep {...structure
definition...};
const struct MyStep BigStep[]{...an array of MyStep...};

<br />
if(x=0){...Do Something...} (Never Happens)<br />
<br />
int x==1;<br />
<br />
for(x=0;x=10;x++){...Do Something...}<br />
switch(){// In VC5 Trashes the Compiler<br />
break;<br />
}<br />

void open ( const char * filename, ios_base :openmode mode = ios_base::in );

open(filename, ios_base::out);
//Or maybe
open(filename, ios_base::in | ios_base::out);

m_hevWSA = ::WSACreateEvent();
m_sockRecv = ::WSASocket(AF_INET, SOCK_DGRAM, IPPROTO_UDP, NULL, 0, WSA_FLAG_OVERLAPPED);
::bind(m_sockRecv, reinterpret_cast<sockaddr*>(&sinRecv), sizeof(struct sockaddr));

// Worker thread
UINT CMyClass::WorkerThread(void)
{
    int nRet = -1;
    bool bPending = false;
    DWORD dwWSARead = 0;
    DWORD dwWSAFlags = 0;receive flags
    char NetBuf[DGRAM_BUF_SIZE];
    WSABUF WSABuf = { DGRAM_BUF_SIZE, NetBuf };
    HANDLE ahWait[2] = { m_evKill.m_hObject, m_hevWSA };
    WSAOVERLAPPED ovWSA;
    struct sockaddr_in SenderAddr;
    ::ZeroMemory(&SenderAddr, sizeof(SenderAddr));
    ::ZeroMemory(&ovWSA, sizeof(WSAOVERLAPPED));
    ovWSA.hEvent = m_hevWSA;
    do
    {
        int nWSAErr = 0;
        unsigned nNetRead = 0;
        if (!bPending)
        {
            dwWSARead = 0;
            dwWSAFlags = 0;
            WSABuf.len = DGRAM_BUF_SIZE;
            WSABuf.buf = NetBuf;
            int nSenderAddrSize = sizeof(SenderAddr);
            if (::WSARecvFrom(m_sockRecv, &WSABuf, 1, &dwWSARead, &dwWSAFlags,
                (SOCKADDR *)&SenderAddr, &nSenderAddrSize, &ovWSA, NULL) == 0)
            {
                nNetRead = static_cast<unsigned>(dwWSARead);
            }
            else
            {
                nWSAErr = ::WSAGetLastError();
                if (nWSAErr == WSA_IO_PENDING)
                    bPending = true;
                else
                    nRet = 1;
            }
        } // if (!m_bPending)
        switch (::WaitForMultipleObjects(bPending ? 2 : 1,
            ahWait, FALSE, bPending ? INFINITE : 0))			
        {
        case WAIT_OBJECT_0 : nRet = 0; break;
        case WAIT_OBJECT_0 + 1 :
            if (::WSAGetOverlappedResult(m_sockRecv, &ovWSA, &dwWSARead, FALSE, &dwWSAFlags))
            {
                nNetRead += static_cast<unsigned>(dwWSARead);
                bPending = false;
            }
            else
            {
                nWSAErr = ::WSAGetLastError();
                if (nWSAErr != WSA_IO_INCOMPLETE)
                    bPending = false;
            }
            ::ResetEvent(m_hevWSA);
            break;
        }
        if (nNetRead)
        {
            // process data
        }
    }
    while (nRet == -1);
    return (nRet == STILL_ACTIVE) ? 1 : static_cast<UINT>(nRet);
}

Jochen Arndt wrote:

Using one receiving thread is enough even with many clients when the UDP packets
are small.

SledgeHammer01 wrote:

What specifics are we talking here? Seems like common convention on the internet is telling me to restrict UDP packet sizes to 256 bytes, correct?

SledgeHammer01 wrote:

Assuming my UDP server is receiving AND sending to clients, how many clients can I handle in a single thread? 100? 1,000? 10,000? 100,000?

SledgeHammer01 wrote:

Basically trying to do something that could scale to millions of clients. Not even sure if thats possible without multiple servers behind a load balancer though

Jochen Arndt wrote:

Thank you too.
 
Did you find the
problem? When I tried to send an answer, the message was gone.

m_hIOCompletionPort = CreateIoCompletionPort(INVALID_HANDLE_VALUE, NULL, 0, 0);

SOCKET socket = WSASocket(pAddrInfo->ai_family, pAddrInfo->ai_socktype, 0, NULL, 0, WSA_FLAG_OVERLAPPED);

if (bind(socket, pAddrInfo->ai_addr, pAddrInfo->ai_addrlen) == SOCKET_ERROR)
{
...
}

CreateIoCompletionPort((HANDLE)socket, m_hIOCompletionPort, (DWORD)pClientContext, 0);

// I have 8 worker threads in this case, post initial recv

for (int nIndex = 0; nIndex < m_nThreadCount; nIndex++)
{
	SOCKADDR_STORAGE addr;

	addr.ss_family = AF_UNSPEC;
	addr.__ss_align = 0;

	int nAddrLen = sizeof(SOCKADDR_STORAGE);

	DWORD dwBytesSent = 0;
	DWORD dwFlags = 0;

	char szBuffer[MAX_BUFFER_SIZE];
	ZeroMemory(szBuffer, sizeof(szBuffer));

	WSABUF wsaBuf;

	wsaBuf.buf = szBuffer;
	wsaBuf.len = sizeof(szBuffer);

	OVERLAPPED overlapped;
	ZeroMemory(&overlapped, sizeof(OVERLAPPED));

	int nResult = ::WSARecvFrom(socket, &wsaBuf, 1, &dwBytesSent, &dwFlags, (sockaddr*)&addr,
							&nAddrLen, &overlapped, NULL);

	int nError = WSAGetLastError();

        // nResult = 1, nError = IO_PENDING which is ok since no data has arrived yet 
}

// create the 8 worker threads now

	while (WaitForSingleObject(m_hShutdownEvent, 0) != WAIT_OBJECT_0)
	{
		CClientContext* pClientContext = NULL;
		OVERLAPPED* pOverlapped = NULL;
		DWORD dwBytesTransferred = 0;
		DWORD dwFlags = 0;
		WSABUF* pWSABUF = NULL;

		BOOL bReturn = GetQueuedCompletionStatus(m_hIOCompletionPort, &dwBytesTransferred,
												 (LPDWORD)&pClientContext, &pOverlapped, INFINITE);

  // if it got here, I'm assuming the data is in the buffer and ready to go, no?

						SOCKADDR_STORAGE from;
						int nFromLen = sizeof(SOCKADDR_STORAGE);
						memset(&from, 0, sizeof(SOCKADDR_STORAGE));

						int nBytesRecv = -1;

							nBytesRecv = WSARecvFrom(pClientContext->GetSocket(), pWSABUF, 1, &dwBytesTransferred,
													&dwFlags, (sockaddr*)&from, &nFromLen, pOverlapped, NULL);
						


						int j = WSAGetLastError();
						int k = 0;


// PROBLEM is here!! nBytesRecv is still -1 and WSAGetLastError() is still 997 :(. It is my understanding that GetQueuedCompletionStatus() will block until buffer is ready? That is how it works on TCP at least.
						}

}