hmbdc
simplify-high-performance-messaging-programming
AttBufferAdaptor.hpp
1 #include "hmbdc/Copyright.hpp"
2 #pragma once
3 #include "hmbdc/app/Message.hpp"
4 
5 #include <memory.h>
6 
7 namespace hmbdc { namespace tips { namespace reliable {
8 template <typename Buffer, typename TransportMessageHeader, typename AttachmentAllocator>
10  private:
11  Buffer& buffer_;
12  std::unique_ptr<uint8_t[]> hasMemoryAttachmentMessageWrapSpace_;
13  app::MessageWrap<app::hasMemoryAttachment>* hasMemoryAttachmentMessageWrap_;
14  app::hasMemoryAttachment* hasMemoryAttachment_ = nullptr;
15  size_t attTrainCount_ = 0;
16  AttachmentAllocator alloc_;
17 
18  void abortAtt() {
19  hasMemoryAttachment_->release();
20  hasMemoryAttachment_ = nullptr;
21  }
22 
23  public:
24  AttBufferAdaptor(Buffer& buffer)
25  : buffer_(buffer)
26  , hasMemoryAttachmentMessageWrapSpace_{new uint8_t[maxItemSize()] {0}}
27  , hasMemoryAttachmentMessageWrap_((app::MessageWrap<app::hasMemoryAttachment>*)
28  hasMemoryAttachmentMessageWrapSpace_.get())
29  {}
30 
31  size_t maxItemSize() const {
32  return buffer_.maxItemSize();
33  }
34  void put(TransportMessageHeader* h) {
35  // HMBDC_LOG_D(h->getSeq(), '-', comment, port, h->messagePayloadLen, ':', h->typeTag(), '=', std::this_thread::get_id());
36  if (hmbdc_unlikely(h->typeTag() == app::StartMemorySegTrain::typeTag)) {
37  if (hmbdc_likely(!hasMemoryAttachment_)) {
38  hasMemoryAttachment_ = &hasMemoryAttachmentMessageWrap_->get<app::hasMemoryAttachment>();
39  *hasMemoryAttachment_ =
40  h->template wrapped<app::StartMemorySegTrain>().att;
41  attTrainCount_ = h->template wrapped<app::StartMemorySegTrain>().segCount;
42  alloc_(h->typeTag(), hasMemoryAttachment_);
43  // hasMemoryAttachment_->attachment = malloc(hasMemoryAttachment_->len);
44  hasMemoryAttachment_->len = 0;
45  // hasMemoryAttachment_->afterConsumedCleanupFunc = app::hasMemoryAttachment::free;
46  }
47  } else if (hmbdc_unlikely(hasMemoryAttachment_
48  && h->typeTag() == app::MemorySeg::typeTag)) {
49  if (attTrainCount_) {
50  auto seg = &h->template wrapped<app::MemorySeg>(); //all attachment seg
51  auto segLen = h->messagePayloadLen - (uint16_t)sizeof(app::MessageHead);
52  memcpy((char*)hasMemoryAttachment_->attachment + hasMemoryAttachment_->len, seg, segLen);
53  hasMemoryAttachment_->len += segLen;
54  attTrainCount_--;
55  } else {
56  abortAtt();
57  }
58  } else if (hmbdc_unlikely(hasMemoryAttachment_)) {
59  if (hmbdc_likely(!attTrainCount_)
60  && h->flag == app::hasMemoryAttachment::flag) {
61  auto l = std::min<size_t>(buffer_.maxItemSize(), h->messagePayloadLen);
62  auto hsm = *hasMemoryAttachment_;
63  memcpy(hasMemoryAttachmentMessageWrapSpace_.get(), h->payload(), l);
64  *hasMemoryAttachment_ = hsm;
65  buffer_.putAtt(hasMemoryAttachmentMessageWrap_, buffer_.maxItemSize());
66  hasMemoryAttachment_ = nullptr;
67  } else {
68  abortAtt();
69  }
70  } else {
71  buffer_.put(h->payload(), h->messagePayloadLen);
72  }
73  }
74 
75  // template <typename T> void put(T& item) {buffer_.put(&item, sizeof(T));}
76  template <typename T> void putSome(T& item) {
77  buffer_.put(&item, std::min(sizeof(item), maxItemSize()));
78  }
79 };
80 }}}
Definition: AttBufferAdaptor.hpp:9
Definition: Message.hpp:212
Definition: Message.hpp:263
if a specific hmbdc network transport (for example tcpcast, rmcast, and rnetmap) supports message wit...
Definition: Message.hpp:125
Definition: Base.hpp:12