1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
/*
* Ceph distributed storage system
*
* Copyright (C) 2015 Mirantis Inc
*
* Author: Mykola Golub <mgolub@mirantis.com>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
*/
#ifndef CRUSH_TREE_DUMPER_H
#define CRUSH_TREE_DUMPER_H
#include "CrushWrapper.h"
/**
* CrushTreeDumper:
* A helper class and functions to dump a crush tree.
*
* Example:
*
* class SimpleDumper : public CrushTreeDumper::Dumper<ostream> {
* public:
* SimpleDumper(const CrushWrapper *crush) :
* CrushTreeDumper::Dumper<ostream>(crush) {}
* protected:
* virtual void dump_item(const CrushTreeDumper::Item &qi, ostream *out) {
* *out << qi.id;
* for (int k = 0; k < qi.depth; k++)
* *out << "-";
* if (qi.is_bucket())
* *out << crush->get_item_name(qi.id)
* else
* *out << "osd." << qi.id;
* *out << "\n";
* }
* };
*
* SimpleDumper(crush).dump(out);
*
*/
namespace CrushTreeDumper {
struct Item {
int id;
int depth;
float weight;
list<int> children;
Item() : id(0), depth(0), weight(0) {}
Item(int i, int d, float w) : id(i), depth(d), weight(w) {}
bool is_bucket() const { return id < 0; }
};
template <typename F>
class Dumper : public list<Item> {
public:
explicit Dumper(const CrushWrapper *crush_) : crush(crush_) {
crush->find_roots(roots);
root = roots.begin();
}
virtual ~Dumper() {}
virtual void reset() {
root = roots.begin();
touched.clear();
clear();
}
bool next(Item &qi) {
if (empty()) {
if (root == roots.end())
return false;
push_back(Item(*root, 0, crush->get_bucket_weightf(*root)));
++root;
}
qi = front();
pop_front();
touched.insert(qi.id);
if (qi.is_bucket()) {
// queue bucket contents...
int s = crush->get_bucket_size(qi.id);
for (int k = s - 1; k >= 0; k--) {
int id = crush->get_bucket_item(qi.id, k);
qi.children.push_back(id);
push_front(Item(id, qi.depth + 1,
crush->get_bucket_item_weightf(qi.id, k)));
}
}
return true;
}
void dump(F *f) {
reset();
Item qi;
while (next(qi))
dump_item(qi, f);
}
bool is_touched(int id) const { return touched.count(id) > 0; }
protected:
virtual void dump_item(const Item &qi, F *f) = 0;
protected:
const CrushWrapper *crush;
private:
set<int> touched;
set<int> roots;
set<int>::iterator root;
};
inline void dump_item_fields(const CrushWrapper *crush,
const Item &qi, Formatter *f) {
f->dump_int("id", qi.id);
if (qi.is_bucket()) {
int type = crush->get_bucket_type(qi.id);
f->dump_string("name", crush->get_item_name(qi.id));
f->dump_string("type", crush->get_type_name(type));
f->dump_int("type_id", type);
} else {
f->dump_stream("name") << "osd." << qi.id;
f->dump_string("type", crush->get_type_name(0));
f->dump_int("type_id", 0);
f->dump_float("crush_weight", qi.weight);
f->dump_unsigned("depth", qi.depth);
}
}
inline void dump_bucket_children(const CrushWrapper *crush,
const Item &qi, Formatter *f) {
if (!qi.is_bucket())
return;
f->open_array_section("children");
for (list<int>::const_iterator i = qi.children.begin();
i != qi.children.end();
++i) {
f->dump_int("child", *i);
}
f->close_section();
}
class FormattingDumper : public Dumper<Formatter> {
public:
explicit FormattingDumper(const CrushWrapper *crush) : Dumper<Formatter>(crush) {}
protected:
void dump_item(const Item &qi, Formatter *f) override {
f->open_object_section("item");
dump_item_fields(qi, f);
dump_bucket_children(qi, f);
f->close_section();
}
virtual void dump_item_fields(const Item &qi, Formatter *f) {
CrushTreeDumper::dump_item_fields(crush, qi, f);
}
virtual void dump_bucket_children(const Item &qi, Formatter *f) {
CrushTreeDumper::dump_bucket_children(crush, qi, f);
}
};
}
#endif
|
