trafficserver-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From masa...@apache.org
Subject [trafficserver] branch quic-latest updated: Using MT_hashtable for VC lookup.
Date Mon, 05 Mar 2018 00:03:12 GMT
This is an automated email from the ASF dual-hosted git repository.

masaori pushed a commit to branch quic-latest
in repository https://gitbox.apache.org/repos/asf/trafficserver.git


The following commit(s) were added to refs/heads/quic-latest by this push:
     new b3759a9  Using MT_hashtable for VC lookup.
b3759a9 is described below

commit b3759a9addf8709c0552cbc282f048f8bbda8614
Author: Jordy Liu <zdliu26@gmail.com>
AuthorDate: Sat Mar 3 17:39:14 2018 +0800

    Using MT_hashtable for VC lookup.
---
 iocore/net/P_QUICPacketHandler.h       |  2 +-
 iocore/net/QUICPacketHandler.cc        |  9 ++++++--
 iocore/net/quic/QUICConfig.cc          | 10 ++++++++-
 iocore/net/quic/QUICConfig.h           |  3 ++-
 iocore/net/quic/QUICConnectionTable.cc | 39 ++++++++++++++++++++--------------
 iocore/net/quic/QUICConnectionTable.h  | 14 ++++++------
 mgmt/RecordsConfig.cc                  |  2 ++
 7 files changed, 52 insertions(+), 27 deletions(-)

diff --git a/iocore/net/P_QUICPacketHandler.h b/iocore/net/P_QUICPacketHandler.h
index 70b3048..886ce70 100644
--- a/iocore/net/P_QUICPacketHandler.h
+++ b/iocore/net/P_QUICPacketHandler.h
@@ -74,7 +74,7 @@ public:
 private:
   void _recv_packet(int event, UDPPacket *udp_packet) override;
 
-  QUICConnectionTable _ctable;
+  QUICConnectionTable *_ctable = nullptr;
   SSL_CTX *_ssl_ctx;
 };
 
diff --git a/iocore/net/QUICPacketHandler.cc b/iocore/net/QUICPacketHandler.cc
index 49ae711..2561005 100644
--- a/iocore/net/QUICPacketHandler.cc
+++ b/iocore/net/QUICPacketHandler.cc
@@ -91,10 +91,15 @@ QUICPacketHandler::_read_connection_id(IOBufferBlock *block)
 QUICPacketHandlerIn::QUICPacketHandlerIn(const NetProcessor::AcceptOptions &opt, SSL_CTX
*ctx) : NetAccept(opt), _ssl_ctx(ctx)
 {
   this->mutex = new_ProxyMutex();
+  // create Connection Table
+  QUICConfig::scoped_config params;
+  _ctable = new QUICConnectionTable(params->connection_table_size());
 }
 
 QUICPacketHandlerIn::~QUICPacketHandlerIn()
 {
+  // TODO: clear all values before destory the table.
+  delete _ctable;
 }
 
 NetProcessor *
@@ -175,7 +180,7 @@ QUICPacketHandlerIn::_recv_packet(int event, UDPPacket *udp_packet)
   }
 
   QUICConnection *qc =
-    this->_ctable.lookup(reinterpret_cast<const uint8_t *>(block->buf()), {udp_packet->from,
udp_packet->to, SOCK_DGRAM});
+    this->_ctable->lookup(reinterpret_cast<const uint8_t *>(block->buf()),
{udp_packet->from, udp_packet->to, SOCK_DGRAM});
 
   vc = static_cast<QUICNetVConnection *>(qc);
   // 7.1. Matching Packets to Connections
@@ -204,7 +209,7 @@ QUICPacketHandlerIn::_recv_packet(int event, UDPPacket *udp_packet)
     // Create a new NetVConnection
     QUICConnectionId original_cid = this->_read_connection_id(block);
     vc                            = static_cast<QUICNetVConnection *>(getNetProcessor()->allocate_vc(nullptr));
-    vc->init(original_cid, udp_packet->getConnection(), this, &this->_ctable);
+    vc->init(original_cid, udp_packet->getConnection(), this, this->_ctable);
     vc->id = net_next_connection_number();
     vc->con.move(con);
     vc->submit_time = Thread::get_hrtime();
diff --git a/iocore/net/quic/QUICConfig.cc b/iocore/net/quic/QUICConfig.cc
index a3ff6ec..8bcf9c9 100644
--- a/iocore/net/quic/QUICConfig.cc
+++ b/iocore/net/quic/QUICConfig.cc
@@ -25,7 +25,8 @@
 
 #include <records/I_RecHttp.h>
 
-int QUICConfig::_config_id = 0;
+int QUICConfig::_config_id                   = 0;
+int QUICConfigParams::_connection_table_size = 65521;
 
 //
 // QUICConfigParams
@@ -38,6 +39,7 @@ QUICConfigParams::initialize()
   REC_EstablishStaticConfigInt32U(this->_initial_max_data, "proxy.config.quic.initial_max_data");
   REC_EstablishStaticConfigInt32U(this->_initial_max_stream_data, "proxy.config.quic.initial_max_stream_data");
   REC_EstablishStaticConfigInt32U(this->_server_id, "proxy.config.quic.server_id");
+  REC_EstablishStaticConfigInt32(_connection_table_size, "proxy.config.quic.connection_table.size");
 }
 
 uint32_t
@@ -58,6 +60,12 @@ QUICConfigParams::server_id() const
   return this->_server_id;
 }
 
+int
+QUICConfigParams::connection_table_size()
+{
+  return _connection_table_size;
+}
+
 uint32_t
 QUICConfigParams::initial_max_data() const
 {
diff --git a/iocore/net/quic/QUICConfig.h b/iocore/net/quic/QUICConfig.h
index 0371774..a7a4f60 100644
--- a/iocore/net/quic/QUICConfig.h
+++ b/iocore/net/quic/QUICConfig.h
@@ -24,7 +24,6 @@
 #pragma once
 
 #include "ProxyConfig.h"
-
 class QUICConfigParams : public ConfigInfo
 {
 public:
@@ -39,6 +38,7 @@ public:
   uint32_t initial_max_stream_id_uni_in() const;
   uint32_t initial_max_stream_id_uni_out() const;
   uint32_t server_id() const;
+  static int connection_table_size();
 
 private:
   // FIXME Fill appropriate default values in RecordsConfig.cc
@@ -47,6 +47,7 @@ private:
   uint32_t _initial_max_data        = 0;
   uint32_t _initial_max_stream_data = 0;
   uint32_t _server_id               = 0;
+  static int _connection_table_size;
 
   uint32_t _initial_max_stream_id_bidi_in  = 100;
   uint32_t _initial_max_stream_id_bidi_out = 101;
diff --git a/iocore/net/quic/QUICConnectionTable.cc b/iocore/net/quic/QUICConnectionTable.cc
index eb048d7..5f860b0 100644
--- a/iocore/net/quic/QUICConnectionTable.cc
+++ b/iocore/net/quic/QUICConnectionTable.cc
@@ -23,29 +23,35 @@
 
 #include "QUICConnectionTable.h"
 
-int
+QUICConnectionTable::~QUICConnectionTable()
+{
+  // TODO: clear all values.
+}
+
+QUICConnection *
 QUICConnectionTable::insert(QUICConnectionId cid, QUICConnection *connection)
 {
-  this->_connections.put(cid, connection);
-  // if (this->_cids.get(connection->endpoint()) == nullptr) {
-  //     this->_cids.put(connection->endpoint(), cid);
-  // }
-  return 0;
+  SCOPED_MUTEX_LOCK(lock, _connections.lock_for_key(cid), this_ethread());
+  // To check whether the return value is nullptr by caller in case memory leak.
+  // The return value isn't nullptr, the new value will take up the slot and return old value.
+  return _connections.insert_entry(cid, connection);
 }
 
 void
 QUICConnectionTable::erase(QUICConnectionId cid, QUICConnection *connection)
 {
-  QUICConnection *qc = this->_connections.get(cid);
-  if (qc == nullptr) {
-    return;
+  SCOPED_MUTEX_LOCK(lock, _connections.lock_for_key(cid), this_ethread());
+  QUICConnection *ret_connection = _connections.remove_entry(cid);
+  if (ret_connection) {
+    ink_assert(ret_connection == connection);
   }
-  ink_assert(qc == connection);
-  Debug("quic_ctable", "ctable erase cid: [%" PRIx64 "] ", static_cast<uint64_t>(cid));
-  // if (this->_cids.get(connection->endpoint(), connection->connection_id()) ==
cid) {
-  //   this->_cids.put(connection->endpoint(), nullptr);
-  // }
-  this->_connections.put(cid, nullptr);
+}
+
+QUICConnection *
+QUICConnectionTable::erase(QUICConnectionId cid)
+{
+  SCOPED_MUTEX_LOCK(lock, _connections.lock_for_key(cid), this_ethread());
+  return _connections.remove_entry(cid);
 }
 
 QUICConnection *
@@ -59,5 +65,6 @@ QUICConnectionTable::lookup(const uint8_t *packet, QUICFiveTuple endpoint)
     // cid = this->_cids.get(endpoint);
     ink_assert(false);
   }
-  return this->_connections.get(cid);
+  SCOPED_MUTEX_LOCK(lock, _connections.lock_for_key(cid), this_ethread());
+  return _connections.lookup_entry(cid);
 }
diff --git a/iocore/net/quic/QUICConnectionTable.h b/iocore/net/quic/QUICConnectionTable.h
index 6bc4b75..0ead233 100644
--- a/iocore/net/quic/QUICConnectionTable.h
+++ b/iocore/net/quic/QUICConnectionTable.h
@@ -25,7 +25,7 @@
 
 #include "QUICTypes.h"
 #include "QUICConnection.h"
-#include "ts/Map.h"
+#include "ts/MT_hashtable.h"
 
 class QUICFiveTuple
 {
@@ -43,12 +43,15 @@ private:
 class QUICConnectionTable
 {
 public:
+  QUICConnectionTable(int hash_table_size = 65521) : _connections(hash_table_size) {}
+  ~QUICConnectionTable();
   /*
    * Insert an entry
    *
-   * Return 1 if it is the only connection or the first connection from the endpoint.
+   * Return zero if it is the only connection or the first connection from the endpoint.
+   * Caller is responsible for memory management.
    */
-  int insert(QUICConnectionId cid, QUICConnection *connection);
+  QUICConnection *insert(QUICConnectionId cid, QUICConnection *connection);
 
   /*
    * Remove an entry
@@ -56,6 +59,7 @@ public:
    * Fails if CID is not associated to a specified connection
    */
   void erase(QUICConnectionId cid, QUICConnection *connection);
+  QUICConnection *erase(QUICConnectionId cid);
 
   /*
    *  Lookup QUICConnection
@@ -65,7 +69,5 @@ public:
   QUICConnection *lookup(const uint8_t *packet, QUICFiveTuple endpoint);
 
 private:
-  // FIXME Use another map impl. that has good support for concurrent access
-  Map<int64_t, QUICConnection *> _connections;
-  // Map<QUICFiveTuple, QUICConnectionId> _cids;
+  MTHashTable<uint64_t, QUICConnection *> _connections;
 };
diff --git a/mgmt/RecordsConfig.cc b/mgmt/RecordsConfig.cc
index b6b3172..4f39a42 100644
--- a/mgmt/RecordsConfig.cc
+++ b/mgmt/RecordsConfig.cc
@@ -1326,6 +1326,8 @@ static const RecordElement RecordsConfig[] =
   ,
   {RECT_CONFIG, "proxy.config.quic.server_id", RECD_INT, "0", RECU_DYNAMIC, RR_NULL, RECC_STR,
"^-?[0-9]+$", RECA_NULL}
   ,
+  {RECT_CONFIG, "proxy.config.quic.connection_table.size", RECD_INT, "65521", RECU_RESTART_TS,
RR_NULL, RECC_INT, "[1-536870909]", RECA_NULL}
+  ,
 
   //# Add LOCAL Records Here
   {RECT_LOCAL, "proxy.local.incoming_ip_to_bind", RECD_STRING, nullptr, RECU_NULL, RR_NULL,
RECC_NULL, nullptr, RECA_NULL}

-- 
To stop receiving notification emails like this one, please contact
masaori@apache.org.

Mime
View raw message