explicitly destroy streams; other perf fixes

1 files changed, 127 insertions, 127 deletions

diff --git a/java/src/IceInternal/Connection.java b/java/src/IceInternal/Connection.java
index dba7087a0f8..5a9a462c1df 100644
--- a/java/src/IceInternal/Connection.java
+++ b/java/src/IceInternal/Connection.java
@@ -58,11 +58,15 @@ public final class Connection extends EventHandler
     prepareRequest(Outgoing out)
     {
         BasicStream os = out.os();
-        os.writeByte(Protocol.protocolVersion);
-        os.writeByte(Protocol.encodingVersion);
-        os.writeByte(Protocol.requestMsg);
-        os.writeInt(0); // Message size (placeholder)
-        os.writeInt(0); // Request ID (placeholder)
+        final byte[] arr =
+        {
+            Protocol.protocolVersion,
+            Protocol.encodingVersion,
+            Protocol.requestMsg,
+            (byte)0, (byte)0, (byte)0, (byte)0, // Message size (placeholder)
+            (byte)0, (byte)0, (byte)0, (byte)0  // Request ID (placeholder)
+        };
+        os.writeBlob(arr);
     }
 
     public void
@@ -98,8 +102,7 @@ public final class Connection extends EventHandler
                     }
                     os.writeInt(requestId);
                 }
-                TraceUtil.traceRequest("sending request", os, _logger,
-                                       _traceLevels);
+                TraceUtil.traceRequest("sending request", os, _logger, _traceLevels);
                 _transceiver.write(os, _endpoint.timeout());
             }
             catch (Ice.LocalException ex)
@@ -142,10 +145,14 @@ public final class Connection extends EventHandler
 
         if (_batchStream.size() == 0)
         {
-            _batchStream.writeByte(Protocol.protocolVersion);
-            _batchStream.writeByte(Protocol.encodingVersion);
-            _batchStream.writeByte(Protocol.requestBatchMsg);
-            _batchStream.writeInt(0); // Message size (placeholder)
+            final byte[] arr =
+            {
+                Protocol.protocolVersion,
+                Protocol.encodingVersion,
+                Protocol.requestBatchMsg,
+                (byte)0, (byte)0, (byte)0, (byte)0 // Message size (placeholder)
+            };
+            _batchStream.writeBlob(arr);
         }
 
         //
@@ -201,14 +208,13 @@ public final class Connection extends EventHandler
                 // Fill in the message size
                 //
                 _batchStream.writeInt(_batchStream.size());
-                TraceUtil.traceBatchRequest("sending batch request",
-                                            _batchStream, _logger,
-                                            _traceLevels);
+                TraceUtil.traceBatchRequest("sending batch request", _batchStream, _logger, _traceLevels);
                 _transceiver.write(_batchStream, _endpoint.timeout());
 
                 //
                 // Reset _batchStream so that new batch messages can be sent.
                 //
+                _batchStream.destroy();
                 _batchStream = new BasicStream(_instance);
             }
             catch (Ice.LocalException ex)
@@ -330,16 +336,13 @@ public final class Connection extends EventHandler
                     {
                         if (_state == StateClosing)
                         {
-                            TraceUtil.traceRequest("received request during " +
-                                                   "closing\n(ignored by " +
-                                                   "server, client will " +
-                                                   "retry)", stream, _logger,
-                                                   _traceLevels);
+                            TraceUtil.traceRequest("received request during closing\n" +
+                                                   "(ignored by server, client will retry)",
+                                                   stream, _logger, _traceLevels);
                         }
                         else
                         {
-                            TraceUtil.traceRequest("received request", stream,
-                                                   _logger, _traceLevels);
+                            TraceUtil.traceRequest("received request", stream, _logger, _traceLevels);
                             invoke = true;
                         }
                         break;
@@ -349,19 +352,13 @@ public final class Connection extends EventHandler
                     {
                         if (_state == StateClosing)
                         {
-                            TraceUtil.traceBatchRequest("received batch " +
-                                                        "request during " +
-                                                        "closing\n" +
-                                                        "(ignored by server, " +
-                                                        "client will retry)",
-                                                        stream, _logger,
-                                                        _traceLevels);
+                            TraceUtil.traceBatchRequest("received batch request during closing\n" +
+                                                        "(ignored by server, client will retry)",
+                                                        stream, _logger, _traceLevels);
                         }
                         else
                         {
-                            TraceUtil.traceBatchRequest("received batch " +
-                                                        "request", stream,
-                                                        _logger, _traceLevels);
+                            TraceUtil.traceBatchRequest("received batch request", stream, _logger, _traceLevels);
                             invoke = true;
                             batch = true;
                         }
@@ -370,11 +367,9 @@ public final class Connection extends EventHandler
 
                     case Protocol.replyMsg:
                     {
-                        TraceUtil.traceReply("received reply", stream,
-                                             _logger, _traceLevels);
+                        TraceUtil.traceReply("received reply", stream, _logger, _traceLevels);
                         int requestId = stream.readInt();
-                        Outgoing out =
-                            (Outgoing)_requests.remove(new Integer(requestId));
+                        Outgoing out = (Outgoing)_requests.remove(new Integer(requestId));
                         if (out == null)
                         {
                             throw new Ice.UnknownRequestIdException();
@@ -385,15 +380,12 @@ public final class Connection extends EventHandler
 
                     case Protocol.closeConnectionMsg:
                     {
-                        TraceUtil.traceHeader("received close connection",
-                                              stream, _logger, _traceLevels);
+                        TraceUtil.traceHeader("received close connection", stream, _logger, _traceLevels);
                         if (_endpoint.datagram())
                         {
                             if (_warn)
                             {
-                                _logger.warning("ignoring close connection " +
-                                                "message for datagram " +
-                                                "connection:\n" +
+                                _logger.warning("ignoring close connection message for datagram connection:\n" +
                                                 _transceiver.toString());
                             }
                         }
@@ -431,123 +423,132 @@ public final class Connection extends EventHandler
         if (invoke)
         {
             Incoming in = new Incoming(_instance, _adapter);
-            BasicStream is = in.is();
-            BasicStream os = in.os();
-            stream.swap(is);
-
-            boolean response = false;
-
             try
             {
-                if (!batch)
-                {
-                    int requestId = is.readInt();
-                    if (!_endpoint.datagram() && requestId != 0) // 0 = oneway
-                    {
-                        response = true;
-                        ++_responseCount;
-                        os.writeByte(Protocol.protocolVersion);
-                        os.writeByte(Protocol.encodingVersion);
-                        os.writeByte(Protocol.replyMsg);
-                        os.writeInt(0); // Message size (placeholder)
-                        os.writeInt(requestId);
-                    }
-                }
+                BasicStream is = in.is();
+                BasicStream os = in.os();
+                stream.swap(is);
 
-                do
+                boolean response = false;
+
+                try
                 {
-                    try
-                    {
-                        in.invoke(response);
-                    }
-                    catch (Ice.LocalException ex)
+                    if (!batch)
                     {
-                        _mutex.lock();
-                        try
+                        int requestId = is.readInt();
+                        if (!_endpoint.datagram() && requestId != 0) // 0 = oneway
                         {
-                            if (_warn)
+                            response = true;
+                            ++_responseCount;
+                            final byte[] arr =
                             {
-                                warning("connection exception", ex);
-                            }
-                        }
-                        finally
-                        {
-                            _mutex.unlock();
+                                Protocol.protocolVersion,
+                                Protocol.encodingVersion,
+                                Protocol.replyMsg,
+                                (byte)0, (byte)0, (byte)0, (byte)0 // Message size (placeholder)
+                            };
+                            os.writeBlob(arr);
+                            os.writeInt(requestId);
                         }
                     }
-                    catch (Exception ex)
+
+                    do
                     {
-                        _mutex.lock();
                         try
                         {
-                            if (_warn)
+                            in.invoke(response);
+                        }
+                        catch (Ice.LocalException ex)
+                        {
+                            _mutex.lock();
+                            try
                             {
-                                warning("unknown exception", ex);
+                                if (_warn)
+                                {
+                                    warning("connection exception", ex);
+                                }
+                            }
+                            finally
+                            {
+                                _mutex.unlock();
                             }
                         }
-                        finally
+                        catch (Exception ex)
                         {
-                            _mutex.unlock();
+                            _mutex.lock();
+                            try
+                            {
+                                if (_warn)
+                                {
+                                    warning("unknown exception", ex);
+                                }
+                            }
+                            finally
+                            {
+                                _mutex.unlock();
+                            }
                         }
                     }
+                    while (batch && is.pos() < is.size());
                 }
-                while (batch && is.pos() < is.size());
-            }
-            catch (Ice.LocalException ex)
-            {
-                _mutex.lock();
-                try
-                {
-                    setState(StateClosed, ex);
-                    return;
-                }
-                finally
+                catch (Ice.LocalException ex)
                 {
-                    _mutex.unlock();
+                    _mutex.lock();
+                    try
+                    {
+                        setState(StateClosed, ex);
+                        return;
+                    }
+                    finally
+                    {
+                        _mutex.unlock();
+                    }
                 }
-            }
 
-            if (response)
-            {
-                _mutex.lock();
-                try
+                if (response)
                 {
+                    _mutex.lock();
                     try
                     {
-                        if (_state == StateClosed)
+                        try
                         {
-                            return;
-                        }
+                            if (_state == StateClosed)
+                            {
+                                return;
+                            }
 
-                        //
-                        // Fill in the message size
-                        //
-                        os.pos(3);
-                        final int sz = os.size();
-                        os.writeInt(sz);
+                            //
+                            // Fill in the message size
+                            //
+                            os.pos(3);
+                            final int sz = os.size();
+                            os.writeInt(sz);
 
-                        TraceUtil.traceReply("sending reply", os, _logger,
-                                             _traceLevels);
-                        _transceiver.write(os, _endpoint.timeout());
+                            TraceUtil.traceReply("sending reply", os, _logger, _traceLevels);
+                            _transceiver.write(os, _endpoint.timeout());
 
-                        --_responseCount;
+                            --_responseCount;
 
-                        if (_state == StateClosing && _responseCount == 0 &&
-                            !_endpoint.datagram())
+                            if (_state == StateClosing && _responseCount == 0 && !_endpoint.datagram())
+                            {
+                                closeConnection();
+                            }
+                        }
+                        catch (Ice.LocalException ex)
                         {
-                            closeConnection();
+                            setState(StateClosed, ex);
+                            return;
                         }
                     }
-                    catch (Ice.LocalException ex)
+                    finally
                     {
-                        setState(StateClosed, ex);
-                        return;
+                        _mutex.unlock();
                     }
                 }
-                finally
-                {
-                    _mutex.unlock();
-                }
+            }
+            finally
+            {
+                in.destroy();
             }
         }
     }
@@ -651,19 +652,19 @@ public final class Connection extends EventHandler
         _mutex.lock();
         try
         {
+            _batchStream.destroy();
+
             switch (reason)
             {
                 case ObjectAdapterDeactivated:
                 {
-                    setState(StateClosing,
-                             new Ice.ObjectAdapterDeactivatedException());
+                    setState(StateClosing, new Ice.ObjectAdapterDeactivatedException());
                     break;
                 }
 
                 case CommunicatorDestroyed:
                 {
-                    setState(StateClosing,
-                             new Ice.CommunicatorDestroyedException());
+                    setState(StateClosing, new Ice.CommunicatorDestroyedException());
                     break;
                 }
             }
@@ -792,8 +793,7 @@ public final class Connection extends EventHandler
         _state = state;
 
 
-        if (_state == StateClosing && _responseCount == 0 &&
-            !_endpoint.datagram())
+        if (_state == StateClosing && _responseCount == 0 && !_endpoint.datagram())
         {
             try
             {