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

}

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

Jochen Arndt wrote:

I have never used GetQueuedCompletionStatus(), because blocking
functions may cause problems. E.g. your shut down event will be only processed
after the blocking function returns. If the network connection of the system
drops, this will never occur.

Jochen Arndt wrote:

To test your code, you should check the return value of
GetQueuedCompletionStatus(), and test if bytes has been read
(dwBytesTransferred).

Jochen Arndt wrote:

You should also test your code with only one thread first to ensure that
problems are not sourced by using multiple threads. In your code you are
starting 8 receives in a loop where each uses the same variables. I'm not sure
if that is working.

Jochen Arndt wrote:

WSARecvFrom() does not return the number of bytes reads. It returns
0 upon success. Upon success you should not call GetLastError()
because it returns the most recent error which may be from any previous called
function that fails. Alternatively, you can call SetLastError(0)
before executing a function that may set an error value.