wassname/ray
1
0
Fork 0
mirror of https://github.com/wassname/ray.git synced 2026-08-18 12:20:14 +08:00
Code Issues Packages Projects Releases Wiki Activity

Revert "[Streaming] Fault Tolerance Implementation (#10008)" (#10582)

Browse Source 
This reverts commit 1b1466748f.
This commit is contained in:
SangBin Cho
2020-09-04 13:21:18 -07:00
committed by GitHub
parent da83bbd764
commit cb919c5e5c
158 changed files with 1226 additions and 7039 deletions
Download Patch File Download Diff File Expand all files Collapse all files
streaming/src/message/message.cc
+29 -40
View File
@@ -10,32 +10,30 @@
namespace ray {
namespace streaming {
StreamingMessage::StreamingMessage(std::shared_ptr<uint8_t> &payload_data,
uint32_t payload_size, uint64_t msg_id,
StreamingMessageType message_type)
: payload_(payload_data),
payload_size_(payload_size),
StreamingMessage::StreamingMessage(std::shared_ptr<uint8_t> &data, uint32_t data_size,
uint64_t seq_id, StreamingMessageType message_type)
: message_data_(data),
data_size_(data_size),
message_type_(message_type),
message_id_(msg_id) {}
message_id_(seq_id) {}
StreamingMessage::StreamingMessage(std::shared_ptr<uint8_t> &&payload_data,
uint32_t payload_size, uint64_t msg_id,
StreamingMessageType message_type)
: payload_(payload_data),
payload_size_(payload_size),
StreamingMessage::StreamingMessage(std::shared_ptr<uint8_t> &&data, uint32_t data_size,
uint64_t seq_id, StreamingMessageType message_type)
: message_data_(data),
data_size_(data_size),
message_type_(message_type),
message_id_(msg_id) {}
message_id_(seq_id) {}
StreamingMessage::StreamingMessage(const uint8_t *payload_data, uint32_t payload_size,
uint64_t msg_id, StreamingMessageType message_type)
: payload_size_(payload_size), message_type_(message_type), message_id_(msg_id) {
payload_.reset(new uint8_t[payload_size], std::default_delete<uint8_t[]>());
std::memcpy(payload_.get(), payload_data, payload_size);
StreamingMessage::StreamingMessage(const uint8_t *data, uint32_t data_size,
uint64_t seq_id, StreamingMessageType message_type)
: data_size_(data_size), message_type_(message_type), message_id_(seq_id) {
message_data_.reset(new uint8_t[data_size], std::default_delete<uint8_t[]>());
std::memcpy(message_data_.get(), data, data_size_);
}
StreamingMessage::StreamingMessage(const StreamingMessage &msg) {
payload_size_ = msg.payload_size_;
payload_ = msg.payload_;
data_size_ = msg.data_size_;
message_data_ = msg.message_data_;
message_id_ = msg.message_id_;
message_type_ = msg.message_type_;
}
@@ -46,8 +44,8 @@ StreamingMessagePtr StreamingMessage::FromBytes(const uint8_t *bytes,
uint32_t data_size = *reinterpret_cast<const uint32_t *>(bytes + byte_offset);
byte_offset += sizeof(data_size);
uint64_t msg_id = *reinterpret_cast<const uint64_t *>(bytes + byte_offset);
byte_offset += sizeof(msg_id);
uint64_t seq_id = *reinterpret_cast<const uint64_t *>(bytes + byte_offset);
byte_offset += sizeof(seq_id);
StreamingMessageType msg_type =
*reinterpret_cast<const StreamingMessageType *>(bytes + byte_offset);
@@ -56,14 +54,14 @@ StreamingMessagePtr StreamingMessage::FromBytes(const uint8_t *bytes,
auto buf = new uint8_t[data_size];
std::memcpy(buf, bytes + byte_offset, data_size);
auto data_ptr = std::shared_ptr<uint8_t>(buf, std::default_delete<uint8_t[]>());
return std::make_shared<StreamingMessage>(data_ptr, data_size, msg_id, msg_type);
return std::make_shared<StreamingMessage>(data_ptr, data_size, seq_id, msg_type);
}
void StreamingMessage::ToBytes(uint8_t *serlizable_data) {
uint32_t byte_offset = 0;
std::memcpy(serlizable_data + byte_offset, reinterpret_cast<char *>(&payload_size_),
sizeof(payload_size_));
byte_offset += sizeof(payload_size_);
std::memcpy(serlizable_data + byte_offset, reinterpret_cast<char *>(&data_size_),
sizeof(data_size_));
byte_offset += sizeof(data_size_);
std::memcpy(serlizable_data + byte_offset, reinterpret_cast<char *>(&message_id_),
sizeof(message_id_));
@@ -73,28 +71,19 @@ void StreamingMessage::ToBytes(uint8_t *serlizable_data) {
sizeof(message_type_));
byte_offset += sizeof(message_type_);
std::memcpy(serlizable_data + byte_offset, reinterpret_cast<char *>(payload_.get()),
payload_size_);
std::memcpy(serlizable_data + byte_offset,
reinterpret_cast<char *>(message_data_.get()), data_size_);
byte_offset += payload_size_;
byte_offset += data_size_;
STREAMING_CHECK(byte_offset == this->ClassBytesSize());
}
bool StreamingMessage::operator==(const StreamingMessage &message) const {
return PayloadSize() == message.PayloadSize() &&
GetMessageId() == message.GetMessageId() &&
return GetDataSize() == message.GetDataSize() &&
GetMessageSeqId() == message.GetMessageSeqId() &&
GetMessageType() == message.GetMessageType() &&
!std::memcmp(Payload(), message.Payload(), PayloadSize());
}
std::ostream &operator<<(std::ostream &os, const StreamingMessage &message) {
os << "{"
<< " message_type_: " << static_cast<int>(message.GetMessageType())
<< " message_id_: " << message.GetMessageId()
<< " payload_size_: " << message.payload_size_
<< " payload_: " << (void *)message.payload_.get() << "}";
return os;
!std::memcmp(RawData(), message.RawData(), data_size_);
}
} // namespace streaming
streaming/src/message/message.h
+23 -71
View File
@@ -1,6 +1,5 @@
#pragma once
#include <cstring>
#include <memory>
namespace ray {
@@ -17,75 +16,52 @@ enum class StreamingMessageType : uint32_t {
MAX = Message
};
enum class StreamingBarrierType : uint32_t { GlobalBarrier = 0 };
struct StreamingBarrierHeader {
StreamingBarrierType barrier_type;
uint64_t barrier_id;
inline bool IsGlobalBarrier() {
return StreamingBarrierType::GlobalBarrier == barrier_type;
}
};
constexpr uint32_t kMessageHeaderSize =
sizeof(uint32_t) + sizeof(uint64_t) + sizeof(StreamingMessageType);
constexpr uint32_t kBarrierHeaderSize = sizeof(StreamingBarrierType) + sizeof(uint64_t);
/// All messages should be wrapped by this protocol.
// DataSize means length of raw data, message id is increasing from [1, +INF].
// MessageType will be used for barrier transporting and checkpoint.
/// +----------------+
/// | PayloadSize=U32|
/// | DataSize=U32 |
/// +----------------+
/// | MessageId=U64 |
/// +----------------+
/// | MessageType=U32|
/// +----------------+
/// | Payload=var |
/// | Data=var |
/// +----------------+
/// Payload field contains barrier header and carried buffer if message type is
/// global/partial barrier.
///
/// Barrier's Payload field:
/// +----------------------------+
/// | StreamingBarrierType=U32 |
/// +----------------------------+
/// | barrier_id=U64 |
/// +----------------------------+
/// | carried_buffer=var |
/// +----------------------------+
class StreamingMessage {
private:
std::shared_ptr<uint8_t> payload_;
uint32_t payload_size_;
std::shared_ptr<uint8_t> message_data_;
uint32_t data_size_;
StreamingMessageType message_type_;
uint64_t message_id_;
public:
/// Copy raw data from outside shared buffer.
/// \param payload_ raw data from user buffer
/// \param payload_size_ raw data size
/// \param msg_id message id
/// \param data raw data from user buffer
/// \param data_size raw data size
/// \param seq_id message id
/// \param message_type
StreamingMessage(std::shared_ptr<uint8_t> &payload_data, uint32_t payload_size,
uint64_t msg_id, StreamingMessageType message_type);
StreamingMessage(std::shared_ptr<uint8_t> &data, uint32_t data_size, uint64_t seq_id,
StreamingMessageType message_type);
/// Move outsite raw data to message data.
/// \param payload_ raw data from user buffer
/// \param payload_size_ raw data size
/// \param msg_id message id
/// \param data raw data from user buffer
/// \param data_size raw data size
/// \param seq_id message id
/// \param message_type
StreamingMessage(std::shared_ptr<uint8_t> &&payload_data, uint32_t payload_size,
uint64_t msg_id, StreamingMessageType message_type);
StreamingMessage(std::shared_ptr<uint8_t> &&data, uint32_t data_size, uint64_t seq_id,
StreamingMessageType message_type);
/// Copy raw data from outside buffer.
/// \param payload_ raw data from user buffer
/// \param payload_size_ raw data size
/// \param msg_id message id
/// \param data raw data from user buffer
/// \param data_size raw data size
/// \param seq_id message id
/// \param message_type
StreamingMessage(const uint8_t *payload_data, uint32_t payload_size, uint64_t msg_id,
StreamingMessage(const uint8_t *data, uint32_t data_size, uint64_t seq_id,
StreamingMessageType message_type);
StreamingMessage(const StreamingMessage &);
@@ -94,44 +70,20 @@ class StreamingMessage {
virtual ~StreamingMessage() = default;
inline uint8_t *RawData() const { return message_data_.get(); }
inline uint32_t GetDataSize() const { return data_size_; }
inline StreamingMessageType GetMessageType() const { return message_type_; }
inline uint64_t GetMessageId() const { return message_id_; }
inline uint8_t *Payload() const { return payload_.get(); }
inline uint32_t PayloadSize() const { return payload_size_; }
inline uint64_t GetMessageSeqId() const { return message_id_; }
inline bool IsMessage() { return StreamingMessageType::Message == message_type_; }
inline bool IsBarrier() { return StreamingMessageType::Barrier == message_type_; }
bool operator==(const StreamingMessage &) const;
static inline std::shared_ptr<uint8_t> MakeBarrierPayload(
StreamingBarrierHeader &barrier_header, const uint8_t *data, uint32_t data_size) {
std::shared_ptr<uint8_t> ptr(new uint8_t[data_size + kBarrierHeaderSize],
std::default_delete<uint8_t[]>());
std::memcpy(ptr.get(), &barrier_header.barrier_type, sizeof(StreamingBarrierType));
std::memcpy(ptr.get() + sizeof(StreamingBarrierType), &barrier_header.barrier_id,
sizeof(uint64_t));
if (data && data_size > 0) {
std::memcpy(ptr.get() + kBarrierHeaderSize, data, data_size);
}
return ptr;
}
virtual void ToBytes(uint8_t *data);
static StreamingMessagePtr FromBytes(const uint8_t *data, bool verifer_check = true);
inline virtual uint32_t ClassBytesSize() { return kMessageHeaderSize + payload_size_; }
static inline void GetBarrierIdFromRawData(const uint8_t *data,
StreamingBarrierHeader *barrier_header) {
barrier_header->barrier_type = *reinterpret_cast<const StreamingBarrierType *>(data);
barrier_header->barrier_id =
*reinterpret_cast<const uint64_t *>(data + sizeof(StreamingBarrierType));
}
friend std::ostream &operator<<(std::ostream &os, const StreamingMessage &message);
inline virtual uint32_t ClassBytesSize() { return kMessageHeaderSize + data_size_; }
};
} // namespace streaming
streaming/src/message/message_bundle.cc
-16
View File
@@ -63,14 +63,6 @@ bool StreamingMessageBundleMeta::operator==(StreamingMessageBundleMeta *meta) co
return operator==(*meta);
}
std::ostream &operator<<(std::ostream &os, const StreamingMessageBundleMeta &meta) {
os << "{"
<< "last_message_id_: " << meta.last_message_id_
<< ", message_list_size_: " << meta.message_list_size_
<< ", bundle_type_: " << static_cast<int>(meta.bundle_type_) << "}";
return os;
}
StreamingMessageBundleMeta::StreamingMessageBundleMeta()
: bundle_type_(StreamingMessageBundleType::Empty) {}
@@ -196,13 +188,5 @@ bool StreamingMessageBundle::operator==(StreamingMessageBundle &bundle) const {
bool StreamingMessageBundle::operator==(StreamingMessageBundle *bundle) const {
return this->operator==(*bundle);
}
std::ostream &operator<<(std::ostream &os, const DataBundle &bundle) {
os << "{"
<< "data: " << (void *)bundle.data << ", data_size: " << bundle.data_size
<< ", channel last_barrier_id: " << bundle.last_barrier_id
<< ", meta: " << *(bundle.meta) << "}";
return os;
}
} // namespace streaming
} // namespace ray
streaming/src/message/message_bundle.h
-30
View File
@@ -7,7 +7,6 @@
#include <string>
#include "message/message.h"
#include "ray/common/id.h"
namespace ray {
namespace streaming {
@@ -84,7 +83,6 @@ class StreamingMessageBundleMeta {
inline bool IsBarrier() { return StreamingMessageBundleType::Barrier == bundle_type_; }
inline bool IsBundle() { return StreamingMessageBundleType::Bundle == bundle_type_; }
inline bool IsEmptyMsg() { return StreamingMessageBundleType::Empty == bundle_type_; }
virtual void ToBytes(uint8_t *data);
static StreamingMessageBundleMetaPtr FromBytes(const uint8_t *data,
@@ -101,9 +99,6 @@ class StreamingMessageBundleMeta {
"," + std::to_string(message_bundle_ts_) + "," +
std::to_string(static_cast<uint32_t>(bundle_type_));
}
friend std::ostream &operator<<(std::ostream &os,
const StreamingMessageBundleMeta &meta);
};
/// StreamingMessageBundle inherits from metadata class (StreamingMessageBundleMeta)
@@ -182,30 +177,5 @@ class StreamingMessageBundle : public StreamingMessageBundleMeta {
const std::list<StreamingMessagePtr> &message_list, uint32_t raw_data_size,
uint8_t *raw_data);
};
/// Databundle is super-bundle that contains channel information (upstream
/// channel id & bundle meta data) and raw buffer pointer.
struct DataBundle {
uint8_t *data = nullptr;
uint32_t data_size;
ObjectID from;
uint32_t last_barrier_id;
StreamingMessageBundleMetaPtr meta;
bool is_reallocated = false;
~DataBundle() {
if (is_reallocated) {
delete[] data;
}
}
void Realloc(uint32_t size) {
data = new uint8_t[size];
is_reallocated = true;
}
friend std::ostream &operator<<(std::ostream &os, const DataBundle &bundle);
};
} // namespace streaming
} // namespace ray