From: tzachid <tzachid@ad392aa1-c5ef-ae45-8dd8-e69d62a5ef86>
Date: Mon, 19 Dec 2005 09:05:16 +0000 (+0000)
Subject: [SDP] Updated the test program to use Multiple Overlapped operation + Minor fixes... 
X-Git-Url: https://openfabrics.org/gitweb/?a=commitdiff_plain;h=91059ce68e6c01f3fa07ae6563961b4c52316f73;p=~shefty%2Frdma-win.git

[SDP] Updated the test program to use Multiple Overlapped operation + Minor fixes to driver (Rev 827)

git-svn-id: svn://openib.tc.cornell.edu/gen1@209 ad392aa1-c5ef-ae45-8dd8-e69d62a5ef86
---

diff --git a/trunk/ulp/sdp/kernel/SdpBufferPool.cpp b/trunk/ulp/sdp/kernel/SdpBufferPool.cpp
index c58d34eb..b554f1cc 100644
--- a/trunk/ulp/sdp/kernel/SdpBufferPool.cpp
+++ b/trunk/ulp/sdp/kernel/SdpBufferPool.cpp
@@ -252,7 +252,7 @@ BufferPool::ReturnBuffer(BufferDescriptor *pBufferDescriptor)
 
 #if DBG    
     if (m_CurrentlySentBuffers == 1) {
-        SDP_PRINT(TRACE_LEVEL_WARNING, SDP_PERFORMANCE, "Currently no packets are bing sent \n");        
+        SDP_PRINT(TRACE_LEVEL_VERBOSE, SDP_PERFORMANCE, "Currently no packets are bing sent \n");        
     }
 #endif
     ASSERT( pBufferDescriptor->GetFlags() == CREDIT_UPDATE ||
@@ -338,7 +338,7 @@ BufferPool::AddToUserBuffers(
                         IRP* pIrp
                         )
 {
-    SDP_PRINT(TRACE_LEVEL_VERBOSE, SDP_BUFFER_POOL, "this = 0x%p \n",this);
+    SDP_PRINT(TRACE_LEVEL_VERBOSE, SDP_BUFFER_POOL, "this = 0x%p m_UserPackets.Size() = %d  \n",this, m_UserPackets.Size());
     AssertLocked();
     NTSTATUS rc = STATUS_SUCCESS;
 
@@ -355,7 +355,6 @@ BufferPool::AddToUserBuffers(
     SetSocket(pIrp,m_pSdpSocket);
 
 
-    ASSERT(m_UserPackets.Size()==0);
     IoMarkIrpPending(pIrp);
     m_UserPackets.InsertTailList(&pIrp->Tail.Overlay.ListEntry);
     *pCopied = true;
@@ -369,11 +368,10 @@ Cleanup:
 #if 0
 The above code should be activated if we want to allow returning offsetof
 the user mode thread as fast as possible.
-
     if (m_CallBackPending == false) {
         NTSTATUS rc1 = m_pSdpSocket->RequestCallBack();
         if (!NT_SUCCESS(rc1)) {
-            SDP_PRINT(SDP_ERR, SDP_BUFFER_POOL, ("PostCredits failed rc = 0x%x\n", rc ));
+            SDP_PRINT(TRACE_LEVEL_ERROR, SDP_BUFFER_POOL, "RequestCallBack failed rc = 0x%x\n", rc );
             ASSERT(FALSE);
         }        
         m_CallBackPending = true;
diff --git a/trunk/ulp/sdp/kernel/SdpDriver.cpp b/trunk/ulp/sdp/kernel/SdpDriver.cpp
index 3d52f827..050676c0 100644
--- a/trunk/ulp/sdp/kernel/SdpDriver.cpp
+++ b/trunk/ulp/sdp/kernel/SdpDriver.cpp
@@ -63,7 +63,7 @@ VOID DriverUnload (
         IN PDRIVER_OBJECT	pDriverObject	
         ) 
 {
-    SDP_PRINT(TRACE_LEVEL_INFORMATION, SDP_DRIVER,"called pDriverObject = 0x%x\n", (uint32_t)pDriverObject );
+    SDP_PRINT(TRACE_LEVEL_INFORMATION, SDP_DRIVER,"called pDriverObject = 0x%p\n", pDriverObject );
     ib_api_status_t ib_status;
 
     g_pSdpDriver->Shutdown();
@@ -271,8 +271,8 @@ NTSTATUS SdpDriver::Dispatch(
     switch (pIrpSp->MajorFunction) {
 
         case IRP_MJ_CREATE: {
-                SDP_PRINT(TRACE_LEVEL_INFORMATION, SDP_DRIVER, "IRP_MJ_CREATE pIrpSp->FileObject = 0x%x\n", 
-                    (uint32_t)pIrpSp->FileObject );
+                SDP_PRINT(TRACE_LEVEL_INFORMATION, SDP_DRIVER, "IRP_MJ_CREATE pIrpSp->FileObject = 0x%p\n", 
+                    pIrpSp->FileObject );
                 pSdpUserFile = new SdpUserFile;
                 if (pSdpUserFile == NULL) {
                     rc = STATUS_NO_MEMORY;
diff --git a/trunk/ulp/sdp/kernel/SdpGenUtils.cpp b/trunk/ulp/sdp/kernel/SdpGenUtils.cpp
index 77626886..db77ec45 100644
--- a/trunk/ulp/sdp/kernel/SdpGenUtils.cpp
+++ b/trunk/ulp/sdp/kernel/SdpGenUtils.cpp
@@ -39,6 +39,8 @@
 #include "SdpGenUtils.tmh"
 #endif
 
+//#define DONT_COPY_DATA
+
 USHORT ntohs(USHORT in)
 {
     return ((in & 0xff) << 8) | ((in & 0xff00) >> 8);
diff --git a/trunk/ulp/sdp/kernel/SdpTrace.cpp b/trunk/ulp/sdp/kernel/SdpTrace.cpp
index 5b8e388a..1fcbdf82 100644
--- a/trunk/ulp/sdp/kernel/SdpTrace.cpp
+++ b/trunk/ulp/sdp/kernel/SdpTrace.cpp
@@ -35,9 +35,12 @@
 #include <stdarg.h>
 #include  <ntstrsafe.h>
 
-
 #if !defined(EVENT_TRACING)
 
+const int g_SdpDbgLevel = SDP_WARN;
+//const int g_SdpDbgLevel = SDP_TRACE;
+//const int g_SdpDbgLevel = SDP_DEBUG;
+
 
 #if DBG 
 //int g_SdpDbgLevel = TRACE_LEVEL_WARNING;
@@ -91,7 +94,7 @@ Return Value:
             KdPrint ((": RtlStringCbVPrintfA failed %x\n", status));
             return;
         }
-        if (lvl <= TRACE_LEVEL_INFORMATION || (lvl <= g_SdpDbgLevel && 
+        if ((lvl <= g_SdpDbgLevel && 
                 ((flags & g_SdpDbgFlags) == flags))) {
             KdPrint(("%s:",__FUNCTION__));
             if(lvl == TRACE_LEVEL_ERROR) KdPrint (("ERROR - "));
@@ -104,4 +107,4 @@ Return Value:
 #endif
 }
 
-#endif 
\ No newline at end of file
+#endif 
diff --git a/trunk/ulp/sdp/tests/basic/SdpConnect.cpp b/trunk/ulp/sdp/tests/basic/SdpConnect.cpp
index 257db86b..b43f503a 100644
--- a/trunk/ulp/sdp/tests/basic/SdpConnect.cpp
+++ b/trunk/ulp/sdp/tests/basic/SdpConnect.cpp
@@ -29,32 +29,32 @@
 #endif
 // Windows linux 
 
-const int NumberOfThreads = 1;
+const int NumberOfThreads = 2;
 
 HANDLE g_ComplitionPort;
-HANDLE *g_pThreads;
+HANDLE g_pThreads[NumberOfThreads];
 
 #define ASSERT assert
 
 struct sockaddr addressFromString(char *address, int port)
 {
-  	unsigned int b1,b2,b3,b4;
+    unsigned int b1,b2,b3,b4;
 
-	struct sockaddr_in socket_address;
-	struct sockaddr *socket_address_ptr = (struct sockaddr*)&socket_address;
+    struct sockaddr_in socket_address;
+    struct sockaddr *socket_address_ptr = (struct sockaddr*)&socket_address;
     
-	memset(&socket_address, 0, sizeof(socket_address));
-	socket_address.sin_family = AF_INET;
-	socket_address.sin_port = htons((u_short)port);
-
-
-	sscanf(address, "%d.%d.%d.%d",&b1, &b2, &b3, &b4);
-	socket_address.sin_addr.s_addr = b4 * 256 * 256 *256 +
-	                                 b3 * 256 * 256 + 
-	                                 b2 * 256 +
-	                                 b1;
-	                                 
-	return *socket_address_ptr;
+    memset(&socket_address, 0, sizeof(socket_address));
+    socket_address.sin_family = AF_INET;
+    socket_address.sin_port = htons((u_short)port);
+
+
+    sscanf(address, "%d.%d.%d.%d",&b1, &b2, &b3, &b4);
+    socket_address.sin_addr.s_addr = b4 * 256 * 256 *256 +
+                                     b3 * 256 * 256 + 
+                                     b2 * 256 +
+                                     b1;
+                                     
+    return *socket_address_ptr;
 }
 
 
@@ -64,13 +64,18 @@ struct OverlappedSend {
     void *Buffer; // The data to send
     int  DataSize;
     DWORD NumberOfBytesSent;
-    int  RemainingSends;
-    int  SendsInAir;     // Curently sent data
-    CRITICAL_SECTION Lock;
-    HANDLE SendDoneEvent;
+    static int  s_RemainingSends;
+    static int  s_SendsInAir;     // Curently sent data (debug only)
+    static CRITICAL_SECTION s_Lock;
+    static HANDLE s_SendDoneEvent;
 
 };
 
+int  OverlappedSend::s_RemainingSends;
+int  OverlappedSend::s_SendsInAir;     // Curently sent data (debug only)
+CRITICAL_SECTION OverlappedSend::s_Lock;
+HANDLE OverlappedSend::s_SendDoneEvent;
+
 
 DWORD WINAPI WorkerThreadFunc( LPVOID lpParam )
 {
@@ -92,16 +97,15 @@ DWORD WINAPI WorkerThreadFunc( LPVOID lpParam )
         ASSERT(ret != 0);
         pOverLappedSend = CONTAINING_RECORD(lpOverlapped, OverlappedSend, Overlapped);
         // Work on the object itself:
-        EnterCriticalSection(&pOverLappedSend->Lock);
-        pOverLappedSend->SendsInAir--;
-        ASSERT(pOverLappedSend->SendsInAir ==0); // Only one thread
-        if (pOverLappedSend->RemainingSends > 0) {
+        EnterCriticalSection(&pOverLappedSend->s_Lock);
+        pOverLappedSend->s_SendsInAir--;
+        if (pOverLappedSend->s_RemainingSends > 0) {
             // do the next send
             WSABUF Buffers;
             Buffers.len = pOverLappedSend->DataSize;
             Buffers.buf = (char *) pOverLappedSend->Buffer;
-            pOverLappedSend->SendsInAir++;
-            pOverLappedSend->RemainingSends--;
+            pOverLappedSend->s_SendsInAir++;
+            pOverLappedSend->s_RemainingSends--;
             
             iRet = WSASend(
                 pOverLappedSend->Socket,
@@ -116,10 +120,10 @@ DWORD WINAPI WorkerThreadFunc( LPVOID lpParam )
 
         } else {
             // Nothing more to send - signal compleation and exit
-            SetEvent(pOverLappedSend->SendDoneEvent);
+            SetEvent(pOverLappedSend->s_SendDoneEvent);
             ContinueLoop = false;
         }
-        LeaveCriticalSection(&pOverLappedSend->Lock);
+        LeaveCriticalSection(&pOverLappedSend->s_Lock);
         if (!ContinueLoop) {
             break;
         }
@@ -130,9 +134,6 @@ DWORD WINAPI WorkerThreadFunc( LPVOID lpParam )
 
 void CreateComplitionPort(SOCKET newfd)
 {
-    g_pThreads = new HANDLE [NumberOfThreads];
-    ASSERT(g_pThreads != NULL);
-
 
     g_ComplitionPort = CreateIoCompletionPort((HANDLE)newfd, NULL, NULL, 2);
     if(g_ComplitionPort == NULL) {
@@ -140,72 +141,94 @@ void CreateComplitionPort(SOCKET newfd)
         exit(1);
     }
 
-    // Create the threads that will work on the complitions
-    g_pThreads[0] = CreateThread(NULL, 0 ,WorkerThreadFunc ,NULL, 0,NULL );
+
+    for (int i=0; i <NumberOfThreads;i++ ) {
+        // Create the threads that will work on the complitions
+        g_pThreads[i] = CreateThread(NULL, 0 ,WorkerThreadFunc ,NULL, 0,NULL );       
+    }
+
+
+
 
 
 }
 
 void CloseComplitionPort()
 {
-    //??? Post a complition thread end message
 
+    // Post a complition thread end message
+    for (int i=0; i <NumberOfThreads - 1;i++ ) {
+        // Sending an overlapped of NULL works, since the
+        // reciever tests first for end of test
+        BOOL  ret = PostQueuedCompletionStatus(
+                              g_ComplitionPort,
+                              0,
+                              NULL,
+                              NULL
+                                );
+        ASSERT(ret != 0);
+    }
     WaitForMultipleObjects(NumberOfThreads,g_pThreads, TRUE, INFINITE);
     CloseHandle(g_ComplitionPort);
 
 }
 
-void SendDataOverlapped(SOCKET newfd, double NumberOfBuffers, double BufferSize, BOOL SendPacketNumber)
+void SendDataOverlapped(SOCKET newfd, int NumberOfOverlappedSend, double NumberOfBuffers, double BufferSize, BOOL SendPacketNumber)
 {
-    // We will start with one operations simultaniously
     int i ;
-    double d;
     VOID *buffer = NULL;
     double elapsed, acc = 0;
-    WSAOVERLAPPED wsa;
     OverlappedSend *pOverLappedSend = NULL;
     BOOL ret;
-    memset(&wsa, 0, sizeof wsa);
 
-    buffer = malloc ((size_t)BufferSize);
-    if (buffer == NULL) {
-        printf("Error allocating buffer\n");
-        exit(1);
-    }
+    printf("Starting to send asyncroniously (%d overlapped) %lf messages of size %lf\n", NumberOfOverlappedSend, NumberOfBuffers, BufferSize );
+
 
     CreateComplitionPort(newfd);
+    pOverLappedSend->s_RemainingSends = (size_t)NumberOfBuffers;
+    pOverLappedSend->s_SendsInAir = 1; // To force a simulate of the compleation
+    InitializeCriticalSection(&pOverLappedSend->s_Lock);
+    pOverLappedSend->s_SendDoneEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
+    
+    double Start = GetTimeMs();
+
+    for(i = 0; i < NumberOfOverlappedSend; i++) {
 
-    pOverLappedSend = new OverlappedSend;
+        buffer = new char [(size_t)BufferSize];
+        if (buffer == NULL) {
+            printf("Error allocating buffer\n");
+            exit(1);
+        }
 
-    // Set it's fields
-    memset(&pOverLappedSend->Overlapped, 0, sizeof (pOverLappedSend->Overlapped));
-    pOverLappedSend->Socket = newfd;
-    pOverLappedSend->Buffer = buffer;
-    pOverLappedSend->DataSize = (size_t)BufferSize;
-    pOverLappedSend->RemainingSends = (size_t)NumberOfBuffers;
-    pOverLappedSend->SendsInAir = 1; // To force a simulate of the compleation
-    InitializeCriticalSection(&pOverLappedSend->Lock);
-    pOverLappedSend->SendDoneEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
+        pOverLappedSend = new OverlappedSend;
 
-    double Start = GetTimeMs();
-    // Post the message that will do the first send
-    ret = PostQueuedCompletionStatus(
+        // Set it's fields
+        memset(&pOverLappedSend->Overlapped, 0, sizeof (pOverLappedSend->Overlapped));
+        pOverLappedSend->Socket = newfd;
+        pOverLappedSend->Buffer = buffer;
+        pOverLappedSend->DataSize = (size_t)BufferSize;
+
+        // Post the message that will do the first send
+        ret = PostQueuedCompletionStatus(
                               g_ComplitionPort,
                               (DWORD)BufferSize,
                               NULL,
                               &pOverLappedSend->Overlapped
                                 );
-    ASSERT(ret != 0);
+        ASSERT(ret != 0);
+
+    }
 
     // wait for the send 
-    WaitForSingleObject(pOverLappedSend->SendDoneEvent, INFINITE);
+    WaitForSingleObject(pOverLappedSend->s_SendDoneEvent, INFINITE);
     elapsed = (GetTimeMs() - Start) / 1000;
     printf("Finishd sending correctly %f mbytes/sec\n", NumberOfBuffers * BufferSize /elapsed/1024/1024 );
     CloseComplitionPort();
 //Cleanup:
-    free(buffer);
-
-
+    for(i = 0; i < NumberOfOverlappedSend; i++) {
+        delete []pOverLappedSend->Buffer;
+        delete pOverLappedSend;
+    }
 }
 
 
@@ -223,7 +246,7 @@ void SendData(SOCKET newfd, double NumberOfBuffers, double BufferSize, BOOL Send
         exit(1);
     }
 
-    printf("Starting to send %lf messages of size %lf\n", NumberOfBuffers, BufferSize );
+    printf("Starting to send syncroniously %lf messages of size %lf\n", NumberOfBuffers, BufferSize );
 
     i = 0;
 
@@ -279,8 +302,8 @@ void RecvData(SOCKET newfd, double NumberOfBuffers, double BufferSize )
         else {
             acc += read1;
 
-//			 printf("read returned %d \"%c%c%c%c\"\n",read1,
-//			 buffer[0],buffer[1], buffer[2], buffer[3]);
+//          printf("read returned %d \"%c%c%c%c\"\n",read1,
+//          buffer[0],buffer[1], buffer[2], buffer[3]);
         }
     }
 
@@ -297,28 +320,28 @@ void RecvData(SOCKET newfd, double NumberOfBuffers, double BufferSize )
 void PrintUsage(char *name)
 {
     printf("The program might be used in client or server mode\n");
-	printf("usage is %s <server> <port number>\n", name);
+    printf("usage is %s <server> <port number>\n", name);
     printf("usage is %s <client> <ip> <port number> <option number> <WritePacketNumber> <UseOverlappedSend> <Number of packets> <PacketSize>\n", name);
     printf("The option will be sent to the remote side\n");
-	printf("Available options are:\n");
-	printf("    1 - just recieve packets forever (the other side will send xxx bytes yyy times)\n");
-	printf("    2 - send xxx bytes yyy times (based on input from network)\n");
+    printf("Available options are:\n");
+    printf("    1 - just recieve packets forever (the other side will send xxx bytes yyy times)\n");
+    printf("    2 - send xxx bytes yyy times (based on input from network)\n");
     printf("    WritePacketNumber can be 0 (no) or 1 (yes)\n");
-    printf("    UseOverlappedSend can be 0 (no) or 1 (yes)\n");
+    printf("    UseOverlappedSend can be 0 (no) or > 0 (number of operations to use)\n");
 
 }
 
 int Connect(int argc, char *argv[])
 {
-	struct sockaddr server_addr;
-  	int port = atoi(argv[3]);
+    struct sockaddr server_addr;
+    int port = atoi(argv[3]);
     int  ret;
     SOCKET s;
     int Send = 0;
     int BufferSize, NumberOfBuffers;
     int result = 0;
-    BOOL SendPacketNumber;
-    int  UseOverlappedSend = 0;
+    bool SendPacketNumber;
+    int  NumberOfOverlappedSend = 0;
 
     if (argv[4][0] == '1') {
         Send = 1;
@@ -330,32 +353,29 @@ int Connect(int argc, char *argv[])
     }
 
     if (argv[5][0] == '0') {
-        SendPacketNumber = FALSE;
+        SendPacketNumber = false;
     }else if (argv[5][0] == '1') {
-        SendPacketNumber = TRUE;
+        SendPacketNumber = true;
     } else {
         printf("Error - don't know if to send the packet number\n");
         exit(1);
     }
 
-    if (argv[6][0] == '0') {
-        UseOverlappedSend = FALSE;
-    }else if (argv[6][0] == '1') {
-        UseOverlappedSend = TRUE;
-    } else {
-        printf("Error - don't know if to send overlapped or not\n");
+    NumberOfOverlappedSend = atoi(argv[6]);
+
+    if ((NumberOfOverlappedSend > 0 ) && (SendPacketNumber == true)) {
+        printf("Warning, Sending packet number is not supported yet in overlapped send\n");
         exit(1);
     }
-    
-
+        
     NumberOfBuffers = atoi(argv[7]);
     BufferSize = atoi(argv[8]);
     
-	printf("Using port %d %s %s %s NumberOfBuffers = %d , BufferSize = %d \n", 
+    printf("Using port %d %s %s %s NumberOfBuffers = %d , BufferSize = %d \n", 
         port, 
         Send == 1 ? "sending" : "recieving", 
         SendPacketNumber ? "Packets Are filed with data" : "Packets are not filled with data",
-        UseOverlappedSend ? "Using overlapped send" : "not using overlapped send", 
+        NumberOfOverlappedSend > 0 ? "Using overlapped send" : "not using overlapped send", 
         NumberOfBuffers,
         BufferSize
         );
@@ -381,7 +401,7 @@ int Connect(int argc, char *argv[])
     // or recieve(=0),UseOverlapped ,NumberOfBuffers, BufferSize,
     if (Send) {
         char message[60];
-        sprintf(message, "1,%d,%d,%d,0,", UseOverlappedSend,NumberOfBuffers, BufferSize);
+        sprintf(message, "1,%d,%d,%d,0,", NumberOfOverlappedSend ,NumberOfBuffers, BufferSize);
         ret = send(s, message, strlen (message), 0);
         if (ret != strlen (message)) {
             printf("Error in send winsock error=%d\n", WSAGetLastError());
@@ -390,7 +410,7 @@ int Connect(int argc, char *argv[])
         } 
     } else {
         char message[60];
-        sprintf(message, "2,%d,%d,%d,%d,",UseOverlappedSend, NumberOfBuffers, BufferSize, SendPacketNumber);
+        sprintf(message, "2,%d,%d,%d,%d,",NumberOfOverlappedSend, NumberOfBuffers, BufferSize, SendPacketNumber ? 1 : 0);
         ret = send(s, message, strlen (message), 0);
         if (ret != strlen (message)) {
             printf("Error in send winsock error=%d\n", WSAGetLastError());
@@ -399,8 +419,8 @@ int Connect(int argc, char *argv[])
         }
     }
     if (Send) {
-        if (UseOverlappedSend) {
-            SendDataOverlapped(s, NumberOfBuffers, BufferSize, SendPacketNumber);
+        if (NumberOfOverlappedSend > 0 ) {
+            SendDataOverlapped(s, NumberOfOverlappedSend, NumberOfBuffers, BufferSize, SendPacketNumber);
         } else {
             SendData(s, NumberOfBuffers, BufferSize, SendPacketNumber);
         }
@@ -435,6 +455,7 @@ int ReadNumber(SOCKET fd)
             printf("Error reading data 1\n");
             exit(1);
         }
+//        printf("%c",Data[i]);
 		if (Data[i] == ',') break;
 		i++;
 		if (i == 20) {
@@ -495,17 +516,23 @@ int Server(int argc, char *argv[])
         BufferSize = ReadNumber(newfd);
         SendPacketNumber = ReadNumber(newfd);
 
-        printf("%s ,%s Using overlapped Send,NumberOfBuffers = %d , BufferSize =%d PacketsFilled=%s \n", 
+        printf("%s ,%d overlapped Send,NumberOfBuffers = %d , BufferSize =%d PacketsFilled=%s \n", 
             option == 2 ? "sending" : "recieving",
-            UseOverlappedSend ? "" : "not",
+            UseOverlappedSend,
             NumberOfBuffers,
             BufferSize,
             SendPacketNumber ? "true" : "false"
             );
         
         if (option == 1) RecvData(newfd, NumberOfBuffers, BufferSize);
-        if (option == 2) SendData(newfd, NumberOfBuffers, BufferSize, SendPacketNumber);
-
+        if (option == 2) {
+            if (UseOverlappedSend > 0) {
+                SendDataOverlapped(newfd, UseOverlappedSend, NumberOfBuffers, BufferSize, SendPacketNumber);
+            } else {
+                SendData(newfd, NumberOfBuffers, BufferSize, SendPacketNumber);
+            }
+        }
+        
         ret = CloseSocket(newfd);
         if (ret == 0) {
             printf("CloseSocket succeeded\n");
@@ -521,20 +548,20 @@ int __cdecl main(int argc, char *argv[])
 {
     int error;	
 
-	if (argc < 3) {
-		PrintUsage(argv[0]);
-		return 1;
-	}
+    if (argc < 3) {
+        PrintUsage(argv[0]);
+        return 1;
+    }
 
 #ifdef _WIN32
     {
         WSADATA wsaData;
 
-    	error = WSAStartup( MAKEWORD( 2, 2 ), &wsaData);
-    	if (error) {
-    		printf("Error in WSAStartup: winsock error=%d\n", WSAGetLastError());
-        		return 1;
-    	}
+        error = WSAStartup( MAKEWORD( 2, 2 ), &wsaData);
+        if (error) {
+            printf("Error in WSAStartup: winsock error=%d\n", WSAGetLastError());
+            return 1;
+        }
     }
 #endif    
     if (!_stricmp(argv[1],"client")) {
@@ -544,16 +571,15 @@ int __cdecl main(int argc, char *argv[])
         Server(argc, argv);
     } else {
         printf("Unknowion option %s", argv[1]);
-		PrintUsage(argv[0]);
+        PrintUsage(argv[0]);
         
     }
-	SOCKET s;
+    SOCKET s;
     s = socket (AF_INET_FAMILY, SOCK_STREAM, 0);
 CloseSocket(s);	
     //printf("calling WSACleanup\n ");
     int ret = WSACleanup ();
     //printf("ret = %d", ret);
-    //Sleep(10000);
     return 0;
 }