Ported throughput to WinCE

1 files changed, 467 insertions, 0 deletions

diff --git a/cppe/demo/IceE/throughput/WinCEClient.cpp b/cppe/demo/IceE/throughput/WinCEClient.cpp
new file mode 100755
index 00000000000..6a5bbefb987
--- /dev/null
+++ b/cppe/demo/IceE/throughput/WinCEClient.cpp
@@ -0,0 +1,467 @@
+// **********************************************************************
+//
+// Copyright (c) 2003-2005 ZeroC, Inc. All rights reserved.
+//
+// This copy of Ice-E is licensed to you under the terms described in the
+// ICEE_LICENSE file included in this distribution.
+//
+// **********************************************************************
+
+#include <IceE/IceE.h>
+#include <Throughput.h>
+
+using namespace std;
+using namespace Demo;
+
+static HWND editHwnd;
+static bool wmDestroy = false;
+
+static LRESULT CALLBACK
+WndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
+{
+    switch(msg)
+    {
+    case WM_CREATE:
+    {
+	RECT rcClient;
+	GetClientRect(hWnd, &rcClient);
+	editHwnd = CreateWindowEx(WS_EX_CLIENTEDGE, L"EDIT", L"", 
+			       WS_CHILD | WS_VISIBLE | WS_VSCROLL | ES_MULTILINE,
+			       0, 0, rcClient.right - rcClient.left, rcClient.bottom - rcClient.top,
+			       hWnd, (HMENU)101, GetModuleHandle(NULL), NULL);
+	assert(editHwnd != NULL);
+    }
+    break;
+
+    case WM_SIZE:
+    {
+	RECT rcClient;
+	GetClientRect(hWnd, &rcClient);
+	SetWindowPos(editHwnd, NULL, 0, 0, rcClient.right, rcClient.bottom, SWP_NOZORDER);
+    }
+    break;
+
+    case WM_CLOSE:
+	DestroyWindow(hWnd);
+	break;
+
+    case WM_DESTROY:
+	wmDestroy = true;
+	PostQuitMessage(0);
+	break;
+
+    default:
+	return DefWindowProc(hWnd, msg, wParam, lParam);
+    }
+    return 0;
+}
+
+int WINAPI
+WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPTSTR lpCmdLine, int nCmdShow)
+{
+    static const TCHAR windowClassName[] = L"Throughput Client";
+    WNDCLASS wc;
+    
+    wc.style	         = CS_HREDRAW|CS_VREDRAW;
+    wc.lpfnWndProc	 = (WNDPROC)WndProc;
+    wc.cbClsExtra	 = 0;
+    wc.cbWndExtra	 = 0;
+    wc.hInstance	 = hInstance;
+    wc.hIcon	         = LoadIcon(NULL, 0);
+    wc.hCursor	         = 0;
+    wc.hbrBackground	 = (HBRUSH) GetStockObject(WHITE_BRUSH);
+    wc.lpszMenuName      = NULL;
+    wc.lpszClassName     = windowClassName;
+
+    if(!RegisterClass(&wc))
+    {
+	MessageBox(NULL, L"Window Registration Failed!", L"Error!",
+		   MB_ICONEXCLAMATION | MB_OK);
+	return 0;
+    }
+
+    RECT rect;
+    GetClientRect(GetDesktopWindow(), &rect);
+    int width = rect.right - rect.left;
+    if(width > 320)
+    {
+	width = 320;
+    }
+    int height = rect.bottom - rect.top;
+    if(height > 200)
+    {
+	height = 200;
+    }
+    HWND mainWnd = CreateWindow(windowClassName, L"Throughput Client", WS_VISIBLE|WS_OVERLAPPED|WS_SYSMENU|WS_SIZEBOX,
+			CW_USEDEFAULT, CW_USEDEFAULT, width, height,
+			NULL, NULL, hInstance, NULL);
+    if(mainWnd == NULL)
+    {
+	MessageBox(NULL, L"Window Creation Failed!", L"Error!", MB_ICONEXCLAMATION | MB_OK);
+	return 0;
+    }
+
+    ShowWindow(mainWnd, SW_SHOW);
+    UpdateWindow(mainWnd);
+
+    int status = EXIT_SUCCESS;
+    Ice::CommunicatorPtr communicator;
+
+    try
+    {
+	Ice::PropertiesPtr properties = Ice::createProperties();
+
+	//
+	// Set a default value for Hello.Proxy so that the demo will
+	// run without a configuration file.
+	//
+	properties->setProperty("Throughput.Throughput", "throughput:tcp -p 10000");
+
+	//
+	// Now, load the configuration file if present.
+	//
+	try
+	{
+	    properties->load("config");
+	}
+	catch(const Ice::FileException&)
+	{
+	}
+	communicator = Ice::initializeWithProperties(__argc, __argv, properties);
+
+	const char* proxyProperty = "Throughput.Throughput";
+	string proxy = properties->getProperty(proxyProperty);
+
+	//
+	// We use a fixed string so that the demo will run without a
+	// configuration file.
+	//
+	ThroughputPrx throughput = ThroughputPrx::checkedCast(communicator->stringToProxy(proxy));
+	if(!throughput)
+	{
+	    MessageBox(NULL, L"invalid proxy", L"Throughput Client", MB_ICONEXCLAMATION | MB_OK);
+	    return EXIT_FAILURE;
+	}
+	ThroughputPrx throughputOneway = ThroughputPrx::uncheckedCast(throughput->ice_oneway());
+
+        //
+        // The amount by which we reduce buffer sizes for CE runs
+        //
+        const int reduce = 100;
+
+	//
+	// Initialize data structures
+	//
+	ByteSeq byteSeq(ByteSeqSize / reduce, 0);
+
+	StringSeq stringSeq(StringSeqSize / reduce, "hello");
+
+	StringDoubleSeq structSeq(StringDoubleSeqSize / 100);
+	int i;
+	for(i = 0; i < StringDoubleSeqSize / reduce; ++i)
+	{
+	    structSeq[i].s = "hello";
+	    structSeq[i].d = 3.14;
+	}
+
+	FixedSeq fixedSeq(FixedSeqSize / reduce);
+	for(i = 0; i < FixedSeqSize / reduce; ++i)
+	{
+	    fixedSeq[i].i = 0;
+	    fixedSeq[i].j = 0;
+	    fixedSeq[i].d = 0;
+	}
+
+	const int repetitions = 1000;
+
+	// Initial ping to setup the connection.
+	throughput->ice_ping();
+
+	::SendMessage(editHwnd, EM_REPLACESEL, (WPARAM)FALSE, 
+		      (LPARAM)L"Running throughput tests (this may take a while)\r\n");
+
+	for(int type = 0; type < 4; ++type)
+	{
+	    wchar_t* data;
+	    int seqSize;
+	    if(type == 0)
+	    {
+	        data = L"byte";
+		seqSize = ByteSeqSize / reduce;
+	    }
+	    else if(type == 1)
+	    {
+	        data = L"string";
+		seqSize = StringSeqSize / reduce;
+	    }
+	    else if(type == 2)
+	    {
+	        data = L"variable-length struct";
+		seqSize = StringDoubleSeqSize / reduce;
+	    }
+	    else if(type == 3)
+	    {
+	        data = L"fixed-length struct";
+		seqSize = FixedSeqSize / reduce;
+	    }
+
+	    
+	    for(int mode = 0; mode < 4; ++mode)
+	    {
+	    	wchar_t* action;
+	    	wchar_t* qualifier = L"";
+		if(mode == 0)
+		{
+		    action = L"sending";
+		}
+		else if(mode == 1)
+		{
+		    action = L"sending";
+		    qualifier = L" as oneway";
+		}
+		else if(mode == 2)
+		{
+		    action = L"receiving";
+		}
+		else if(mode == 3)
+		{
+		    action = L"sending and receiving";
+		}
+	        
+
+	        wchar_t buf[1000];
+	        wsprintf(buf, L"\r\n%s %d %s sequences of size %d%s\r\n", action, repetitions, data, seqSize,
+			 qualifier);
+	        ::SendMessage(editHwnd, EM_REPLACESEL, (WPARAM)FALSE, (LPARAM)buf);
+
+	        IceUtil::Time tm = IceUtil::Time::now();
+	        for(i = 0; i < repetitions; ++i)
+	        {
+                    switch(type)
+                    {
+                        case 0:
+                        {
+                            switch(mode)
+                            {
+                                case 0:
+                                {
+                                    throughput->sendByteSeq(byteSeq);
+                                    break;
+                                }
+
+                                case 1:
+                                {
+                                    throughputOneway->sendByteSeq(byteSeq);
+                                    break;
+                                }
+
+                                case 2:
+                                {
+                                    throughput->recvByteSeq();
+                                    break;
+                                }
+
+                                case 3:
+                                {
+                                    throughput->echoByteSeq(byteSeq);
+                                    break;
+                                }
+                            }
+                            break;
+                        }
+
+                        case 1:
+                        {
+                            switch(mode)
+                            {
+                                case 0:
+                                {
+                                    throughput->sendStringSeq(stringSeq);
+                                    break;
+                                }
+
+                                case 1:
+                                {
+                                    throughputOneway->sendStringSeq(stringSeq);
+                                    break;
+                                }
+
+                                case 2:
+                                {
+                                    throughput->recvStringSeq();
+                                    break;
+                                }
+
+                                case 3:
+                                {
+                                    throughput->echoStringSeq(stringSeq);
+                                    break;
+                                }
+                            }
+                            break;
+                        }
+
+                        case 2:
+                        {
+                            switch(mode)
+                            {
+                                case 0:
+                                {
+                                    throughput->sendStructSeq(structSeq);
+                                    break;
+                                }
+
+                                case 1:
+                                {
+                                    throughputOneway->sendStructSeq(structSeq);
+                                    break;
+                                }
+
+                                case 2:
+                                {
+                                    throughput->recvStructSeq();
+                                    break;
+                                }
+
+                                case 3:
+                                {
+                                    throughput->echoStructSeq(structSeq);
+                                    break;
+                                }
+                            }
+                            break;
+                        }
+
+                        case 3:
+                        {
+                            switch(mode)
+                            {
+                                case 0:
+                                {
+                                    throughput->sendFixedSeq(fixedSeq);
+                                    break;
+                                }
+
+                                case 1:
+                                {
+                                    throughputOneway->sendFixedSeq(fixedSeq);
+                                    break;
+                                }
+
+                                case 2:
+                                {
+                                    throughput->recvFixedSeq();
+                                    break;
+                                }
+
+                                case 3:
+                                {
+                                    throughput->echoFixedSeq(fixedSeq);
+                                    break;
+                                }
+                            }
+                            break;
+                        }
+		    }
+
+	            if((i % 100) == 0)
+	            {
+		        ::SendMessage(editHwnd, EM_REPLACESEL, (WPARAM)FALSE, (LPARAM)L".");
+		        //
+		        // Run the message pump just in case the user tries to close the app.
+		        //
+		        MSG Msg;
+		        while(PeekMessage(&Msg, NULL, 0, 0, PM_REMOVE))
+		        {
+		            TranslateMessage(&Msg);
+		            DispatchMessage(&Msg);
+		        }
+		        if(wmDestroy)
+		        {
+		            break;
+		        }
+	            }   
+		}
+		tm = IceUtil::Time::now() - tm;
+	
+		wsprintf(buf, L"\r\ntime for %d sequences: %fms\r\ntime per sequence: %fms\r\n",
+		         repetitions, tm.toMilliSecondsDouble(), tm.toMilliSecondsDouble() / repetitions);
+		::SendMessage(editHwnd, EM_REPLACESEL, (WPARAM)FALSE, (LPARAM)buf);
+
+                int wireSize = 0;
+                switch(type)
+                {
+                    case 0:
+                    {
+                        wireSize = 1;
+                        break;
+                    }
+                    case 1:
+                    {
+                        wireSize = static_cast<int>(stringSeq[0].size());
+                        break;
+                    }
+                    case 2:
+                    {
+                        wireSize = static_cast<int>(structSeq[0].s.size());
+                        wireSize += 8; // Size of double on the wire.
+                        break;
+                    }
+                    case 3:
+                    {
+                        wireSize = 16; // Size of two ints and a double on the wire.
+                        break;
+                    }
+                }
+                double mbit = repetitions * seqSize * wireSize * 8.0 / tm.toMicroSeconds();
+                if(mode == 3)
+                {
+                    mbit *= 2;
+                }
+		wsprintf(buf, L"throughput: %f MBit/s\r\n", mbit);
+		::SendMessage(editHwnd, EM_REPLACESEL, (WPARAM)FALSE, (LPARAM)buf);
+	    }
+	}
+	
+	::SendMessage(editHwnd, EM_REPLACESEL, (WPARAM)FALSE, 
+		      (LPARAM)L"\r\nThroughput tests completed\r\n");
+
+	//
+	// Run the message pump.
+	//
+	MSG Msg;
+	while(GetMessage(&Msg, NULL, 0, 0) > 0)
+	{
+	    TranslateMessage(&Msg);
+	    DispatchMessage(&Msg);
+	}
+    }
+    catch(const Ice::Exception& ex)
+    {
+	TCHAR wtext[1024];
+	string err = ex.toString();
+	mbstowcs(wtext, err.c_str(), err.size());
+	MessageBox(NULL, wtext, L"Error", MB_ICONEXCLAMATION | MB_OK);
+
+	status = EXIT_FAILURE;
+    }
+
+    if(communicator)
+    {
+	try
+	{
+	    communicator->destroy();
+	}
+	catch(const Ice::Exception& ex)
+	{
+	    TCHAR wtext[1024];
+	    string err = ex.toString();
+	    mbstowcs(wtext, err.c_str(), err.size());
+	    MessageBox(NULL, wtext, L"Error", MB_ICONEXCLAMATION | MB_OK);
+
+	    status = EXIT_FAILURE;
+	}
+    }
+
+    return status;
+}