rabit.h

Go to the documentation of this file.

 
#ifndef RABIT_RABIT_H_  // NOLINT(*)
#define RABIT_RABIT_H_  // NOLINT(*)
#include <string>
#include <vector>
#include <functional>
// engine definition of rabit, defines internal implementation
// to use rabit interface, there is no need to read engine.h
// rabit.h and serializable.h are enough to use the interface
#include "./internal/engine.h"
 
namespace rabit {
using Stream = dmlc::Stream;
using Serializable = dmlc::Serializable;
 
namespace op {
struct Max;
struct Min;
struct Sum;
struct BitAND;
struct BitOR;
struct BitXOR;
}  // namespace op
inline bool Init(int argc, char *argv[]);
inline bool Finalize();
inline int GetRank();
inline int GetWorldSize();
inline bool IsDistributed();
 
inline std::string GetProcessorName();
inline void TrackerPrint(const std::string &msg);
 
#ifndef RABIT_STRICT_CXX98_
inline void TrackerPrintf(const char *fmt, ...);
#endif  // RABIT_STRICT_CXX98_
inline void Broadcast(void *sendrecv_data, size_t size, int root);
 
template<typename DType>
inline void Broadcast(std::vector<DType> *sendrecv_data, int root);
inline void Broadcast(std::string *sendrecv_data, int root);
template<typename OP, typename DType>
inline void Allreduce(DType *sendrecvbuf, size_t count,
                      void (*prepare_fun)(void *) = nullptr,
                      void *prepare_arg = nullptr);
 
template<typename DType>
inline void Allgather(DType *sendrecvbuf_,
                  size_t total_size,
                  size_t slice_begin,
                  size_t slice_end,
                  size_t size_prev_slice);
 
// C++11 support for lambda prepare function
#if DMLC_USE_CXX11
template<typename OP, typename DType>
inline void Allreduce(DType *sendrecvbuf, size_t count,
                      std::function<void()> prepare_fun);
#endif  // C++11
 
inline int LoadCheckPoint();
inline void CheckPoint();
 
inline int VersionNumber();
}  // namespace rabit
// implementation of template functions
#include "./internal/rabit-inl.h"
#endif  // RABIT_RABIT_H_ // NOLINT(*)