LLVM  6.0.0svn
RPCSerialization.h
Go to the documentation of this file.
1 //===- llvm/ExecutionEngine/Orc/RPCSerialization.h --------------*- C++ -*-===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 
10 #ifndef LLVM_EXECUTIONENGINE_ORC_RPCSERIALIZATION_H
11 #define LLVM_EXECUTIONENGINE_ORC_RPCSERIALIZATION_H
12 
13 #include "OrcError.h"
14 #include "llvm/Support/thread.h"
15 #include <map>
16 #include <mutex>
17 #include <sstream>
18 
19 namespace llvm {
20 namespace orc {
21 namespace rpc {
22 
23 template <typename T>
25 
26 /// TypeNameSequence is a utility for rendering sequences of types to a string
27 /// by rendering each type, separated by ", ".
28 template <typename... ArgTs> class RPCTypeNameSequence {};
29 
30 /// Render an empty TypeNameSequence to an ostream.
31 template <typename OStream>
32 OStream &operator<<(OStream &OS, const RPCTypeNameSequence<> &V) {
33  return OS;
34 }
35 
36 /// Render a TypeNameSequence of a single type to an ostream.
37 template <typename OStream, typename ArgT>
38 OStream &operator<<(OStream &OS, const RPCTypeNameSequence<ArgT> &V) {
40  return OS;
41 }
42 
43 /// Render a TypeNameSequence of more than one type to an ostream.
44 template <typename OStream, typename ArgT1, typename ArgT2, typename... ArgTs>
45 OStream&
49  return OS;
50 }
51 
52 template <>
53 class RPCTypeName<void> {
54 public:
55  static const char* getName() { return "void"; }
56 };
57 
58 template <>
59 class RPCTypeName<int8_t> {
60 public:
61  static const char* getName() { return "int8_t"; }
62 };
63 
64 template <>
65 class RPCTypeName<uint8_t> {
66 public:
67  static const char* getName() { return "uint8_t"; }
68 };
69 
70 template <>
71 class RPCTypeName<int16_t> {
72 public:
73  static const char* getName() { return "int16_t"; }
74 };
75 
76 template <>
77 class RPCTypeName<uint16_t> {
78 public:
79  static const char* getName() { return "uint16_t"; }
80 };
81 
82 template <>
83 class RPCTypeName<int32_t> {
84 public:
85  static const char* getName() { return "int32_t"; }
86 };
87 
88 template <>
90 public:
91  static const char* getName() { return "uint32_t"; }
92 };
93 
94 template <>
95 class RPCTypeName<int64_t> {
96 public:
97  static const char* getName() { return "int64_t"; }
98 };
99 
100 template <>
101 class RPCTypeName<uint64_t> {
102 public:
103  static const char* getName() { return "uint64_t"; }
104 };
105 
106 template <>
108 public:
109  static const char* getName() { return "bool"; }
110 };
111 
112 template <>
113 class RPCTypeName<std::string> {
114 public:
115  static const char* getName() { return "std::string"; }
116 };
117 
118 template <>
120 public:
121  static const char* getName() { return "Error"; }
122 };
123 
124 template <typename T>
126 public:
127  static const char* getName() {
128  std::lock_guard<std::mutex> Lock(NameMutex);
129  if (Name.empty())
130  raw_string_ostream(Name) << "Expected<"
132  << ">";
133  return Name.data();
134  }
135 
136 private:
137  static std::mutex NameMutex;
138  static std::string Name;
139 };
140 
141 template <typename T>
142 std::mutex RPCTypeName<Expected<T>>::NameMutex;
143 
144 template <typename T>
145 std::string RPCTypeName<Expected<T>>::Name;
146 
147 template <typename T1, typename T2>
148 class RPCTypeName<std::pair<T1, T2>> {
149 public:
150  static const char* getName() {
151  std::lock_guard<std::mutex> Lock(NameMutex);
152  if (Name.empty())
154  << ">";
155  return Name.data();
156  }
157 private:
158  static std::mutex NameMutex;
159  static std::string Name;
160 };
161 
162 template <typename T1, typename T2>
163 std::mutex RPCTypeName<std::pair<T1, T2>>::NameMutex;
164 template <typename T1, typename T2>
166 
167 template <typename... ArgTs>
168 class RPCTypeName<std::tuple<ArgTs...>> {
169 public:
170  static const char* getName() {
171  std::lock_guard<std::mutex> Lock(NameMutex);
172  if (Name.empty())
173  raw_string_ostream(Name) << "std::tuple<"
174  << RPCTypeNameSequence<ArgTs...>() << ">";
175  return Name.data();
176  }
177 private:
178  static std::mutex NameMutex;
179  static std::string Name;
180 };
181 
182 template <typename... ArgTs>
183 std::mutex RPCTypeName<std::tuple<ArgTs...>>::NameMutex;
184 template <typename... ArgTs>
185 std::string RPCTypeName<std::tuple<ArgTs...>>::Name;
186 
187 template <typename T>
188 class RPCTypeName<std::vector<T>> {
189 public:
190  static const char*getName() {
191  std::lock_guard<std::mutex> Lock(NameMutex);
192  if (Name.empty())
193  raw_string_ostream(Name) << "std::vector<" << RPCTypeName<T>::getName()
194  << ">";
195  return Name.data();
196  }
197 
198 private:
199  static std::mutex NameMutex;
200  static std::string Name;
201 };
202 
203 template <typename T>
204 std::mutex RPCTypeName<std::vector<T>>::NameMutex;
205 template <typename T>
207 
208 
209 /// The SerializationTraits<ChannelT, T> class describes how to serialize and
210 /// deserialize an instance of type T to/from an abstract channel of type
211 /// ChannelT. It also provides a representation of the type's name via the
212 /// getName method.
213 ///
214 /// Specializations of this class should provide the following functions:
215 ///
216 /// @code{.cpp}
217 ///
218 /// static const char* getName();
219 /// static Error serialize(ChannelT&, const T&);
220 /// static Error deserialize(ChannelT&, T&);
221 ///
222 /// @endcode
223 ///
224 /// The third argument of SerializationTraits is intended to support SFINAE.
225 /// E.g.:
226 ///
227 /// @code{.cpp}
228 ///
229 /// class MyVirtualChannel { ... };
230 ///
231 /// template <DerivedChannelT>
232 /// class SerializationTraits<DerivedChannelT, bool,
233 /// typename std::enable_if<
234 /// std::is_base_of<VirtChannel, DerivedChannel>::value
235 /// >::type> {
236 /// public:
237 /// static const char* getName() { ... };
238 /// }
239 ///
240 /// @endcode
241 template <typename ChannelT, typename WireType,
242  typename ConcreteType = WireType, typename = void>
244 
245 template <typename ChannelT>
247 public:
248  static Error emitSeparator(ChannelT &C) { return Error::success(); }
249  static Error consumeSeparator(ChannelT &C) { return Error::success(); }
250 };
251 
252 /// Utility class for serializing sequences of values of varying types.
253 /// Specializations of this class contain 'serialize' and 'deserialize' methods
254 /// for the given channel. The ArgTs... list will determine the "over-the-wire"
255 /// types to be serialized. The serialize and deserialize methods take a list
256 /// CArgTs... ("caller arg types") which must be the same length as ArgTs...,
257 /// but may be different types from ArgTs, provided that for each CArgT there
258 /// is a SerializationTraits specialization
259 /// SerializeTraits<ChannelT, ArgT, CArgT> with methods that can serialize the
260 /// caller argument to over-the-wire value.
261 template <typename ChannelT, typename... ArgTs>
263 
264 template <typename ChannelT>
265 class SequenceSerialization<ChannelT> {
266 public:
267  static Error serialize(ChannelT &C) { return Error::success(); }
268  static Error deserialize(ChannelT &C) { return Error::success(); }
269 };
270 
271 template <typename ChannelT, typename ArgT>
272 class SequenceSerialization<ChannelT, ArgT> {
273 public:
274 
275  template <typename CArgT>
276  static Error serialize(ChannelT &C, CArgT &&CArg) {
277  return SerializationTraits<ChannelT, ArgT,
278  typename std::decay<CArgT>::type>::
279  serialize(C, std::forward<CArgT>(CArg));
280  }
281 
282  template <typename CArgT>
283  static Error deserialize(ChannelT &C, CArgT &CArg) {
285  }
286 };
287 
288 template <typename ChannelT, typename ArgT, typename... ArgTs>
289 class SequenceSerialization<ChannelT, ArgT, ArgTs...> {
290 public:
291 
292  template <typename CArgT, typename... CArgTs>
293  static Error serialize(ChannelT &C, CArgT &&CArg,
294  CArgTs &&... CArgs) {
295  if (auto Err =
296  SerializationTraits<ChannelT, ArgT, typename std::decay<CArgT>::type>::
297  serialize(C, std::forward<CArgT>(CArg)))
298  return Err;
299  if (auto Err = SequenceTraits<ChannelT>::emitSeparator(C))
300  return Err;
302  serialize(C, std::forward<CArgTs>(CArgs)...);
303  }
304 
305  template <typename CArgT, typename... CArgTs>
306  static Error deserialize(ChannelT &C, CArgT &CArg,
307  CArgTs &... CArgs) {
308  if (auto Err =
310  return Err;
312  return Err;
314  }
315 };
316 
317 template <typename ChannelT, typename... ArgTs>
318 Error serializeSeq(ChannelT &C, ArgTs &&... Args) {
320  serialize(C, std::forward<ArgTs>(Args)...);
321 }
322 
323 template <typename ChannelT, typename... ArgTs>
324 Error deserializeSeq(ChannelT &C, ArgTs &... Args) {
326 }
327 
328 template <typename ChannelT>
329 class SerializationTraits<ChannelT, Error> {
330 public:
331 
332  using WrappedErrorSerializer =
333  std::function<Error(ChannelT &C, const ErrorInfoBase&)>;
334 
336  std::function<Error(ChannelT &C, Error &Err)>;
337 
338  template <typename ErrorInfoT, typename SerializeFtor,
339  typename DeserializeFtor>
340  static void registerErrorType(std::string Name, SerializeFtor Serialize,
341  DeserializeFtor Deserialize) {
342  assert(!Name.empty() &&
343  "The empty string is reserved for the Success value");
344 
345  const std::string *KeyName = nullptr;
346  {
347  // We're abusing the stability of std::map here: We take a reference to the
348  // key of the deserializers map to save us from duplicating the string in
349  // the serializer. This should be changed to use a stringpool if we switch
350  // to a map type that may move keys in memory.
351  std::lock_guard<std::recursive_mutex> Lock(DeserializersMutex);
352  auto I =
353  Deserializers.insert(Deserializers.begin(),
354  std::make_pair(std::move(Name),
355  std::move(Deserialize)));
356  KeyName = &I->first;
357  }
358 
359  {
360  assert(KeyName != nullptr && "No keyname pointer");
361  std::lock_guard<std::recursive_mutex> Lock(SerializersMutex);
362  // FIXME: Move capture Serialize once we have C++14.
363  Serializers[ErrorInfoT::classID()] =
364  [KeyName, Serialize](ChannelT &C, const ErrorInfoBase &EIB) -> Error {
365  assert(EIB.dynamicClassID() == ErrorInfoT::classID() &&
366  "Serializer called for wrong error type");
367  if (auto Err = serializeSeq(C, *KeyName))
368  return Err;
369  return Serialize(C, static_cast<const ErrorInfoT &>(EIB));
370  };
371  }
372  }
373 
374  static Error serialize(ChannelT &C, Error &&Err) {
375  std::lock_guard<std::recursive_mutex> Lock(SerializersMutex);
376 
377  if (!Err)
378  return serializeSeq(C, std::string());
379 
380  return handleErrors(std::move(Err),
381  [&C](const ErrorInfoBase &EIB) {
382  auto SI = Serializers.find(EIB.dynamicClassID());
383  if (SI == Serializers.end())
384  return serializeAsStringError(C, EIB);
385  return (SI->second)(C, EIB);
386  });
387  }
388 
389  static Error deserialize(ChannelT &C, Error &Err) {
390  std::lock_guard<std::recursive_mutex> Lock(DeserializersMutex);
391 
392  std::string Key;
393  if (auto Err = deserializeSeq(C, Key))
394  return Err;
395 
396  if (Key.empty()) {
397  ErrorAsOutParameter EAO(&Err);
398  Err = Error::success();
399  return Error::success();
400  }
401 
402  auto DI = Deserializers.find(Key);
403  assert(DI != Deserializers.end() && "No deserializer for error type");
404  return (DI->second)(C, Err);
405  }
406 
407 private:
408 
409  static Error serializeAsStringError(ChannelT &C, const ErrorInfoBase &EIB) {
410  std::string ErrMsg;
411  {
412  raw_string_ostream ErrMsgStream(ErrMsg);
413  EIB.log(ErrMsgStream);
414  }
415  return serialize(C, make_error<StringError>(std::move(ErrMsg),
417  }
418 
419  static std::recursive_mutex SerializersMutex;
420  static std::recursive_mutex DeserializersMutex;
421  static std::map<const void*, WrappedErrorSerializer> Serializers;
422  static std::map<std::string, WrappedErrorDeserializer> Deserializers;
423 };
424 
425 template <typename ChannelT>
427 
428 template <typename ChannelT>
430 
431 template <typename ChannelT>
432 std::map<const void*,
435 
436 template <typename ChannelT>
437 std::map<std::string,
440 
441 /// Registers a serializer and deserializer for the given error type on the
442 /// given channel type.
443 template <typename ChannelT, typename ErrorInfoT, typename SerializeFtor,
444  typename DeserializeFtor>
445 void registerErrorSerialization(std::string Name, SerializeFtor &&Serialize,
446  DeserializeFtor &&Deserialize) {
447  SerializationTraits<ChannelT, Error>::template registerErrorType<ErrorInfoT>(
448  std::move(Name),
449  std::forward<SerializeFtor>(Serialize),
450  std::forward<DeserializeFtor>(Deserialize));
451 }
452 
453 /// Registers serialization/deserialization for StringError.
454 template <typename ChannelT>
456  static bool AlreadyRegistered = false;
457  if (!AlreadyRegistered) {
458  registerErrorSerialization<ChannelT, StringError>(
459  "StringError",
460  [](ChannelT &C, const StringError &SE) {
461  return serializeSeq(C, SE.getMessage());
462  },
463  [](ChannelT &C, Error &Err) -> Error {
464  ErrorAsOutParameter EAO(&Err);
465  std::string Msg;
466  if (auto E2 = deserializeSeq(C, Msg))
467  return E2;
468  Err =
469  make_error<StringError>(std::move(Msg),
470  orcError(
472  return Error::success();
473  });
474  AlreadyRegistered = true;
475  }
476 }
477 
478 /// SerializationTraits for Expected<T1> from an Expected<T2>.
479 template <typename ChannelT, typename T1, typename T2>
480 class SerializationTraits<ChannelT, Expected<T1>, Expected<T2>> {
481 public:
482 
483  static Error serialize(ChannelT &C, Expected<T2> &&ValOrErr) {
484  if (ValOrErr) {
485  if (auto Err = serializeSeq(C, true))
486  return Err;
488  }
489  if (auto Err = serializeSeq(C, false))
490  return Err;
491  return serializeSeq(C, ValOrErr.takeError());
492  }
493 
494  static Error deserialize(ChannelT &C, Expected<T2> &ValOrErr) {
495  ExpectedAsOutParameter<T2> EAO(&ValOrErr);
496  bool HasValue;
497  if (auto Err = deserializeSeq(C, HasValue))
498  return Err;
499  if (HasValue)
501  Error Err = Error::success();
502  if (auto E2 = deserializeSeq(C, Err))
503  return E2;
504  ValOrErr = std::move(Err);
505  return Error::success();
506  }
507 };
508 
509 /// SerializationTraits for Expected<T1> from a T2.
510 template <typename ChannelT, typename T1, typename T2>
511 class SerializationTraits<ChannelT, Expected<T1>, T2> {
512 public:
513 
514  static Error serialize(ChannelT &C, T2 &&Val) {
515  return serializeSeq(C, Expected<T2>(std::forward<T2>(Val)));
516  }
517 };
518 
519 /// SerializationTraits for Expected<T1> from an Error.
520 template <typename ChannelT, typename T>
521 class SerializationTraits<ChannelT, Expected<T>, Error> {
522 public:
523 
524  static Error serialize(ChannelT &C, Error &&Err) {
525  return serializeSeq(C, Expected<T>(std::move(Err)));
526  }
527 };
528 
529 /// SerializationTraits default specialization for std::pair.
530 template <typename ChannelT, typename T1, typename T2>
531 class SerializationTraits<ChannelT, std::pair<T1, T2>> {
532 public:
533  static Error serialize(ChannelT &C, const std::pair<T1, T2> &V) {
534  return serializeSeq(C, V.first, V.second);
535  }
536 
537  static Error deserialize(ChannelT &C, std::pair<T1, T2> &V) {
538  return deserializeSeq(C, V.first, V.second);
539  }
540 };
541 
542 /// SerializationTraits default specialization for std::tuple.
543 template <typename ChannelT, typename... ArgTs>
544 class SerializationTraits<ChannelT, std::tuple<ArgTs...>> {
545 public:
546 
547  /// RPC channel serialization for std::tuple.
548  static Error serialize(ChannelT &C, const std::tuple<ArgTs...> &V) {
549  return serializeTupleHelper(C, V, llvm::index_sequence_for<ArgTs...>());
550  }
551 
552  /// RPC channel deserialization for std::tuple.
553  static Error deserialize(ChannelT &C, std::tuple<ArgTs...> &V) {
554  return deserializeTupleHelper(C, V, llvm::index_sequence_for<ArgTs...>());
555  }
556 
557 private:
558  // Serialization helper for std::tuple.
559  template <size_t... Is>
560  static Error serializeTupleHelper(ChannelT &C, const std::tuple<ArgTs...> &V,
562  return serializeSeq(C, std::get<Is>(V)...);
563  }
564 
565  // Serialization helper for std::tuple.
566  template <size_t... Is>
567  static Error deserializeTupleHelper(ChannelT &C, std::tuple<ArgTs...> &V,
569  return deserializeSeq(C, std::get<Is>(V)...);
570  }
571 };
572 
573 /// SerializationTraits default specialization for std::vector.
574 template <typename ChannelT, typename T>
575 class SerializationTraits<ChannelT, std::vector<T>> {
576 public:
577 
578  /// Serialize a std::vector<T> from std::vector<T>.
579  static Error serialize(ChannelT &C, const std::vector<T> &V) {
580  if (auto Err = serializeSeq(C, static_cast<uint64_t>(V.size())))
581  return Err;
582 
583  for (const auto &E : V)
584  if (auto Err = serializeSeq(C, E))
585  return Err;
586 
587  return Error::success();
588  }
589 
590  /// Deserialize a std::vector<T> to a std::vector<T>.
591  static Error deserialize(ChannelT &C, std::vector<T> &V) {
592  uint64_t Count = 0;
593  if (auto Err = deserializeSeq(C, Count))
594  return Err;
595 
596  V.resize(Count);
597  for (auto &E : V)
598  if (auto Err = deserializeSeq(C, E))
599  return Err;
600 
601  return Error::success();
602  }
603 };
604 
605 } // end namespace rpc
606 } // end namespace orc
607 } // end namespace llvm
608 
609 #endif // LLVM_EXECUTIONENGINE_ORC_RPCSERIALIZATION_H
uint64_t CallInst * C
Compute iterated dominance frontiers using a linear time algorithm.
Definition: AllocatorList.h:24
static Error deserialize(ChannelT &C, std::vector< T > &V)
Deserialize a std::vector<T> to a std::vector<T>.
Helper for Expected<T>s used as out-parameters.
Definition: Error.h:1012
static sys::Mutex Lock
static Error serialize(ChannelT &C, const std::pair< T1, T2 > &V)
Base class for error info classes.
Definition: Error.h:47
std::function< Error(ChannelT &C, Error &Err)> WrappedErrorDeserializer
Definition: BitVector.h:920
std::error_code orcError(OrcErrorCode ErrCode)
Definition: OrcError.cpp:72
virtual void log(raw_ostream &OS) const =0
Print an error message to an output stream.
static StringRef getName(Value *V)
Tagged union holding either a T or a Error.
Definition: CachePruning.h:23
Alias for the common case of a sequence of size_ts.
Definition: STLExtras.h:299
Error serializeSeq(ChannelT &C, ArgTs &&... Args)
Key
PAL metadata keys.
static Error serialize(ChannelT &C, CArgT &&CArg, CArgTs &&... CArgs)
static Error emitSeparator(ChannelT &C)
void registerStringError()
Registers serialization/deserialization for StringError.
virtual const void * dynamicClassID() const =0
void registerErrorSerialization(std::string Name, SerializeFtor &&Serialize, DeserializeFtor &&Deserialize)
Registers a serializer and deserializer for the given error type on the given channel type...
The SerializationTraits<ChannelT, T> class describes how to serialize and deserialize an instance of ...
static Error deserialize(ChannelT &C, std::tuple< ArgTs... > &V)
RPC channel deserialization for std::tuple.
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
static Error deserialize(ChannelT &C, std::pair< T1, T2 > &V)
OStream & operator<<(OStream &OS, const RPCTypeNameSequence<> &V)
Render an empty TypeNameSequence to an ostream.
static ErrorSuccess success()
Create a success value.
Definition: Error.h:313
static void registerErrorType(std::string Name, SerializeFtor Serialize, DeserializeFtor Deserialize)
Creates a compile-time integer sequence for a parameter pack.
Definition: STLExtras.h:301
Helper for Errors used as out-parameters.
Definition: Error.h:990
static Error deserialize(ChannelT &C, Error &Err)
This class wraps a string in an Error.
Definition: Error.h:1088
#define I(x, y, z)
Definition: MD5.cpp:58
Error deserializeSeq(ChannelT &C, ArgTs &... Args)
static Error serialize(ChannelT &C, const std::vector< T > &V)
Serialize a std::vector<T> from std::vector<T>.
TypeNameSequence is a utility for rendering sequences of types to a string by rendering each type...
std::function< Error(ChannelT &C, const ErrorInfoBase &)> WrappedErrorSerializer
static Error serialize(ChannelT &C, Error &&Err)
Utility class for serializing sequences of values of varying types.
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
static Error deserialize(ChannelT &C, CArgT &CArg, CArgTs &... CArgs)
A raw_ostream that writes to an std::string.
Definition: raw_ostream.h:462
static Error deserialize(ChannelT &C, CArgT &CArg)
Lightweight error class with error context and mandatory checking.
Definition: Error.h:156
static Error serialize(ChannelT &C, CArgT &&CArg)
Error handleErrors(Error E, HandlerTs &&... Hs)
Pass the ErrorInfo(s) contained in E to their respective handlers.
Definition: Error.h:866
static Error serialize(ChannelT &C, const std::tuple< ArgTs... > &V)
RPC channel serialization for std::tuple.
constexpr char Args[]
Key for Kernel::Metadata::mArgs.
#define T1
static Error consumeSeparator(ChannelT &C)
std::error_code inconvertibleErrorCode()
The value returned by this function can be returned from convertToErrorCode for Error values where no...
Definition: Error.cpp:73