Flex  0.17.9
mutable_csr.h
Go to the documentation of this file.
1 
16 #ifndef STORAGES_RT_MUTABLE_GRAPH_CSR_MUTABLE_CSR_H_
17 #define STORAGES_RT_MUTABLE_GRAPH_CSR_MUTABLE_CSR_H_
18 
19 #include <thread>
20 
21 #include "grape/utils/concurrent_queue.h"
22 
26 
27 namespace gs {
28 
29 void read_file(const std::string& filename, void* buffer, size_t size,
30  size_t num);
31 
32 void write_file(const std::string& filename, const void* buffer, size_t size,
33  size_t num);
34 
35 template <typename EDATA_T>
38 
39  public:
41  : cur_(slice.begin()), end_(slice.end()) {}
42  ~MutableCsrConstEdgeIter() = default;
43 
44  vid_t get_neighbor() const override { return (*cur_).get_neighbor(); }
45  Any get_data() const override {
46  return AnyConverter<EDATA_T>::to_any((*cur_).get_data());
47  }
48  timestamp_t get_timestamp() const override { return (*cur_).get_timestamp(); }
49 
50  void next() override { ++cur_; }
51  CsrConstEdgeIterBase& operator+=(size_t offset) override {
52  cur_ += offset;
53  if (!(cur_ < end_)) {
54  cur_ = end_;
55  }
56  return *this;
57  }
58  bool is_valid() const override { return cur_ != end_; }
59  size_t size() const override { return end_ - cur_; }
60 
61  private:
64 };
65 
66 template <typename EDATA_T>
69 
70  public:
72  : cur_(slice.begin()), end_(slice.end()) {}
73  ~MutableCsrEdgeIter() = default;
74 
75  vid_t get_neighbor() const override { return cur_->neighbor; }
76  Any get_data() const override {
78  }
79  timestamp_t get_timestamp() const override { return cur_->timestamp.load(); }
80 
81  void set_data(const Any& value, timestamp_t ts) override {
83  cur_->timestamp.store(ts);
84  }
85 
86  CsrEdgeIterBase& operator+=(size_t offset) override {
87  if (cur_ + offset >= end_) {
88  cur_ = end_;
89  } else {
90  cur_ += offset;
91  }
92  return *this;
93  }
94 
95  void next() override { ++cur_; }
96  bool is_valid() const override { return cur_ != end_; }
97  size_t size() const override { return end_ - cur_; }
98 
99  private:
102 };
103 
104 template <>
105 class MutableCsrEdgeIter<std::string_view> : public CsrEdgeIterBase {
107 
108  public:
110  : cur_(slice.begin()), end_(slice.end()) {}
111  ~MutableCsrEdgeIter() = default;
112 
113  vid_t get_neighbor() const override { return cur_.get_neighbor(); }
114  Any get_data() const override {
116  }
117  timestamp_t get_timestamp() const override { return cur_.get_timestamp(); }
118 
119  void set_data(const Any& value, timestamp_t ts) override {
120  cur_.set_data(value.AsStringView(), ts);
121  }
122  size_t get_index() const { return cur_.get_index(); }
124 
125  CsrEdgeIterBase& operator+=(size_t offset) override {
126  cur_ += offset;
127  if (!(cur_ < end_)) {
128  cur_ = end_;
129  }
130  return *this;
131  }
132 
133  void next() override { ++cur_; }
134  bool is_valid() const override { return cur_ != end_; }
135  size_t size() const override { return end_.ptr_ - cur_.ptr_; }
136 
137  private:
140 };
141 
142 template <>
145 
146  public:
148  : cur_(slice.begin()), end_(slice.end()) {}
149  ~MutableCsrEdgeIter() = default;
150 
151  vid_t get_neighbor() const override { return cur_->get_neighbor(); }
152  Any get_data() const override {
154  }
155  size_t get_index() const { return cur_.get_index(); }
156 
157  timestamp_t get_timestamp() const override { return cur_->get_timestamp(); }
158 
160 
161  void set_data(const Any& value, timestamp_t ts) override {
162  Record rv = value.AsRecord();
163  cur_->set_data(rv, ts);
164  }
165 
166  CsrEdgeIterBase& operator+=(size_t offset) override {
167  cur_ += offset;
168  if (!(cur_ < end_)) {
169  cur_ = end_;
170  }
171  return *this;
172  }
173 
174  void next() override { ++cur_; }
175  bool is_valid() const override { return cur_ != end_; }
176  size_t size() const override { return end_ - cur_; }
177 
178  private:
181 };
182 template <typename EDATA_T>
183 class MutableCsr : public TypedMutableCsrBase<EDATA_T> {
184  public:
189 
190  MutableCsr() : locks_(nullptr) {}
192  if (locks_ != nullptr) {
193  delete[] locks_;
194  }
195  }
196 
197  size_t batch_init(const std::string& name, const std::string& work_dir,
198  const std::vector<int>& degree,
199  double reserve_ratio) override {
200  reserve_ratio = std::max(reserve_ratio, 1.0);
201  size_t vnum = degree.size();
202  adj_lists_.open(work_dir + "/" + name + ".adj", true);
203  adj_lists_.resize(vnum);
204 
205  locks_ = new grape::SpinLock[vnum];
206 
207  size_t edge_num = 0;
208  for (auto d : degree) {
209  edge_num += (std::ceil(d * reserve_ratio));
210  }
211  nbr_list_.open(work_dir + "/" + name + ".nbr", true);
212  nbr_list_.resize(edge_num);
213 
214  nbr_t* ptr = nbr_list_.data();
215  for (vid_t i = 0; i < vnum; ++i) {
216  int deg = degree[i];
217  int cap = std::ceil(deg * reserve_ratio);
218  adj_lists_[i].init(ptr, cap, 0);
219  ptr += cap;
220  }
221 
222  unsorted_since_ = 0;
223  return edge_num;
224  }
225 
226  size_t batch_init_in_memory(const std::vector<int>& degree,
227  double reserve_ratio) override {
228  reserve_ratio = std::max(reserve_ratio, 1.0);
229  size_t vnum = degree.size();
230  adj_lists_.open("", false);
231  adj_lists_.resize(vnum);
232 
233  locks_ = new grape::SpinLock[vnum];
234 
235  size_t edge_num = 0;
236  for (auto d : degree) {
237  edge_num += (std::ceil(d * reserve_ratio));
238  }
239  nbr_list_.open("", false);
240  nbr_list_.resize(edge_num);
241 
242  nbr_t* ptr = nbr_list_.data();
243  for (vid_t i = 0; i < vnum; ++i) {
244  int deg = degree[i];
245  int cap = std::ceil(deg * reserve_ratio);
246  adj_lists_[i].init(ptr, cap, 0);
247  ptr += cap;
248  }
249 
250  unsorted_since_ = 0;
251  return edge_num;
252  }
253 
254  void batch_put_edge(vid_t src, vid_t dst, const EDATA_T& data,
255  timestamp_t ts) override {
256  adj_lists_[src].batch_put_edge(dst, data, ts);
257  }
258 
260  size_t vnum = adj_lists_.size();
261  for (size_t i = 0; i != vnum; ++i) {
262  std::sort(adj_lists_[i].data(),
263  adj_lists_[i].data() + adj_lists_[i].size(),
264  [](const nbr_t& lhs, const nbr_t& rhs) {
265  return lhs.data < rhs.data;
266  });
267  }
268  unsorted_since_ = ts;
269  }
270 
271  timestamp_t unsorted_since() const override { return unsorted_since_; }
272 
273  void open(const std::string& name, const std::string& snapshot_dir,
274  const std::string& work_dir) override {
275  mmap_array<int> degree_list;
276  mmap_array<int>* cap_list = &degree_list;
277  if (snapshot_dir != "") {
278  degree_list.open(snapshot_dir + "/" + name + ".deg", false);
279  if (std::filesystem::exists(snapshot_dir + "/" + name + ".cap")) {
280  cap_list = new mmap_array<int>();
281  cap_list->open(snapshot_dir + "/" + name + ".cap", false);
282  }
283  nbr_list_.open(snapshot_dir + "/" + name + ".nbr", false);
284  load_meta(snapshot_dir + "/" + name);
285  }
286  nbr_list_.touch(work_dir + "/" + name + ".nbr");
287  adj_lists_.open(work_dir + "/" + name + ".adj", true);
288 
289  adj_lists_.resize(degree_list.size());
290  locks_ = new grape::SpinLock[degree_list.size()];
291 
292  nbr_t* ptr = nbr_list_.data();
293  for (size_t i = 0; i < degree_list.size(); ++i) {
294  int degree = degree_list[i];
295  int cap = (*cap_list)[i];
296  adj_lists_[i].init(ptr, cap, degree);
297  ptr += cap;
298  }
299  if (cap_list != &degree_list) {
300  delete cap_list;
301  }
302  }
303 
304  void open_in_memory(const std::string& prefix, size_t v_cap) override {
305  mmap_array<int> degree_list;
306  degree_list.open(prefix + ".deg", false);
307  load_meta(prefix);
308  mmap_array<int>* cap_list = &degree_list;
309  if (std::filesystem::exists(prefix + ".cap")) {
310  cap_list = new mmap_array<int>();
311  cap_list->open(prefix + ".cap", false);
312  }
313 
314  nbr_list_.open(prefix + ".nbr", false);
315 
316  adj_lists_.reset();
317  v_cap = std::max(v_cap, degree_list.size());
318  adj_lists_.resize(v_cap);
319  locks_ = new grape::SpinLock[v_cap];
320 
321  nbr_t* ptr = nbr_list_.data();
322  for (size_t i = 0; i < degree_list.size(); ++i) {
323  int degree = degree_list[i];
324  int cap = (*cap_list)[i];
325  adj_lists_[i].init(ptr, cap, degree);
326  ptr += cap;
327  }
328  for (size_t i = degree_list.size(); i < v_cap; ++i) {
329  adj_lists_[i].init(ptr, 0, 0);
330  }
331 
332  if (cap_list != &degree_list) {
333  delete cap_list;
334  }
335  }
336 
337  void open_with_hugepages(const std::string& prefix, size_t v_cap) override {
338  mmap_array<int> degree_list;
339  degree_list.open(prefix + ".deg", false);
340  load_meta(prefix);
341  mmap_array<int>* cap_list = &degree_list;
342  if (std::filesystem::exists(prefix + ".cap")) {
343  cap_list = new mmap_array<int>();
344  cap_list->open(prefix + ".cap", false);
345  }
346 
347  nbr_list_.open_with_hugepages(prefix + ".nbr");
348 
349  adj_lists_.reset();
350  v_cap = std::max(v_cap, degree_list.size());
351  adj_lists_.open_with_hugepages("");
352  adj_lists_.resize(v_cap);
353  locks_ = new grape::SpinLock[v_cap];
354 
355  nbr_t* ptr = nbr_list_.data();
356  for (size_t i = 0; i < degree_list.size(); ++i) {
357  int degree = degree_list[i];
358  int cap = (*cap_list)[i];
359  adj_lists_[i].init(ptr, cap, degree);
360  ptr += cap;
361  }
362  for (size_t i = degree_list.size(); i < v_cap; ++i) {
363  adj_lists_[i].init(ptr, 0, 0);
364  }
365 
366  if (cap_list != &degree_list) {
367  delete cap_list;
368  }
369  }
370 
371  void dump(const std::string& name,
372  const std::string& new_snapshot_dir) override {
373  size_t vnum = adj_lists_.size();
374  bool reuse_nbr_list = true;
375  dump_meta(new_snapshot_dir + "/" + name);
376  mmap_array<int> degree_list;
377  std::vector<int> cap_list;
378  degree_list.open(new_snapshot_dir + "/" + name + ".deg", true);
379  degree_list.resize(vnum);
380  cap_list.resize(vnum);
381  bool need_cap_list = false;
382  size_t offset = 0;
383  for (size_t i = 0; i < vnum; ++i) {
384  if (adj_lists_[i].size() != 0) {
385  if (!(adj_lists_[i].data() == nbr_list_.data() + offset &&
386  offset < nbr_list_.size())) {
387  reuse_nbr_list = false;
388  }
389  }
390  offset += adj_lists_[i].capacity();
391 
392  degree_list[i] = adj_lists_[i].size();
393  cap_list[i] = adj_lists_[i].capacity();
394  if (degree_list[i] != cap_list[i]) {
395  need_cap_list = true;
396  }
397  }
398 
399  if (need_cap_list) {
400  write_file(new_snapshot_dir + "/" + name + ".cap", cap_list.data(),
401  sizeof(int), cap_list.size());
402  }
403 
404  if (reuse_nbr_list && !nbr_list_.filename().empty() &&
405  std::filesystem::exists(nbr_list_.filename())) {
406  std::error_code errorCode;
407  std::filesystem::create_hard_link(nbr_list_.filename(),
408  new_snapshot_dir + "/" + name + ".nbr",
409  errorCode);
410  if (errorCode) {
411  std::stringstream ss;
412  ss << "Failed to create hard link from " << nbr_list_.filename()
413  << " to " << new_snapshot_dir + "/" + name + ".snbr"
414  << ", error code: " << errorCode << " " << errorCode.message();
415  LOG(ERROR) << ss.str();
416  throw std::runtime_error(ss.str());
417  }
418  } else {
419  FILE* fout =
420  fopen((new_snapshot_dir + "/" + name + ".nbr").c_str(), "wb");
421  std::string filename = new_snapshot_dir + "/" + name + ".nbr";
422  if (fout == nullptr) {
423  std::stringstream ss;
424  ss << "Failed to open nbr list " << filename << ", " << strerror(errno);
425  LOG(ERROR) << ss.str();
426  throw std::runtime_error(ss.str());
427  }
428 
429  for (size_t i = 0; i < vnum; ++i) {
430  size_t ret{};
431  if ((ret = fwrite(adj_lists_[i].data(), sizeof(nbr_t),
432  adj_lists_[i].capacity(), fout)) !=
433  static_cast<size_t>(adj_lists_[i].capacity())) {
434  std::stringstream ss;
435  ss << "Failed to write nbr list " << filename << ", expected "
436  << adj_lists_[i].capacity() << ", got " << ret << ", "
437  << strerror(errno);
438  LOG(ERROR) << ss.str();
439  throw std::runtime_error(ss.str());
440  }
441  }
442  int ret = 0;
443  if ((ret = fflush(fout)) != 0) {
444  std::stringstream ss;
445  ss << "Failed to flush nbr list " << filename << ", error code: " << ret
446  << " " << strerror(errno);
447  LOG(ERROR) << ss.str();
448  throw std::runtime_error(ss.str());
449  }
450  if ((ret = fclose(fout)) != 0) {
451  std::stringstream ss;
452  ss << "Failed to close nbr list " << filename << ", error code: " << ret
453  << " " << strerror(errno);
454  LOG(ERROR) << ss.str();
455  throw std::runtime_error(ss.str());
456  }
457  }
458  }
459 
460  void warmup(int thread_num) const override {
461  size_t vnum = adj_lists_.size();
462  std::vector<std::thread> threads;
463  std::atomic<size_t> v_i(0);
464  const size_t chunk = 4096;
465  std::atomic<size_t> output(0);
466  for (int i = 0; i < thread_num; ++i) {
467  threads.emplace_back([&]() {
468  size_t ret = 0;
469  while (true) {
470  size_t begin = std::min(v_i.fetch_add(chunk), vnum);
471  size_t end = std::min(begin + chunk, vnum);
472 
473  if (begin == end) {
474  break;
475  }
476 
477  while (begin < end) {
478  auto adj_list = get_edges(begin);
479  for (auto& nbr : adj_list) {
480  ret += nbr.neighbor;
481  }
482  ++begin;
483  }
484  }
485  output.fetch_add(ret);
486  });
487  }
488  for (auto& thrd : threads) {
489  thrd.join();
490  }
491  (void) output.load();
492  }
493 
494  void resize(vid_t vnum) override {
495  if (vnum > adj_lists_.size()) {
496  size_t old_size = adj_lists_.size();
497  adj_lists_.resize(vnum);
498  for (size_t k = old_size; k != vnum; ++k) {
499  adj_lists_[k].init(NULL, 0, 0);
500  }
501  delete[] locks_;
502  locks_ = new grape::SpinLock[vnum];
503  } else {
504  adj_lists_.resize(vnum);
505  }
506  }
507  size_t size() const override { return adj_lists_.size(); }
508 
509  size_t edge_num() const override {
510  size_t res = 0;
511  for (size_t i = 0; i < adj_lists_.size(); ++i) {
512  res += adj_lists_[i].size();
513  }
514  return res;
515  }
516 
517  std::shared_ptr<CsrConstEdgeIterBase> edge_iter(vid_t v) const override {
518  return std::make_shared<MutableCsrConstEdgeIter<EDATA_T>>(get_edges(v));
519  }
522  }
523  std::shared_ptr<CsrEdgeIterBase> edge_iter_mut(vid_t v) override {
524  return std::make_shared<MutableCsrEdgeIter<EDATA_T>>(get_edges_mut(v));
525  }
526 
527  void put_edge(vid_t src, vid_t dst, const EDATA_T& data, timestamp_t ts,
528  Allocator& alloc) override {
529  CHECK_LT(src, adj_lists_.size());
530  locks_[src].lock();
531  adj_lists_[src].put_edge(dst, data, ts, alloc);
532  locks_[src].unlock();
533  }
534 
535  inline slice_t get_edges(vid_t v) const override {
536  return adj_lists_[v].get_edges();
537  }
538 
540  return adj_lists_[i].get_edges_mut();
541  }
542 
543  void close() override {
544  if (locks_ != nullptr) {
545  delete[] locks_;
546  locks_ = nullptr;
547  }
548  adj_lists_.reset();
549  nbr_list_.reset();
550  }
551 
552  private:
553  void load_meta(const std::string& prefix) {
554  std::string meta_file_path = prefix + ".meta";
555  if (std::filesystem::exists(meta_file_path)) {
556  read_file(meta_file_path, &unsorted_since_, sizeof(timestamp_t), 1);
557 
558  } else {
559  unsorted_since_ = 0;
560  }
561  }
562 
563  void dump_meta(const std::string& prefix) const {
564  std::string meta_file_path = prefix + ".meta";
565  write_file(meta_file_path, &unsorted_since_, sizeof(timestamp_t), 1);
566  }
567 
568  grape::SpinLock* locks_;
572 };
573 
574 template <>
575 class MutableCsr<std::string_view>
576  : public TypedMutableCsrBase<std::string_view> {
577  public:
582 
583  MutableCsr(StringColumn& column) : column_(column), csr_() {}
585 
586  size_t batch_init(const std::string& name, const std::string& work_dir,
587  const std::vector<int>& degree,
588  double reserve_ratio) override {
589  return csr_.batch_init(name, work_dir, degree, reserve_ratio);
590  }
591 
592  size_t batch_init_in_memory(const std::vector<int>& degree,
593  double reserve) override {
594  return csr_.batch_init_in_memory(degree, reserve);
595  }
596 
597  void batch_put_edge_with_index(vid_t src, vid_t dst, size_t data,
598  timestamp_t ts) override {
599  csr_.batch_put_edge(src, dst, data, ts);
600  }
601 
602  void open(const std::string& name, const std::string& snapshot_dir,
603  const std::string& work_dir) override {
604  csr_.open(name, snapshot_dir, work_dir);
605  }
606 
607  void open_in_memory(const std::string& prefix, size_t v_cap) override {
608  csr_.open_in_memory(prefix, v_cap);
609  }
610 
611  void dump(const std::string& name,
612  const std::string& new_snapshot_dir) override {
613  csr_.dump(name, new_snapshot_dir);
614  }
615 
616  void warmup(int thread_num) const override { csr_.warmup(thread_num); }
617 
618  void resize(vid_t vnum) override { csr_.resize(vnum); }
619 
620  size_t size() const override { return csr_.size(); }
621 
622  size_t edge_num() const override { return csr_.edge_num(); }
623 
624  std::shared_ptr<CsrConstEdgeIterBase> edge_iter(vid_t v) const override {
625  return std::make_shared<MutableCsrConstEdgeIter<std::string_view>>(
626  get_edges(v));
627  }
628 
631  }
632  std::shared_ptr<CsrEdgeIterBase> edge_iter_mut(vid_t v) override {
633  return std::make_shared<MutableCsrEdgeIter<std::string_view>>(
634  get_edges_mut(v));
635  }
636 
637  void put_edge(vid_t src, vid_t dst, size_t data, timestamp_t ts,
638  Allocator& alloc) {
639  csr_.put_edge(src, dst, data, ts, alloc);
640  }
641 
642  void put_edge_with_index(vid_t src, vid_t dst, size_t index, timestamp_t ts,
643  Allocator& alloc) override {
644  csr_.put_edge(src, dst, index, ts, alloc);
645  }
646 
647  inline slice_t get_edges(vid_t i) const override {
648  return slice_t(csr_.get_edges(i), column_);
649  }
650 
652  return mut_slice_t(csr_.get_edges_mut(i), column_);
653  }
654 
655  void close() override { csr_.close(); }
656 
657  private:
660 };
661 
662 template <>
663 class MutableCsr<RecordView> : public TypedMutableCsrBase<RecordView> {
664  public:
669  MutableCsr(Table& table) : table_(table), csr_() {}
671 
672  size_t batch_init(const std::string& name, const std::string& work_dir,
673  const std::vector<int>& degree,
674  double reserve_ratio = 1.2) override {
675  return csr_.batch_init(name, work_dir, degree, reserve_ratio);
676  }
677 
678  size_t batch_init_in_memory(const std::vector<int>& degree,
679  double reserve_ratio = 1.2) override {
680  return csr_.batch_init_in_memory(degree, reserve_ratio);
681  }
682 
683  void batch_put_edge_with_index(vid_t src, vid_t dst, size_t data,
684  timestamp_t ts = 0) override {
685  csr_.batch_put_edge(src, dst, data, ts);
686  }
687 
688  void open(const std::string& name, const std::string& snapshot_dir,
689  const std::string& work_dir) override {
690  csr_.open(name, snapshot_dir, work_dir);
691  }
692 
693  void open_in_memory(const std::string& prefix, size_t v_cap) override {
694  csr_.open_in_memory(prefix, v_cap);
695  }
696 
697  void dump(const std::string& name,
698  const std::string& new_snapshot_dir) override {
699  csr_.dump(name, new_snapshot_dir);
700  }
701 
702  void warmup(int thread_num) const override { csr_.warmup(thread_num); }
703 
704  void resize(vid_t vnum) override { csr_.resize(vnum); }
705 
706  size_t size() const override { return csr_.size(); }
707 
708  size_t edge_num() const override { return csr_.edge_num(); }
709 
710  std::shared_ptr<CsrConstEdgeIterBase> edge_iter(vid_t v) const override {
711  return std::make_shared<MutableCsrConstEdgeIter<RecordView>>(get_edges(v));
712  }
713 
716  }
717  std::shared_ptr<CsrEdgeIterBase> edge_iter_mut(vid_t v) override {
718  return std::make_shared<MutableCsrEdgeIter<RecordView>>(get_edges_mut(v));
719  }
720 
721  void put_edge(vid_t src, vid_t dst, size_t data, timestamp_t ts,
722  Allocator& alloc) {
723  csr_.put_edge(src, dst, data, ts, alloc);
724  }
725 
726  void put_edge_with_index(vid_t src, vid_t dst, size_t index, timestamp_t ts,
727  Allocator& alloc) override {
728  csr_.put_edge(src, dst, index, ts, alloc);
729  }
730 
731  inline slice_t get_edges(vid_t i) const override {
732  return slice_t(csr_.get_edges(i), table_);
733  }
734 
736  return mut_slice_t(csr_.get_edges_mut(i), table_);
737  }
738 
739  void close() override { csr_.close(); }
740 
741  private:
744 };
745 
746 template <typename EDATA_T>
747 class SingleMutableCsr : public TypedMutableCsrBase<EDATA_T> {
748  public:
752 
755 
756  size_t batch_init(const std::string& name, const std::string& work_dir,
757  const std::vector<int>& degree,
758  double reserve_ratio) override {
759  size_t vnum = degree.size();
760  nbr_list_.open(work_dir + "/" + name + ".snbr", true);
761  nbr_list_.resize(vnum);
762  for (size_t k = 0; k != vnum; ++k) {
763  nbr_list_[k].timestamp.store(std::numeric_limits<timestamp_t>::max());
764  }
765  return vnum;
766  }
767 
768  size_t batch_init_in_memory(const std::vector<int>& degree,
769  double reserve_ratio) override {
770  size_t vnum = degree.size();
771  nbr_list_.open("", false);
772  nbr_list_.resize(vnum);
773  for (size_t k = 0; k != vnum; ++k) {
774  nbr_list_[k].timestamp.store(std::numeric_limits<timestamp_t>::max());
775  }
776  return vnum;
777  }
778 
779  void batch_put_edge(vid_t src, vid_t dst, const EDATA_T& data,
780  timestamp_t ts = 0) override {
781  nbr_list_[src].neighbor = dst;
782  nbr_list_[src].data = data;
783  CHECK_EQ(nbr_list_[src].timestamp.load(),
784  std::numeric_limits<timestamp_t>::max());
785  nbr_list_[src].timestamp.store(ts);
786  }
787 
789 
790  timestamp_t unsorted_since() const override {
791  return std::numeric_limits<timestamp_t>::max();
792  }
793 
794  void open(const std::string& name, const std::string& snapshot_dir,
795  const std::string& work_dir) override {
796  if (!std::filesystem::exists(work_dir + "/" + name + ".snbr")) {
797  copy_file(snapshot_dir + "/" + name + ".snbr",
798  work_dir + "/" + name + ".snbr");
799  }
800  nbr_list_.open(work_dir + "/" + name + ".snbr", true);
801  }
802 
803  void open_in_memory(const std::string& prefix, size_t v_cap) override {
804  nbr_list_.open(prefix + ".snbr", false);
805  if (nbr_list_.size() < v_cap) {
806  size_t old_size = nbr_list_.size();
807  nbr_list_.reset();
808  nbr_list_.resize(v_cap);
809  read_file(prefix + ".snbr", nbr_list_.data(), sizeof(nbr_t), old_size);
810  for (size_t k = old_size; k != v_cap; ++k) {
811  nbr_list_[k].timestamp.store(std::numeric_limits<timestamp_t>::max());
812  }
813  }
814  }
815 
816  void open_with_hugepages(const std::string& prefix, size_t v_cap) override {
817  nbr_list_.open_with_hugepages(prefix + ".snbr", v_cap);
818  size_t old_size = nbr_list_.size();
819  if (old_size < v_cap) {
820  nbr_list_.resize(v_cap);
821  for (size_t k = old_size; k != v_cap; ++k) {
822  nbr_list_[k].timestamp.store(std::numeric_limits<timestamp_t>::max());
823  }
824  }
825  }
826 
827  void dump(const std::string& name,
828  const std::string& new_snapshot_dir) override {
829  if ((!nbr_list_.filename().empty() &&
830  std::filesystem::exists(nbr_list_.filename()))) {
831  std::error_code errorCode;
832  std::filesystem::create_hard_link(nbr_list_.filename(),
833  new_snapshot_dir + "/" + name + ".snbr",
834  errorCode);
835  if (errorCode) {
836  std::stringstream ss;
837  ss << "Failed to create hard link from " << nbr_list_.filename()
838  << " to " << new_snapshot_dir + "/" + name + ".snbr"
839  << ", error code: " << errorCode << " " << errorCode.message();
840  LOG(ERROR) << ss.str();
841  throw std::runtime_error(ss.str());
842  }
843  } else {
844  write_file(new_snapshot_dir + "/" + name + ".snbr", nbr_list_.data(),
845  sizeof(nbr_t), nbr_list_.size());
846  }
847  }
848 
849  void warmup(int thread_num) const override {
850  size_t vnum = nbr_list_.size();
851  std::vector<std::thread> threads;
852  std::atomic<size_t> v_i(0);
853  std::atomic<size_t> output(0);
854  const size_t chunk = 4096;
855  for (int i = 0; i < thread_num; ++i) {
856  threads.emplace_back([&]() {
857  size_t ret = 0;
858  while (true) {
859  size_t begin = std::min(v_i.fetch_add(chunk), vnum);
860  size_t end = std::min(begin + chunk, vnum);
861  if (begin == end) {
862  break;
863  }
864  while (begin < end) {
865  auto& nbr = nbr_list_[begin];
866  ret += nbr.neighbor;
867  ++begin;
868  }
869  }
870  output.fetch_add(ret);
871  });
872  }
873  for (auto& thrd : threads) {
874  thrd.join();
875  }
876  (void) output.load();
877  }
878 
879  void resize(vid_t vnum) override {
880  if (vnum > nbr_list_.size()) {
881  size_t old_size = nbr_list_.size();
882  nbr_list_.resize(vnum);
883  for (size_t k = old_size; k != vnum; ++k) {
884  nbr_list_[k].timestamp.store(std::numeric_limits<timestamp_t>::max());
885  }
886  } else {
887  nbr_list_.resize(vnum);
888  }
889  }
890 
891  size_t size() const override { return nbr_list_.size(); }
892 
893  size_t edge_num() const override {
894  size_t cnt = 0;
895  for (size_t k = 0; k != nbr_list_.size(); ++k) {
896  if (nbr_list_[k].timestamp.load() !=
897  std::numeric_limits<timestamp_t>::max()) {
898  ++cnt;
899  }
900  }
901  return cnt;
902  }
903 
904  std::shared_ptr<CsrConstEdgeIterBase> edge_iter(vid_t v) const override {
905  return std::make_shared<MutableCsrConstEdgeIter<EDATA_T>>(get_edges(v));
906  }
909  }
910  std::shared_ptr<CsrEdgeIterBase> edge_iter_mut(vid_t v) override {
911  return std::make_shared<MutableCsrEdgeIter<EDATA_T>>(get_edges_mut(v));
912  }
913 
914  void put_edge(vid_t src, vid_t dst, const EDATA_T& data, timestamp_t ts,
915  Allocator& alloc) override {
916  CHECK_LT(src, nbr_list_.size());
917  nbr_list_[src].neighbor = dst;
918  nbr_list_[src].data = data;
919  CHECK_EQ(nbr_list_[src].timestamp, std::numeric_limits<timestamp_t>::max());
920  nbr_list_[src].timestamp.store(ts);
921  }
922 
923  inline slice_t get_edges(vid_t v) const override {
924  slice_t ret;
925  ret.set_size(nbr_list_[v].timestamp.load() ==
926  std::numeric_limits<timestamp_t>::max()
927  ? 0
928  : 1);
929  if (ret.size() != 0) {
930  ret.set_begin(&nbr_list_[v]);
931  }
932  return ret;
933  }
934 
936  mut_slice_t ret;
937  ret.set_size(nbr_list_[i].timestamp.load() ==
938  std::numeric_limits<timestamp_t>::max()
939  ? 0
940  : 1);
941  if (ret.size() != 0) {
942  ret.set_begin(&nbr_list_[i]);
943  }
944  return ret;
945  }
946 
947  inline const nbr_t& get_edge(vid_t i) const { return nbr_list_[i]; }
948 
949  void close() override { nbr_list_.reset(); }
950 
951  private:
953 };
954 
955 template <>
956 class SingleMutableCsr<std::string_view>
957  : public TypedMutableCsrBase<std::string_view> {
958  public:
962 
963  SingleMutableCsr(StringColumn& column) : column_(column), csr_() {}
965 
966  size_t batch_init(const std::string& name, const std::string& work_dir,
967  const std::vector<int>& degree,
968  double reserve_ratio) override {
969  return csr_.batch_init(name, work_dir, degree, reserve_ratio);
970  }
971 
972  size_t batch_init_in_memory(const std::vector<int>& degree,
973  double reserve_ratio) override {
974  return csr_.batch_init_in_memory(degree, reserve_ratio);
975  }
976 
977  void batch_put_edge_with_index(vid_t src, vid_t dst, size_t data,
978  timestamp_t ts) override {
979  csr_.batch_put_edge(src, dst, data, ts);
980  }
981 
983 
984  timestamp_t unsorted_since() const override {
985  return std::numeric_limits<timestamp_t>::max();
986  }
987 
988  void open(const std::string& name, const std::string& snapshot_dir,
989  const std::string& work_dir) override {
990  csr_.open(name, snapshot_dir, work_dir);
991  }
992 
993  void open_in_memory(const std::string& prefix, size_t v_cap) override {
994  csr_.open_in_memory(prefix, v_cap);
995  }
996 
997  void dump(const std::string& name,
998  const std::string& new_snapshot_dir) override {
999  csr_.dump(name, new_snapshot_dir);
1000  }
1001 
1002  void warmup(int thread_num) const override { csr_.warmup(thread_num); }
1003 
1004  void resize(vid_t vnum) override { csr_.resize(vnum); }
1005 
1006  size_t size() const override { return csr_.size(); }
1007 
1008  size_t edge_num() const override { return csr_.edge_num(); }
1009 
1010  std::shared_ptr<CsrConstEdgeIterBase> edge_iter(vid_t v) const override {
1011  return std::make_shared<MutableCsrConstEdgeIter<std::string_view>>(
1012  get_edges(v));
1013  }
1014 
1017  }
1018 
1019  std::shared_ptr<CsrEdgeIterBase> edge_iter_mut(vid_t v) override {
1020  return std::make_shared<MutableCsrEdgeIter<std::string_view>>(
1021  get_edges_mut(v));
1022  }
1023 
1024  void put_edge(vid_t src, vid_t dst, size_t data, timestamp_t ts,
1025  Allocator& alloc) {
1026  csr_.put_edge(src, dst, data, ts, alloc);
1027  }
1028 
1029  void put_edge_with_index(vid_t src, vid_t dst, size_t index, timestamp_t ts,
1030  Allocator& alloc) override {
1031  put_edge(src, dst, index, ts, alloc);
1032  }
1033 
1034  inline slice_t get_edges(vid_t i) const override {
1035  auto ret = csr_.get_edges(i);
1036  return slice_t(ret, column_);
1037  }
1038 
1040  auto ret = csr_.get_edges_mut(i);
1041  return mut_slice_t(ret, column_);
1042  }
1043 
1046  auto nbr_tmp = csr_.get_edge(i);
1047  nbr.neighbor = nbr_tmp.neighbor;
1048  nbr.timestamp.store(nbr_tmp.timestamp.load());
1049  nbr.data = column_.get_view(nbr_tmp.data);
1050  return nbr;
1051  }
1052 
1053  void close() override { csr_.close(); }
1054 
1055  private:
1058 };
1059 
1060 template <>
1061 class SingleMutableCsr<RecordView> : public TypedMutableCsrBase<RecordView> {
1062  public:
1066 
1067  SingleMutableCsr(Table& table) : table_(table), csr_() {}
1069 
1070  size_t batch_init(const std::string& name, const std::string& work_dir,
1071  const std::vector<int>& degree,
1072  double reserve_ratio) override {
1073  return csr_.batch_init(name, work_dir, degree, reserve_ratio);
1074  }
1075 
1076  size_t batch_init_in_memory(const std::vector<int>& degree,
1077  double reserve_ratio) override {
1078  return csr_.batch_init_in_memory(degree, reserve_ratio);
1079  }
1080 
1081  void batch_put_edge_with_index(vid_t src, vid_t dst, size_t data,
1082  timestamp_t ts) override {
1083  csr_.batch_put_edge(src, dst, data, ts);
1084  }
1085 
1087 
1088  timestamp_t unsorted_since() const override {
1089  return std::numeric_limits<timestamp_t>::max();
1090  }
1091 
1092  void open(const std::string& name, const std::string& snapshot_dir,
1093  const std::string& work_dir) override {
1094  csr_.open(name, snapshot_dir, work_dir);
1095  }
1096 
1097  void open_in_memory(const std::string& prefix, size_t v_cap) override {
1098  csr_.open_in_memory(prefix, v_cap);
1099  }
1100 
1101  void dump(const std::string& name,
1102  const std::string& new_snapshot_dir) override {
1103  csr_.dump(name, new_snapshot_dir);
1104  }
1105 
1106  void warmup(int thread_num) const override { csr_.warmup(thread_num); }
1107 
1108  void resize(vid_t vnum) override { csr_.resize(vnum); }
1109 
1110  size_t size() const override { return csr_.size(); }
1111 
1112  size_t edge_num() const override { return csr_.edge_num(); }
1113 
1114  std::shared_ptr<CsrConstEdgeIterBase> edge_iter(vid_t v) const override {
1115  return std::make_shared<MutableCsrConstEdgeIter<RecordView>>(get_edges(v));
1116  }
1117 
1120  }
1121 
1122  std::shared_ptr<CsrEdgeIterBase> edge_iter_mut(vid_t v) override {
1123  return std::make_shared<MutableCsrEdgeIter<RecordView>>(get_edges_mut(v));
1124  }
1125 
1126  void put_edge(vid_t src, vid_t dst, size_t data, timestamp_t ts,
1127  Allocator& alloc) {
1128  csr_.put_edge(src, dst, data, ts, alloc);
1129  }
1130 
1131  void put_edge_with_index(vid_t src, vid_t dst, size_t index, timestamp_t ts,
1132  Allocator& alloc) override {
1133  put_edge(src, dst, index, ts, alloc);
1134  }
1135 
1136  inline slice_t get_edges(vid_t i) const override {
1137  auto ret = csr_.get_edges(i);
1138  return slice_t(ret, table_);
1139  }
1140 
1142  auto ret = csr_.get_edges_mut(i);
1143  return mut_slice_t(ret, table_);
1144  }
1145 
1146  struct RecordNbr {
1148  RecordNbr(const nbr_t* ptr, Table& table) : ptr_(ptr), table_(table) {}
1149  vid_t get_neighbor() const { return ptr_->neighbor; }
1150  timestamp_t get_timestamp() const { return ptr_->timestamp.load(); }
1151  size_t get_index() const { return ptr_->data; }
1152  RecordView get_data() const { return RecordView(ptr_->data, &table_); }
1153  const nbr_t* ptr_;
1155  };
1156 
1157  inline RecordNbr get_edge(vid_t i) const {
1158  auto nbr = csr_.get_edge(i);
1159  return RecordNbr(&nbr, table_);
1160  }
1161 
1162  void close() override { csr_.close(); }
1163 
1164  private:
1167 };
1168 
1169 template <typename EDATA_T>
1170 class EmptyCsr : public TypedMutableCsrBase<EDATA_T> {
1171  public:
1173 
1174  EmptyCsr() = default;
1175  ~EmptyCsr() = default;
1176 
1177  size_t batch_init(const std::string& name, const std::string& work_dir,
1178  const std::vector<int>& degree,
1179  double reserve_ratio) override {
1180  return 0;
1181  }
1182 
1183  size_t batch_init_in_memory(const std::vector<int>& degree,
1184  double reserve_ratio) override {
1185  return 0;
1186  }
1187 
1188  void open(const std::string& name, const std::string& snapshot_dir,
1189  const std::string& work_dir) override {}
1190 
1191  void open_in_memory(const std::string& prefix, size_t v_cap) override {}
1192 
1193  void open_with_hugepages(const std::string& prefix, size_t v_cap) override {}
1194 
1195  void dump(const std::string& name,
1196  const std::string& new_snapshot_dir) override {}
1197 
1198  void warmup(int thread_num) const override {}
1199 
1200  void resize(vid_t vnum) override {}
1201 
1202  size_t size() const override { return 0; }
1203 
1204  size_t edge_num() const override { return 0; }
1205 
1206  void batch_put_edge(vid_t src, vid_t dst, const EDATA_T& data,
1207  timestamp_t ts = 0) override {}
1208  void put_edge(vid_t src, vid_t dst, const EDATA_T& data, timestamp_t ts,
1209  Allocator&) override {}
1210 
1211  std::shared_ptr<CsrConstEdgeIterBase> edge_iter(vid_t v) const override {
1212  return std::make_shared<MutableCsrConstEdgeIter<EDATA_T>>(
1214  }
1218  }
1219  std::shared_ptr<CsrEdgeIterBase> edge_iter_mut(vid_t v) override {
1220  return std::make_shared<MutableCsrEdgeIter<EDATA_T>>(
1222  }
1223 
1225 
1226  timestamp_t unsorted_since() const override {
1227  return std::numeric_limits<timestamp_t>::max();
1228  }
1229 
1230  inline slice_t get_edges(vid_t v) const override { return slice_t::empty(); }
1231 
1232  void close() override {}
1233 };
1234 
1235 template <>
1236 class EmptyCsr<std::string_view>
1237  : public TypedMutableCsrBase<std::string_view> {
1238  public:
1240 
1241  EmptyCsr(StringColumn& column) : column_(column) {}
1242  ~EmptyCsr() = default;
1243 
1244  size_t batch_init(const std::string& name, const std::string& work_dir,
1245  const std::vector<int>& degree,
1246  double reserve_ratio) override {
1247  return 0;
1248  }
1249  size_t batch_init_in_memory(const std::vector<int>& degree,
1250  double reserve_ratio) override {
1251  return 0;
1252  }
1253 
1254  void open(const std::string& name, const std::string& snapshot_dir,
1255  const std::string& work_dir) override {}
1256 
1257  void open_in_memory(const std::string& prefix, size_t v_cap) override {}
1258 
1259  void dump(const std::string& name,
1260  const std::string& new_snapshot_dir) override {}
1261 
1262  void warmup(int thread_num) const override {}
1263 
1264  void resize(vid_t vnum) override {}
1265 
1266  size_t size() const override { return 0; }
1267 
1268  size_t edge_num() const override { return 0; }
1269 
1270  void put_edge_with_index(vid_t src, vid_t dst, size_t index, timestamp_t ts,
1271  Allocator& alloc) override {}
1272  void batch_put_edge_with_index(vid_t src, vid_t dst, size_t data,
1273  timestamp_t ts = 0) override {}
1274  std::shared_ptr<CsrConstEdgeIterBase> edge_iter(vid_t v) const override {
1275  return std::make_shared<MutableCsrConstEdgeIter<std::string_view>>(
1277  }
1281  }
1282  std::shared_ptr<CsrEdgeIterBase> edge_iter_mut(vid_t v) override {
1283  return std::make_shared<MutableCsrEdgeIter<std::string_view>>(
1285  }
1286 
1287  inline slice_t get_edges(vid_t v) const override {
1288  return slice_t::empty(column_);
1289  }
1290 
1291  void close() override {}
1292 
1294 };
1295 
1296 template <>
1297 class EmptyCsr<RecordView> : public TypedMutableCsrBase<RecordView> {
1298  public:
1300 
1301  EmptyCsr(Table& table) : table_(table) {}
1302  ~EmptyCsr() = default;
1303 
1304  size_t batch_init(const std::string& name, const std::string& work_dir,
1305  const std::vector<int>& degree,
1306  double reserve_ratio) override {
1307  return 0;
1308  }
1309 
1310  size_t batch_init_in_memory(const std::vector<int>& degree,
1311  double reserve_ratio) override {
1312  return 0;
1313  }
1314 
1315  void open(const std::string& name, const std::string& snapshot_dir,
1316  const std::string& work_dir) override {}
1317 
1318  void open_in_memory(const std::string& prefix, size_t v_cap) override {}
1319 
1320  void dump(const std::string& name,
1321  const std::string& new_snapshot_dir) override {}
1322 
1323  void warmup(int thread_num) const override {}
1324 
1325  void resize(vid_t vnum) override {}
1326 
1327  size_t size() const override { return 0; }
1328 
1329  size_t edge_num() const override { return 0; }
1330 
1331  void put_edge_with_index(vid_t src, vid_t dst, size_t index, timestamp_t ts,
1332  Allocator& alloc) override {}
1333  void batch_put_edge_with_index(vid_t src, vid_t dst, size_t data,
1334  timestamp_t ts = 0) override {}
1335  std::shared_ptr<CsrConstEdgeIterBase> edge_iter(vid_t v) const override {
1336  return std::make_shared<MutableCsrConstEdgeIter<RecordView>>(
1338  }
1342  }
1343  std::shared_ptr<CsrEdgeIterBase> edge_iter_mut(vid_t v) override {
1344  return std::make_shared<MutableCsrEdgeIter<RecordView>>(
1346  }
1347 
1348  inline slice_t get_edges(vid_t v) const override {
1349  return slice_t::empty(table_);
1350  }
1351 
1352  void close() override {}
1353 
1354  private:
1356 };
1357 
1358 } // namespace gs
1359 
1360 #endif // STORAGES_RT_MUTABLE_GRAPH_CSR_MUTABLE_CSR_H_
gs::MutableCsrEdgeIter< std::string_view >::get_timestamp
timestamp_t get_timestamp() const override
Definition: mutable_csr.h:117
gs::MutableCsr< std::string_view >::csr_
MutableCsr< size_t > csr_
Definition: mutable_csr.h:659
gs::SingleMutableCsr< RecordView >::batch_sort_by_edge_data
void batch_sort_by_edge_data(timestamp_t ts) override
Definition: mutable_csr.h:1086
gs::SingleMutableCsr< std::string_view >::close
void close() override
Definition: mutable_csr.h:1053
gs::MutableCsrEdgeIter::is_valid
bool is_valid() const override
Definition: mutable_csr.h:96
gs::SingleMutableCsr< std::string_view >::open_in_memory
void open_in_memory(const std::string &prefix, size_t v_cap) override
Definition: mutable_csr.h:993
gs::SingleMutableCsr< RecordView >::batch_init
size_t batch_init(const std::string &name, const std::string &work_dir, const std::vector< int > &degree, double reserve_ratio) override
Definition: mutable_csr.h:1070
gs::MutableCsr< RecordView >::dump
void dump(const std::string &name, const std::string &new_snapshot_dir) override
Definition: mutable_csr.h:697
gs::MutableCsr::MutableCsr
MutableCsr()
Definition: mutable_csr.h:190
gs::MutableCsrEdgeIter< std::string_view >::set_timestamp
void set_timestamp(timestamp_t ts)
Definition: mutable_csr.h:123
gs::MutableCsrEdgeIter< std::string_view >::operator+=
CsrEdgeIterBase & operator+=(size_t offset) override
Definition: mutable_csr.h:125
gs::SingleMutableCsr< std::string_view >::~SingleMutableCsr
~SingleMutableCsr()
Definition: mutable_csr.h:964
gs::EmptyCsr::open_with_hugepages
void open_with_hugepages(const std::string &prefix, size_t v_cap) override
Definition: mutable_csr.h:1193
gs::MutableNbrSliceMut::set_size
void set_size(int size)
Definition: nbr.h:503
gs::SingleMutableCsr::~SingleMutableCsr
~SingleMutableCsr()
Definition: mutable_csr.h:754
gs::MutableCsr< std::string_view >::dump
void dump(const std::string &name, const std::string &new_snapshot_dir) override
Definition: mutable_csr.h:611
gs::MutableCsr< RecordView >::put_edge_with_index
void put_edge_with_index(vid_t src, vid_t dst, size_t index, timestamp_t ts, Allocator &alloc) override
Definition: mutable_csr.h:726
gs::EmptyCsr< std::string_view >::batch_init_in_memory
size_t batch_init_in_memory(const std::vector< int > &degree, double reserve_ratio) override
Definition: mutable_csr.h:1249
gs::MutableCsr< RecordView >::edge_iter_mut
std::shared_ptr< CsrEdgeIterBase > edge_iter_mut(vid_t v) override
Definition: mutable_csr.h:717
gs::read_file
void read_file(const std::string &filename, void *buffer, size_t size, size_t num)
Definition: mutable_csr.cc:23
gs::SingleMutableCsr::edge_iter_raw
CsrConstEdgeIterBase * edge_iter_raw(vid_t v) const override
Definition: mutable_csr.h:907
gs::SingleMutableCsr< std::string_view >::get_edges_mut
mut_slice_t get_edges_mut(vid_t i)
Definition: mutable_csr.h:1039
gs::MutableNbr::get_timestamp
timestamp_t get_timestamp() const
Definition: nbr.h:275
gs::MutableCsr< RecordView >::csr_
MutableCsr< size_t > csr_
Definition: mutable_csr.h:743
gs::MutableCsrEdgeIter< std::string_view >::get_data
Any get_data() const override
Definition: mutable_csr.h:114
gs::MutableCsr< RecordView >::edge_iter
std::shared_ptr< CsrConstEdgeIterBase > edge_iter(vid_t v) const override
Definition: mutable_csr.h:710
gs::EmptyCsr< std::string_view >::EmptyCsr
EmptyCsr(StringColumn &column)
Definition: mutable_csr.h:1241
gs::EmptyCsr< std::string_view >::resize
void resize(vid_t vnum) override
Definition: mutable_csr.h:1264
gs::EmptyCsr< std::string_view >::edge_num
size_t edge_num() const override
Definition: mutable_csr.h:1268
gs::Any
Definition: types.h:399
gs::MutableCsrEdgeIter::cur_
nbr_t * cur_
Definition: mutable_csr.h:100
gs::SingleMutableCsr< RecordView >::edge_iter_raw
CsrConstEdgeIterBase * edge_iter_raw(vid_t v) const override
Definition: mutable_csr.h:1118
gs::MutableCsr::batch_sort_by_edge_data
void batch_sort_by_edge_data(timestamp_t ts) override
Definition: mutable_csr.h:259
gs::MutableCsrEdgeIter< std::string_view >::is_valid
bool is_valid() const override
Definition: mutable_csr.h:134
gs::EmptyCsr::size
size_t size() const override
Definition: mutable_csr.h:1202
gs::MutableCsrConstEdgeIter::get_neighbor
vid_t get_neighbor() const override
Definition: mutable_csr.h:44
gs::SingleMutableCsr< std::string_view >::edge_iter_mut
std::shared_ptr< CsrEdgeIterBase > edge_iter_mut(vid_t v) override
Definition: mutable_csr.h:1019
gs::MutableCsr< std::string_view >::size
size_t size() const override
Definition: mutable_csr.h:620
gs::MutableNbr::set_data
void set_data(const EDATA_T &val, timestamp_t ts)
Definition: nbr.h:277
gs::MutableCsr< RecordView >::put_edge
void put_edge(vid_t src, vid_t dst, size_t data, timestamp_t ts, Allocator &alloc)
Definition: mutable_csr.h:721
gs::SingleMutableCsr< std::string_view >::edge_iter
std::shared_ptr< CsrConstEdgeIterBase > edge_iter(vid_t v) const override
Definition: mutable_csr.h:1010
gs::MutableCsrConstEdgeIter::const_nbr_ptr_t
typename MutableNbrSlice< EDATA_T >::const_nbr_ptr_t const_nbr_ptr_t
Definition: mutable_csr.h:37
gs::MutableCsr< RecordView >::warmup
void warmup(int thread_num) const override
Definition: mutable_csr.h:702
gs::EmptyCsr< RecordView >::batch_init_in_memory
size_t batch_init_in_memory(const std::vector< int > &degree, double reserve_ratio) override
Definition: mutable_csr.h:1310
gs::EmptyCsr< RecordView >::put_edge_with_index
void put_edge_with_index(vid_t src, vid_t dst, size_t index, timestamp_t ts, Allocator &alloc) override
Definition: mutable_csr.h:1331
gs::MutableCsr< std::string_view >::open_in_memory
void open_in_memory(const std::string &prefix, size_t v_cap) override
Definition: mutable_csr.h:607
gs::timestamp_t
uint32_t timestamp_t
Definition: types.h:30
gs::EmptyCsr::batch_init
size_t batch_init(const std::string &name, const std::string &work_dir, const std::vector< int > &degree, double reserve_ratio) override
Definition: mutable_csr.h:1177
gs::MutableNbrSlice::set_size
void set_size(int size)
Definition: nbr.h:327
gs::MutableCsrEdgeIter< std::string_view >::end_
nbr_ptr_t end_
Definition: mutable_csr.h:139
gs::MutableNbrSliceMut< RecordView >
Definition: nbr.h:598
gs::SingleMutableCsr::edge_num
size_t edge_num() const override
Definition: mutable_csr.h:893
gs::SingleMutableCsr::put_edge
void put_edge(vid_t src, vid_t dst, const EDATA_T &data, timestamp_t ts, Allocator &alloc) override
Definition: mutable_csr.h:914
gs::SingleMutableCsr< RecordView >::close
void close() override
Definition: mutable_csr.h:1162
gs::MutableCsr::slice_t
MutableNbrSlice< EDATA_T > slice_t
Definition: mutable_csr.h:187
gs::MutableCsr< std::string_view >::batch_init
size_t batch_init(const std::string &name, const std::string &work_dir, const std::vector< int > &degree, double reserve_ratio) override
Definition: mutable_csr.h:586
gs::SingleMutableCsr< std::string_view >::batch_init
size_t batch_init(const std::string &name, const std::string &work_dir, const std::vector< int > &degree, double reserve_ratio) override
Definition: mutable_csr.h:966
gs::SingleMutableCsr::unsorted_since
timestamp_t unsorted_since() const override
Definition: mutable_csr.h:790
gs::MutableCsr< RecordView >::size
size_t size() const override
Definition: mutable_csr.h:706
gs::EmptyCsr::open
void open(const std::string &name, const std::string &snapshot_dir, const std::string &work_dir) override
Definition: mutable_csr.h:1188
gs::MutableNbrSlice::set_begin
void set_begin(const_nbr_ptr_t ptr)
Definition: nbr.h:330
gs::MutableCsrEdgeIter< std::string_view >::next
void next() override
Definition: mutable_csr.h:133
gs::MutableCsrEdgeIter::end_
nbr_t * end_
Definition: mutable_csr.h:101
gs::MutableCsr< std::string_view >::batch_put_edge_with_index
void batch_put_edge_with_index(vid_t src, vid_t dst, size_t data, timestamp_t ts) override
Definition: mutable_csr.h:597
gs::MutableCsr< std::string_view >::edge_iter_mut
std::shared_ptr< CsrEdgeIterBase > edge_iter_mut(vid_t v) override
Definition: mutable_csr.h:632
gs::SingleMutableCsr::size
size_t size() const override
Definition: mutable_csr.h:891
gs::MutableCsrEdgeIter::operator+=
CsrEdgeIterBase & operator+=(size_t offset) override
Definition: mutable_csr.h:86
nbr.h
gs::MutableCsr< RecordView >::get_edges_mut
mut_slice_t get_edges_mut(vid_t i)
Definition: mutable_csr.h:735
gs::MutableCsr::dump_meta
void dump_meta(const std::string &prefix) const
Definition: mutable_csr.h:563
gs::write_file
void write_file(const std::string &filename, const void *buffer, size_t size, size_t num)
Definition: mutable_csr.cc:50
gs::MutableCsrEdgeIter< RecordView >::get_neighbor
vid_t get_neighbor() const override
Definition: mutable_csr.h:151
gs::SingleMutableCsr::get_edge
const nbr_t & get_edge(vid_t i) const
Definition: mutable_csr.h:947
gs::MutableCsrEdgeIter::MutableCsrEdgeIter
MutableCsrEdgeIter(MutableNbrSliceMut< EDATA_T > slice)
Definition: mutable_csr.h:71
gs::MutableCsrConstEdgeIter::get_data
Any get_data() const override
Definition: mutable_csr.h:45
gs::MutableCsrEdgeIter< std::string_view >::nbr_ptr_t
typename MutableNbrSliceMut< std::string_view >::nbr_ptr_t nbr_ptr_t
Definition: mutable_csr.h:106
gs::vid_t
uint32_t vid_t
Definition: types.h:31
gs::MutableCsrConstEdgeIter
Definition: mutable_csr.h:36
gs::EmptyCsr::batch_sort_by_edge_data
void batch_sort_by_edge_data(timestamp_t ts) override
Definition: mutable_csr.h:1224
gs::MutableCsr::mut_slice_t
MutableNbrSliceMut< EDATA_T > mut_slice_t
Definition: mutable_csr.h:188
gs::SingleMutableCsr< RecordView >::dump
void dump(const std::string &name, const std::string &new_snapshot_dir) override
Definition: mutable_csr.h:1101
gs::SingleMutableCsr< RecordView >::csr_
SingleMutableCsr< size_t > csr_
Definition: mutable_csr.h:1166
gs::MutableCsr< std::string_view >::close
void close() override
Definition: mutable_csr.h:655
gs::MutableCsr::warmup
void warmup(int thread_num) const override
Definition: mutable_csr.h:460
gs::EmptyCsr< RecordView >::close
void close() override
Definition: mutable_csr.h:1352
gs::SingleMutableCsr< RecordView >::RecordNbr::table_
Table table_
Definition: mutable_csr.h:1154
gs::mmap_array::resize
void resize(size_t size)
Definition: mmap_array.h:319
gs::SingleMutableCsr::open
void open(const std::string &name, const std::string &snapshot_dir, const std::string &work_dir) override
Definition: mutable_csr.h:794
gs::MutableCsr< RecordView >::batch_put_edge_with_index
void batch_put_edge_with_index(vid_t src, vid_t dst, size_t data, timestamp_t ts=0) override
Definition: mutable_csr.h:683
gs::EmptyCsr< std::string_view >::close
void close() override
Definition: mutable_csr.h:1291
gs::SingleMutableCsr< RecordView >::get_edges
slice_t get_edges(vid_t i) const override
Definition: mutable_csr.h:1136
gs::SingleMutableCsr::SingleMutableCsr
SingleMutableCsr()
Definition: mutable_csr.h:753
gs::EmptyCsr::batch_put_edge
void batch_put_edge(vid_t src, vid_t dst, const EDATA_T &data, timestamp_t ts=0) override
Definition: mutable_csr.h:1206
gs::SingleMutableCsr< std::string_view >::put_edge_with_index
void put_edge_with_index(vid_t src, vid_t dst, size_t index, timestamp_t ts, Allocator &alloc) override
Definition: mutable_csr.h:1029
gs::EmptyCsr::open_in_memory
void open_in_memory(const std::string &prefix, size_t v_cap) override
Definition: mutable_csr.h:1191
gs::MutableNbrSliceMut::size
int size() const
Definition: nbr.h:504
gs::SingleMutableCsr< RecordView >::RecordNbr::ptr_
const nbr_t * ptr_
Definition: mutable_csr.h:1153
gs::CsrEdgeIterBase
Definition: csr_base.h:43
gs::ConvertAny::to
static void to(const Any &value, T &out)
Definition: types.h:815
gs::MutableCsrEdgeIter< RecordView >::is_valid
bool is_valid() const override
Definition: mutable_csr.h:175
gs::MutableCsr< RecordView >::get_edges
slice_t get_edges(vid_t i) const override
Definition: mutable_csr.h:731
gs::MutableCsr::put_edge
void put_edge(vid_t src, vid_t dst, const EDATA_T &data, timestamp_t ts, Allocator &alloc) override
Definition: mutable_csr.h:527
gs::EmptyCsr::EmptyCsr
EmptyCsr()=default
gs::SingleMutableCsr< RecordView >::resize
void resize(vid_t vnum) override
Definition: mutable_csr.h:1108
gs::MutableAdjlist
Definition: adj_list.h:33
gs
Definition: adj_list.h:23
gs::SingleMutableCsr< std::string_view >::SingleMutableCsr
SingleMutableCsr(StringColumn &column)
Definition: mutable_csr.h:963
gs::SingleMutableCsr< std::string_view >::batch_put_edge_with_index
void batch_put_edge_with_index(vid_t src, vid_t dst, size_t data, timestamp_t ts) override
Definition: mutable_csr.h:977
gs::SingleMutableCsr< RecordView >::put_edge
void put_edge(vid_t src, vid_t dst, size_t data, timestamp_t ts, Allocator &alloc)
Definition: mutable_csr.h:1126
gs::MutableCsrEdgeIter< RecordView >::nbr_ptr_t
typename MutableNbrSliceMut< RecordView >::nbr_ptr_t nbr_ptr_t
Definition: mutable_csr.h:144
gs::EmptyCsr< std::string_view >::dump
void dump(const std::string &name, const std::string &new_snapshot_dir) override
Definition: mutable_csr.h:1259
gs::MutableNbrSlice< std::string_view >
Definition: nbr.h:421
gs::MutableCsr::get_edges_mut
mut_slice_t get_edges_mut(vid_t i)
Definition: mutable_csr.h:539
gs::MutableNbr
Definition: nbr.h:258
gs::MutableNbr::timestamp
std::atomic< timestamp_t > timestamp
Definition: nbr.h:285
gs::MutableCsrEdgeIter< RecordView >::end_
nbr_ptr_t end_
Definition: mutable_csr.h:180
gs::SingleMutableCsr< RecordView >::RecordNbr::RecordNbr
RecordNbr(const nbr_t *ptr, Table &table)
Definition: mutable_csr.h:1148
gs::MutableCsrConstEdgeIter::cur_
const_nbr_ptr_t cur_
Definition: mutable_csr.h:62
gs::MutableCsr< std::string_view >::warmup
void warmup(int thread_num) const override
Definition: mutable_csr.h:616
gs::SingleMutableCsr::get_edges
slice_t get_edges(vid_t v) const override
Definition: mutable_csr.h:923
gs::Table
Definition: table.h:30
gs::SingleMutableCsr::batch_sort_by_edge_data
void batch_sort_by_edge_data(timestamp_t ts) override
Definition: mutable_csr.h:788
gs::SingleMutableCsr< std::string_view >::size
size_t size() const override
Definition: mutable_csr.h:1006
gs::MutableCsr< RecordView >::table_
Table & table_
Definition: mutable_csr.h:742
gs::mmap_array::open
void open(const std::string &filename, bool sync_to_file=false)
Definition: mmap_array.h:129
gs::MutableCsrEdgeIter< std::string_view >::MutableCsrEdgeIter
MutableCsrEdgeIter(MutableNbrSliceMut< std::string_view > slice)
Definition: mutable_csr.h:109
gs::EmptyCsr< RecordView >::size
size_t size() const override
Definition: mutable_csr.h:1327
gs::ArenaAllocator
Definition: allocators.h:29
gs::EmptyCsr< RecordView >::edge_num
size_t edge_num() const override
Definition: mutable_csr.h:1329
gs::SingleMutableCsr< RecordView >::get_edge
RecordNbr get_edge(vid_t i) const
Definition: mutable_csr.h:1157
gs::SingleMutableCsr< RecordView >::~SingleMutableCsr
~SingleMutableCsr()
Definition: mutable_csr.h:1068
gs::MutableNbr::get_neighbor
vid_t get_neighbor() const
Definition: nbr.h:274
gs::MutableCsr::batch_put_edge
void batch_put_edge(vid_t src, vid_t dst, const EDATA_T &data, timestamp_t ts) override
Definition: mutable_csr.h:254
gs::MutableCsr::nbr_list_
mmap_array< nbr_t > nbr_list_
Definition: mutable_csr.h:570
gs::MutableCsrEdgeIter< std::string_view >::set_data
void set_data(const Any &value, timestamp_t ts) override
Definition: mutable_csr.h:119
gs::SingleMutableCsr::edge_iter_mut
std::shared_ptr< CsrEdgeIterBase > edge_iter_mut(vid_t v) override
Definition: mutable_csr.h:910
gs::EmptyCsr::edge_num
size_t edge_num() const override
Definition: mutable_csr.h:1204
gs::EmptyCsr::edge_iter_raw
CsrConstEdgeIterBase * edge_iter_raw(vid_t v) const override
Definition: mutable_csr.h:1215
gs::SingleMutableCsr< RecordView >::edge_iter_mut
std::shared_ptr< CsrEdgeIterBase > edge_iter_mut(vid_t v) override
Definition: mutable_csr.h:1122
gs::SingleMutableCsr::resize
void resize(vid_t vnum) override
Definition: mutable_csr.h:879
gs::EmptyCsr< RecordView >::batch_init
size_t batch_init(const std::string &name, const std::string &work_dir, const std::vector< int > &degree, double reserve_ratio) override
Definition: mutable_csr.h:1304
gs::EmptyCsr< RecordView >::batch_put_edge_with_index
void batch_put_edge_with_index(vid_t src, vid_t dst, size_t data, timestamp_t ts=0) override
Definition: mutable_csr.h:1333
gs::MutableCsrConstEdgeIter::~MutableCsrConstEdgeIter
~MutableCsrConstEdgeIter()=default
gs::MutableCsr< std::string_view >::edge_iter_raw
CsrConstEdgeIterBase * edge_iter_raw(vid_t v) const override
Definition: mutable_csr.h:629
gs::MutableCsr< std::string_view >::put_edge
void put_edge(vid_t src, vid_t dst, size_t data, timestamp_t ts, Allocator &alloc)
Definition: mutable_csr.h:637
gs::SingleMutableCsr< std::string_view >::put_edge
void put_edge(vid_t src, vid_t dst, size_t data, timestamp_t ts, Allocator &alloc)
Definition: mutable_csr.h:1024
gs::MutableCsr< RecordView >::open_in_memory
void open_in_memory(const std::string &prefix, size_t v_cap) override
Definition: mutable_csr.h:693
gs::MutableCsr< std::string_view >::MutableCsr
MutableCsr(StringColumn &column)
Definition: mutable_csr.h:583
gs::MutableCsr< std::string_view >::put_edge_with_index
void put_edge_with_index(vid_t src, vid_t dst, size_t index, timestamp_t ts, Allocator &alloc) override
Definition: mutable_csr.h:642
gs::MutableNbr::set_timestamp
void set_timestamp(timestamp_t ts)
Definition: nbr.h:282
gs::SingleMutableCsr< std::string_view >::edge_iter_raw
CsrConstEdgeIterBase * edge_iter_raw(vid_t v) const override
Definition: mutable_csr.h:1015
gs::SingleMutableCsr< std::string_view >::unsorted_since
timestamp_t unsorted_since() const override
Definition: mutable_csr.h:984
gs::SingleMutableCsr< RecordView >::SingleMutableCsr
SingleMutableCsr(Table &table)
Definition: mutable_csr.h:1067
gs::MutableCsr::locks_
grape::SpinLock * locks_
Definition: mutable_csr.h:568
gs::SingleMutableCsr< RecordView >::warmup
void warmup(int thread_num) const override
Definition: mutable_csr.h:1106
gs::SingleMutableCsr< std::string_view >::batch_init_in_memory
size_t batch_init_in_memory(const std::vector< int > &degree, double reserve_ratio) override
Definition: mutable_csr.h:972
gs::MutableNbr::data
EDATA_T data
Definition: nbr.h:286
gs::MutableCsr::edge_iter_raw
CsrConstEdgeIterBase * edge_iter_raw(vid_t v) const override
Definition: mutable_csr.h:520
gs::EmptyCsr::get_edges
slice_t get_edges(vid_t v) const override
Definition: mutable_csr.h:1230
gs::CsrConstEdgeIterBase
Definition: csr_base.h:27
gs::EmptyCsr::batch_init_in_memory
size_t batch_init_in_memory(const std::vector< int > &degree, double reserve_ratio) override
Definition: mutable_csr.h:1183
gs::MutableNbrSlice< RecordView >
Definition: nbr.h:348
gs::SingleMutableCsr< RecordView >::put_edge_with_index
void put_edge_with_index(vid_t src, vid_t dst, size_t index, timestamp_t ts, Allocator &alloc) override
Definition: mutable_csr.h:1131
gs::Record
Definition: types.h:316
gs::SingleMutableCsr::edge_iter
std::shared_ptr< CsrConstEdgeIterBase > edge_iter(vid_t v) const override
Definition: mutable_csr.h:904
gs::MutableCsr::load_meta
void load_meta(const std::string &prefix)
Definition: mutable_csr.h:553
gs::MutableCsr::edge_iter
std::shared_ptr< CsrConstEdgeIterBase > edge_iter(vid_t v) const override
Definition: mutable_csr.h:517
gs::SingleMutableCsr::dump
void dump(const std::string &name, const std::string &new_snapshot_dir) override
Definition: mutable_csr.h:827
csr_base.h
gs::EmptyCsr< RecordView >::open
void open(const std::string &name, const std::string &snapshot_dir, const std::string &work_dir) override
Definition: mutable_csr.h:1315
gs::EmptyCsr::unsorted_since
timestamp_t unsorted_since() const override
Definition: mutable_csr.h:1226
gs::TypedColumn< std::string_view >
Definition: column.h:347
gs::MutableCsr< std::string_view >::get_edges
slice_t get_edges(vid_t i) const override
Definition: mutable_csr.h:647
gs::SingleMutableCsr< RecordView >::open_in_memory
void open_in_memory(const std::string &prefix, size_t v_cap) override
Definition: mutable_csr.h:1097
gs::SingleMutableCsr::batch_init
size_t batch_init(const std::string &name, const std::string &work_dir, const std::vector< int > &degree, double reserve_ratio) override
Definition: mutable_csr.h:756
gs::MutableCsrEdgeIter< RecordView >::MutableCsrEdgeIter
MutableCsrEdgeIter(MutableNbrSliceMut< RecordView > slice)
Definition: mutable_csr.h:147
gs::SingleMutableCsr< RecordView >::unsorted_since
timestamp_t unsorted_since() const override
Definition: mutable_csr.h:1088
gs::EmptyCsr< std::string_view >::size
size_t size() const override
Definition: mutable_csr.h:1266
gs::EmptyCsr::edge_iter_mut
std::shared_ptr< CsrEdgeIterBase > edge_iter_mut(vid_t v) override
Definition: mutable_csr.h:1219
gs::MutableCsrEdgeIter< RecordView >::set_data
void set_data(const Any &value, timestamp_t ts) override
Definition: mutable_csr.h:161
gs::mmap_array::size
size_t size() const
Definition: mmap_array.h:415
gs::MutableCsr< std::string_view >::edge_num
size_t edge_num() const override
Definition: mutable_csr.h:622
gs::MutableCsr< RecordView >::~MutableCsr
~MutableCsr()
Definition: mutable_csr.h:670
gs::EmptyCsr< std::string_view >::column_
StringColumn & column_
Definition: mutable_csr.h:1293
gs::EmptyCsr< RecordView >::edge_iter_mut
std::shared_ptr< CsrEdgeIterBase > edge_iter_mut(vid_t v) override
Definition: mutable_csr.h:1343
gs::MutableCsr::open_in_memory
void open_in_memory(const std::string &prefix, size_t v_cap) override
Definition: mutable_csr.h:304
gs::EmptyCsr::resize
void resize(vid_t vnum) override
Definition: mutable_csr.h:1200
gs::EmptyCsr::warmup
void warmup(int thread_num) const override
Definition: mutable_csr.h:1198
gs::SingleMutableCsr::nbr_list_
mmap_array< nbr_t > nbr_list_
Definition: mutable_csr.h:952
gs::SingleMutableCsr< std::string_view >::get_edges
slice_t get_edges(vid_t i) const override
Definition: mutable_csr.h:1034
gs::SingleMutableCsr< RecordView >::size
size_t size() const override
Definition: mutable_csr.h:1110
gs::MutableCsrEdgeIter::next
void next() override
Definition: mutable_csr.h:95
gs::MutableCsrConstEdgeIter::operator+=
CsrConstEdgeIterBase & operator+=(size_t offset) override
Definition: mutable_csr.h:51
gs::SingleMutableCsr< RecordView >::open
void open(const std::string &name, const std::string &snapshot_dir, const std::string &work_dir) override
Definition: mutable_csr.h:1092
gs::MutableCsr< std::string_view >::resize
void resize(vid_t vnum) override
Definition: mutable_csr.h:618
gs::SingleMutableCsr< std::string_view >::batch_sort_by_edge_data
void batch_sort_by_edge_data(timestamp_t ts) override
Definition: mutable_csr.h:982
gs::Any::AsRecord
const Record & AsRecord() const
Definition: types.h:691
gs::MutableCsrConstEdgeIter::MutableCsrConstEdgeIter
MutableCsrConstEdgeIter(const MutableNbrSlice< EDATA_T > &slice)
Definition: mutable_csr.h:40
gs::MutableCsr::open_with_hugepages
void open_with_hugepages(const std::string &prefix, size_t v_cap) override
Definition: mutable_csr.h:337
gs::MutableCsr
Definition: mutable_csr.h:183
gs::SingleMutableCsr< std::string_view >::edge_num
size_t edge_num() const override
Definition: mutable_csr.h:1008
gs::SingleMutableCsr< RecordView >::get_edges_mut
mut_slice_t get_edges_mut(vid_t i)
Definition: mutable_csr.h:1141
gs::MutableCsr< RecordView >::edge_iter_raw
CsrConstEdgeIterBase * edge_iter_raw(vid_t v) const override
Definition: mutable_csr.h:714
gs::SingleMutableCsr::close
void close() override
Definition: mutable_csr.h:949
gs::SingleMutableCsr< std::string_view >::warmup
void warmup(int thread_num) const override
Definition: mutable_csr.h:1002
gs::EmptyCsr< RecordView >::resize
void resize(vid_t vnum) override
Definition: mutable_csr.h:1325
gs::EmptyCsr< RecordView >::dump
void dump(const std::string &name, const std::string &new_snapshot_dir) override
Definition: mutable_csr.h:1320
gs::SingleMutableCsr< std::string_view >::resize
void resize(vid_t vnum) override
Definition: mutable_csr.h:1004
gs::EmptyCsr::close
void close() override
Definition: mutable_csr.h:1232
gs::MutableCsrEdgeIter< RecordView >::cur_
nbr_ptr_t cur_
Definition: mutable_csr.h:179
gs::MutableCsrEdgeIter< std::string_view >::get_index
size_t get_index() const
Definition: mutable_csr.h:122
gs::EmptyCsr< RecordView >::warmup
void warmup(int thread_num) const override
Definition: mutable_csr.h:1323
gs::SingleMutableCsr::mut_slice_t
MutableNbrSliceMut< EDATA_T > mut_slice_t
Definition: mutable_csr.h:751
gs::MutableCsr::size
size_t size() const override
Definition: mutable_csr.h:507
gs::SingleMutableCsr::open_in_memory
void open_in_memory(const std::string &prefix, size_t v_cap) override
Definition: mutable_csr.h:803
gs::MutableCsrConstEdgeIter::get_timestamp
timestamp_t get_timestamp() const override
Definition: mutable_csr.h:48
gs::MutableCsr< RecordView >::batch_init
size_t batch_init(const std::string &name, const std::string &work_dir, const std::vector< int > &degree, double reserve_ratio=1.2) override
Definition: mutable_csr.h:672
gs::MutableCsr::adj_lists_
mmap_array< adjlist_t > adj_lists_
Definition: mutable_csr.h:569
gs::MutableCsr< std::string_view >::open
void open(const std::string &name, const std::string &snapshot_dir, const std::string &work_dir) override
Definition: mutable_csr.h:602
gs::EmptyCsr< std::string_view >::batch_put_edge_with_index
void batch_put_edge_with_index(vid_t src, vid_t dst, size_t data, timestamp_t ts=0) override
Definition: mutable_csr.h:1272
gs::SingleMutableCsr::get_edges_mut
mut_slice_t get_edges_mut(vid_t i)
Definition: mutable_csr.h:935
gs::MutableNbrSliceMut::set_begin
void set_begin(nbr_t *ptr)
Definition: nbr.h:506
gs::MutableCsr::unsorted_since
timestamp_t unsorted_since() const override
Definition: mutable_csr.h:271
gs::MutableCsrEdgeIter< std::string_view >::cur_
nbr_ptr_t cur_
Definition: mutable_csr.h:138
gs::TypedMutableCsrBase
Definition: csr_base.h:135
gs::SingleMutableCsr< RecordView >::RecordNbr::get_index
size_t get_index() const
Definition: mutable_csr.h:1151
gs::MutableCsrEdgeIter::get_neighbor
vid_t get_neighbor() const override
Definition: mutable_csr.h:75
gs::EmptyCsr::~EmptyCsr
~EmptyCsr()=default
gs::SingleMutableCsr< RecordView >::table_
Table & table_
Definition: mutable_csr.h:1165
gs::SingleMutableCsr< RecordView >::RecordNbr::get_timestamp
timestamp_t get_timestamp() const
Definition: mutable_csr.h:1150
gs::MutableCsrConstEdgeIter::next
void next() override
Definition: mutable_csr.h:50
gs::SingleMutableCsr::batch_put_edge
void batch_put_edge(vid_t src, vid_t dst, const EDATA_T &data, timestamp_t ts=0) override
Definition: mutable_csr.h:779
gs::MutableCsr::unsorted_since_
timestamp_t unsorted_since_
Definition: mutable_csr.h:571
gs::MutableNbr::neighbor
vid_t neighbor
Definition: nbr.h:284
gs::MutableCsrEdgeIter< RecordView >::get_timestamp
timestamp_t get_timestamp() const override
Definition: mutable_csr.h:157
gs::MutableCsrConstEdgeIter::is_valid
bool is_valid() const override
Definition: mutable_csr.h:58
gs::MutableCsrEdgeIter::size
size_t size() const override
Definition: mutable_csr.h:97
gs::copy_file
void copy_file(const std::string &src, const std::string &dst)
Definition: file_names.h:80
gs::MutableCsrEdgeIter::~MutableCsrEdgeIter
~MutableCsrEdgeIter()=default
gs::MutableNbrSliceMut
Definition: nbr.h:496
gs::SingleMutableCsr< std::string_view >::column_
StringColumn & column_
Definition: mutable_csr.h:1056
gs::MutableCsr::open
void open(const std::string &name, const std::string &snapshot_dir, const std::string &work_dir) override
Definition: mutable_csr.h:273
gs::EmptyCsr< std::string_view >::open_in_memory
void open_in_memory(const std::string &prefix, size_t v_cap) override
Definition: mutable_csr.h:1257
gs::MutableCsr::~MutableCsr
~MutableCsr()
Definition: mutable_csr.h:191
gs::EmptyCsr
Definition: mutable_csr.h:1170
gs::SingleMutableCsr::batch_init_in_memory
size_t batch_init_in_memory(const std::vector< int > &degree, double reserve_ratio) override
Definition: mutable_csr.h:768
gs::MutableCsrEdgeIter< RecordView >::size
size_t size() const override
Definition: mutable_csr.h:176
gs::MutableCsrEdgeIter< std::string_view >::get_neighbor
vid_t get_neighbor() const override
Definition: mutable_csr.h:113
gs::mmap_array< int >
gs::MutableCsr::dump
void dump(const std::string &name, const std::string &new_snapshot_dir) override
Definition: mutable_csr.h:371
gs::SingleMutableCsr< RecordView >::batch_put_edge_with_index
void batch_put_edge_with_index(vid_t src, vid_t dst, size_t data, timestamp_t ts) override
Definition: mutable_csr.h:1081
gs::snapshot_dir
std::string snapshot_dir(const std::string &work_dir, uint32_t version)
Definition: file_names.h:192
gs::SingleMutableCsr< std::string_view >::dump
void dump(const std::string &name, const std::string &new_snapshot_dir) override
Definition: mutable_csr.h:997
std
Definition: loading_config.h:232
gs::SingleMutableCsr< RecordView >::edge_iter
std::shared_ptr< CsrConstEdgeIterBase > edge_iter(vid_t v) const override
Definition: mutable_csr.h:1114
adj_list.h
gs::MutableCsr< RecordView >::batch_init_in_memory
size_t batch_init_in_memory(const std::vector< int > &degree, double reserve_ratio=1.2) override
Definition: mutable_csr.h:678
gs::SingleMutableCsr
Definition: mutable_csr.h:747
gs::EmptyCsr::put_edge
void put_edge(vid_t src, vid_t dst, const EDATA_T &data, timestamp_t ts, Allocator &) override
Definition: mutable_csr.h:1208
gs::EmptyCsr< RecordView >::EmptyCsr
EmptyCsr(Table &table)
Definition: mutable_csr.h:1301
gs::EmptyCsr< std::string_view >::put_edge_with_index
void put_edge_with_index(vid_t src, vid_t dst, size_t index, timestamp_t ts, Allocator &alloc) override
Definition: mutable_csr.h:1270
gs::MutableCsrEdgeIter< RecordView >::get_index
size_t get_index() const
Definition: mutable_csr.h:155
gs::EmptyCsr< std::string_view >::edge_iter_mut
std::shared_ptr< CsrEdgeIterBase > edge_iter_mut(vid_t v) override
Definition: mutable_csr.h:1282
gs::SingleMutableCsr< RecordView >::RecordNbr::get_neighbor
vid_t get_neighbor() const
Definition: mutable_csr.h:1149
gs::MutableCsrEdgeIter::get_timestamp
timestamp_t get_timestamp() const override
Definition: mutable_csr.h:79
gs::MutableCsr< RecordView >::resize
void resize(vid_t vnum) override
Definition: mutable_csr.h:704
gs::EmptyCsr< RecordView >::open_in_memory
void open_in_memory(const std::string &prefix, size_t v_cap) override
Definition: mutable_csr.h:1318
gs::EmptyCsr< RecordView >::table_
Table & table_
Definition: mutable_csr.h:1355
gs::MutableCsrEdgeIter::set_data
void set_data(const Any &value, timestamp_t ts) override
Definition: mutable_csr.h:81
gs::SingleMutableCsr::warmup
void warmup(int thread_num) const override
Definition: mutable_csr.h:849
gs::MutableCsrConstEdgeIter::size
size_t size() const override
Definition: mutable_csr.h:59
gs::SingleMutableCsr< RecordView >::batch_init_in_memory
size_t batch_init_in_memory(const std::vector< int > &degree, double reserve_ratio) override
Definition: mutable_csr.h:1076
gs::EmptyCsr< std::string_view >::edge_iter
std::shared_ptr< CsrConstEdgeIterBase > edge_iter(vid_t v) const override
Definition: mutable_csr.h:1274
gs::SingleMutableCsr< std::string_view >::get_edge
MutableNbr< std::string_view > get_edge(vid_t i) const
Definition: mutable_csr.h:1044
gs::MutableCsr< std::string_view >::get_edges_mut
mut_slice_t get_edges_mut(vid_t i)
Definition: mutable_csr.h:651
gs::MutableCsrEdgeIter< RecordView >::get_data
Any get_data() const override
Definition: mutable_csr.h:152
gs::MutableNbr::get_data
const EDATA_T & get_data() const
Definition: nbr.h:273
gs::EmptyCsr< RecordView >::edge_iter_raw
CsrConstEdgeIterBase * edge_iter_raw(vid_t v) const override
Definition: mutable_csr.h:1339
gs::MutableCsrEdgeIter::get_data
Any get_data() const override
Definition: mutable_csr.h:76
gs::AnyConverter
Definition: types.h:397
gs::MutableCsr< RecordView >::edge_num
size_t edge_num() const override
Definition: mutable_csr.h:708
gs::MutableCsr< std::string_view >::~MutableCsr
~MutableCsr()
Definition: mutable_csr.h:584
gs::EmptyCsr< RecordView >::get_edges
slice_t get_edges(vid_t v) const override
Definition: mutable_csr.h:1348
gs::EmptyCsr< std::string_view >::batch_init
size_t batch_init(const std::string &name, const std::string &work_dir, const std::vector< int > &degree, double reserve_ratio) override
Definition: mutable_csr.h:1244
gs::MutableCsrEdgeIter< RecordView >::operator+=
CsrEdgeIterBase & operator+=(size_t offset) override
Definition: mutable_csr.h:166
gs::MutableCsr< RecordView >::MutableCsr
MutableCsr(Table &table)
Definition: mutable_csr.h:669
gs::EmptyCsr< std::string_view >::edge_iter_raw
CsrConstEdgeIterBase * edge_iter_raw(vid_t v) const override
Definition: mutable_csr.h:1278
gs::MutableCsr::close
void close() override
Definition: mutable_csr.h:543
gs::SingleMutableCsr< RecordView >::RecordNbr::get_data
RecordView get_data() const
Definition: mutable_csr.h:1152
gs::MutableNbrSliceMut< std::string_view >
Definition: nbr.h:524
gs::EmptyCsr< std::string_view >::get_edges
slice_t get_edges(vid_t v) const override
Definition: mutable_csr.h:1287
gs::MutableCsr::get_edges
slice_t get_edges(vid_t v) const override
Definition: mutable_csr.h:535
gs::MutableCsrConstEdgeIter::end_
const_nbr_ptr_t end_
Definition: mutable_csr.h:63
gs::MutableCsr::batch_init_in_memory
size_t batch_init_in_memory(const std::vector< int > &degree, double reserve_ratio) override
Definition: mutable_csr.h:226
gs::MutableCsr::resize
void resize(vid_t vnum) override
Definition: mutable_csr.h:494
gs::MutableNbrSlice::size
int size() const
Definition: nbr.h:328
gs::EmptyCsr< std::string_view >::open
void open(const std::string &name, const std::string &snapshot_dir, const std::string &work_dir) override
Definition: mutable_csr.h:1254
gs::MutableCsrEdgeIter< RecordView >::next
void next() override
Definition: mutable_csr.h:174
gs::MutableCsrEdgeIter< RecordView >::set_timestamp
void set_timestamp(timestamp_t ts)
Definition: mutable_csr.h:159
gs::MutableCsr< std::string_view >::column_
StringColumn & column_
Definition: mutable_csr.h:658
gs::MutableNbrSlice::empty
static MutableNbrSlice empty()
Definition: nbr.h:335
gs::SingleMutableCsr< std::string_view >::csr_
SingleMutableCsr< size_t > csr_
Definition: mutable_csr.h:1057
gs::MutableCsr< std::string_view >::edge_iter
std::shared_ptr< CsrConstEdgeIterBase > edge_iter(vid_t v) const override
Definition: mutable_csr.h:624
gs::MutableNbrSliceMut::empty
static MutableNbrSliceMut empty()
Definition: nbr.h:511
gs::RecordView
Definition: types.h:292
gs::MutableCsr< std::string_view >::batch_init_in_memory
size_t batch_init_in_memory(const std::vector< int > &degree, double reserve) override
Definition: mutable_csr.h:592
gs::EmptyCsr< std::string_view >::warmup
void warmup(int thread_num) const override
Definition: mutable_csr.h:1262
gs::SingleMutableCsr< std::string_view >::open
void open(const std::string &name, const std::string &snapshot_dir, const std::string &work_dir) override
Definition: mutable_csr.h:988
gs::EmptyCsr< RecordView >::edge_iter
std::shared_ptr< CsrConstEdgeIterBase > edge_iter(vid_t v) const override
Definition: mutable_csr.h:1335
gs::EmptyCsr::edge_iter
std::shared_ptr< CsrConstEdgeIterBase > edge_iter(vid_t v) const override
Definition: mutable_csr.h:1211
gs::MutableCsrEdgeIter
Definition: mutable_csr.h:67
gs::MutableCsr< RecordView >::close
void close() override
Definition: mutable_csr.h:739
gs::MutableCsr::edge_iter_mut
std::shared_ptr< CsrEdgeIterBase > edge_iter_mut(vid_t v) override
Definition: mutable_csr.h:523
gs::MutableCsr::batch_init
size_t batch_init(const std::string &name, const std::string &work_dir, const std::vector< int > &degree, double reserve_ratio) override
Definition: mutable_csr.h:197
gs::MutableNbrSlice
Definition: nbr.h:318
gs::EmptyCsr::dump
void dump(const std::string &name, const std::string &new_snapshot_dir) override
Definition: mutable_csr.h:1195
gs::Any::AsStringView
std::string_view AsStringView() const
Definition: types.h:657
gs::SingleMutableCsr::open_with_hugepages
void open_with_hugepages(const std::string &prefix, size_t v_cap) override
Definition: mutable_csr.h:816
gs::MutableCsr< RecordView >::open
void open(const std::string &name, const std::string &snapshot_dir, const std::string &work_dir) override
Definition: mutable_csr.h:688
gs::MutableCsrEdgeIter< std::string_view >::size
size_t size() const override
Definition: mutable_csr.h:135
gs::MutableCsr::edge_num
size_t edge_num() const override
Definition: mutable_csr.h:509
gs::SingleMutableCsr::slice_t
MutableNbrSlice< EDATA_T > slice_t
Definition: mutable_csr.h:750
gs::SingleMutableCsr< RecordView >::edge_num
size_t edge_num() const override
Definition: mutable_csr.h:1112