Flex  0.17.9
immutable_csr.h
Go to the documentation of this file.
1 
16 #ifndef STORAGES_RT_MUTABLE_GRAPH_CSR_IMMUTABLE_CSR_H_
17 #define STORAGES_RT_MUTABLE_GRAPH_CSR_IMMUTABLE_CSR_H_
18 
19 namespace gs {
20 
21 template <typename EDATA_T>
24 
25  public:
27  : cur_(slice.begin()), end_(slice.end()) {}
28  ~ImmutableCsrConstEdgeIter() = default;
29 
30  vid_t get_neighbor() const override { return (*cur_).get_neighbor(); }
31  Any get_data() const override {
32  return AnyConverter<EDATA_T>::to_any((*cur_).get_data());
33  }
34  timestamp_t get_timestamp() const override { return 0; }
35 
36  void next() override { ++cur_; }
37  CsrConstEdgeIterBase& operator+=(size_t offset) override {
38  cur_ += offset;
39  if (!(cur_ < end_)) {
40  cur_ = end_;
41  }
42  return *this;
43  }
44  bool is_valid() const override { return cur_ != end_; }
45  size_t size() const override { return end_ - cur_; }
46 
47  private:
50 };
51 
52 template <typename EDATA_T>
53 class ImmutableCsr : public TypedImmutableCsrBase<EDATA_T> {
54  public:
57 
58  size_t batch_init(const std::string& name, const std::string& work_dir,
59  const std::vector<int>& degree,
60  double reserve_ratio) override {
61  size_t vnum = degree.size();
62  adj_lists_.open(work_dir + "/" + name + ".adj", true);
63  adj_lists_.resize(vnum);
64 
65  size_t edge_num = 0;
66  for (auto d : degree) {
67  edge_num += d;
68  }
69 
70  nbr_list_.open(work_dir + "/" + name + ".nbr", true);
71  nbr_list_.resize(edge_num);
72 
73  degree_list_.open(work_dir + "/" + name + ".deg", true);
74  degree_list_.resize(vnum);
75 
76  nbr_t* ptr = nbr_list_.data();
77  for (vid_t i = 0; i < vnum; ++i) {
78  int deg = degree[i];
79  if (deg != 0) {
80  adj_lists_[i] = ptr;
81  } else {
82  adj_lists_[i] = NULL;
83  }
84  ptr += deg;
85 
86  degree_list_[i] = 0;
87  }
88 
89  unsorted_since_ = 0;
90  return edge_num;
91  }
92 
93  size_t batch_init_in_memory(const std::vector<int>& degree,
94  double reserve_ratio) override {
95  size_t vnum = degree.size();
96  adj_lists_.open("", false);
97  adj_lists_.resize(vnum);
98 
99  size_t edge_num = 0;
100  for (auto d : degree) {
101  edge_num += d;
102  }
103 
104  nbr_list_.open("", false);
105  nbr_list_.resize(edge_num);
106 
107  degree_list_.open("", false);
108  degree_list_.resize(vnum);
109 
110  nbr_t* ptr = nbr_list_.data();
111  for (vid_t i = 0; i < vnum; ++i) {
112  int deg = degree[i];
113  if (deg != 0) {
114  adj_lists_[i] = ptr;
115  } else {
116  adj_lists_[i] = NULL;
117  }
118  ptr += deg;
119 
120  degree_list_[i] = 0;
121  }
122 
123  unsorted_since_ = 0;
124  return edge_num;
125  }
126 
127  void batch_put_edge(vid_t src, vid_t dst, const EDATA_T& data,
128  timestamp_t ts) override {
129  auto& nbr = adj_lists_[src][degree_list_[src]++];
130  nbr.neighbor = dst;
131  nbr.data = data;
132  }
133 
135  size_t vnum = adj_lists_.size();
136  for (size_t i = 0; i != vnum; ++i) {
137  std::sort(adj_lists_[i], adj_lists_[i] + degree_list_[i],
138  [](const nbr_t& lhs, const nbr_t& rhs) {
139  return lhs.data < rhs.data;
140  });
141  }
142  unsorted_since_ = ts;
143  }
144 
145  timestamp_t unsorted_since() const override { return unsorted_since_; }
146 
147  void open(const std::string& name, const std::string& snapshot_dir,
148  const std::string& work_dir) override {
149  // Changes made to the CSR will not be synchronized to the file
150  // TODO(luoxiaojian): Implement the insert operation on ImmutableCsr.
151  if (snapshot_dir != "") {
152  degree_list_.open(snapshot_dir + "/" + name + ".deg", false);
153  nbr_list_.open(snapshot_dir + "/" + name + ".nbr", false);
154  load_meta(snapshot_dir + "/" + name);
155  }
156 
157  adj_lists_.open(work_dir + "/" + name + ".adj", true);
158  adj_lists_.resize(degree_list_.size());
159 
160  nbr_t* ptr = nbr_list_.data();
161  for (size_t i = 0; i < degree_list_.size(); ++i) {
162  int deg = degree_list_[i];
163  adj_lists_[i] = ptr;
164  ptr += deg;
165  }
166  }
167 
168  void open_in_memory(const std::string& prefix, size_t v_cap) override {
169  degree_list_.open(prefix + ".deg", false);
170  load_meta(prefix);
171  nbr_list_.open(prefix + ".nbr", false);
172  adj_lists_.reset();
173  v_cap = std::max(v_cap, degree_list_.size());
174  adj_lists_.resize(v_cap);
175  size_t old_degree_size = degree_list_.size();
176  degree_list_.resize(v_cap);
177 
178  nbr_t* ptr = nbr_list_.data();
179  for (size_t i = 0; i < old_degree_size; ++i) {
180  int deg = degree_list_[i];
181  if (deg != 0) {
182  adj_lists_[i] = ptr;
183  } else {
184  adj_lists_[i] = NULL;
185  }
186  ptr += deg;
187  }
188  for (size_t i = old_degree_size; i < degree_list_.size(); ++i) {
189  degree_list_[i] = 0;
190  adj_lists_[i] = NULL;
191  }
192  }
193 
194  void open_with_hugepages(const std::string& prefix, size_t v_cap) override {
195  degree_list_.open_with_hugepages(prefix + ".deg", v_cap);
196  load_meta(prefix);
197  nbr_list_.open_with_hugepages(prefix + ".nbr");
198  adj_lists_.reset();
199  v_cap = std::max(v_cap, degree_list_.size());
200  adj_lists_.resize(v_cap);
201  size_t old_degree_size = degree_list_.size();
202  degree_list_.resize(v_cap);
203 
204  nbr_t* ptr = nbr_list_.data();
205  for (size_t i = 0; i < old_degree_size; ++i) {
206  int deg = degree_list_[i];
207  if (deg != 0) {
208  adj_lists_[i] = ptr;
209  } else {
210  adj_lists_[i] = NULL;
211  }
212  ptr += deg;
213  }
214  for (size_t i = old_degree_size; i < degree_list_.size(); ++i) {
215  degree_list_[i] = 0;
216  adj_lists_[i] = NULL;
217  }
218  }
219 
220  void dump(const std::string& name,
221  const std::string& new_snapshot_dir) override {
222  dump_meta(new_snapshot_dir + "/" + name);
223  size_t vnum = adj_lists_.size();
224  {
225  FILE* fout =
226  fopen((new_snapshot_dir + "/" + name + ".deg").c_str(), "wb");
227  fwrite(degree_list_.data(), sizeof(int), vnum, fout);
228  fflush(fout);
229  fclose(fout);
230  }
231  {
232  FILE* fout =
233  fopen((new_snapshot_dir + "/" + name + ".nbr").c_str(), "wb");
234  for (size_t k = 0; k < vnum; ++k) {
235  if (adj_lists_[k] != NULL && degree_list_[k] != 0) {
236  fwrite(adj_lists_[k], sizeof(nbr_t), degree_list_[k], fout);
237  }
238  }
239  fflush(fout);
240  fclose(fout);
241  }
242  }
243 
244  void warmup(int thread_num) const override {}
245 
246  void resize(vid_t vnum) override {
247  if (vnum > adj_lists_.size()) {
248  size_t old_size = adj_lists_.size();
249  adj_lists_.resize(vnum);
250  degree_list_.resize(vnum);
251  for (size_t k = old_size; k != vnum; ++k) {
252  adj_lists_[k] = NULL;
253  degree_list_[k] = 0;
254  }
255  } else {
256  adj_lists_.resize(vnum);
257  degree_list_.resize(vnum);
258  }
259  }
260 
261  size_t size() const override { return adj_lists_.size(); }
262 
263  size_t edge_num() const override {
264  size_t ret = 0;
265  for (size_t i = 0; i < adj_lists_.size(); ++i) {
266  ret += degree_list_[i];
267  }
268  return ret;
269  }
270 
271  std::shared_ptr<CsrConstEdgeIterBase> edge_iter(vid_t v) const override {
272  return std::make_shared<ImmutableCsrConstEdgeIter<EDATA_T>>(get_edges(v));
273  }
276  }
277  std::shared_ptr<CsrEdgeIterBase> edge_iter_mut(vid_t v) override {
278  return nullptr;
279  }
280 
281  void put_edge(vid_t src, vid_t dst, const EDATA_T& data, timestamp_t ts,
282  Allocator& alloc) override {
283  LOG(FATAL) << "Put single edge is not supported";
284  }
285 
286  slice_t get_edges(vid_t v) const override {
287  slice_t ret;
288  ret.set_begin(adj_lists_[v]);
289  ret.set_size(degree_list_[v]);
290  return ret;
291  }
292 
293  void close() override {
294  adj_lists_.reset();
296  nbr_list_.reset();
297  }
298 
299  private:
300  void load_meta(const std::string& prefix) {
301  std::string meta_file_path = prefix + ".meta";
302  if (std::filesystem::exists(meta_file_path)) {
303  FILE* meta_file_fd = fopen(meta_file_path.c_str(), "r");
304  CHECK_EQ(fread(&unsorted_since_, sizeof(timestamp_t), 1, meta_file_fd),
305  1);
306  fclose(meta_file_fd);
307  } else {
308  unsorted_since_ = 0;
309  }
310  }
311 
312  void dump_meta(const std::string& prefix) const {
313  std::string meta_file_path = prefix + ".meta";
314  FILE* meta_file_fd = fopen((prefix + ".meta").c_str(), "wb");
315  CHECK_EQ(fwrite(&unsorted_since_, sizeof(timestamp_t), 1, meta_file_fd), 1);
316  fflush(meta_file_fd);
317  fclose(meta_file_fd);
318  }
319 
324 };
325 
326 template <>
327 class ImmutableCsr<std::string_view>
328  : public TypedImmutableCsrBase<std::string_view> {
329  public:
332  ImmutableCsr(StringColumn& column) : column_(column), csr_() {}
334 
335  size_t batch_init(const std::string& name, const std::string& work_dir,
336  const std::vector<int>& degree,
337  double reserve_ratio = 1.2) override {
338  return csr_.batch_init(name, work_dir, degree, reserve_ratio);
339  }
340 
341  size_t batch_init_in_memory(const std::vector<int>& degree,
342  double reserve_ratio = 1.2) override {
343  return csr_.batch_init_in_memory(degree, reserve_ratio);
344  }
345 
346  void batch_put_edge_with_index(vid_t src, vid_t dst, size_t data,
347  timestamp_t ts = 0) override {
348  csr_.batch_put_edge(src, dst, data, ts);
349  }
350 
351  void open(const std::string& name, const std::string& snapshot_dir,
352  const std::string& work_dir) override {
353  csr_.open(name, snapshot_dir, work_dir);
354  }
355 
356  void open_in_memory(const std::string& prefix, size_t v_cap) override {
357  csr_.open_in_memory(prefix, v_cap);
358  }
359 
360  void open_with_hugepages(const std::string& prefix, size_t v_cap) override {
361  csr_.open_with_hugepages(prefix, v_cap);
362  }
363 
364  void dump(const std::string& name,
365  const std::string& new_snapshot_dir) override {
366  csr_.dump(name, new_snapshot_dir);
367  }
368 
369  void warmup(int thread_num) const override { csr_.warmup(thread_num); }
370 
371  void resize(vid_t vnum) override { csr_.resize(vnum); }
372 
373  size_t size() const override { return csr_.size(); }
374 
375  std::shared_ptr<CsrConstEdgeIterBase> edge_iter(vid_t v) const override {
376  return std::make_shared<ImmutableCsrConstEdgeIter<std::string_view>>(
377  get_edges(v));
378  }
379 
382  }
383  std::shared_ptr<CsrEdgeIterBase> edge_iter_mut(vid_t v) override {
384  return nullptr;
385  }
386 
387  void put_edge(vid_t src, vid_t dst, size_t data, timestamp_t ts,
388  Allocator& alloc) {
389  csr_.put_edge(src, dst, data, ts, alloc);
390  }
391 
392  void put_edge_with_index(vid_t src, vid_t dst, size_t index, timestamp_t ts,
393  Allocator& alloc) override {
394  csr_.put_edge(src, dst, index, ts, alloc);
395  }
396 
397  slice_t get_edges(vid_t i) const override {
398  return slice_t(csr_.get_edges(i), column_);
399  }
400 
401  void close() override { csr_.close(); }
402 
403  size_t edge_num() const override { return csr_.edge_num(); }
404 
405  private:
408 };
409 
410 template <>
411 class ImmutableCsr<RecordView> : public TypedImmutableCsrBase<RecordView> {
412  public:
415  ImmutableCsr(Table& table) : table_(table), csr_() {}
417 
418  size_t batch_init(const std::string& name, const std::string& work_dir,
419  const std::vector<int>& degree,
420  double reserve_ratio = 1.2) override {
421  return csr_.batch_init(name, work_dir, degree, reserve_ratio);
422  }
423 
424  size_t batch_init_in_memory(const std::vector<int>& degree,
425  double reserve_ratio = 1.2) override {
426  return csr_.batch_init_in_memory(degree, reserve_ratio);
427  }
428 
429  void batch_put_edge_with_index(vid_t src, vid_t dst, size_t data,
430  timestamp_t ts = 0) override {
431  csr_.batch_put_edge(src, dst, data, ts);
432  }
433 
434  void open(const std::string& name, const std::string& snapshot_dir,
435  const std::string& work_dir) override {
436  csr_.open(name, snapshot_dir, work_dir);
437  }
438 
439  void open_in_memory(const std::string& prefix, size_t v_cap) override {
440  csr_.open_in_memory(prefix, v_cap);
441  }
442 
443  void open_with_hugepages(const std::string& prefix, size_t v_cap) override {
444  csr_.open_with_hugepages(prefix, v_cap);
445  }
446 
447  void dump(const std::string& name,
448  const std::string& new_snapshot_dir) override {
449  csr_.dump(name, new_snapshot_dir);
450  }
451 
452  void warmup(int thread_num) const override { csr_.warmup(thread_num); }
453 
454  void resize(vid_t vnum) override { csr_.resize(vnum); }
455 
456  size_t size() const override { return csr_.size(); }
457 
458  std::shared_ptr<CsrConstEdgeIterBase> edge_iter(vid_t v) const override {
459  return std::make_shared<ImmutableCsrConstEdgeIter<RecordView>>(
460  get_edges(v));
461  }
462 
465  }
466  std::shared_ptr<CsrEdgeIterBase> edge_iter_mut(vid_t v) override {
467  return nullptr;
468  }
469 
470  void put_edge(vid_t src, vid_t dst, size_t data, timestamp_t ts,
471  Allocator& alloc) {
472  csr_.put_edge(src, dst, data, ts, alloc);
473  }
474 
475  void put_edge_with_index(vid_t src, vid_t dst, size_t index, timestamp_t ts,
476  Allocator& alloc) override {
477  csr_.put_edge(src, dst, index, ts, alloc);
478  }
479 
480  slice_t get_edges(vid_t i) const override {
481  return slice_t(csr_.get_edges(i), table_);
482  }
483 
484  void close() override { csr_.close(); }
485 
486  size_t edge_num() const override { return csr_.edge_num(); }
487 
488  private:
491 };
492 
493 template <typename EDATA_T>
494 class SingleImmutableCsr : public TypedImmutableCsrBase<EDATA_T> {
495  public:
498 
501 
502  size_t batch_init(const std::string& name, const std::string& work_dir,
503  const std::vector<int>& degree,
504  double reserve_ratio) override {
505  size_t vnum = degree.size();
506  nbr_list_.open(work_dir + "/" + name + ".snbr", true);
507  nbr_list_.resize(vnum);
508  for (size_t k = 0; k != vnum; ++k) {
509  nbr_list_[k].neighbor = std::numeric_limits<vid_t>::max();
510  }
511  return vnum;
512  }
513 
514  size_t batch_init_in_memory(const std::vector<int>& degree,
515  double reserve_ratio) override {
516  size_t vnum = degree.size();
517  nbr_list_.open("", false);
518  nbr_list_.resize(vnum);
519  for (size_t k = 0; k != vnum; ++k) {
520  nbr_list_[k].neighbor = std::numeric_limits<vid_t>::max();
521  }
522  return vnum;
523  }
524 
525  void batch_put_edge(vid_t src, vid_t dst, const EDATA_T& data,
526  timestamp_t ts) override {
527  CHECK_EQ(nbr_list_[src].neighbor, std::numeric_limits<vid_t>::max());
528  nbr_list_[src].neighbor = dst;
529  nbr_list_[src].data = data;
530  }
531 
533 
534  timestamp_t unsorted_since() const override {
535  return std::numeric_limits<timestamp_t>::max();
536  }
537 
538  void open(const std::string& name, const std::string& snapshot_dir,
539  const std::string& work_dir) override {
540  if (!std::filesystem::exists(work_dir + "/" + name + ".snbr")) {
541  copy_file(snapshot_dir + "/" + name + ".snbr",
542  work_dir + "/" + name + ".snbr");
543  }
544  nbr_list_.open(work_dir + "/" + name + ".snbr", true);
545  }
546 
547  void open_in_memory(const std::string& prefix, size_t v_cap) override {
548  nbr_list_.open(prefix + ".snbr", false);
549  if (nbr_list_.size() < v_cap) {
550  size_t old_size = nbr_list_.size();
551  nbr_list_.reset();
552  nbr_list_.resize(v_cap);
553  FILE* fin = fopen((prefix + ".snbr").c_str(), "r");
554  CHECK_EQ(fread(nbr_list_.data(), sizeof(nbr_t), old_size, fin), old_size);
555  fclose(fin);
556  for (size_t k = old_size; k != v_cap; ++k) {
557  nbr_list_[k].neighbor = std::numeric_limits<vid_t>::max();
558  }
559  }
560  }
561 
562  void open_with_hugepages(const std::string& prefix, size_t v_cap) override {
563  nbr_list_.open_with_hugepages(prefix + ".snbr", v_cap);
564  size_t old_size = nbr_list_.size();
565  if (old_size < v_cap) {
566  nbr_list_.resize(v_cap);
567  for (size_t k = old_size; k != v_cap; ++k) {
568  nbr_list_[k].neighbor = std::numeric_limits<vid_t>::max();
569  }
570  }
571  }
572 
573  void dump(const std::string& name,
574  const std::string& new_snapshot_dir) override {
575  if (!nbr_list_.filename().empty() &&
576  std::filesystem::exists(nbr_list_.filename())) {
577  std::filesystem::create_hard_link(
578  nbr_list_.filename(), new_snapshot_dir + "/" + name + ".snbr");
579  } else {
580  FILE* fp = fopen((new_snapshot_dir + "/" + name + ".snbr").c_str(), "wb");
581  fwrite(nbr_list_.data(), sizeof(nbr_t), nbr_list_.size(), fp);
582  fflush(fp);
583  fclose(fp);
584  }
585  }
586 
587  void warmup(int thread_num) const override {
588  size_t vnum = nbr_list_.size();
589  std::vector<std::thread> threads;
590  std::atomic<size_t> v_i(0);
591  std::atomic<size_t> output(0);
592  const size_t chunk = 4096;
593  for (int i = 0; i < thread_num; ++i) {
594  threads.emplace_back([&]() {
595  size_t ret = 0;
596  while (true) {
597  size_t begin = std::min(v_i.fetch_add(chunk), vnum);
598  size_t end = std::min(begin + chunk, vnum);
599  if (begin == end) {
600  break;
601  }
602  while (begin < end) {
603  auto& nbr = nbr_list_[begin];
604  ret += nbr.neighbor;
605  ++begin;
606  }
607  }
608  output.fetch_add(ret);
609  });
610  }
611  for (auto& thrd : threads) {
612  thrd.join();
613  }
614  (void) output.load();
615  }
616 
617  void resize(vid_t vnum) override {
618  if (vnum > nbr_list_.size()) {
619  size_t old_size = nbr_list_.size();
620  nbr_list_.resize(vnum);
621  for (size_t k = old_size; k != vnum; ++k) {
622  nbr_list_[k].neighbor = std::numeric_limits<vid_t>::max();
623  }
624  } else {
625  nbr_list_.resize(vnum);
626  }
627  }
628 
629  size_t size() const override { return nbr_list_.size(); }
630 
631  size_t edge_num() const override {
632  size_t ret = 0;
633  for (size_t i = 0; i < nbr_list_.size(); ++i) {
634  if (nbr_list_[i].neighbor != std::numeric_limits<vid_t>::max()) {
635  ++ret;
636  }
637  }
638  return ret;
639  }
640 
641  std::shared_ptr<CsrConstEdgeIterBase> edge_iter(vid_t v) const override {
642  return std::make_shared<ImmutableCsrConstEdgeIter<EDATA_T>>(get_edges(v));
643  }
644 
647  }
648 
649  std::shared_ptr<CsrEdgeIterBase> edge_iter_mut(vid_t v) override {
650  return nullptr;
651  }
652 
653  void put_edge(vid_t src, vid_t dst, const EDATA_T& data, timestamp_t ts,
654  Allocator&) override {
655  CHECK_LT(src, nbr_list_.size());
656  CHECK_EQ(nbr_list_[src].neighbor, std::numeric_limits<vid_t>::max());
657  nbr_list_[src].neighbor = dst;
658  nbr_list_[src].data = data;
659  }
660 
661  slice_t get_edges(vid_t i) const override {
662  slice_t ret;
663  ret.set_size(
664  nbr_list_[i].neighbor == std::numeric_limits<vid_t>::max() ? 0 : 1);
665  if (ret.size() != 0) {
666  ret.set_begin(&nbr_list_[i]);
667  }
668  return ret;
669  }
670 
671  void close() override { nbr_list_.reset(); }
672 
673  const nbr_t& get_edge(vid_t i) const { return nbr_list_[i]; }
674 
675  private:
677 };
678 
679 template <>
680 class SingleImmutableCsr<std::string_view>
681  : public TypedImmutableCsrBase<std::string_view> {
682  public:
685 
686  SingleImmutableCsr(StringColumn& column) : column_(column), csr_() {}
688 
689  size_t batch_init(const std::string& name, const std::string& work_dir,
690  const std::vector<int>& degree,
691  double reserve_ratio) override {
692  return csr_.batch_init(name, work_dir, degree, reserve_ratio);
693  }
694 
695  size_t batch_init_in_memory(const std::vector<int>& degree,
696  double reserve_ratio) override {
697  return csr_.batch_init_in_memory(degree, reserve_ratio);
698  }
699 
700  void batch_put_edge_with_index(vid_t src, vid_t dst, size_t data,
701  timestamp_t ts) override {
702  csr_.batch_put_edge(src, dst, data, ts);
703  }
704 
706 
707  timestamp_t unsorted_since() const override {
708  return std::numeric_limits<timestamp_t>::max();
709  }
710 
711  void open(const std::string& name, const std::string& snapshot_dir,
712  const std::string& work_dir) override {
713  csr_.open(name, snapshot_dir, work_dir);
714  }
715 
716  void open_in_memory(const std::string& prefix, size_t v_cap) override {
717  csr_.open_in_memory(prefix, v_cap);
718  }
719 
720  void open_with_hugepages(const std::string& prefix, size_t v_cap) override {
721  csr_.open_with_hugepages(prefix, v_cap);
722  }
723 
724  void dump(const std::string& name,
725  const std::string& new_snapshot_dir) override {
726  csr_.dump(name, new_snapshot_dir);
727  }
728 
729  void warmup(int thread_num) const override { csr_.warmup(thread_num); }
730 
731  void resize(vid_t vnum) override { csr_.resize(vnum); }
732 
733  size_t size() const override { return csr_.size(); }
734 
735  size_t edge_num() const override { return csr_.edge_num(); }
736 
737  std::shared_ptr<CsrConstEdgeIterBase> edge_iter(vid_t v) const override {
738  return std::make_shared<ImmutableCsrConstEdgeIter<std::string_view>>(
739  get_edges(v));
740  }
741 
744  }
745 
746  std::shared_ptr<CsrEdgeIterBase> edge_iter_mut(vid_t v) override {
747  return nullptr;
748  }
749 
750  void put_edge_with_index(vid_t src, vid_t dst, size_t data, timestamp_t ts,
751  Allocator& alloc) override {
752  csr_.put_edge(src, dst, data, ts, alloc);
753  }
754 
755  slice_t get_edges(vid_t i) const override {
756  return slice_t(csr_.get_edges(i), column_);
757  }
758 
761  nbr.neighbor = csr_.get_edge(i).neighbor;
762  size_t index = csr_.get_edge(i).data;
763  nbr.data = column_.get_view(index);
764  return nbr;
765  }
766  void close() override { csr_.close(); }
767 
768  private:
771 };
772 
773 template <>
775  : public TypedImmutableCsrBase<RecordView> {
776  public:
779  SingleImmutableCsr(Table& table) : table_(table), csr_() {}
781 
782  size_t batch_init(const std::string& name, const std::string& work_dir,
783  const std::vector<int>& degree,
784  double reserve_ratio) override {
785  return csr_.batch_init(name, work_dir, degree, reserve_ratio);
786  }
787 
788  size_t batch_init_in_memory(const std::vector<int>& degree,
789  double reserve_ratio) override {
790  return csr_.batch_init_in_memory(degree, reserve_ratio);
791  }
792 
793  void batch_put_edge_with_index(vid_t src, vid_t dst, size_t data,
794  timestamp_t ts) override {
795  csr_.batch_put_edge(src, dst, data, ts);
796  }
797 
799 
800  timestamp_t unsorted_since() const override {
801  return std::numeric_limits<timestamp_t>::max();
802  }
803 
804  void open(const std::string& name, const std::string& snapshot_dir,
805  const std::string& work_dir) override {
806  csr_.open(name, snapshot_dir, work_dir);
807  }
808 
809  void open_in_memory(const std::string& prefix, size_t v_cap) override {
810  csr_.open_in_memory(prefix, v_cap);
811  }
812 
813  void open_with_hugepages(const std::string& prefix, size_t v_cap) override {
814  csr_.open_with_hugepages(prefix, v_cap);
815  }
816 
817  void dump(const std::string& name,
818  const std::string& new_snapshot_dir) override {
819  csr_.dump(name, new_snapshot_dir);
820  }
821 
822  void warmup(int thread_num) const override { csr_.warmup(thread_num); }
823 
824  void resize(vid_t vnum) override { csr_.resize(vnum); }
825 
826  size_t size() const override { return csr_.size(); }
827 
828  size_t edge_num() const override { return csr_.edge_num(); }
829 
830  std::shared_ptr<CsrConstEdgeIterBase> edge_iter(vid_t v) const override {
831  return std::make_shared<ImmutableCsrConstEdgeIter<RecordView>>(
832  get_edges(v));
833  }
834 
837  }
838 
839  std::shared_ptr<CsrEdgeIterBase> edge_iter_mut(vid_t v) override {
840  return nullptr;
841  }
842 
843  void put_edge_with_index(vid_t src, vid_t dst, size_t data, timestamp_t ts,
844  Allocator& alloc) override {
845  csr_.put_edge(src, dst, data, ts, alloc);
846  }
847 
848  slice_t get_edges(vid_t i) const override {
849  return slice_t(csr_.get_edges(i), table_);
850  }
851 
854  nbr.neighbor = csr_.get_edge(i).neighbor;
855  nbr.data = RecordView(csr_.get_edge(i).data, &table_);
856  return nbr;
857  }
858 
859  void close() override { csr_.close(); }
860 
861  private:
864 };
865 
866 } // namespace gs
867 
868 #endif // STORAGES_RT_MUTABLE_GRAPH_CSR_IMMUTABLE_CSR_H_
gs::ImmutableCsr::nbr_list_
mmap_array< nbr_t > nbr_list_
Definition: immutable_csr.h:322
gs::ImmutableCsr< 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: immutable_csr.h:418
gs::ImmutableCsr< RecordView >::get_edges
slice_t get_edges(vid_t i) const override
Definition: immutable_csr.h:480
gs::SingleImmutableCsr< 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: immutable_csr.h:782
gs::ImmutableCsr< RecordView >::edge_iter
std::shared_ptr< CsrConstEdgeIterBase > edge_iter(vid_t v) const override
Definition: immutable_csr.h:458
gs::ImmutableCsr< RecordView >::open
void open(const std::string &name, const std::string &snapshot_dir, const std::string &work_dir) override
Definition: immutable_csr.h:434
gs::SingleImmutableCsr::edge_iter_mut
std::shared_ptr< CsrEdgeIterBase > edge_iter_mut(vid_t v) override
Definition: immutable_csr.h:649
gs::ImmutableNbrSlice< std::string_view >
Definition: nbr.h:130
gs::ImmutableCsrConstEdgeIter::end_
const_nbr_ptr_t end_
Definition: immutable_csr.h:49
gs::SingleImmutableCsr< RecordView >::edge_iter_raw
CsrConstEdgeIterBase * edge_iter_raw(vid_t v) const override
Definition: immutable_csr.h:835
gs::SingleImmutableCsr< RecordView >::edge_num
size_t edge_num() const override
Definition: immutable_csr.h:828
gs::ImmutableCsr< RecordView >::size
size_t size() const override
Definition: immutable_csr.h:456
gs::ImmutableCsr< RecordView >::edge_num
size_t edge_num() const override
Definition: immutable_csr.h:486
gs::SingleImmutableCsr< std::string_view >::open_with_hugepages
void open_with_hugepages(const std::string &prefix, size_t v_cap) override
Definition: immutable_csr.h:720
gs::SingleImmutableCsr< RecordView >::dump
void dump(const std::string &name, const std::string &new_snapshot_dir) override
Definition: immutable_csr.h:817
gs::SingleImmutableCsr< RecordView >::size
size_t size() const override
Definition: immutable_csr.h:826
gs::Any
Definition: types.h:399
gs::SingleImmutableCsr< std::string_view >::put_edge_with_index
void put_edge_with_index(vid_t src, vid_t dst, size_t data, timestamp_t ts, Allocator &alloc) override
Definition: immutable_csr.h:750
gs::ImmutableCsr::adj_lists_
mmap_array< nbr_t * > adj_lists_
Definition: immutable_csr.h:320
gs::SingleImmutableCsr< RecordView >::get_edges
slice_t get_edges(vid_t i) const override
Definition: immutable_csr.h:848
gs::ImmutableCsr
Definition: immutable_csr.h:53
gs::ImmutableCsr< RecordView >::table_
Table & table_
Definition: immutable_csr.h:489
gs::ImmutableCsr::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: immutable_csr.h:58
gs::ImmutableCsr::close
void close() override
Definition: immutable_csr.h:293
gs::SingleImmutableCsr< RecordView >::table_
Table & table_
Definition: immutable_csr.h:862
gs::timestamp_t
uint32_t timestamp_t
Definition: types.h:30
gs::ImmutableCsr::open
void open(const std::string &name, const std::string &snapshot_dir, const std::string &work_dir) override
Definition: immutable_csr.h:147
gs::ImmutableCsr::resize
void resize(vid_t vnum) override
Definition: immutable_csr.h:246
gs::SingleImmutableCsr< std::string_view >::column_
StringColumn & column_
Definition: immutable_csr.h:769
gs::ImmutableCsr::unsorted_since
timestamp_t unsorted_since() const override
Definition: immutable_csr.h:145
gs::ImmutableCsrConstEdgeIter::get_timestamp
timestamp_t get_timestamp() const override
Definition: immutable_csr.h:34
gs::ImmutableCsr< RecordView >::resize
void resize(vid_t vnum) override
Definition: immutable_csr.h:454
gs::SingleImmutableCsr::size
size_t size() const override
Definition: immutable_csr.h:629
gs::SingleImmutableCsr::open
void open(const std::string &name, const std::string &snapshot_dir, const std::string &work_dir) override
Definition: immutable_csr.h:538
gs::SingleImmutableCsr< std::string_view >::SingleImmutableCsr
SingleImmutableCsr(StringColumn &column)
Definition: immutable_csr.h:686
gs::ImmutableCsr::get_edges
slice_t get_edges(vid_t v) const override
Definition: immutable_csr.h:286
gs::ImmutableCsr< std::string_view >::get_edges
slice_t get_edges(vid_t i) const override
Definition: immutable_csr.h:397
gs::ImmutableCsr< RecordView >::put_edge
void put_edge(vid_t src, vid_t dst, size_t data, timestamp_t ts, Allocator &alloc)
Definition: immutable_csr.h:470
gs::ImmutableNbrSlice
Definition: nbr.h:100
gs::SingleImmutableCsr::batch_sort_by_edge_data
void batch_sort_by_edge_data(timestamp_t ts) override
Definition: immutable_csr.h:532
gs::ImmutableNbrSlice::set_begin
void set_begin(const_nbr_ptr_t ptr)
Definition: nbr.h:112
gs::SingleImmutableCsr::batch_put_edge
void batch_put_edge(vid_t src, vid_t dst, const EDATA_T &data, timestamp_t ts) override
Definition: immutable_csr.h:525
gs::ImmutableCsrConstEdgeIter::operator+=
CsrConstEdgeIterBase & operator+=(size_t offset) override
Definition: immutable_csr.h:37
gs::SingleImmutableCsr::SingleImmutableCsr
SingleImmutableCsr()
Definition: immutable_csr.h:499
gs::SingleImmutableCsr::batch_init_in_memory
size_t batch_init_in_memory(const std::vector< int > &degree, double reserve_ratio) override
Definition: immutable_csr.h:514
gs::vid_t
uint32_t vid_t
Definition: types.h:31
gs::ImmutableCsrConstEdgeIter::cur_
const_nbr_ptr_t cur_
Definition: immutable_csr.h:48
gs::ImmutableCsr< std::string_view >::edge_iter
std::shared_ptr< CsrConstEdgeIterBase > edge_iter(vid_t v) const override
Definition: immutable_csr.h:375
gs::ImmutableNbrSlice< RecordView >
Definition: nbr.h:196
gs::SingleImmutableCsr< RecordView >::edge_iter
std::shared_ptr< CsrConstEdgeIterBase > edge_iter(vid_t v) const override
Definition: immutable_csr.h:830
gs::ImmutableNbr::neighbor
vid_t neighbor
Definition: nbr.h:49
gs::ImmutableCsr< RecordView >::warmup
void warmup(int thread_num) const override
Definition: immutable_csr.h:452
gs::SingleImmutableCsr< std::string_view >::resize
void resize(vid_t vnum) override
Definition: immutable_csr.h:731
gs::ImmutableCsr< 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=1.2) override
Definition: immutable_csr.h:335
gs::mmap_array::resize
void resize(size_t size)
Definition: mmap_array.h:319
gs::SingleImmutableCsr::slice_t
ImmutableNbrSlice< EDATA_T > slice_t
Definition: immutable_csr.h:497
gs::SingleImmutableCsr::~SingleImmutableCsr
~SingleImmutableCsr()
Definition: immutable_csr.h:500
gs::SingleImmutableCsr< std::string_view >::open_in_memory
void open_in_memory(const std::string &prefix, size_t v_cap) override
Definition: immutable_csr.h:716
gs::ImmutableCsrConstEdgeIter::const_nbr_ptr_t
typename ImmutableNbrSlice< EDATA_T >::const_nbr_ptr_t const_nbr_ptr_t
Definition: immutable_csr.h:23
gs::ImmutableCsr< RecordView >::~ImmutableCsr
~ImmutableCsr()
Definition: immutable_csr.h:416
gs::SingleImmutableCsr::dump
void dump(const std::string &name, const std::string &new_snapshot_dir) override
Definition: immutable_csr.h:573
gs::ImmutableCsr::dump_meta
void dump_meta(const std::string &prefix) const
Definition: immutable_csr.h:312
gs
Definition: adj_list.h:23
gs::ImmutableCsr::load_meta
void load_meta(const std::string &prefix)
Definition: immutable_csr.h:300
gs::SingleImmutableCsr::edge_num
size_t edge_num() const override
Definition: immutable_csr.h:631
gs::ImmutableCsrConstEdgeIter
Definition: immutable_csr.h:22
gs::ImmutableCsr< std::string_view >::warmup
void warmup(int thread_num) const override
Definition: immutable_csr.h:369
gs::SingleImmutableCsr< 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: immutable_csr.h:689
gs::ImmutableCsr::unsorted_since_
timestamp_t unsorted_since_
Definition: immutable_csr.h:323
gs::ImmutableCsr< std::string_view >::edge_iter_mut
std::shared_ptr< CsrEdgeIterBase > edge_iter_mut(vid_t v) override
Definition: immutable_csr.h:383
gs::ImmutableCsr::open_in_memory
void open_in_memory(const std::string &prefix, size_t v_cap) override
Definition: immutable_csr.h:168
gs::SingleImmutableCsr::put_edge
void put_edge(vid_t src, vid_t dst, const EDATA_T &data, timestamp_t ts, Allocator &) override
Definition: immutable_csr.h:653
gs::Table
Definition: table.h:30
gs::mmap_array::open
void open(const std::string &filename, bool sync_to_file=false)
Definition: mmap_array.h:129
gs::ArenaAllocator
Definition: allocators.h:29
gs::ImmutableNbrSlice::set_size
void set_size(int size)
Definition: nbr.h:109
gs::ImmutableCsr< RecordView >::csr_
ImmutableCsr< size_t > csr_
Definition: immutable_csr.h:490
gs::SingleImmutableCsr< RecordView >::open_in_memory
void open_in_memory(const std::string &prefix, size_t v_cap) override
Definition: immutable_csr.h:809
gs::SingleImmutableCsr< std::string_view >::close
void close() override
Definition: immutable_csr.h:766
gs::ImmutableCsr::edge_iter
std::shared_ptr< CsrConstEdgeIterBase > edge_iter(vid_t v) const override
Definition: immutable_csr.h:271
gs::ImmutableCsr< 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: immutable_csr.h:429
gs::ImmutableCsr::size
size_t size() const override
Definition: immutable_csr.h:261
gs::CsrConstEdgeIterBase
Definition: csr_base.h:27
gs::mmap_array::data
T * data()
Definition: mmap_array.h:405
gs::SingleImmutableCsr::unsorted_since
timestamp_t unsorted_since() const override
Definition: immutable_csr.h:534
gs::ImmutableCsr< RecordView >::edge_iter_raw
CsrConstEdgeIterBase * edge_iter_raw(vid_t v) const override
Definition: immutable_csr.h:463
gs::SingleImmutableCsr< std::string_view >::edge_iter_raw
CsrConstEdgeIterBase * edge_iter_raw(vid_t v) const override
Definition: immutable_csr.h:742
gs::ImmutableCsr< std::string_view >::put_edge
void put_edge(vid_t src, vid_t dst, size_t data, timestamp_t ts, Allocator &alloc)
Definition: immutable_csr.h:387
gs::SingleImmutableCsr< RecordView >::edge_iter_mut
std::shared_ptr< CsrEdgeIterBase > edge_iter_mut(vid_t v) override
Definition: immutable_csr.h:839
gs::ImmutableCsr< RecordView >::open_in_memory
void open_in_memory(const std::string &prefix, size_t v_cap) override
Definition: immutable_csr.h:439
gs::TypedColumn< std::string_view >
Definition: column.h:347
gs::ImmutableCsr< std::string_view >::open
void open(const std::string &name, const std::string &snapshot_dir, const std::string &work_dir) override
Definition: immutable_csr.h:351
gs::TypedImmutableCsrBase
Definition: csr_base.h:127
gs::SingleImmutableCsr< RecordView >::open
void open(const std::string &name, const std::string &snapshot_dir, const std::string &work_dir) override
Definition: immutable_csr.h:804
gs::ImmutableCsr< RecordView >::dump
void dump(const std::string &name, const std::string &new_snapshot_dir) override
Definition: immutable_csr.h:447
gs::mmap_array::size
size_t size() const
Definition: mmap_array.h:415
gs::ImmutableCsr::dump
void dump(const std::string &name, const std::string &new_snapshot_dir) override
Definition: immutable_csr.h:220
gs::ImmutableCsr< RecordView >::open_with_hugepages
void open_with_hugepages(const std::string &prefix, size_t v_cap) override
Definition: immutable_csr.h:443
gs::ImmutableCsr::batch_sort_by_edge_data
void batch_sort_by_edge_data(timestamp_t ts) override
Definition: immutable_csr.h:134
gs::ImmutableCsr< std::string_view >::edge_num
size_t edge_num() const override
Definition: immutable_csr.h:403
gs::SingleImmutableCsr
Definition: immutable_csr.h:494
gs::ImmutableCsrConstEdgeIter::get_neighbor
vid_t get_neighbor() const override
Definition: immutable_csr.h:30
gs::SingleImmutableCsr::edge_iter_raw
CsrConstEdgeIterBase * edge_iter_raw(vid_t v) const override
Definition: immutable_csr.h:645
gs::SingleImmutableCsr::open_in_memory
void open_in_memory(const std::string &prefix, size_t v_cap) override
Definition: immutable_csr.h:547
gs::ImmutableCsr< RecordView >::edge_iter_mut
std::shared_ptr< CsrEdgeIterBase > edge_iter_mut(vid_t v) override
Definition: immutable_csr.h:466
gs::SingleImmutableCsr< 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: immutable_csr.h:700
gs::SingleImmutableCsr< RecordView >::close
void close() override
Definition: immutable_csr.h:859
gs::ImmutableNbr::data
EDATA_T data
Definition: nbr.h:50
gs::ImmutableCsr::edge_num
size_t edge_num() const override
Definition: immutable_csr.h:263
gs::SingleImmutableCsr< RecordView >::put_edge_with_index
void put_edge_with_index(vid_t src, vid_t dst, size_t data, timestamp_t ts, Allocator &alloc) override
Definition: immutable_csr.h:843
gs::ImmutableCsr::edge_iter_raw
CsrConstEdgeIterBase * edge_iter_raw(vid_t v) const override
Definition: immutable_csr.h:274
gs::ImmutableCsr::batch_put_edge
void batch_put_edge(vid_t src, vid_t dst, const EDATA_T &data, timestamp_t ts) override
Definition: immutable_csr.h:127
gs::ImmutableCsr< std::string_view >::ImmutableCsr
ImmutableCsr(StringColumn &column)
Definition: immutable_csr.h:332
gs::SingleImmutableCsr< std::string_view >::edge_num
size_t edge_num() const override
Definition: immutable_csr.h:735
gs::ImmutableCsr< std::string_view >::batch_init_in_memory
size_t batch_init_in_memory(const std::vector< int > &degree, double reserve_ratio=1.2) override
Definition: immutable_csr.h:341
gs::ImmutableCsr::edge_iter_mut
std::shared_ptr< CsrEdgeIterBase > edge_iter_mut(vid_t v) override
Definition: immutable_csr.h:277
gs::ImmutableCsr::degree_list_
mmap_array< int > degree_list_
Definition: immutable_csr.h:321
gs::SingleImmutableCsr< std::string_view >::dump
void dump(const std::string &name, const std::string &new_snapshot_dir) override
Definition: immutable_csr.h:724
gs::SingleImmutableCsr< std::string_view >::edge_iter_mut
std::shared_ptr< CsrEdgeIterBase > edge_iter_mut(vid_t v) override
Definition: immutable_csr.h:746
gs::SingleImmutableCsr< std::string_view >::get_edge
ImmutableNbr< std::string_view > get_edge(vid_t i) const
Definition: immutable_csr.h:759
gs::SingleImmutableCsr< std::string_view >::open
void open(const std::string &name, const std::string &snapshot_dir, const std::string &work_dir) override
Definition: immutable_csr.h:711
gs::SingleImmutableCsr< RecordView >::resize
void resize(vid_t vnum) override
Definition: immutable_csr.h:824
gs::SingleImmutableCsr< std::string_view >::size
size_t size() const override
Definition: immutable_csr.h:733
gs::copy_file
void copy_file(const std::string &src, const std::string &dst)
Definition: file_names.h:80
gs::ImmutableCsrConstEdgeIter::next
void next() override
Definition: immutable_csr.h:36
gs::ImmutableCsr< RecordView >::ImmutableCsr
ImmutableCsr(Table &table)
Definition: immutable_csr.h:415
gs::SingleImmutableCsr< RecordView >::csr_
SingleImmutableCsr< size_t > csr_
Definition: immutable_csr.h:863
gs::SingleImmutableCsr::resize
void resize(vid_t vnum) override
Definition: immutable_csr.h:617
gs::ImmutableCsr< std::string_view >::resize
void resize(vid_t vnum) override
Definition: immutable_csr.h:371
gs::mmap_array
Definition: mmap_array.h:65
gs::ImmutableCsrConstEdgeIter::~ImmutableCsrConstEdgeIter
~ImmutableCsrConstEdgeIter()=default
gs::snapshot_dir
std::string snapshot_dir(const std::string &work_dir, uint32_t version)
Definition: file_names.h:192
std
Definition: loading_config.h:232
gs::SingleImmutableCsr< std::string_view >::unsorted_since
timestamp_t unsorted_since() const override
Definition: immutable_csr.h:707
gs::SingleImmutableCsr< std::string_view >::~SingleImmutableCsr
~SingleImmutableCsr()
Definition: immutable_csr.h:687
gs::SingleImmutableCsr< std::string_view >::warmup
void warmup(int thread_num) const override
Definition: immutable_csr.h:729
gs::ImmutableCsr< RecordView >::close
void close() override
Definition: immutable_csr.h:484
gs::ImmutableCsr::slice_t
ImmutableNbrSlice< EDATA_T > slice_t
Definition: immutable_csr.h:56
gs::ImmutableCsr< std::string_view >::dump
void dump(const std::string &name, const std::string &new_snapshot_dir) override
Definition: immutable_csr.h:364
gs::SingleImmutableCsr::warmup
void warmup(int thread_num) const override
Definition: immutable_csr.h:587
gs::SingleImmutableCsr< std::string_view >::batch_init_in_memory
size_t batch_init_in_memory(const std::vector< int > &degree, double reserve_ratio) override
Definition: immutable_csr.h:695
gs::SingleImmutableCsr< RecordView >::batch_sort_by_edge_data
void batch_sort_by_edge_data(timestamp_t ts) override
Definition: immutable_csr.h:798
gs::SingleImmutableCsr::nbr_list_
mmap_array< nbr_t > nbr_list_
Definition: immutable_csr.h:676
gs::ImmutableNbr
Definition: nbr.h:29
gs::SingleImmutableCsr< RecordView >::open_with_hugepages
void open_with_hugepages(const std::string &prefix, size_t v_cap) override
Definition: immutable_csr.h:813
gs::SingleImmutableCsr< std::string_view >::csr_
SingleImmutableCsr< size_t > csr_
Definition: immutable_csr.h:770
gs::ImmutableCsr::open_with_hugepages
void open_with_hugepages(const std::string &prefix, size_t v_cap) override
Definition: immutable_csr.h:194
gs::AnyConverter
Definition: types.h:397
gs::SingleImmutableCsr< 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: immutable_csr.h:793
gs::ImmutableCsrConstEdgeIter::get_data
Any get_data() const override
Definition: immutable_csr.h:31
gs::SingleImmutableCsr::open_with_hugepages
void open_with_hugepages(const std::string &prefix, size_t v_cap) override
Definition: immutable_csr.h:562
gs::ImmutableCsr< std::string_view >::~ImmutableCsr
~ImmutableCsr()
Definition: immutable_csr.h:333
gs::mmap_array::open_with_hugepages
void open_with_hugepages(const std::string &filename, size_t capacity=0)
Definition: mmap_array.h:214
gs::SingleImmutableCsr::close
void close() override
Definition: immutable_csr.h:671
gs::SingleImmutableCsr::get_edge
const nbr_t & get_edge(vid_t i) const
Definition: immutable_csr.h:673
gs::SingleImmutableCsr< std::string_view >::edge_iter
std::shared_ptr< CsrConstEdgeIterBase > edge_iter(vid_t v) const override
Definition: immutable_csr.h:737
gs::SingleImmutableCsr< RecordView >::get_edge
ImmutableNbr< RecordView > get_edge(vid_t i) const
Definition: immutable_csr.h:852
gs::SingleImmutableCsr< std::string_view >::batch_sort_by_edge_data
void batch_sort_by_edge_data(timestamp_t ts) override
Definition: immutable_csr.h:705
gs::SingleImmutableCsr< RecordView >::warmup
void warmup(int thread_num) const override
Definition: immutable_csr.h:822
gs::ImmutableCsr< std::string_view >::edge_iter_raw
CsrConstEdgeIterBase * edge_iter_raw(vid_t v) const override
Definition: immutable_csr.h:380
gs::ImmutableCsrConstEdgeIter::is_valid
bool is_valid() const override
Definition: immutable_csr.h:44
gs::ImmutableCsr< 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: immutable_csr.h:392
gs::RecordView
Definition: types.h:292
gs::ImmutableCsrConstEdgeIter::ImmutableCsrConstEdgeIter
ImmutableCsrConstEdgeIter(const ImmutableNbrSlice< EDATA_T > &slice)
Definition: immutable_csr.h:26
gs::ImmutableCsr< std::string_view >::open_in_memory
void open_in_memory(const std::string &prefix, size_t v_cap) override
Definition: immutable_csr.h:356
gs::SingleImmutableCsr< RecordView >::SingleImmutableCsr
SingleImmutableCsr(Table &table)
Definition: immutable_csr.h:779
gs::ImmutableNbrSlice::size
int size() const
Definition: nbr.h:110
gs::SingleImmutableCsr::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: immutable_csr.h:502
gs::mmap_array::reset
void reset()
Definition: mmap_array.h:84
gs::ImmutableCsr< 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: immutable_csr.h:346
gs::SingleImmutableCsr< RecordView >::unsorted_since
timestamp_t unsorted_since() const override
Definition: immutable_csr.h:800
gs::ImmutableCsr< std::string_view >::size
size_t size() const override
Definition: immutable_csr.h:373
gs::ImmutableCsr< std::string_view >::open_with_hugepages
void open_with_hugepages(const std::string &prefix, size_t v_cap) override
Definition: immutable_csr.h:360
gs::ImmutableCsr< std::string_view >::csr_
ImmutableCsr< size_t > csr_
Definition: immutable_csr.h:407
gs::SingleImmutableCsr::get_edges
slice_t get_edges(vid_t i) const override
Definition: immutable_csr.h:661
gs::ImmutableCsr< std::string_view >::column_
StringColumn & column_
Definition: immutable_csr.h:406
gs::ImmutableCsrConstEdgeIter::size
size_t size() const override
Definition: immutable_csr.h:45
gs::ImmutableCsr::put_edge
void put_edge(vid_t src, vid_t dst, const EDATA_T &data, timestamp_t ts, Allocator &alloc) override
Definition: immutable_csr.h:281
gs::SingleImmutableCsr< RecordView >::batch_init_in_memory
size_t batch_init_in_memory(const std::vector< int > &degree, double reserve_ratio) override
Definition: immutable_csr.h:788
gs::SingleImmutableCsr< RecordView >::~SingleImmutableCsr
~SingleImmutableCsr()
Definition: immutable_csr.h:780
gs::ImmutableCsr< std::string_view >::close
void close() override
Definition: immutable_csr.h:401
gs::ImmutableCsr::warmup
void warmup(int thread_num) const override
Definition: immutable_csr.h:244
gs::SingleImmutableCsr::edge_iter
std::shared_ptr< CsrConstEdgeIterBase > edge_iter(vid_t v) const override
Definition: immutable_csr.h:641
gs::ImmutableCsr::batch_init_in_memory
size_t batch_init_in_memory(const std::vector< int > &degree, double reserve_ratio) override
Definition: immutable_csr.h:93
gs::SingleImmutableCsr< std::string_view >::get_edges
slice_t get_edges(vid_t i) const override
Definition: immutable_csr.h:755
gs::ImmutableCsr< RecordView >::batch_init_in_memory
size_t batch_init_in_memory(const std::vector< int > &degree, double reserve_ratio=1.2) override
Definition: immutable_csr.h:424
gs::ImmutableCsr< 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: immutable_csr.h:475