From c7d70d1201bb77bfe04d2affdf7b2fa02e129d24 Mon Sep 17 00:00:00 2001 From: Radoslaw Zarzynski Date: Fri, 8 Mar 2019 02:39:33 +0100 Subject: [PATCH] msg/async: replace CONTINUATION_PARAM() with specialized types. Signed-off-by: Radoslaw Zarzynski --- src/msg/async/Protocol.h | 13 ++++++++----- src/msg/async/ProtocolV1.cc | 22 ++++++++++++---------- src/msg/async/ProtocolV1.h | 4 ++-- src/msg/async/ProtocolV2.cc | 25 +++++++++++++------------ src/msg/async/ProtocolV2.h | 7 ++++--- 5 files changed, 39 insertions(+), 32 deletions(-) diff --git a/src/msg/async/Protocol.h b/src/msg/async/Protocol.h index b4a29814c538..08a6481240f1 100644 --- a/src/msg/async/Protocol.h +++ b/src/msg/async/Protocol.h @@ -28,8 +28,8 @@ public: template class CtFun : public Ct { private: - using fn = Ct *(C::*)(Args...); - fn _f; + using fn_t = Ct *(C::*)(Args...); + fn_t _f; std::tuple _params; template @@ -38,7 +38,7 @@ private: } public: - CtFun(fn f) : _f(f) {} + CtFun(fn_t f) : _f(f) {} inline void setParams(Args... args) { _params = std::make_tuple(args...); } inline Ct *call(C *foo) const override { @@ -46,11 +46,14 @@ public: } }; + +template using CONTINUATION_TYPE = CtFun; +template using CONTINUATION_TX_TYPE = CtFun; +template using CONTINUATION_RX_TYPE = CtFun; + #define CONTINUATION_DECL(C, F, ...) \ CtFun F##_cont { (&C::F) }; -#define CONTINUATION_PARAM(V, C, ...) CtFun &V##_cont - #define CONTINUATION(F) F##_cont #define CONTINUE(F, ...) (F##_cont.setParams(__VA_ARGS__), &F##_cont) diff --git a/src/msg/async/ProtocolV1.cc b/src/msg/async/ProtocolV1.cc index e7aeb4f197a3..a392529bb9d2 100644 --- a/src/msg/async/ProtocolV1.cc +++ b/src/msg/async/ProtocolV1.cc @@ -414,31 +414,33 @@ void ProtocolV1::run_continuation(CtPtr pcontinuation) { } } -CtPtr ProtocolV1::read(CONTINUATION_PARAM(next, ProtocolV1, char *, int), +CtPtr ProtocolV1::read(CONTINUATION_RX_TYPE &next, int len, char *buffer) { if (!buffer) { buffer = temp_buffer; } ssize_t r = connection->read(len, buffer, - [&CONTINUATION(next), this](char *buffer, int r) { - CONTINUATION(next).setParams(buffer, r); - CONTINUATION_RUN(CONTINUATION(next)); + [&next, this](char *buffer, int r) { + next.setParams(buffer, r); + CONTINUATION_RUN(next); }); if (r <= 0) { - return CONTINUE(next, buffer, r); + next.setParams(buffer, r); + return &next; } return nullptr; } -CtPtr ProtocolV1::write(CONTINUATION_PARAM(next, ProtocolV1, int), +CtPtr ProtocolV1::write(CONTINUATION_TX_TYPE &next, bufferlist &buffer) { - ssize_t r = connection->write(buffer, [&CONTINUATION(next), this](int r) { - CONTINUATION(next).setParams(r); - CONTINUATION_RUN(CONTINUATION(next)); + ssize_t r = connection->write(buffer, [&next, this](int r) { + next.setParams(r); + CONTINUATION_RUN(next); }); if (r <= 0) { - return CONTINUE(next, r); + next.setParams(r); + return &next; } return nullptr; diff --git a/src/msg/async/ProtocolV1.h b/src/msg/async/ProtocolV1.h index eb0d7f72d353..6248a6f2e199 100644 --- a/src/msg/async/ProtocolV1.h +++ b/src/msg/async/ProtocolV1.h @@ -145,9 +145,9 @@ protected: State state; void run_continuation(CtPtr pcontinuation); - CtPtr read(CONTINUATION_PARAM(next, ProtocolV1, char *, int), int len, + CtPtr read(CONTINUATION_RX_TYPE &next, int len, char *buffer = nullptr); - CtPtr write(CONTINUATION_PARAM(next, ProtocolV1, int), bufferlist &bl); + CtPtr write(CONTINUATION_TX_TYPE &next,bufferlist &bl); inline CtPtr _fault() { // helper fault method that stops continuation fault(); return nullptr; diff --git a/src/msg/async/ProtocolV2.cc b/src/msg/async/ProtocolV2.cc index 3748755bf844..256c835bd487 100644 --- a/src/msg/async/ProtocolV2.cc +++ b/src/msg/async/ProtocolV2.cc @@ -698,18 +698,18 @@ uint32_t ProtocolV2::get_epilogue_size() const { } } -CtPtr ProtocolV2::read(CONTINUATION_PARAM(next, ProtocolV2, char *, int), +CtPtr ProtocolV2::read(CONTINUATION_RX_TYPE &next, int len, char *buffer) { if (!buffer) { buffer = temp_buffer; } - ssize_t r = connection->read(len, buffer, - [&CONTINUATION(next), this](char *buffer, int r) { - CONTINUATION(next).setParams(buffer, r); - run_continuation(CONTINUATION(next)); + [&next, this](char *buffer, int r) { + next.setParams(buffer, r); + run_continuation(next); }); if (r <= 0) { - return CONTINUE(next, buffer, r); + next.setParams(buffer, r); + return &next; } return nullptr; @@ -717,24 +717,24 @@ CtPtr ProtocolV2::read(CONTINUATION_PARAM(next, ProtocolV2, char *, int), template CtPtr ProtocolV2::write(const std::string &desc, - CONTINUATION_PARAM(next, ProtocolV2), + CONTINUATION_TYPE &next, F &frame) { ceph::bufferlist bl = frame.get_buffer(session_stream_handlers); - return write(desc, CONTINUATION(next), bl); + return write(desc, next, bl); } CtPtr ProtocolV2::write(const std::string &desc, - CONTINUATION_PARAM(next, ProtocolV2), + CONTINUATION_TYPE &next, bufferlist &buffer) { ssize_t r = - connection->write(buffer, [&CONTINUATION(next), desc, this](int r) { + connection->write(buffer, [&next, desc, this](int r) { if (r < 0) { ldout(cct, 1) << __func__ << " " << desc << " write failed r=" << r << " (" << cpp_strerror(r) << ")" << dendl; connection->inject_delay(); _fault(); } - run_continuation(CONTINUATION(next)); + run_continuation(next); }); if (r <= 0) { @@ -743,7 +743,8 @@ CtPtr ProtocolV2::write(const std::string &desc, << " (" << cpp_strerror(r) << ")" << dendl; return _fault(); } - return CONTINUE(next); + next.setParams(); + return &next; } return nullptr; diff --git a/src/msg/async/ProtocolV2.h b/src/msg/async/ProtocolV2.h index 084ffe05253f..3e8e84a4e0ef 100644 --- a/src/msg/async/ProtocolV2.h +++ b/src/msg/async/ProtocolV2.h @@ -115,13 +115,14 @@ private: void run_continuation(Ct *pcontinuation); void run_continuation(Ct &continuation); - Ct *read(CONTINUATION_PARAM(next, ProtocolV2, char *, int), + Ct *read(CONTINUATION_RX_TYPE &next, int len, char *buffer = nullptr); template Ct *write(const std::string &desc, - CONTINUATION_PARAM(next, ProtocolV2), F &frame); + CONTINUATION_TYPE &next, + F &frame); Ct *write(const std::string &desc, - CONTINUATION_PARAM(next, ProtocolV2), + CONTINUATION_TYPE &next, bufferlist &buffer); void requeue_sent(); -- 2.47.3