Bug#36796808 scalability of HTTP request handling is limited

The http-request router doesn't scale to large number of parallel
requests. At 32 parallel connections handling GET requests to
/no-such-file, the requests per seconds is more or less the same as at
16 parallel connections (on a 128 core machine).

Running `perf` shows that a lot time is spent in the mutex of
HttpRequestRouter::find_route_handler().

Change
======

- changed the std::mutex around the request-handlers into a
  std::shared_mutex to allow parallel reads

Requests/s over parallel connections:

+----+----------+----------+-------+
|    | Before   | After    | Diff  |
+----+----------+----------+-------+
|  1 |  11483.5 |  11703.0 |   +2% |
|  2 |  23964.0 |  24591.0 |   +2% |
|  4 |  39662.5 |  41094.5 |   +3% |
|  8 |  72266.5 |  76064.0 |   +5% |
| 16 |  86481.0 | 148098.5 |  +72% |
| 32 |  98067.5 | 289619.0 | +195% |
| 64 | 102125.5 | 504629.0 | +394% |
+----+----------+----------+-------+

Change-Id: I1481d7700182c67e2a83d9408455b4980615d759

Author: weigon

router/src/http/src/http_request_router.cc

@@ -48,14 +48,15 @@ using BaseRequestHandlerPtr = HttpRequestRouter::BaseRequestHandlerPtr;
 void HttpRequestRouter::append(const std::string &url_regex_str,
                                std::unique_ptr<http::base::RequestHandler> cb) {
   log_debug("adding route for regex: %s", url_regex_str.c_str());
-  std::lock_guard<std::mutex> lock(route_mtx_);
+  std::unique_lock lock(route_mtx_);
+
   request_handlers_.emplace_back(RouterData{
       url_regex_str, std::regex{url_regex_str, std::regex_constants::extended},
       std::move(cb)});
 }
 
 void HttpRequestRouter::remove(const void *handler_id) {
-  std::lock_guard<std::mutex> lock(route_mtx_);
+  std::unique_lock lock(route_mtx_);
 
   for (auto it = request_handlers_.begin(); it != request_handlers_.end();) {
     if (it->handler.get() == handler_id) {
@@ -69,7 +70,8 @@ void HttpRequestRouter::remove(const void *handler_id) {
 
 void HttpRequestRouter::remove(const std::string &url_regex_str) {
   log_debug("removing route for regex: %s", url_regex_str.c_str());
-  std::lock_guard<std::mutex> lock(route_mtx_);
+  std::unique_lock lock(route_mtx_);
+
   for (auto it = request_handlers_.begin(); it != request_handlers_.end();) {
     if (it->url_regex_str == url_regex_str) {
       it = request_handlers_.erase(it);
@@ -98,13 +100,15 @@ void HttpRequestRouter::handler_not_found(http::base::Request &req) {
 void HttpRequestRouter::set_default_route(
     std::unique_ptr<http::base::RequestHandler> cb) {
   log_debug("adding default route");
-  std::lock_guard<std::mutex> lock(route_mtx_);
+  std::unique_lock lock(route_mtx_);
+
   default_route_ = std::move(cb);
 }
 
 void HttpRequestRouter::clear_default_route() {
   log_debug("removing default route");
-  std::lock_guard<std::mutex> lock(route_mtx_);
+  std::unique_lock lock(route_mtx_);
+
   default_route_ = nullptr;
 }
 
@@ -147,7 +151,7 @@ void HttpRequestRouter::route(http::base::Request &req) {
 
 BaseRequestHandlerPtr HttpRequestRouter::find_route_handler(
     const std::string &path) {
-  std::lock_guard<std::mutex> lock(route_mtx_);
+  std::shared_lock lock(route_mtx_);
 
   for (auto &request_handler : request_handlers_) {
     if (std::regex_search(path, request_handler.url_regex)) {

router/src/http/src/http_request_router.h

@@ -27,8 +27,8 @@
 #define ROUTER_SRC_HTTP_SRC_HTTP_REQUEST_ROUTER_H_
 
 #include <memory>
-#include <mutex>
 #include <regex>
+#include <shared_mutex>
 #include <string>
 #include <thread>
 #include <vector>
@@ -44,7 +44,6 @@ class HttpRequestRouter : public http::server::RequestHandlerInterface {
   using RequestHandler = http::base::RequestHandler;
   using BaseRequestHandlerPtr = std::shared_ptr<http::base::RequestHandler>;
 
- public:
   void append(const std::string &url_regex_str,
               std::unique_ptr<RequestHandler> cb);
   void remove(const void *handler_id);
@@ -72,7 +71,7 @@ class HttpRequestRouter : public http::server::RequestHandlerInterface {
   BaseRequestHandlerPtr default_route_;
   std::string require_realm_;
 
-  std::mutex route_mtx_;
+  mutable std::shared_mutex route_mtx_;
 };
 
 #endif  // ROUTER_SRC_HTTP_SRC_HTTP_REQUEST_ROUTER_H_