C / C++ / MFC

Vaclav_Sal wrote:

What are the basic benefits of using mmioxxxx “file” functions as opposed to “plain “ MFC CFile?

Mark Salsbery
Microsoft MVP - Visual C++

// OVERLAPPEDOP_xxx used for overlapped IO

#define OVERLAPPEDOP_NOOP				0
#define OVERLAPPEDOP_SOCKACCEPT			1	// CompletionKey = SOCKET, pData  = 0
#define OVERLAPPEDOP_SOCKSEND			2	// CompletionKey = SOCKET, pData  = NETCOMMPACKET*
#define OVERLAPPEDOP_SOCKRECVHEADER		3	// CompletionKey = SOCKET, pData  = NETPACKETHEADER*
#define OVERLAPPEDOP_SOCKRECVPACKET		4	// CompletionKey = SOCKET, pData  = NETCOMMPACKET*
#define OVERLAPPEDOP_EXITTHREAD			5	// CompletionKey = 0

// MANAGEROP_xxx used for server manager thread operations

#define MANAGEROP_ADDCLIENTCONNECTION		1	// pData  = NEWUSERSOCKETINFO*
#define MANAGEROP_REMOVECLIENTCONNECTION	2	// lParam1 = CClientConnection*
#define MANAGEROP_REMOVEIOCPTHREAD			3	// lParam1 = CIOCPHandlerThread*
#define MANAGEROP_BROADCASTMESSAGE			4	// lParam1 = NETCOMMPACKETLITE* (alloc'd as BYTE*), lParam2 = CClientConnection* client to exclude

//-------------------------------------------------------------------------


#pragma pack( push, SRVRMGR_OVERLAPPEDpack, 1 )
//-------------------------------------------------------------------------
struct SRVRMGR_OVERLAPPED
//-------------------------------------------------------------------------
{
	OVERLAPPED Overlapped;

	DWORD dwOpCode;    // OVERLAPPEDOP_xxxx and MANAGEROP_xxxx codes defined above
	CClientConnection *pClientConnection;
	LPARAM	lParam1;
	LPARAM	lParam2;
	DWORD dwDataLength;
	DWORD dwDataLengthProcessed;
	BYTE *pData;

	SRVRMGR_OVERLAPPED()  {memset(this, 0, sizeof(SRVRMGR_OVERLAPPED));}
};
#pragma pack( pop, SRVRMGR_OVERLAPPEDpack)
typedef CTypedPtrList<CPtrList, SRVRMGR_OVERLAPPED*> SRVRMGR_OVERLAPPEDPtrList;

Mark Salsbery
Microsoft MVP - Visual C++

struct IOContext
{
	WSAOVERLAPPED	m_Overlapped;

	enum IOOperation
	{
		IOAccept, 
		IORead, 
		IOWrite, 
		IOConnect, 
		IODisconnect, 
		IODefault,
		IOTerminate,
		IOTerminateStopService
	};
// some more data here
//................
        IOOperation		m_IOOperation;
	IOSocket		* m_pSocket; // this is wrapper class for WSA functions
	LPBYTE			m_pbIoRecvBuffer;	// recv buffer
	DWORD			m_cbIoRecvBuffer;	// currently received bytes
	DWORD			m_sbIoRecvBuffer;	// bytes to receive

	LPBYTE			m_pbIoSendBuffer;	// send buffer
	DWORD			m_cbIoSendBuffer;	// currently sent bytes
	DWORD			m_sbIoSendBuffer;	// bytes to send

	bool GrowRecvBuffer();
	bool FlushRecvBuffer();

	bool GrowSendBuffer();
	bool FlushSendBuffer();
	bool AllocSendBuffer(DWORD dwSize);
}

bool IOContext::GrowRecvBuffer()
{
	m_sbIoRecvBuffer += 2048;
	m_pbIoRecvBuffer = (LPBYTE)::realloc(m_pbIoRecvBuffer, 
										 m_sbIoRecvBuffer);
	if(m_pbIoRecvBuffer == NULL)
	{
		return false;
	}
	return true;
}

bool IOContext::FlushRecvBuffer()
{
	m_sbIoRecvBuffer = 0;
	m_cbIoRecvBuffer = 0;
	if(m_pbIoRecvBuffer)
	{
		::free(m_pbIoRecvBuffer);
		m_pbIoRecvBuffer = NULL;
	}
	return true;
}

bool IOContext::GrowSendBuffer()
{
	return true;
}

bool IOContext::FlushSendBuffer()
{
	m_cbIoSendBuffer = 0;
	m_sbIoSendBuffer = 0;
	if(m_pbIoSendBuffer)
	{
		::free(m_pbIoSendBuffer);
		m_pbIoSendBuffer = NULL;
	}
	return true;
}

bool IOContext::AllocSendBuffer(DWORD dwSize)
{
	m_sbIoSendBuffer = dwSize;
	if(m_pbIoSendBuffer)
	{
		::free(m_pbIoSendBuffer);
		m_pbIoSendBuffer = NULL;
	}
	m_pbIoSendBuffer = new BYTE[m_sbIoSendBuffer];
	return m_pbIoSendBuffer ? true : false;
}

int myclass::StreamAccept()
{
	int WSAStatus = 0;
	DWORD dwFlags = 0;

	IOContext * pIoContextEx = new IOContext();

	try
	{
	::RtlSecureZeroMemory(pIoContextEx, sizeof(IOContext));

	// associate our listen socket with IO port
	if(m_bCorePortUpdated == false)
	{
		this->m_pCorePort->Update(m_pCoreSocket->Socket(), (ULONG_PTR)pIoContextEx);
		m_bCorePortUpdated = true;
	}

	// this will return accepted socket
	pIoContextEx->m_pSocket = m_pCoreSocket->WSAAccept(NULL, NULL);

	// associate new socket with completion port

	this->UpdateCorePort(pIoContextEx->m_pSocket, pIoContextEx);

	// set current IO operation
	pIoContextEx->m_IOOperation = pIoContextEx->IORead;

	// prepare recv buffer
	if(pIoContextEx->m_sbIoRecvBuffer <= pIoContextEx->m_cbIoRecvBuffer)
	{
		pIoContextEx->GrowRecvBuffer();
	}

	// post initial recv and transfer control to worker thread
	WSAStatus = pIoContextEx->m_pSocket->WSARecv(pIoContextEx->m_pbIoRecvBuffer, 
												 pIoContextEx->m_sbIoRecvBuffer, 
												 &pIoContextEx->m_dwBytesTransfered, 
												 &dwFlags, 
												 &pIoContextEx->m_Overlapped);
	}
	catch(Exception &ex)
	{
		::MessageBox(0, ex.ErrorString(), NULL, 0);
	}
	if(WSAStatus == SOCKET_ERROR && ::WSAGetLastError() != ERROR_IO_PENDING)
	{
		throw Exception(::WSAGetLastError(), TEXT(__FILE__), TEXT(__FUNCTION__), __LINE__);
	}
	return WSAStatus;
}

	IOComPort * pIOComPort = (IOComPort *)lpParam; // wrapper class for completion ports API

	IOContext * pIOContext = NULL;	// per socket context
	IOContext * pIOContextCasted = NULL;	// per call context

	LPWSAOVERLAPPED Overlapped = NULL;
	DWORD dwBytesTransfered = 0;

	try
	{
		while(true)
		{

			BOOL bRet = pIOComPort->GetQueuedCompletionStatus(&dwBytesTransfered,
															  (PULONG_PTR)&pIOContext,
															  (LPOVERLAPPED *)&Overlapped,
															  -1);
			pIOContextCasted = (IOContext *)Overlapped;

//.......................
// some parsing here, checking for NULL's and stuff, and there is a read event:

                                case pIOContextCasted->IORead:
					{
						pIOContextCasted->m_dwBytesTransfered = dwBytesTransfered;
						OnStreamRecved(pIOContextCasted, pIOComPort);
					}
				break;

int myclass::OnStreamRecved(IOContext * pIoContext, IOComPort * pIoComPort)
{
	DWORD dwLastError = ERROR_SUCCESS;
	int WSAStatus = 0;

	CGuiPrintf::Inst()->PrintfAppend(TEXT("Total bytes transfered: %d\r\n"), pIoContext->m_dwBytesTransfered);
	if(pIoContext->m_dwBytesTransfered != 0)
	{
		pIoContext->m_cbIoRecvBuffer += pIoContext->m_dwBytesTransfered;
	}
	if(!LastPacket(	pIoContext->m_pbIoRecvBuffer, 
					&pIoContext->m_cbIoRecvBuffer, 
					pIoContext->m_sbIoRecvBuffer))
	{
		CGuiPrintf::Inst()->PrintfAppend(TEXT("Need to fetch more data!\r\n"));
		DWORD dwFlags = 0;
		if(pIoContext->m_sbIoRecvBuffer <= pIoContext->m_cbIoRecvBuffer)
		{
			pIoContext->GrowRecvBuffer();
		}

		pIoContext->m_IOOperation = pIoContext->IORead;

		try
		{

			WSAStatus = pIoContext->m_pSocket->WSARecv(	pIoContext->m_pbIoRecvBuffer + pIoContext->m_cbIoRecvBuffer,
														pIoContext->m_sbIoRecvBuffer - pIoContext->m_cbIoRecvBuffer, 
														&pIoContext->m_dwBytesTransfered, 
														&dwFlags, 
														&pIoContext->m_Overlapped);
		}
		catch(Exception &ex)
		{
			CGuiPrintf::Inst()->PrintfAppend(TEXT("%s\r\n"), ex.ErrorString());
		}

		if(WSAStatus == SOCKET_ERROR && ::WSAGetLastError() != WSA_IO_PENDING)
		{
			return OnStreamDefault(pIoContext, pIoComPort);
		}
		return WSAStatus;
	}

	if(m_bLogTransmition)
	{
		CGuiPrintf::Inst()->PrintfAppend(
			TEXT("CLIENT [%s : %d] SENT THIS: %s\r\n"),
			::inet_ntoa(pIoContext->m_remote), pIoContext->m_port_remote,
			(char *)pIoContext->m_pbIoRecvBuffer);
	}

	// now we are going to send something to a client, something that will 
	// indicate we have recved data, first we set up current IO operation

	::RtlSecureZeroMemory(&pIoContext->m_Overlapped, sizeof(pIoContext->m_Overlapped));
	pIoContext->m_IOOperation = pIoContext->IOWrite;

	// next we prepare some data to send

	BYTE bRes[] = " - server recieved.";
	DWORD dwRespSize = pIoContext->m_cbIoRecvBuffer + sizeof(bRes) + 1;

	pIoContext->AllocSendBuffer(dwRespSize);

	::RtlCopyMemory(pIoContext->m_pbIoSendBuffer, 
					pIoContext->m_pbIoRecvBuffer,
					pIoContext->m_cbIoRecvBuffer);

	::RtlCopyMemory(pIoContext->m_pbIoSendBuffer + pIoContext->m_cbIoRecvBuffer,
					bRes,
					sizeof(bRes));

	// now we send it all

	try
	{

		WSAStatus = pIoContext->m_pSocket->WSASend(pIoContext->m_pbIoSendBuffer, 
												   pIoContext->m_sbIoSendBuffer,
												   &pIoContext->m_dwBytesTransfered,
												   0,
												   &pIoContext->m_Overlapped);
	}
	catch(Exception &ex)
	{
		CGuiPrintf::Inst()->PrintfAppend(TEXT("%s\r\n"), ex.ErrorString());
	}

	pIoContext->FlushRecvBuffer();

	if(WSAStatus == SOCKET_ERROR && ::WSAGetLastError() != ERROR_IO_PENDING)
	{
		return OnStreamDefault(pIoContext, pIoComPort); // clean up client
	}

	return WSAStatus;
}

csrss wrote:

Thats basically doesnt matter, you can mix it.

csrss wrote:

It seems to me that its kind of not possible to have memory allocations with IOCP

Mark Salsbery
Microsoft MVP - Visual C++

john5632 wrote:

I have a node with 2 field 1. Self Record Number and 2. Parent Record Number