MR_LIBS/sparse__page__writer_8h_source.html

#ifndef XGBOOST_DATA_SPARSE_PAGE_WRITER_H_

#define XGBOOST_DATA_SPARSE_PAGE_WRITER_H_


#include <functional>  // for function

#include <string>      // for string


#include "../common/io.h"   // for AlignedResourceReadStream, AlignedFileWriteStream

#include "dmlc/io.h"        // for Stream

#include "dmlc/registry.h"  // for Registry, FunctionRegEntryBase

#include "xgboost/data.h"   // for SparsePage,CSCPage,SortedCSCPage,EllpackPage ...


namespace xgboost::data {

template<typename T>

struct SparsePageFormatReg;


template <typename T>


class SparsePageFormat {

 public:

  virtual ~SparsePageFormat() = default;

  virtual bool Read(T* page, common::AlignedResourceReadStream* fi) = 0;

  virtual size_t Write(const T& page, common::AlignedFileWriteStream* fo) = 0;

};


template<typename T>


inline SparsePageFormat<T>* CreatePageFormat(const std::string& name) {

  auto *e = ::dmlc::Registry<SparsePageFormatReg<T>>::Get()->Find(name);

  if (e == nullptr) {

    LOG(FATAL) << "Unknown format type " << name;

    return nullptr;

  }

  return (e->body)();

}


template<typename T>


struct SparsePageFormatReg

    : public dmlc::FunctionRegEntryBase<SparsePageFormatReg<T>,

                                        std::function<SparsePageFormat<T>* ()>> {

};


#define SparsePageFmt SparsePageFormat<SparsePage>

#define XGBOOST_REGISTER_SPARSE_PAGE_FORMAT(Name)                       \

  DMLC_REGISTRY_REGISTER(SparsePageFormatReg<SparsePage>, SparsePageFmt, Name)


#define CSCPageFmt SparsePageFormat<CSCPage>

#define XGBOOST_REGISTER_CSC_PAGE_FORMAT(Name)                       \

  DMLC_REGISTRY_REGISTER(SparsePageFormatReg<CSCPage>, CSCPageFmt, Name)


#define SortedCSCPageFmt SparsePageFormat<SortedCSCPage>

#define XGBOOST_REGISTER_SORTED_CSC_PAGE_FORMAT(Name)                       \

  DMLC_REGISTRY_REGISTER(SparsePageFormatReg<SortedCSCPage>, SortedCSCPageFmt, Name)


#define EllpackPageFmt SparsePageFormat<EllpackPage>

#define XGBOOST_REGISTER_ELLPACK_PAGE_FORMAT(Name)                       \

  DMLC_REGISTRY_REGISTER(SparsePageFormatReg<EllpackPage>, EllpackPageFmt, Name)


#define GHistIndexPageFmt SparsePageFormat<GHistIndexMatrix>

#define XGBOOST_REGISTER_GHIST_INDEX_PAGE_FORMAT(Name)                         \

  DMLC_REGISTRY_REGISTER(SparsePageFormatReg<GHistIndexMatrix>,                \

                         GHistIndexPageFmt, Name)


}  // namespace xgboost::data

#endif  // XGBOOST_DATA_SPARSE_PAGE_WRITER_H_

dmlc::FunctionRegEntryBase
Common base class for function registry.
Definition registry.h:151

dmlc::Registry
Registry class. Registry can be used to register global singletons. The most commonly use case are fa...
Definition registry.h:27

dmlc::Registry::Find
static const EntryType * Find(const std::string &name)
Find the entry with corresponding name.
Definition registry.h:48

xgboost::common::AlignedFileWriteStream
Output stream backed by a file.
Definition io.h:426

xgboost::common::AlignedResourceReadStream
Wrap resource into a dmlc stream.
Definition io.h:282

xgboost.data::SparsePageFormat
Format specification of various data formats like SparsePage.
Definition sparse_page_writer.h:25

xgboost.data::SparsePageFormat::Write
virtual size_t Write(const T &page, common::AlignedFileWriteStream *fo)=0
save the data to fo, when a page was written.

xgboost.data::SparsePageFormat::Read
virtual bool Read(T *page, common::AlignedResourceReadStream *fi)=0
Load all the segments into page, advance fi to end of the block.

io.h
defines serializable interface of dmlc

data.h
Copyright 2015-2023 by XGBoost Contributors.

xgboost.data
Copyright 2019-2023, XGBoost Contributors.
Definition data.py:1

xgboost.data::CreatePageFormat
SparsePageFormat< T > * CreatePageFormat(const std::string &name)
Create sparse page of format.
Definition sparse_page_writer.h:49

registry.h
Registry utility that helps to build registry singletons.

xgboost.data::SparsePageFormatReg
Registry entry for sparse page format.
Definition sparse_page_writer.h:64