added x86_64 version of SPSC ring buffer (#118)

* added x86_64 version of SPSC ring buffer
* add missing atomic include
* formatting
* update to FB coding on constants.

Author: tmontgomery

CMakeLists.txt

@@ -140,6 +140,9 @@ add_library(
   src/ResumeTracker.h
   src/ResumeCache.h
   src/ResumeCache.cpp
+  src/concurrent/atomic64.h
+  src/concurrent/atomic64_gcc_x86_64.h
+  src/concurrent/OneToOneRingBuffer.h
 )
 
 target_link_libraries(
@@ -171,6 +174,7 @@ add_executable(
   test/ReactiveStreamsMocksCompat.h
   test/Test.cpp
   test/MockStats.h
+  test/concurrent/OneToOneRingBufferTest.cpp
 )
 
 target_link_libraries(

src/ConnectionAutomaton.cpp

@@ -71,10 +71,11 @@ void ConnectionAutomaton::disconnect() {
   }
 }
 
-void ConnectionAutomaton::reconnect(std::unique_ptr<DuplexConnection> newConnection) {
-    disconnect();
-    connection_ = std::move(newConnection);
-    connect();
+void ConnectionAutomaton::reconnect(
+    std::unique_ptr<DuplexConnection> newConnection) {
+  disconnect();
+  connection_ = std::move(newConnection);
+  connect();
 }
 
 ConnectionAutomaton::~ConnectionAutomaton() {
@@ -138,7 +139,8 @@ void ConnectionAutomaton::onNext(std::unique_ptr<folly::IOBuf> frame) {
 
   stats_.frameRead(ss.str());
 
-  // TODO(tmont): If a frame is invalid, it will still be tracked. However, we actually want that. We want to keep
+  // TODO(tmont): If a frame is invalid, it will still be tracked. However, we
+  // actually want that. We want to keep
   // each side in sync, even if a frame is invalid.
   resumeTracker_->trackReceivedFrame(*frame);
 
@@ -218,17 +220,20 @@ void ConnectionAutomaton::onConnectionFrame(
         bool canResume = false;
 
         if (isServer_ && isResumable_) {
-            // find old ConnectionAutmaton via calling listener.
-            // Application will call resumeFromAutomaton to setup streams and resume information
-            canResume = resumeListener_(frame.token_, frame.position_);
+          // find old ConnectionAutmaton via calling listener.
+          // Application will call resumeFromAutomaton to setup streams and
+          // resume information
+          canResume = resumeListener_(frame.token_, frame.position_);
         }
 
         if (canResume) {
           outputFrameOrEnqueue(
-              Frame_RESUME_OK(resumeTracker_->impliedPosition()).serializeOut());
+              Frame_RESUME_OK(resumeTracker_->impliedPosition())
+                  .serializeOut());
           resumeCache_->retransmitFromPosition(frame.position_, *this);
         } else {
-          outputFrameOrEnqueue(Frame_ERROR::canNotResume("can not resume").serializeOut());
+          outputFrameOrEnqueue(
+              Frame_ERROR::canNotResume("can not resume").serializeOut());
           disconnect();
         }
       } else {
@@ -240,11 +245,13 @@ void ConnectionAutomaton::onConnectionFrame(
     case FrameType::RESUME_OK: {
       Frame_RESUME_OK frame;
       if (frame.deserializeFrom(std::move(payload))) {
-        if (!isServer_ && isResumable_ && resumeCache_->isPositionAvailable(frame.position_)) {
+        if (!isServer_ && isResumable_ &&
+            resumeCache_->isPositionAvailable(frame.position_)) {
           resumeCache_->retransmitFromPosition(frame.position_, *this);
         } else {
-            outputFrameOrEnqueue(Frame_ERROR::canNotResume("can not resume").serializeOut());
-            disconnect();
+          outputFrameOrEnqueue(
+              Frame_ERROR::canNotResume("can not resume").serializeOut());
+          disconnect();
         }
       } else {
         outputFrameOrEnqueue(Frame_ERROR::unexpectedFrame().serializeOut());
@@ -321,17 +328,18 @@ void ConnectionAutomaton::sendKeepalive() {
   outputFrameOrEnqueue(pingFrame.serializeOut());
 }
 
-void ConnectionAutomaton::sendResume(const ResumeIdentificationToken &token) {
+void ConnectionAutomaton::sendResume(const ResumeIdentificationToken& token) {
   Frame_RESUME resumeFrame(token, resumeTracker_->impliedPosition());
   outputFrameOrEnqueue(resumeFrame.serializeOut());
 }
 
 bool ConnectionAutomaton::isPositionAvailable(ResumePosition position) {
-    return resumeCache_->isPositionAvailable(position);
+  return resumeCache_->isPositionAvailable(position);
 }
 
-ResumePosition ConnectionAutomaton::positionDifference(ResumePosition position) {
-    return resumeCache_->position() - position;
+ResumePosition ConnectionAutomaton::positionDifference(
+    ResumePosition position) {
+  return resumeCache_->position() - position;
 }
 
 void ConnectionAutomaton::onClose(ConnectionCloseListener listener) {
@@ -374,16 +382,14 @@ void ConnectionAutomaton::outputFrame(
   connectionOutput_.onNext(std::move(outputFrame));
 }
 
-void ConnectionAutomaton::resumeFromAutomaton(ConnectionAutomaton& oldAutomaton)
-{
-  if (isServer_ && isResumable_)
-  {
+void ConnectionAutomaton::resumeFromAutomaton(
+    ConnectionAutomaton& oldAutomaton) {
+  if (isServer_ && isResumable_) {
     streams_ = std::move(oldAutomaton.streams_);
     factory_ = oldAutomaton.factory_;
 
     resumeTracker_ = std::move(oldAutomaton.resumeTracker_);
     resumeCache_ = std::move(oldAutomaton.resumeCache_);
   }
 }
-
 }

src/ConnectionAutomaton.h

@@ -11,9 +11,9 @@
 #include "ReactiveSocket.h"
 #include "src/Payload.h"
 #include "src/ReactiveStreamsCompat.h"
-#include "src/Stats.h"
-#include "src/ResumeTracker.h"
 #include "src/ResumeCache.h"
+#include "src/ResumeTracker.h"
+#include "src/Stats.h"
 
 namespace reactivesocket {
 
@@ -34,8 +34,8 @@ using StreamId = uint32_t;
 using StreamAutomatonFactory =
     std::function<bool(StreamId, std::unique_ptr<folly::IOBuf>)>;
 
-using ResumeListener =
-    std::function<bool(const ResumeIdentificationToken &token, ResumePosition position)>;
+using ResumeListener = std::function<
+    bool(const ResumeIdentificationToken& token, ResumePosition position)>;
 
 using ConnectionCloseListener = std::function<void()>;
 
@@ -117,12 +117,13 @@ class ConnectionAutomaton :
   ///   ConnectionAutomaton.
   void endStream(StreamId streamId, StreamCompletionSignal signal);
 
-  /// Copy the streams and resumption information from a previous ConnectionAutomaton
+  /// Copy the streams and resumption information from a previous
+  /// ConnectionAutomaton
   void resumeFromAutomaton(ConnectionAutomaton& oldAutomaton);
   /// @}
 
   void sendKeepalive();
-  void sendResume(const ResumeIdentificationToken &token);
+  void sendResume(const ResumeIdentificationToken& token);
 
   bool isPositionAvailable(ResumePosition position);
   ResumePosition positionDifference(ResumePosition position);

src/Frame.cpp

@@ -356,7 +356,7 @@ Frame_ERROR Frame_ERROR::applicationError(
 }
 
 Frame_ERROR Frame_ERROR::canNotResume(const std::string& message) {
-    return Frame_ERROR(0, ErrorCode::CONNECTION_ERROR, Payload(message));
+  return Frame_ERROR(0, ErrorCode::CONNECTION_ERROR, Payload(message));
 }
 
 std::unique_ptr<folly::IOBuf> Frame_ERROR::serializeOut() {
@@ -432,7 +432,7 @@ std::unique_ptr<folly::IOBuf> Frame_SETUP::serializeOut() {
   appender.writeBE(static_cast<uint32_t>(maxLifetime_));
   appender.push((const uint8_t*)token_.data(), token_.size());
 
-    CHECK(metadataMimeType_.length() <= std::numeric_limits<uint8_t>::max());
+  CHECK(metadataMimeType_.length() <= std::numeric_limits<uint8_t>::max());
   appender.writeBE(static_cast<uint8_t>(metadataMimeType_.length()));
   appender.push(
       (const uint8_t*)metadataMimeType_.data(), metadataMimeType_.length());
@@ -509,7 +509,8 @@ std::ostream& operator<<(std::ostream& os, const Frame_LEASE& frame) {
 /// @{
 std::unique_ptr<folly::IOBuf> Frame_RESUME::serializeOut() {
   auto queue = createBufferQueue(
-      FrameHeader::kSize + sizeof(ResumeIdentificationToken) + sizeof(ResumePosition));
+      FrameHeader::kSize + sizeof(ResumeIdentificationToken) +
+      sizeof(ResumePosition));
   folly::io::QueueAppender appender(&queue, /* do not grow */ 0);
 
   header_.serializeInto(appender);
@@ -533,14 +534,14 @@ bool Frame_RESUME::deserializeFrom(std::unique_ptr<folly::IOBuf> in) {
 
 std::ostream& operator<<(std::ostream& os, const Frame_RESUME& frame) {
   return os << frame.header_ << ", ("
-            << "token" << ", @" << frame.position_ << ")";
+            << "token"
+            << ", @" << frame.position_ << ")";
 }
 /// @}
 
 /// @{
 std::unique_ptr<folly::IOBuf> Frame_RESUME_OK::serializeOut() {
-  auto queue = createBufferQueue(
-      FrameHeader::kSize + sizeof(ResumePosition));
+  auto queue = createBufferQueue(FrameHeader::kSize + sizeof(ResumePosition));
   folly::io::QueueAppender appender(&queue, /* do not grow */ 0);
 
   header_.serializeInto(appender);
@@ -564,5 +565,4 @@ std::ostream& operator<<(std::ostream& os, const Frame_RESUME_OK& frame) {
   return os << frame.header_ << ", (@" << frame.position_ << ")";
 }
 /// @}
-
 }

src/Frame.h

@@ -2,9 +2,9 @@
 
 #pragma once
 
+#include <array>
 #include <iosfwd>
 #include <limits>
-#include <array>
 
 /// Needed for inline d'tors of frames.
 #include <folly/io/IOBuf.h>
@@ -397,7 +397,7 @@ class Frame_SETUP {
       uint32_t version,
       uint32_t keepaliveTime,
       uint32_t maxLifetime,
-      const ResumeIdentificationToken &token,
+      const ResumeIdentificationToken& token,
       std::string metadataMimeType,
       std::string dataMimeType,
       Payload payload)
@@ -454,44 +454,37 @@ std::ostream& operator<<(std::ostream&, const Frame_SETUP&);
 /// @}
 
 class Frame_RESUME {
-public:
-    static constexpr bool Trait_CarriesAllowance = false;
-
-    Frame_RESUME() = default;
-    Frame_RESUME(
-        const ResumeIdentificationToken &token,
-        ResumePosition position)
-        : header_(FrameType::RESUME, 0, 0),
-        token_(token),
-        position_(position) {}
+ public:
+  static constexpr bool Trait_CarriesAllowance = false;
+
+  Frame_RESUME() = default;
+  Frame_RESUME(const ResumeIdentificationToken& token, ResumePosition position)
+      : header_(FrameType::RESUME, 0, 0), token_(token), position_(position) {}
 
-    std::unique_ptr<folly::IOBuf> serializeOut();
-    bool deserializeFrom(std::unique_ptr<folly::IOBuf> in);
+  std::unique_ptr<folly::IOBuf> serializeOut();
+  bool deserializeFrom(std::unique_ptr<folly::IOBuf> in);
 
-    FrameHeader header_;
-    ResumeIdentificationToken token_;
-    ResumePosition position_;
+  FrameHeader header_;
+  ResumeIdentificationToken token_;
+  ResumePosition position_;
 };
 std::ostream& operator<<(std::ostream&, const Frame_RESUME&);
 /// @}
 
 class Frame_RESUME_OK {
-public:
-    static constexpr bool Trait_CarriesAllowance = false;
+ public:
+  static constexpr bool Trait_CarriesAllowance = false;
 
-    Frame_RESUME_OK() = default;
-    Frame_RESUME_OK(
-        ResumePosition position)
-        : header_(FrameType::RESUME_OK, 0, 0),
-        position_(position) {}
+  Frame_RESUME_OK() = default;
+  Frame_RESUME_OK(ResumePosition position)
+      : header_(FrameType::RESUME_OK, 0, 0), position_(position) {}
 
-    std::unique_ptr<folly::IOBuf> serializeOut();
-    bool deserializeFrom(std::unique_ptr<folly::IOBuf> in);
+  std::unique_ptr<folly::IOBuf> serializeOut();
+  bool deserializeFrom(std::unique_ptr<folly::IOBuf> in);
 
-    FrameHeader header_;
-    ResumePosition position_;
+  FrameHeader header_;
+  ResumePosition position_;
 };
 std::ostream& operator<<(std::ostream&, const Frame_RESUME_OK&);
 /// @}
-
 }

src/ReactiveSocket.cpp

@@ -65,12 +65,14 @@ std::unique_ptr<ReactiveSocket> ReactiveSocket::fromClientConnection(
     ConnectionSetupPayload setupPayload,
     Stats& stats,
     std::unique_ptr<KeepaliveTimer> keepaliveTimer,
-    const ResumeIdentificationToken &token) {
+    const ResumeIdentificationToken& token) {
   std::unique_ptr<ReactiveSocket> socket(new ReactiveSocket(
       false,
       std::move(connection),
       std::move(handler),
-      [](ReactiveSocket&, const ResumeIdentificationToken&, ResumePosition) { return false; },
+      [](ReactiveSocket&, const ResumeIdentificationToken&, ResumePosition) {
+        return false;
+      },
       stats,
       std::move(keepaliveTimer)));
   socket->connection_->connect();
@@ -301,8 +303,10 @@ bool ReactiveSocket::createResponder(
   return true;
 }
 
-bool ReactiveSocket::resumeListener(const ResumeIdentificationToken& token, ResumePosition position) {
-    return resumeSocketListener_(*this, token, position);
+bool ReactiveSocket::resumeListener(
+    const ResumeIdentificationToken& token,
+    ResumePosition position) {
+  return resumeSocketListener_(*this, token, position);
 }
 
 void ReactiveSocket::close() {
@@ -313,12 +317,13 @@ void ReactiveSocket::onClose(CloseListener listener) {
   connection_->onClose([listener, this]() { listener(*this); });
 }
 
-void ReactiveSocket::resumeFromSocket(ReactiveSocket &socket) {
+void ReactiveSocket::resumeFromSocket(ReactiveSocket& socket) {
   connection_->resumeFromAutomaton(*socket.connection_);
 }
 
 void ReactiveSocket::tryClientResume(
-    std::unique_ptr<DuplexConnection> newConnection, const ResumeIdentificationToken& token) {
+    std::unique_ptr<DuplexConnection> newConnection,
+    const ResumeIdentificationToken& token) {
   connection_->reconnect(std::move(newConnection));
   connection_->sendResume(token);
 }
@@ -330,5 +335,4 @@ bool ReactiveSocket::isPositionAvailable(ResumePosition position) {
 ResumePosition ReactiveSocket::positionDifference(ResumePosition position) {
   return connection_->positionDifference(position);
 }
-
 }