Author: gonzalo
Date: 2005-04-17 22:38:44 -0400 (Sun, 17 Apr 2005)
New Revision: 43180

Modified:
   trunk/mcs/class/System/System.Net.Sockets/ChangeLog
   trunk/mcs/class/System/System.Net.Sockets/Socket.cs
Log:
2005-04-17 Gonzalo Paniagua Javier <[EMAIL PROTECTED]>

        * Socket.cs: no need for locking in Worker. The actual read / write for
        Receive / Send is performed in the runtime time.




Modified: trunk/mcs/class/System/System.Net.Sockets/ChangeLog
===================================================================
--- trunk/mcs/class/System/System.Net.Sockets/ChangeLog 2005-04-18 02:38:39 UTC 
(rev 43179)
+++ trunk/mcs/class/System/System.Net.Sockets/ChangeLog 2005-04-18 02:38:44 UTC 
(rev 43180)
@@ -1,3 +1,8 @@
+2005-04-17 Gonzalo Paniagua Javier <[EMAIL PROTECTED]>
+
+       * Socket.cs: no need for locking in Worker. The actual read / write for
+       Receive / Send is performed in the runtime time.
+
 2005-04-15 Gonzalo Paniagua Javier <[EMAIL PROTECTED]>
 
        * Socket.cs: added a 'blocking' field that is passed to the runtime.

Modified: trunk/mcs/class/System/System.Net.Sockets/Socket.cs
===================================================================
--- trunk/mcs/class/System/System.Net.Sockets/Socket.cs 2005-04-18 02:38:39 UTC 
(rev 43179)
+++ trunk/mcs/class/System/System.Net.Sockets/Socket.cs 2005-04-18 02:38:44 UTC 
(rev 43180)
@@ -98,8 +98,10 @@
                                if (delayedException != null)
                                        throw delayedException;
 
-                               if (error != 0)
+                               if (error != 0) {
+                                       Console.WriteLine ("Error: {0}", error);
                                        throw new SocketException (error);
+                               }
                        }
 
                        public void Complete ()
@@ -244,105 +246,74 @@
 
                        public void Accept ()
                        {
-                               lock (result) {
-                                       Socket acc_socket = null;
-                                       try {
-                                               acc_socket = result.Sock.Accept 
();
-                                       } catch (Exception e) {
-                                               result.Complete (e);
-                                               return;
-                                       }
-
-                                       result.Complete (acc_socket);
+                               Socket acc_socket = null;
+                               try {
+                                       acc_socket = result.Sock.Accept ();
+                               } catch (Exception e) {
+                                       result.Complete (e);
+                                       return;
                                }
+
+                               result.Complete (acc_socket);
                        }
 
                        public void Connect ()
                        {
-                               lock (result) {
-                                       try {
-                                               result.Sock.Connect 
(result.EndPoint);
-                                               result.Sock.connected = true;
-                                       } catch (Exception e) {
-                                               result.Complete (e);
-                                               return;
-                                       }
-
-                                       result.Complete ();
+                               try {
+                                       result.Sock.Connect (result.EndPoint);
+                                       result.Sock.connected = true;
+                               } catch (Exception e) {
+                                       result.Complete (e);
+                                       return;
                                }
+
+                               result.Complete ();
                        }
 
                        public void Receive ()
                        {
-                               lock (result) {
-                                       int total = 0;
-                                       try {
-                                               total = 
result.Sock.Receive_nochecks (result.Buffer,
-                                                                            
result.Offset,
-                                                                            
result.Size,
-                                                                            
result.SockFlags);
-                                       } catch (Exception e) {
-                                               result.Complete (e);
-                                               return;
-                                       }
-
-                                       result.Complete (total);
-                               }
+                               // Actual recv() done in the runtime
+                               result.Complete ();
                        }
 
                        public void ReceiveFrom ()
                        {
-                               lock (result) {
-                                       int total = 0;
-                                       try {
-                                               total = 
result.Sock.ReceiveFrom_nochecks (result.Buffer,
-                                                                               
 result.Offset,
-                                                                               
 result.Size,
-                                                                               
 result.SockFlags,
-                                                                               
 ref result.EndPoint);
-                                       } catch (Exception e) {
-                                               result.Complete (e);
-                                               return;
-                                       }
-
-                                       result.Complete (total);
+                               int total = 0;
+                               try {
+                                       total = 
result.Sock.ReceiveFrom_nochecks (result.Buffer,
+                                                                        
result.Offset,
+                                                                        
result.Size,
+                                                                        
result.SockFlags,
+                                                                        ref 
result.EndPoint);
+                               } catch (Exception e) {
+                                       result.Complete (e);
+                                       return;
                                }
+
+                               result.Complete (total);
                        }
 
                        public void Send ()
                        {
-                               lock (result) {
-                                       int total = 0;
-                                       try {
-                                               total = 
result.Sock.Send_nochecks (result.Buffer,
-                                                                         
result.Offset,
-                                                                         
result.Size,
-                                                                         
result.SockFlags);
-                                       } catch (Exception e) {
-                                               result.Complete (e);
-                                               return;
-                                       }
-
-                                       result.Complete (total);
-                               }
+                               // Actual send() done in the runtime
+                               result.Complete ();
                        }
 
-                       public void SendTo() {
-                               lock (result) {
-                                       int total = 0;
-                                       try {
-                                               total = 
result.Sock.SendTo_nochecks (result.Buffer,
-                                                                           
result.Offset,
-                                                                           
result.Size,
-                                                                           
result.SockFlags,
-                                                                           
result.EndPoint);
-                                       } catch (Exception e) {
-                                               result.Complete (e);
-                                               return;
-                                       }
-
-                                       result.Complete (total);
+                       public void SendTo ()
+                       {
+                               int total = 0;
+                               try {
+                                       total = result.Sock.SendTo_nochecks 
(result.Buffer,
+                                                                   
result.Offset,
+                                                                   result.Size,
+                                                                   
result.SockFlags,
+                                                                   
result.EndPoint);
+                               } catch (Exception e) {
+                                       result.Complete (e);
+                                       return;
                                }
+
+                               result.Complete (total);
                        }
                }
                        

_______________________________________________
Mono-patches maillist  -  [email protected]
http://lists.ximian.com/mailman/listinfo/mono-patches

Reply via email to