context.h

 
#pragma once
 
#include <cstdint>
#include <cstring>
#include <memory>
#include <string>
 
#include <ucp/api/ucp.h>
 
#include <ucxx/component.h>
#include <ucxx/config.h>
#include <ucxx/constructors.h>
 
namespace ucxx {
 
namespace experimental {
class ContextBuilder;
}  // namespace experimental
 
class MemoryHandle;
class Worker;
 
class Context : public Component {
 private:
  ucp_context_h _handle{nullptr};  
  Config _config{{}};              
  uint64_t _featureFlags{0};       
  bool _cudaSupport{false};        
 
  Context(const ConfigMap ucxConfig, const uint64_t featureFlags);
 
 public:
  static constexpr uint64_t defaultFeatureFlags =
    UCP_FEATURE_TAG | UCP_FEATURE_WAKEUP | UCP_FEATURE_STREAM | UCP_FEATURE_AM |
    UCP_FEATURE_RMA;  
 
  Context()                          = delete;
  Context(const Context&)            = delete;
  Context& operator=(Context const&) = delete;
  Context(Context&& o)               = delete;
  Context& operator=(Context&& o)    = delete;
 
  friend std::shared_ptr<Context> createContext(ConfigMap ucxConfig, const uint64_t featureFlags);
 
  friend class experimental::ContextBuilder;
 
  ~Context();
 
  [[nodiscard]] ConfigMap getConfig();
 
  [[nodiscard]] ucp_context_h getHandle();
 
  [[nodiscard]] std::string getInfo();
 
  [[nodiscard]] uint64_t getFeatureFlags() const;
 
  [[nodiscard]] bool hasCudaSupport() const;
 
  [[nodiscard]] std::shared_ptr<Worker> createWorker(const bool enableDelayedSubmission = false,
                                                     const bool enableFuture            = false);
 
  [[nodiscard]] std::shared_ptr<MemoryHandle> createMemoryHandle(
    const size_t size, void* buffer, const ucs_memory_type_t memoryType = UCS_MEMORY_TYPE_HOST);
};
 
std::shared_ptr<Context> createContext(ConfigMap ucxConfig, const uint64_t featureFlags);
 
}  // namespace ucxx
 
// Include experimental features
#include <ucxx/experimental/context_builder.h>