Changeset 5630 in orxonox.OLD for branches/network/src/lib/network/network_socket.cc

Timestamp:

Nov 18, 2005, 2:21:30 PM (18 years ago)

Author:

rennerc

Message:

network_socket: uses now a thread to send

File:

• branches/network/src/lib/network/network_socket.cc (modified) (19 diffs)

branches/network/src/lib/network/network_socket.cc

@@ -38 +38 @@
 
   tcpSocket = NULL;
-  bufferlength = 0;
-
-  mutex = SDL_CreateMutex();
-  socketmutex = SDL_CreateMutex();
+  incomingBufferLength = 0;
+  outgoingBufferLength = 0;
+
+  incomingBufferMutex = SDL_CreateMutex();
+  outgoingBufferMutex = SDL_CreateMutex();
+  socketMutex = SDL_CreateMutex();
   terminateThread = false;
 
@@ -68 +70 @@
   PRINTF(5)("SDL_net shutdown\n");
 
-  SDL_DestroyMutex(mutex);
-  SDL_DestroyMutex(socketmutex);
+  _isListening = false;
+
+  SDL_DestroyMutex(incomingBufferMutex);
+  SDL_DestroyMutex(outgoingBufferMutex);
+  SDL_DestroyMutex(socketMutex);
 }
 
@@ -94 +99 @@
   }
 
+  _isListening = false;
+
   SDL_CreateThread(thread_read, (void*)this);
+  SDL_CreateThread(thread_write, (void*)this);
 }
 
@@ -104 +112 @@
 void NetworkSocket::listen(unsigned int port)
 {
+  _isListening = true;
   //check if not already connected or listening
   if (tcpSocket)
   {
     PRINTF(1)("NetworkSocket::listen: tcpSocket!=NULL! maybe you already called listen or connectToServer or did not call disconnectServer()!\n");
+    _isListening = false;
     return;
   }
@@ -116 +126 @@
   {
     PRINTF(1)("SDLNet_ResolveHost: %s\n", SDLNet_GetError());
+    _isListening = false;
     return;
   }
@@ -124 +135 @@
   {
     PRINTF(1)("SDLNet_TCP_Open: %s\n", SDLNet_GetError());
+    _isListening = false;
     return;
   }
 
   SDL_CreateThread(thread_listen, (void*)this);
+  SDL_CreateThread(thread_write, (void*)this);
 }
 
@@ -138 +151 @@
   /* Close the connection */
 
-  SDL_mutexP(socketmutex);
+  SDL_mutexP(socketMutex);
   SDLNet_TCP_Close(tcpSocket);
   tcpSocket = NULL;
-  SDL_mutexV(socketmutex);
+  SDL_mutexV(socketMutex);
 
 }
@@ -156 +169 @@
 int NetworkSocket::writeBytes(byte * data, int length)
 {
-  SDL_mutexP(socketmutex);
+#ifdef _USE_OUTGOING_BUFFER
+
+  //printf("length=%d, bufsize=%d\n", length, _OUTGOING_BUFFER_SIZE);
+  if (length>_OUTGOING_BUFFER_SIZE)
+  {
+    int res = 0;
+    int n = length / _OUTGOING_BUFFER_SIZE;
+    if (length % _OUTGOING_BUFFER_SIZE != 0)
+      n++;
+//     printf("n=%d\n", n);
+    SDL_Delay(500);
+    for (int i = 0; i<n; i++)
+    {
+//       printf("i=%d\n", i);
+      if (i==n-1)
+      {
+        res += writeBytes(data + i*_OUTGOING_BUFFER_SIZE, length-i*_OUTGOING_BUFFER_SIZE);
+//         printf("res = %d\n", res);
+      }
+      else
+      {
+        res += writeBytes(data + i*_OUTGOING_BUFFER_SIZE, _OUTGOING_BUFFER_SIZE);
+//         printf("res = %d\n", res);
+      }
+    }
+    return res;
+  }
+
+#define min(a,b) (a<b)?a:b
+  int nbytes = min(_OUTGOING_BUFFER_SIZE - outgoingBufferLength, length);
+#undef min
+
+  if (!tcpSocket || data==NULL || nbytes<=0)
+    return 0;
+
+  SDL_mutexP(outgoingBufferMutex);
+
+  memcpy(outgoingBuffer + outgoingBufferLength, data, nbytes);
+  outgoingBufferLength += nbytes;
+
+  SDL_mutexV(outgoingBufferMutex);
+
+  return nbytes;
+#else
+  SDL_mutexP(socketMutex);
 
   if (!tcpSocket || data==NULL)
@@ -163 +220 @@
   int res = SDLNet_TCP_Send(tcpSocket, data, length);
 
-  SDL_mutexV(socketmutex);
+  SDL_mutexV(socketMutex);
 
   if (res<length)
@@ -169 +226 @@
 
   return res;
+#endif
 }
 
@@ -186 +244 @@
     return 0;
 
-  int nbytes = (length<bufferlength) ? length : bufferlength;
+  int nbytes = (length<incomingBufferLength) ? length : incomingBufferLength;
+
+  //printf("readBytes: nbytes = %d; length=%d; incomingBufferLength=%d\n", nbytes, length, incomingBufferLength);
 
   // just in case ...
@@ -195 +255 @@
       return 0;
 
-  SDL_mutexP(mutex);
-
-  memcpy(data, buf, nbytes);
+  SDL_mutexP(incomingBufferMutex);
+
+  memcpy(data, incomingBuffer, nbytes);
 
   //important: use memmove because the memory areas may overlap
-  memmove(buf, buf+nbytes, bufferlength-nbytes);
-  bufferlength -= nbytes;
-
-  SDL_mutexV(mutex);
+  memmove(incomingBuffer, incomingBuffer+nbytes, incomingBufferLength-nbytes);
+  incomingBufferLength -= nbytes;
+
+  SDL_mutexV(incomingBufferMutex);
 
   return nbytes;
@@ -216 +276 @@
 {
   NetworkSocket * self = (NetworkSocket*)data;
+  self->_isListening = true;
   TCPsocket tempsocket;
 
   tempsocket = SDLNet_TCP_Accept(self->tcpSocket);
 
-  SDL_mutexP(self->socketmutex);
+  while (!tempsocket && !self->terminateThread)
+    tempsocket = SDLNet_TCP_Accept(self->tcpSocket);
+
+  SDL_mutexP(self->socketMutex);
   SDLNet_TCP_Close(self->tcpSocket);
   self->tcpSocket = NULL;
@@ -227 +291 @@
   {
     PRINTF(1)("SDLNet_TCP_Accept: %s\n", SDLNet_GetError());
-    SDL_mutexV(self->socketmutex);
+    //printf("SDLNet_TCP_Accept: %s\n", SDLNet_GetError());
+    SDL_mutexV(self->socketMutex);
+    self->_isListening = false;
     return -1;
   }
@@ -233 +299 @@
   self->tcpSocket = tempsocket;
 
-  SDL_mutexV(self->socketmutex);
-
+  SDL_mutexV(self->socketMutex);
+
+  self->_isListening = false;
   return thread_read(data);
 }
@@ -252 +319 @@
   {
 #define min(a,b) (a<b)?a:b
-    nbytestoread = min(_INCOMING_BUFFER_SIZE - self->bufferlength, _LOCAL_BUFFER_SIZE);
+    nbytestoread = min(_INCOMING_BUFFER_SIZE - self->incomingBufferLength, _LOCAL_BUFFER_SIZE);
+#undef min
 
     //if buffer is full
-    if (nbytestoread<=0)
+    if (nbytestoread<=0 || self->_isListening)
     {
       SDL_Delay(_MSECONDS_SLEEP_FULL_BUFFER);
@@ -263 +331 @@
     nbytesread = SDLNet_TCP_Recv(self->tcpSocket, buffer, nbytestoread);
 
-    SDL_mutexP(self->mutex);
+    SDL_mutexP(self->incomingBufferMutex);
 
     if (nbytesread<=0)
@@ -269 +337 @@
       PRINTF(1)("SDLNet_TCP_Recv: %s\n", SDLNet_GetError());
 
-      SDL_mutexP(self->socketmutex);
+      SDL_mutexP(self->socketMutex);
 
       SDLNet_TCP_Close(self->tcpSocket);
       self->tcpSocket = NULL;
 
-      SDL_mutexV(self->socketmutex);
-      SDL_mutexV(self->mutex);
+      SDL_mutexV(self->socketMutex);
+      SDL_mutexV(self->incomingBufferMutex);
       return -1;
     }
 
-    memcpy(self->buf+self->bufferlength, buffer, nbytesread);
-    self->bufferlength += nbytesread;
-
-    SDL_mutexV(self->mutex);
+    //printf("thread_read: nbytesread=%d\n", nbytesread);
+
+    memcpy(self->incomingBuffer+self->incomingBufferLength, buffer, nbytesread);
+    self->incomingBufferLength += nbytesread;
+
+    SDL_mutexV(self->incomingBufferMutex);
   }
 
@@ -288 +358 @@
 }
 
-
-
+int NetworkSocket::thread_write( void * data )
+{
+  int nbyteswrite = 0;
+  int nbytestowrite = 0;
+  char buffer[_LOCAL_BUFFER_SIZE];
+  NetworkSocket * self = (NetworkSocket*)data;
+
+  while (!self->terminateThread)
+  {
+#define min(a,b) (a<b)?a:b
+    nbytestowrite = min(self->outgoingBufferLength, _LOCAL_BUFFER_SIZE);
+#undef min
+
+    //printf("thread_write nbytes=%d listening=%d\n", nbytestowrite, (int)self->_isListening);
+
+    //if buffer is full
+    if (nbytestowrite<=0 || self->_isListening)
+    {
+      SDL_Delay(_MSECONDS_SLEEP_EMPTY_BUFFER);
+      continue;
+    }
+
+    SDL_mutexP(self->outgoingBufferMutex);
+
+    //printf("a\n");
+
+    memcpy(buffer, self->outgoingBuffer, nbytestowrite);
+    self->outgoingBufferLength -= nbytestowrite;
+    memmove(self->outgoingBuffer, self->outgoingBuffer+nbytestowrite, self->outgoingBufferLength);
+
+    SDL_mutexV(self->outgoingBufferMutex);
+
+    nbyteswrite = SDLNet_TCP_Send(self->tcpSocket, buffer, nbytestowrite);
+
+    if (nbyteswrite<=0)
+    {
+      PRINTF(1)("SDLNet_TCP_Recv: %s\n", SDLNet_GetError());
+
+      SDL_mutexP(self->socketMutex);
+
+      SDLNet_TCP_Close(self->tcpSocket);
+      self->tcpSocket = NULL;
+
+      SDL_mutexV(self->socketMutex);
+      return -1;
+    }
+
+  }
+
+  return 0;
+}
+