[tor-commits] [tor/release-0.2.2] Consider sending stream-level SENDME cells on partial flushes.

arma at torproject.org arma at torproject.org
Fri Apr 1 14:17:53 UTC 2011


commit 1d36a8e9ae766f67097f4c5e522c33ff0c4a693f
Author: Nick Mathewson <nickm at torproject.org>
Date:   Mon Mar 14 17:48:45 2011 -0400

    Consider sending stream-level SENDME cells on partial flushes.
    
    Right now, we only consider sending stream-level SENDME cells when we
    have completely flushed a connection_edge's outbuf, or when it sends
    us a DATA cell.  Neither of these is ideal for throughput.
    
    This patch changes the behavior so we now call
    connection_edge_consider_sending_sendme when we flush _some_ data from
    an edge outbuf.
    
    Fix for bug 2756; bugfix on svn r152.
---
 changes/bug2756          |   11 +++++++++++
 src/or/connection.c      |    2 ++
 src/or/connection_edge.c |   17 +++++++++++++++++
 src/or/connection_edge.h |    1 +
 4 files changed, 31 insertions(+), 0 deletions(-)

diff --git a/changes/bug2756 b/changes/bug2756
new file mode 100644
index 0000000..0cad515
--- /dev/null
+++ b/changes/bug2756
@@ -0,0 +1,11 @@
+  o Minor bugfixes (spec conformance, performance):
+    - We now ask the other side of a stream (the client or the exit)
+      for more data on that stream when the amount of queued data on
+      that stream dips low enough.  Previously, we wouldn't ask the
+      other side for more data until either it sent us more data
+      (which it wasn't supposed to do if it had exhausted its
+      window!) or until we had completely flushed all our queued
+      data.  Fixing this should improve throughput.  Fixes bug 2756;
+      bugfix on the earliest released versions of Tor (svn commit
+      r152).
+
diff --git a/src/or/connection.c b/src/or/connection.c
index fd30ac8..86ed45e 100644
--- a/src/or/connection.c
+++ b/src/or/connection.c
@@ -3245,6 +3245,8 @@ connection_flushed_some(connection_t *conn)
     r = connection_dirserv_flushed_some(TO_DIR_CONN(conn));
   } else if (conn->type == CONN_TYPE_OR) {
     r = connection_or_flushed_some(TO_OR_CONN(conn));
+  } else if (CONN_IS_EDGE(conn)) {
+    r = connection_edge_flushed_some(TO_EDGE_CONN(conn));
   }
   conn->in_flushed_some = 0;
   return r;
diff --git a/src/or/connection_edge.c b/src/or/connection_edge.c
index f02479f..85a5225 100644
--- a/src/or/connection_edge.c
+++ b/src/or/connection_edge.c
@@ -301,6 +301,23 @@ connection_edge_end_errno(edge_connection_t *conn)
   return connection_edge_end(conn, reason);
 }
 
+/** We just wrote some data to <b>conn</b>; act appropriately.
+ *
+ * (That is, if it's open, consider sending a stream-level sendme cell if we
+ * have just flushed enough.)
+ */
+int
+connection_edge_flushed_some(edge_connection_t *conn)
+{
+  switch (conn->_base.state) {
+    case AP_CONN_STATE_OPEN:
+    case EXIT_CONN_STATE_OPEN:
+      connection_edge_consider_sending_sendme(conn);
+      break;
+  }
+  return 0;
+}
+
 /** Connection <b>conn</b> has finished writing and has no bytes left on
  * its outbuf.
  *
diff --git a/src/or/connection_edge.h b/src/or/connection_edge.h
index fa5f91c..0b08dd0 100644
--- a/src/or/connection_edge.h
+++ b/src/or/connection_edge.h
@@ -23,6 +23,7 @@ int connection_edge_process_inbuf(edge_connection_t *conn,
 int connection_edge_destroy(circid_t circ_id, edge_connection_t *conn);
 int connection_edge_end(edge_connection_t *conn, uint8_t reason);
 int connection_edge_end_errno(edge_connection_t *conn);
+int connection_edge_flushed_some(edge_connection_t *conn);
 int connection_edge_finished_flushing(edge_connection_t *conn);
 int connection_edge_finished_connecting(edge_connection_t *conn);
 





More information about the tor-commits mailing list