ATL / WTL / STL

waiting on events for socket activity

20-Nov-13 22:21

Member 10415780 wrote:
I have problem about it

What problem? Are you using pure Win32, MFC or WTL? Where do you want to save the text? Please give proper details of what you are doing and what does not work.

Veni, vidi, abiit domum

stl thread safe

G.aius.CodeCreator18-Nov-13 15:38

G.aius.CodeCreator

18-Nov-13 15:38

template<typename Container>
class Lock {
public:
    // have been omitted
    Lock(const Container& container)
        : c(container){
            getMutexFor(c);
    }

    ~Lock() {
        releaseMutexFor(c);
    }
private:
    const Container& c;
};

How to realize the releaseMutexFor and getMutexFor?

bkelly1318-Nov-13 14:05

18-Nov-13 14:05

Windows 7, visual studio 2008, C++
Reference: http://www.winsocketdotnetworkprogramming.com/[^]

I just discovered this site and now I think that a TPC/IP class can be created that does not use messages and needs no window. Async socket operation can generate events such as FD_SEND (it is okay to send now) and FD_READ (Windows has received some data for the application to capture.)

I can also declare and generate my own events. If I put the TCP/IP code in a class, make it a thread and crank it up, I can also pass it handles of events I have created along with the some other goodies in a single structure (such as the address of the buffer where the main app puts data to send out).

One of the key calls is WSAWaitForMultipleEvents() function where one of the arguments is an array of event handles. I did not recognize anything that places a limit on the type or category of events that it can received. (Is there any such thing as that? I know that Windows reserves event numbers below a certain value.)

Rather than a long post I will hope that the knowledgeable reader will recognize the intent and comment on the feasibility and/or loop holes and gotchas that await.

Thanks for your time
If you work with telemetry, please check this bulletin board: http://www.bkelly.ws/irig_106/

Orjan Westin19-Nov-13 23:03

Orjan Westin

19-Nov-13 23:03

This is perfectly feasible, and there's a good example at the WSAWaitForMultipleEvents[^] help page.

bkelly1325-Nov-13 16:08

25-Nov-13 16:08

OK, I am going that way, mostly, I think. After a bunch of searching I have found/concluded that the several version of WaitForMultiple[Event,Object] all wind up using this:

ASM

DWORD WINAPI WaitForMultipleObjects(
  _In_  DWORD nCount,
  _In_  const HANDLE *lpHandles,
  _In_  BOOL bWaitAll,
  _In_  DWORD dwMilliseconds  );

from this page: http://msdn.microsoft.com/en-us/library/windows/desktop/ms687025(v=vs.85).aspx[^]

If the other versions, specifically the WSA versions are wrappers, and my primary goal is speed (i.e. minimum overhead), then it seems I should use the most fundamental call. This looks just about as simple as it could be. I am coding up a simple bare-bones thread to test it out. I think I have that ready will start of the main app that will create the events that the thread waits on.

Do you foresee any problems with this?

Edit: My searches have not produced a clear distinction between wait for EVENT and wait for OBJECT. They appear to be synonyms. Is that correct?

Thanks for your time
If you work with telemetry, please check this bulletin board: http://www.bkelly.ws/irig_106/

modified 25-Nov-13 22:28pm.

Orjan Westin25-Nov-13 23:01

Orjan Westin

25-Nov-13 23:01

You'll need to implement a mechanism to shutdown and close the connected sockets if the client closes the connection (I used a WaitForSingleObject in the listening socket thread, with timeout 0 on each of the associated thread handles in turn, to see if it's still running, but it can be done in many other ways).

The WSA versions are wrappers around the WaitForSingleObject and WaitForMultipleObject, yes.

EVENT and OBJECT and HANDLE are effectively all the same thing - they are numerical identifiers that the system uses to look up internal things. In most cases . This means that you can wait on a thread handle (that identifier will be signaled when the thread terminates) for instance. There's a list of the things that can be waited on in the documentation.

Best of luck!

bkelly1326-Nov-13 8:07

What is the window argument in WSAAsyncSelect(...)

26-Nov-13 8:07

Very Cool. That helps. I shall sally forth into this new arena.
Thank you for taking the time to reply.

Thanks for your time
If you work with telemetry, please check this bulletin board: http://www.bkelly.ws/irig_106/

bkelly1310-Nov-13 15:59

Re: What is the window argument in WSAAsyncSelect(...)

10-Nov-13 15:59

I am trying to figure out async sockets with the WIN API functions. My learning activity is to create a light-weight and fast class that can be used almost anywhere (within Windows OS of course) to create a TCP/IP interface. I used CAsyncSockets, got it working, but it was too slow. Blocking TCP/IP is fast enough, but has some difficulties I want to circumvent with async code.. In this article:
Programming Windows TCP Sockets in C++ for the Beginner[^]

The author references this call to set the socket mode to asynchronous:

//Switch the socket to a non-blocking asynchronous one
int PASCAL WSAAsyncSelect(SOCKET,HWND,u_int,long);

The MSDN page says the second argument is a handle to the window that will receive the messages.
Some details: I want to create a class that can be instantiated to create a TCP/IP interface from an application without a window interface. Specifically, my application will fetch telemetry data from some hardware, no user interface required there, I have the function calls to get the data. My app will open a socket as the server. When a client connects, it will send telemetry data to the user. No “window” or other user interface. No console window or DOS cmd window required or wanted.
Question: What can be put in as argument 2 for WSAAsyncSelect(…) Here it is from the MSDN page:

int WSAAsyncSelect(
  _In_  SOCKET s,
  _In_  HWND hWnd,
  _In_  unsigned int wMsg,
  _In_  long lEvent
);

Possible answer: The author included this next:

#define MY_MESSAGE_NOTIFICATION      1048 //Custom notification message

//This is our message handler/window procedure
LRESULT CALLBACK WndProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
    switch (message) //handle the messages
    {
    case MY_MESSAGE_NOTIFICATION: //Is a message being sent?
…

It is not in the downloaded code and not described fully. Does this become the “window” passed in that argument?

Thanks for your time
If you work with telemetry, please check this bulletin board: http://www.bkelly.ws/irig_106/

modified 10-Nov-13 22:09pm.

Richard MacCutchan10-Nov-13 21:08

create a window for callbacks

10-Nov-13 21:08

The application in question must have a window in order to receive the messages; that is the way that Windows works. The example you have above is merely showing how to implement a user defined message. If the application requires no user interaction at all then it is not necessary to show the Window, but it must still be created.

Veni, vidi, abiit domum

bkelly1311-Nov-13 2:00

11-Nov-13 2:00

Some searches indicate that I can create a window just for the callback with something like:

hwnd = ::CreateWindowEx(...)

Then I use the above noted procedure to get those messages, identify the message, and call the appropriate method.

Am I getting close? Will it be that simple?

Thanks for your time
If you work with telemetry, please check this bulletin board: http://www.bkelly.ws/irig_106/

Richard MacCutchan11-Nov-13 3:01

11-Nov-13 3:01

bkelly13 wrote:
Will it be that simple?

Pretty much, yes. You also need a message pump to dispatch the messages to your handler. I would suggest you create a basic Windows application from the Win32 app template that comes with Visual Studio, and then add your socket code to it. That will allow you to display information as the application proceeds, and also to use the debugger to trace things. Once you have everything working as you require you can hide the window in your release version.

Veni, vidi, abiit domum

bkelly1311-Nov-13 4:49

11-Nov-13 4:49

Hello,
RE:

Quote:
I would suggest you create a basic Windows application from the Win32 app template that comes with Visual Studio, and then add your socket code to it.

That puzzles me a bit. My end result for this code is a class that can be included in various projects as opposed to a stand alone application. I cannot see very far down this path yet so will this method yield the results I want? Will I be able to just simply instantiate the class in a new project and have all that is needed for a TCP/IP link with another application/computer?

Thanks for your time
If you work with telemetry, please check this bulletin board: http://www.bkelly.ws/irig_106/

Richard MacCutchan11-Nov-13 6:33

11-Nov-13 6:33

bkelly13 wrote:
Will I be able to just simply instantiate the class in a new project and have all that is needed for a TCP/IP link with another application/computer?

Quite possibly, but you still need to get it working first. My suggestion was to create a simple application in which to build and test your class. Once you have it all working you can convert your class into a library which can be used by other people.

Veni, vidi, abiit domum

bkelly1311-Nov-13 8:33

11-Nov-13 8:33

OK, I am going down that path, but I still see two parallel but close roads to take.

1. Write my TCP/IP class and find the handle to the main application and pass that to the class for the WndProc method.

2. Create any type of app/template in Visual studio, create a TCP/IP class, and use the CreateWindowEx(...) to create a new window. Make that window hidden and use it only to catch the TCP/IP messages.

From my perspective the second makes much more sense. If I create a new window from within the TCP/IP class then it does not need to capture message from the main app, or alternative, the main app does not need to tell the class about the messages received.

Thanks for your time
If you work with telemetry, please check this bulletin board: http://www.bkelly.ws/irig_106/

Richard MacCutchan11-Nov-13 22:37

11-Nov-13 22:37

I guess you have to try it and see which works best.

Veni, vidi, abiit domum

bkelly1312-Nov-13 15:50

Re: What is the window argument in WSAAsyncSelect(...)

12-Nov-13 15:50

Yes. I am working on a tutorial on the basic window and messaging (again) to try to get that right before I try to make it work with a specific class. This will take a bit.
Thanks for taking the time to converse and advise me on this.

Thanks for your time
If you work with telemetry, please check this bulletin board: http://www.bkelly.ws/irig_106/

Orjan Westin19-Nov-13 23:25

Orjan Westin

19-Nov-13 23:25

You do not need a window, or a message pump, if you use Winsock2 (see Creating a Basic Winsock Application[^] and it's following articles).

Call socket to create a listening socket, bind it to the host address, set it to be non-blocking with ioctlsocket, and set it to listen with listen. Once listening, accept incoming connections and foist the resulting socket off to its own thread where it can receive data using recv. If there's nothing to accept, sleep for a bit and loop around.

Simple. Smile | :)

(I'd post proper code if I had the right to do so. This is reading from an implementation I wrote for $EMPLOYER a couple of years ago. Somewhere at home I have the code I wrote for myself many years ago, and I'll try to dig it out, write it up, and post it one of these days.)

Alternatively, have you had a look at boost::asio[^]?

Re: What is the window argument in WSAAsyncSelect(...)

bkelly1321-Nov-13 14:51

MFC vs STL performance test

21-Nov-13 14:51

Cool. I will be working that concept.
Thank you for taking the time to post.

Thanks for your time
If you work with telemetry, please check this bulletin board: http://www.bkelly.ws/irig_106/

Alexander Fedorov18-Oct-13 11:42

Alexander Fedorov

18-Oct-13 11:42

Hi guys,
I did some performance comparison between MFC and STL containers and I think maybe it could evolve into an article here at Codeproject. Please have a look at my code and suggest some improvements to make comparison more valid. So far I found that STL still sucks big time even after 10 or 15 years of polishing (and neglecting of MFC) in VS2012. Following is complete source code, just drop it into console project with MFC support, compile and run in Release mode.

// MFCvsSTL.cpp : Performance comparison between MFC and STL containers
// (c) Alex Fedorov http:://alexf.name 2013

#include "stdafx.h"
#include "MFCvsSTL.h" // nothing special here

#include <unordered_map>
#include <map>
#include <vector>
#include <list>


#ifdef _DEBUG
#define new DEBUG_NEW
#endif

// The one and only application object

CWinApp theApp;

using namespace std;

// typedef map<DWORD, void*> stlmap;
typedef unordered_map<DWORD, void*> stlmap;

int stlMap(int nCount)
{
	int nSize = (int)(1.2 * (float)nCount);
	stlmap a(nSize);
	// unordered_map <DWORD, void*> a(nSize);
	for( int i = 0; i < nCount; ++i )
	{
		a[ i ] = (void *) i;
	}
	stlmap::iterator iter;
	for( int j = 0; j < nCount; ++j )
	{
		iter = a.find( ( abs( rand() * j ) % nCount ) ); 
	}
	return 1;
}

int mfcMap(int nCount)
{
	int nSize = (int)(1.2 * (float)nCount);
	// CMapWordToPtr a;
	CMap<DWORD, DWORD, void*, void*> a;
	a.InitHashTable( nSize );
	for( int i = 0; i < nCount; ++i )
	{
		a[ i ] = (void *) i;
	}
	void * val;
	for( int j = 0; j < nCount; ++j )
	{
		a.Lookup( ( abs( rand() * j ) % nCount ), val );
	}
	return 0;
}

int stlArray(int nCount)
{
	vector <int> bigarray;
	int nMs = bigarray.max_size();
	try
	{
		bigarray.reserve(nCount);
	}
	catch (...)
	{
		CString str;
		str.Format(_T("Memory allocation error trying to reserve %d elements. vector.max_size=%d\r\n"), nCount, nMs);
		_tprintf(str);
		return 0;
	}
	for(int k = 0; k < nCount; ++k)
	{
		bigarray.push_back(k);
		// bigarray[k] = k;
	}
	int ret = bigarray.size();
	return ret;
}

int mfcArray(int nCount)
{
	// CArray<int,int> arr;
	// OCArray<int> arr;
	CUIntArray arr;
	arr.SetSize(0, nCount);
	for(int k = 0; k < nCount; ++k)
	{
		arr.Add(k);
		// arr[k] = k;
	}
	int ret = arr.GetCount();
	return ret;
}

int mfcList(int nCount)
{
	CList<int, int> a;
	for(int k = 0; k < nCount; ++k)
	{
		a.AddHead(k);
	}
	for( int j = 0; j < nCount; ++j )
	{
		int n = abs(rand() * j ) % nCount;
		POSITION pos = a.Find(n);
	}
	return 1;
}

int stlList(int nCount)
{
	list<int> mylist;
	for(int k = 0; k < nCount; ++k)
	{
		mylist.push_front (k);
	}
	for( int j = 0; j < nCount; ++j )
	{
		int n = abs(rand() * j ) % nCount;
		std::list<int>::iterator findIter = std::find(mylist.begin(), mylist.end(), n);
	}
	return 1;
}

class CTimeHelper2013
{
public:
	SYSTEMTIME m_st1;
	SYSTEMTIME m_st2;
	BOOL m_bStarted;
	//
	int Start();
	int DiffMS();
	//
	CTimeHelper2013();
	virtual ~CTimeHelper2013();
};

int timeMFCl(int nCount)
{
	CTimeHelper2013 th;
	th.Start();
	mfcList(nCount);
	return th.DiffMS();
}

int timeSTLl(int nCount)
{
	CTimeHelper2013 th;
	th.Start();
	stlList(nCount);
	return th.DiffMS();
}

int timeMFCv(int nCount)
{
	CTimeHelper2013 th;
	th.Start();
	mfcArray(nCount);
	return th.DiffMS();
}

int timeSTLv(int nCount)
{
	CTimeHelper2013 th;
	th.Start();
	stlArray(nCount);
	return th.DiffMS();
}

int timeMFCh(int nCount)
{
	CTimeHelper2013 th;
	th.Start();
	mfcMap(nCount);
	return th.DiffMS();
}

int timeSTLh(int nCount)
{
	CTimeHelper2013 th;
	th.Start();
	stlMap(nCount);
	return th.DiffMS();
}

// http://forums.codeguru.com/showthread.php?129321-STL-vs-MFC
int testHash(int nCount)
{
	int d2 = timeSTLh(nCount);
	int d1 = timeMFCh(nCount);
	CString str;
	str.Format(_T("CMap vs unordered_map. Fill & find %d elements. MFC (%d)ms STL (%d)ms\r\n"), nCount, d1, d2);
	_tprintf(str);
	return 1;
}

int testArray(int nCount)
{
	int d2 = timeSTLv(nCount);
	int d1 = timeMFCv(nCount);
	CString str;
	str.Format(_T("CArray vs vector. Fill %d elements. MFC (%d)ms STL (%d)ms\r\n"), nCount, d1, d2);
	_tprintf(str);
	return 1;
}

int testList(int nCount)
{
	int d2 = timeSTLl(nCount);
	int d1 = timeMFCl(nCount);
	CString str;
	str.Format(_T("CList vs list. Fill & find %d elements. MFC (%d)ms STL (%d)ms\r\n"), nCount, d1, d2);
	_tprintf(str);
	return 1;
}

// http://blogs.msdn.com/b/vcblog/archive/2009/06/23/stl-performance.aspx
void perf_startup()
{
	SetThreadAffinityMask(GetCurrentThread(), 1);
	SetThreadIdealProcessor(GetCurrentThread(), 0);
	Sleep(1);
}

CTimeHelper2013::CTimeHelper2013()
{
	m_bStarted = 0;

}

CTimeHelper2013::~CTimeHelper2013()
{

}

int CTimeHelper2013::Start()
{
	GetLocalTime(&m_st1);
	m_bStarted = 1;
	return 1;
}

int CTimeHelper2013::DiffMS()
{
	GetLocalTime(&m_st2);
	m_bStarted = 0;
	int nRet1 = m_st2.wMilliseconds - m_st1.wMilliseconds;
	int nRet2 = m_st2.wSecond - m_st1.wSecond;
	int nRet3 = m_st2.wMinute - m_st1.wMinute;
	int nRet4 = m_st2.wHour - m_st1.wHour;
	int nRet5 = m_st2.wDay - m_st1.wDay;
	int nRet6 = m_st2.wMonth - m_st1.wMonth;
	int nRet7 = m_st2.wYear - m_st1.wYear;
	int nRet = 0;
	nRet += nRet1;
	nRet += nRet2 * 1000;
	nRet += nRet3 * 1000 * 60;
	nRet += nRet4 * 1000 * 60 * 60;
	nRet += nRet5 * 1000 * 60 * 60 * 24;
	nRet += nRet6 * 1000 * 60 * 60 * 24 * 30; // approximation
	nRet += nRet7 * 1000 * 60 * 60 * 24 * 365; // approximation
	return nRet;
}

int _tmain(int argc, TCHAR* argv[], TCHAR* envp[])
{
	int nRetCode = 0;
	HMODULE hModule = ::GetModuleHandle(NULL);

	if (NULL == hModule != NULL)
	{
		// TODO: change error code to suit your needs
		_tprintf(_T("Fatal Error: GetModuleHandle failed\n"));
		return 1;
	}
	if (!AfxWinInit(hModule, NULL, ::GetCommandLine(), 0))
	{
		// TODO: change error code to suit your needs
		_tprintf(_T("Fatal Error: MFC initialization failed\n"));
		return 2;
	}
	_tprintf(_T("MFC vs STL performance test\n"));
	perf_startup(); // unnecessary
	testList(1000 * 10);
	testList(1000 * 100);
	testList(1000 * 200);
	testArray(1000 * 100);
	testArray(1000 * 1000);
	testArray(1000 * 1000 * 200);
	testHash(1000 * 100);
	testHash(1000 * 1000);
	testHash(1000 * 1000 * 20);
	return nRetCode;
}

Richard MacCutchan18-Oct-13 21:08

See http://www.codeproject.com/Messages/3122363/How-to-get-an-answer-to-your-question.aspx[^].

18-Oct-13 21:08

Veni, vidi, abiit domum

Alexander Fedorov19-Oct-13 0:46

Alexander Fedorov

19-Oct-13 0:46

Exactly why? I can't believe I am violating something.

pasztorpisti19-Oct-13 4:44

pasztorpisti

19-Oct-13 4:44

To me this simply doesn't seem to be a question and posting code bloat is not really valid on CP I think.

MFC containers: Read this: http://stackoverflow.com/questions/1348078/why-stl-containers-are-preferred-over-mfc-containers[^]

MFC containers vs stl containers: stl is highly portable. The MFC/ATL CString is often better. And we could list pros and contras but I would suggest using stl because it is portable across platforms/compilers...

None of these containers are perfect. They are still OK for 99% of average user applications because performance really doesn't matter in most applications. The threads of an average program spend most of their time sleeping and waiting for IO so the heavy weightlifting is done by the OS and not by the containers compiled into a program.

In far less then 1% of the cases when performance or memory usage matters often none of the above solutions are OK and in that case you have to write your own container specialized for an edge case. For example what do you do if you want a vector that doesn't allocate capacity for 16 items by default even if its empty? Or if you want a vector that takes only the space of a null pointer when empty (because you want to have a lot of vectors and most of them will be empty)?

I wouldn't waste my time comparing the efficiency of two general-purpose container libraries for the reasons mentioned above, especially because you use general-purpose containers usually when performance/memory usage isn't a terrible issue. If you have issues then you circumvent them either by changing your algorithm/memory access to help the general-purpose container library to perform better or by providing custom allocators or as a last resort by writing your own.