This is necessary now that operator< is not defined.
Signed-off-by: Sage Weil <sage@redhat.com>
map<string,bufferlist> attrset;
interval_set<uint64_t> data_subset;
- map<hobject_t, interval_set<uint64_t> > clone_subsets;
+ map<hobject_t, interval_set<uint64_t>, hobject_t::BitwiseComparator> clone_subsets;
bool first, complete;
struct RecoveryMessages {
map<hobject_t,
- ECBackend::read_request_t> reads;
+ ECBackend::read_request_t, hobject_t::BitwiseComparator> reads;
void read(
ECBackend *ec,
const hobject_t &hoid, uint64_t off, uint64_t len,
add_temp_objs(op.temp_added);
}
if (op.t.empty()) {
- for (set<hobject_t>::iterator i = op.temp_removed.begin();
+ for (set<hobject_t, hobject_t::BitwiseComparator>::iterator i = op.temp_removed.begin();
i != op.temp_removed.end();
++i) {
dout(10) << __func__ << ": removing object " << *i
ECSubRead &op,
ECSubReadReply *reply)
{
- for(map<hobject_t, list<boost::tuple<uint64_t, uint64_t, uint32_t> > >::iterator i =
+ for(map<hobject_t, list<boost::tuple<uint64_t, uint64_t, uint32_t> >, hobject_t::BitwiseComparator>::iterator i =
op.to_read.begin();
i != op.to_read.end();
++i) {
}
}
}
- for (set<hobject_t>::iterator i = op.attrs_to_read.begin();
+ for (set<hobject_t, hobject_t::BitwiseComparator>::iterator i = op.attrs_to_read.begin();
i != op.attrs_to_read.end();
++i) {
dout(10) << __func__ << ": fulfilling attr request on "
return;
}
ReadOp &rop = iter->second;
- for (map<hobject_t, list<pair<uint64_t, bufferlist> > >::iterator i =
+ for (map<hobject_t, list<pair<uint64_t, bufferlist> >, hobject_t::BitwiseComparator>::iterator i =
op.buffers_read.begin();
i != op.buffers_read.end();
++i) {
riter->get<2>()[from].claim(j->second);
}
}
- for (map<hobject_t, map<string, bufferlist> >::iterator i = op.attrs_read.begin();
+ for (map<hobject_t, map<string, bufferlist>, hobject_t::BitwiseComparator>::iterator i = op.attrs_read.begin();
i != op.attrs_read.end();
++i) {
assert(!op.errors.count(i->first));
rop.complete[i->first].attrs = map<string, bufferlist>();
(*(rop.complete[i->first].attrs)).swap(i->second);
}
- for (map<hobject_t, int>::iterator i = op.errors.begin();
+ for (map<hobject_t, int, hobject_t::BitwiseComparator>::iterator i = op.errors.begin();
i != op.errors.end();
++i) {
rop.complete[i->first].errors.insert(
void ECBackend::complete_read_op(ReadOp &rop, RecoveryMessages *m)
{
- map<hobject_t, read_request_t>::iterator reqiter =
+ map<hobject_t, read_request_t, hobject_t::BitwiseComparator>::iterator reqiter =
rop.to_read.begin();
- map<hobject_t, read_result_t>::iterator resiter =
+ map<hobject_t, read_result_t, hobject_t::BitwiseComparator>::iterator resiter =
rop.complete.begin();
assert(rop.to_read.size() == rop.complete.size());
for (; reqiter != rop.to_read.end(); ++reqiter, ++resiter) {
const OSDMapRef osdmap,
ReadOp &op)
{
- set<hobject_t> to_cancel;
- for (map<pg_shard_t, set<hobject_t> >::iterator i = op.source_to_obj.begin();
+ set<hobject_t, hobject_t::BitwiseComparator> to_cancel;
+ for (map<pg_shard_t, set<hobject_t, hobject_t::BitwiseComparator> >::iterator i = op.source_to_obj.begin();
i != op.source_to_obj.end();
++i) {
if (osdmap->is_down(i->first.osd)) {
if (to_cancel.empty())
return;
- for (map<pg_shard_t, set<hobject_t> >::iterator i = op.source_to_obj.begin();
+ for (map<pg_shard_t, set<hobject_t, hobject_t::BitwiseComparator> >::iterator i = op.source_to_obj.begin();
i != op.source_to_obj.end();
) {
- for (set<hobject_t>::iterator j = i->second.begin();
+ for (set<hobject_t, hobject_t::BitwiseComparator>::iterator j = i->second.begin();
j != i->second.end();
) {
if (to_cancel.count(*j))
}
}
- for (set<hobject_t>::iterator i = to_cancel.begin();
+ for (set<hobject_t, hobject_t::BitwiseComparator>::iterator i = to_cancel.begin();
i != to_cancel.end();
++i) {
get_parent()->cancel_pull(*i);
i != tid_to_read_map.end();
++i) {
dout(10) << __func__ << ": cancelling " << i->second << dendl;
- for (map<hobject_t, read_request_t>::iterator j =
+ for (map<hobject_t, read_request_t, hobject_t::BitwiseComparator>::iterator j =
i->second.to_read.begin();
j != i->second.to_read.end();
++j) {
void ECBackend::dump_recovery_info(Formatter *f) const
{
f->open_array_section("recovery_ops");
- for (map<hobject_t, RecoveryOp>::const_iterator i = recovery_ops.begin();
+ for (map<hobject_t, RecoveryOp, hobject_t::BitwiseComparator>::const_iterator i = recovery_ops.begin();
i != recovery_ops.end();
++i) {
f->open_object_section("op");
op->t = static_cast<ECTransaction*>(_t);
- set<hobject_t> need_hinfos;
+ set<hobject_t, hobject_t::BitwiseComparator> need_hinfos;
op->t->get_append_objects(&need_hinfos);
- for (set<hobject_t>::iterator i = need_hinfos.begin();
+ for (set<hobject_t, hobject_t::BitwiseComparator>::iterator i = need_hinfos.begin();
i != need_hinfos.end();
++i) {
ECUtil::HashInfoRef ref = get_hash_info(*i);
bool for_recovery,
set<pg_shard_t> *to_read)
{
- map<hobject_t, set<pg_shard_t> >::const_iterator miter =
+ map<hobject_t, set<pg_shard_t>, hobject_t::BitwiseComparator>::const_iterator miter =
get_parent()->get_missing_loc_shards().find(hoid);
set<int> have;
void ECBackend::start_read_op(
int priority,
- map<hobject_t, read_request_t> &to_read,
+ map<hobject_t, read_request_t, hobject_t::BitwiseComparator> &to_read,
OpRequestRef _op)
{
ceph_tid_t tid = get_parent()->get_tid();
dout(10) << __func__ << ": starting " << op << dendl;
map<pg_shard_t, ECSubRead> messages;
- for (map<hobject_t, read_request_t>::iterator i = op.to_read.begin();
+ for (map<hobject_t, read_request_t, hobject_t::BitwiseComparator>::iterator i = op.to_read.begin();
i != op.to_read.end();
++i) {
list<boost::tuple<
&shards);
assert(r == 0);
- map<hobject_t, read_request_t> for_read_op;
+ map<hobject_t, read_request_t, hobject_t::BitwiseComparator> for_read_op;
for_read_op.insert(
make_pair(
hoid,
RecoveryOp() : pending_read(false), state(IDLE) {}
};
friend ostream &operator<<(ostream &lhs, const RecoveryOp &rhs);
- map<hobject_t, RecoveryOp> recovery_ops;
+ map<hobject_t, RecoveryOp, hobject_t::BitwiseComparator> recovery_ops;
public:
/**
ceph_tid_t tid;
OpRequestRef op; // may be null if not on behalf of a client
- map<hobject_t, read_request_t> to_read;
- map<hobject_t, read_result_t> complete;
+ map<hobject_t, read_request_t, hobject_t::BitwiseComparator> to_read;
+ map<hobject_t, read_result_t, hobject_t::BitwiseComparator> complete;
- map<hobject_t, set<pg_shard_t> > obj_to_source;
- map<pg_shard_t, set<hobject_t> > source_to_obj;
+ map<hobject_t, set<pg_shard_t>, hobject_t::BitwiseComparator> obj_to_source;
+ map<pg_shard_t, set<hobject_t, hobject_t::BitwiseComparator> > source_to_obj;
void dump(Formatter *f) const;
map<pg_shard_t, set<ceph_tid_t> > shard_to_read_map;
void start_read_op(
int priority,
- map<hobject_t, read_request_t> &to_read,
+ map<hobject_t, read_request_t, hobject_t::BitwiseComparator> &to_read,
OpRequestRef op);
ECTransaction *t;
- set<hobject_t> temp_added;
- set<hobject_t> temp_cleared;
+ set<hobject_t, hobject_t::BitwiseComparator> temp_added;
+ set<hobject_t, hobject_t::BitwiseComparator> temp_cleared;
set<pg_shard_t> pending_commit;
set<pg_shard_t> pending_apply;
- map<hobject_t, ECUtil::HashInfoRef> unstable_hash_infos;
+ map<hobject_t, ECUtil::HashInfoRef, hobject_t::BitwiseComparator> unstable_hash_infos;
~Op() {
delete t;
delete on_local_applied_sync;
const ECUtil::stripe_info_t sinfo;
/// If modified, ensure that the ref is held until the update is applied
- SharedPtrRegistry<hobject_t, ECUtil::HashInfo> unstable_hashinfo_registry;
+ SharedPtrRegistry<hobject_t, ECUtil::HashInfo, hobject_t::BitwiseComparator> unstable_hashinfo_registry;
ECUtil::HashInfoRef get_hash_info(const hobject_t &hoid);
friend struct ReadCB;
ENCODE_START(1, 1, bl);
::encode(from, bl);
::encode(tid, bl);
- map<hobject_t, list<pair<uint64_t, uint64_t> > > tmp;
- for (map<hobject_t, list<boost::tuple<uint64_t, uint64_t, uint32_t> > >::const_iterator m = to_read.begin();
+ map<hobject_t, list<pair<uint64_t, uint64_t> >, hobject_t::BitwiseComparator> tmp;
+ for (map<hobject_t, list<boost::tuple<uint64_t, uint64_t, uint32_t> >, hobject_t::BitwiseComparator>::const_iterator m = to_read.begin();
m != to_read.end(); ++m) {
list<pair<uint64_t, uint64_t> > tlist;
for (list<boost::tuple<uint64_t, uint64_t, uint32_t> >::const_iterator l = m->second.begin();
::decode(from, bl);
::decode(tid, bl);
if (struct_v == 1) {
- map<hobject_t, list<pair<uint64_t, uint64_t> > >tmp;
+ map<hobject_t, list<pair<uint64_t, uint64_t> >, hobject_t::BitwiseComparator>tmp;
::decode(tmp, bl);
- for (map<hobject_t, list<pair<uint64_t, uint64_t> > >::const_iterator m = tmp.begin();
+ for (map<hobject_t, list<pair<uint64_t, uint64_t> >, hobject_t::BitwiseComparator>::const_iterator m = tmp.begin();
m != tmp.end(); ++m) {
list<boost::tuple<uint64_t, uint64_t, uint32_t> > tlist;
for (list<pair<uint64_t, uint64_t> > ::const_iterator l = m->second.begin();
f->dump_stream("from") << from;
f->dump_unsigned("tid", tid);
f->open_array_section("objects");
- for (map<hobject_t, list<boost::tuple<uint64_t, uint64_t, uint32_t> > >::const_iterator i =
+ for (map<hobject_t, list<boost::tuple<uint64_t, uint64_t, uint32_t> >, hobject_t::BitwiseComparator>::const_iterator i =
to_read.begin();
i != to_read.end();
++i) {
f->close_section();
f->open_array_section("object_attrs_requested");
- for (set<hobject_t>::const_iterator i = attrs_to_read.begin();
+ for (set<hobject_t,hobject_t::BitwiseComparator>::const_iterator i = attrs_to_read.begin();
i != attrs_to_read.end();
++i) {
f->open_object_section("object");
f->dump_stream("from") << from;
f->dump_unsigned("tid", tid);
f->open_array_section("buffers_read");
- for (map<hobject_t, list<pair<uint64_t, bufferlist> > >::const_iterator i =
+ for (map<hobject_t, list<pair<uint64_t, bufferlist> >, hobject_t::BitwiseComparator>::const_iterator i =
buffers_read.begin();
i != buffers_read.end();
++i) {
f->close_section();
f->open_array_section("attrs_returned");
- for (map<hobject_t, map<string, bufferlist> >::const_iterator i =
+ for (map<hobject_t, map<string, bufferlist>, hobject_t::BitwiseComparator>::const_iterator i =
attrs_read.begin();
i != attrs_read.end();
++i) {
f->close_section();
f->open_array_section("errors");
- for (map<hobject_t, int>::const_iterator i = errors.begin();
+ for (map<hobject_t, int, hobject_t::BitwiseComparator>::const_iterator i = errors.begin();
i != errors.end();
++i) {
f->open_object_section("error_pair");
eversion_t trim_to;
eversion_t trim_rollback_to;
vector<pg_log_entry_t> log_entries;
- set<hobject_t> temp_added;
- set<hobject_t> temp_removed;
+ set<hobject_t, hobject_t::BitwiseComparator> temp_added;
+ set<hobject_t, hobject_t::BitwiseComparator> temp_removed;
boost::optional<pg_hit_set_history_t> updated_hit_set_history;
ECSubWrite() : tid(0) {}
ECSubWrite(
eversion_t trim_rollback_to,
vector<pg_log_entry_t> log_entries,
boost::optional<pg_hit_set_history_t> updated_hit_set_history,
- const set<hobject_t> &temp_added,
- const set<hobject_t> &temp_removed)
+ const set<hobject_t, hobject_t::BitwiseComparator> &temp_added,
+ const set<hobject_t, hobject_t::BitwiseComparator> &temp_removed)
: from(from), tid(tid), reqid(reqid),
soid(soid), stats(stats), t(t),
at_version(at_version),
struct ECSubRead {
pg_shard_t from;
ceph_tid_t tid;
- map<hobject_t, list<boost::tuple<uint64_t, uint64_t, uint32_t> > > to_read;
- set<hobject_t> attrs_to_read;
+ map<hobject_t, list<boost::tuple<uint64_t, uint64_t, uint32_t> >, hobject_t::BitwiseComparator> to_read;
+ set<hobject_t, hobject_t::BitwiseComparator> attrs_to_read;
void encode(bufferlist &bl, uint64_t features) const;
void decode(bufferlist::iterator &bl);
void dump(Formatter *f) const;
struct ECSubReadReply {
pg_shard_t from;
ceph_tid_t tid;
- map<hobject_t, list<pair<uint64_t, bufferlist> > > buffers_read;
- map<hobject_t, map<string, bufferlist> > attrs_read;
- map<hobject_t, int> errors;
+ map<hobject_t, list<pair<uint64_t, bufferlist> >, hobject_t::BitwiseComparator> buffers_read;
+ map<hobject_t, map<string, bufferlist>, hobject_t::BitwiseComparator> attrs_read;
+ map<hobject_t, int, hobject_t::BitwiseComparator> errors;
void encode(bufferlist &bl) const;
void decode(bufferlist::iterator &bl);
void dump(Formatter *f) const;
#include "os/ObjectStore.h"
struct AppendObjectsGenerator: public boost::static_visitor<void> {
- set<hobject_t> *out;
- AppendObjectsGenerator(set<hobject_t> *out) : out(out) {}
+ set<hobject_t, hobject_t::BitwiseComparator> *out;
+ AppendObjectsGenerator(set<hobject_t, hobject_t::BitwiseComparator> *out) : out(out) {}
void operator()(const ECTransaction::AppendOp &op) {
out->insert(op.oid);
}
void operator()(const ECTransaction::NoOp &op) {}
};
void ECTransaction::get_append_objects(
- set<hobject_t> *out) const
+ set<hobject_t, hobject_t::BitwiseComparator> *out) const
{
AppendObjectsGenerator gen(out);
reverse_visit(gen);
}
struct TransGenerator : public boost::static_visitor<void> {
- map<hobject_t, ECUtil::HashInfoRef> &hash_infos;
+ map<hobject_t, ECUtil::HashInfoRef, hobject_t::BitwiseComparator> &hash_infos;
ErasureCodeInterfaceRef &ecimpl;
const pg_t pgid;
const ECUtil::stripe_info_t sinfo;
map<shard_id_t, ObjectStore::Transaction> *trans;
set<int> want;
- set<hobject_t> *temp_added;
- set<hobject_t> *temp_removed;
+ set<hobject_t, hobject_t::BitwiseComparator> *temp_added;
+ set<hobject_t, hobject_t::BitwiseComparator> *temp_removed;
stringstream *out;
TransGenerator(
- map<hobject_t, ECUtil::HashInfoRef> &hash_infos,
+ map<hobject_t, ECUtil::HashInfoRef, hobject_t::BitwiseComparator> &hash_infos,
ErasureCodeInterfaceRef &ecimpl,
pg_t pgid,
const ECUtil::stripe_info_t &sinfo,
map<shard_id_t, ObjectStore::Transaction> *trans,
- set<hobject_t> *temp_added,
- set<hobject_t> *temp_removed,
+ set<hobject_t, hobject_t::BitwiseComparator> *temp_added,
+ set<hobject_t, hobject_t::BitwiseComparator> *temp_removed,
stringstream *out)
: hash_infos(hash_infos),
ecimpl(ecimpl), pgid(pgid),
void ECTransaction::generate_transactions(
- map<hobject_t, ECUtil::HashInfoRef> &hash_infos,
+ map<hobject_t, ECUtil::HashInfoRef, hobject_t::BitwiseComparator> &hash_infos,
ErasureCodeInterfaceRef &ecimpl,
pg_t pgid,
const ECUtil::stripe_info_t &sinfo,
map<shard_id_t, ObjectStore::Transaction> *transactions,
- set<hobject_t> *temp_added,
- set<hobject_t> *temp_removed,
+ set<hobject_t, hobject_t::BitwiseComparator> *temp_added,
+ set<hobject_t, hobject_t::BitwiseComparator> *temp_removed,
stringstream *out) const
{
TransGenerator gen(
}
}
void get_append_objects(
- set<hobject_t> *out) const;
+ set<hobject_t, hobject_t::BitwiseComparator> *out) const;
void generate_transactions(
- map<hobject_t, ECUtil::HashInfoRef> &hash_infos,
+ map<hobject_t, ECUtil::HashInfoRef, hobject_t::BitwiseComparator> &hash_infos,
ErasureCodeInterfaceRef &ecimpl,
pg_t pgid,
const ECUtil::stripe_info_t &sinfo,
map<shard_id_t, ObjectStore::Transaction> *transactions,
- set<hobject_t> *temp_added,
- set<hobject_t> *temp_removed,
+ set<hobject_t, hobject_t::BitwiseComparator> *temp_added,
+ set<hobject_t, hobject_t::BitwiseComparator> *temp_removed,
stringstream *out = 0) const;
};
pg->lock();
fout << *pg << std::endl;
- std::map<hobject_t, pg_missing_t::item>::const_iterator mend =
+ std::map<hobject_t, pg_missing_t::item, hobject_t::BitwiseComparator>::const_iterator mend =
pg->pg_log.get_missing().missing.end();
- std::map<hobject_t, pg_missing_t::item>::const_iterator mi =
+ std::map<hobject_t, pg_missing_t::item, hobject_t::BitwiseComparator>::const_iterator mi =
pg->pg_log.get_missing().missing.begin();
for (; mi != mend; ++mi) {
fout << mi->first << " -> " << mi->second << std::endl;
bool agent_valid_iterator;
int agent_ops;
int flush_mode_high_count; //once have one pg with FLUSH_MODE_HIGH then flush objects with high speed
- set<hobject_t> agent_oids;
+ set<hobject_t, hobject_t::BitwiseComparator> agent_oids;
bool agent_active;
struct AgentThread : public Thread {
OSDService *osd;
utime_t defer_recovery_until;
int recovery_ops_active;
#ifdef DEBUG_RECOVERY_OIDS
- map<spg_t, set<hobject_t> > recovery_oids;
+ map<spg_t, set<hobject_t, hobject_t::BitwiseComparator> > recovery_oids;
#endif
struct RecoveryWQ : public ThreadPool::WorkQueue<PG> {
dout(10) << " peer osd." << from << " now " << oinfo << " " << omissing << dendl;
might_have_unfound.insert(from);
- for (map<hobject_t, pg_missing_t::item>::iterator i = omissing.missing.begin();
+ for (map<hobject_t, pg_missing_t::item, hobject_t::BitwiseComparator>::iterator i = omissing.missing.begin();
i != omissing.missing.end();
++i) {
dout(20) << " after missing " << i->first << " need " << i->second.need
const set<pg_shard_t> &sources)
{
dout(10) << __func__ << ": adding sources in batch " << sources.size() << dendl;
- for (map<hobject_t, pg_missing_t::item>::const_iterator i = needs_recovery_map.begin();
+ for (map<hobject_t, pg_missing_t::item, hobject_t::BitwiseComparator>::const_iterator i = needs_recovery_map.begin();
i != needs_recovery_map.end();
++i) {
missing_loc[i->first].insert(sources.begin(), sources.end());
{
bool found_missing = false;
// found items?
- for (map<hobject_t,pg_missing_t::item>::const_iterator p = needs_recovery_map.begin();
+ for (map<hobject_t,pg_missing_t::item, hobject_t::BitwiseComparator>::const_iterator p = needs_recovery_map.begin();
p != needs_recovery_map.end();
++p) {
const hobject_t &soid(p->first);
}
}
-void PG::requeue_object_waiters(map<hobject_t, list<OpRequestRef> >& m)
+void PG::requeue_object_waiters(map<hobject_t, list<OpRequestRef>, hobject_t::BitwiseComparator>& m)
{
- for (map<hobject_t, list<OpRequestRef> >::iterator it = m.begin();
+ for (map<hobject_t, list<OpRequestRef>, hobject_t::BitwiseComparator>::iterator it = m.begin();
it != m.end();
++it)
requeue_ops(it->second);
void PG::_scan_snaps(ScrubMap &smap)
{
- for (map<hobject_t, ScrubMap::object>::iterator i = smap.objects.begin();
+ for (map<hobject_t, ScrubMap::object, hobject_t::BitwiseComparator>::iterator i = smap.objects.begin();
i != smap.objects.end();
++i) {
const hobject_t &hoid = i->first;
// construct authoritative scrub map for type specific scrubbing
ScrubMap authmap(scrubber.primary_scrubmap);
- map<hobject_t, pair<uint32_t, uint32_t> > missing_digest;
+ map<hobject_t, pair<uint32_t, uint32_t>, hobject_t::BitwiseComparator> missing_digest;
if (acting.size() > 1) {
dout(10) << __func__ << " comparing replica scrub maps" << dendl;
stringstream ss;
// Map from object with errors to good peer
- map<hobject_t, list<pg_shard_t> > authoritative;
+ map<hobject_t, list<pg_shard_t>, hobject_t::BitwiseComparator> authoritative;
map<pg_shard_t, ScrubMap *> maps;
dout(2) << __func__ << " osd." << acting[0] << " has "
osd->clog->error(ss);
}
- for (map<hobject_t, list<pg_shard_t> >::iterator i = authoritative.begin();
+ for (map<hobject_t, list<pg_shard_t>, hobject_t::BitwiseComparator>::iterator i = authoritative.begin();
i != authoritative.end();
++i) {
list<pair<ScrubMap::object, pg_shard_t> > good_peers;
good_peers));
}
- for (map<hobject_t, list<pg_shard_t> >::iterator i = authoritative.begin();
+ for (map<hobject_t, list<pg_shard_t>, hobject_t::BitwiseComparator>::iterator i = authoritative.begin();
i != authoritative.end();
++i) {
authmap.objects.erase(i->first);
osd->clog->error(ss);
if (repair) {
state_clear(PG_STATE_CLEAN);
- for (map<hobject_t, list<pair<ScrubMap::object, pg_shard_t> > >::iterator i =
+ for (map<hobject_t, list<pair<ScrubMap::object, pg_shard_t> >, hobject_t::BitwiseComparator>::iterator i =
scrubber.authoritative.begin();
i != scrubber.authoritative.end();
++i) {
ghobject_t pgmeta_oid;
class MissingLoc {
- map<hobject_t, pg_missing_t::item> needs_recovery_map;
- map<hobject_t, set<pg_shard_t> > missing_loc;
+ map<hobject_t, pg_missing_t::item, hobject_t::BitwiseComparator> needs_recovery_map;
+ map<hobject_t, set<pg_shard_t>, hobject_t::BitwiseComparator > missing_loc;
set<pg_shard_t> missing_loc_sources;
PG *pg;
set<pg_shard_t> empty_set;
bool needs_recovery(
const hobject_t &hoid,
eversion_t *v = 0) const {
- map<hobject_t, pg_missing_t::item>::const_iterator i =
+ map<hobject_t, pg_missing_t::item, hobject_t::BitwiseComparator>::const_iterator i =
needs_recovery_map.find(hoid);
if (i == needs_recovery_map.end())
return false;
const set<pg_shard_t> &acting) const;
uint64_t num_unfound() const {
uint64_t ret = 0;
- for (map<hobject_t, pg_missing_t::item>::const_iterator i =
+ for (map<hobject_t, pg_missing_t::item, hobject_t::BitwiseComparator>::const_iterator i =
needs_recovery_map.begin();
i != needs_recovery_map.end();
++i) {
missing_loc[hoid].erase(location);
}
void add_active_missing(const pg_missing_t &missing) {
- for (map<hobject_t, pg_missing_t::item>::const_iterator i =
+ for (map<hobject_t, pg_missing_t::item, hobject_t::BitwiseComparator>::const_iterator i =
missing.missing.begin();
i != missing.missing.end();
++i) {
- map<hobject_t, pg_missing_t::item>::const_iterator j =
+ map<hobject_t, pg_missing_t::item, hobject_t::BitwiseComparator>::const_iterator j =
needs_recovery_map.find(i->first);
if (j == needs_recovery_map.end()) {
needs_recovery_map.insert(*i);
return missing_loc.count(hoid) ?
missing_loc.find(hoid)->second : empty_set;
}
- const map<hobject_t, set<pg_shard_t> > &get_missing_locs() const {
+ const map<hobject_t, set<pg_shard_t>, hobject_t::BitwiseComparator> &get_missing_locs() const {
return missing_loc;
}
- const map<hobject_t, pg_missing_t::item> &get_needs_recovery() const {
+ const map<hobject_t, pg_missing_t::item, hobject_t::BitwiseComparator> &get_needs_recovery() const {
return needs_recovery_map;
}
} missing_loc;
int recovery_ops_active;
set<pg_shard_t> waiting_on_backfill;
#ifdef DEBUG_RECOVERY_OIDS
- set<hobject_t> recovering_oids;
+ set<hobject_t, hobject_t::BitwiseComparator> recovering_oids;
#endif
utime_t replay_until;
struct BackfillInterval {
// info about a backfill interval on a peer
eversion_t version; /// version at which the scan occurred
- map<hobject_t,eversion_t> objects;
+ map<hobject_t,eversion_t, hobject_t::BitwiseComparator> objects;
hobject_t begin;
hobject_t end;
f->dump_stream("begin") << begin;
f->dump_stream("end") << end;
f->open_array_section("objects");
- for (map<hobject_t, eversion_t>::const_iterator i = objects.begin();
+ for (map<hobject_t, eversion_t, hobject_t::BitwiseComparator>::const_iterator i = objects.begin();
i != objects.end();
++i) {
f->open_object_section("object");
list<OpRequestRef> waiting_for_cache_not_full;
list<OpRequestRef> waiting_for_all_missing;
- map<hobject_t, list<OpRequestRef> > waiting_for_unreadable_object,
+ map<hobject_t, list<OpRequestRef>, hobject_t::BitwiseComparator> waiting_for_unreadable_object,
waiting_for_degraded_object,
waiting_for_blocked_object;
// Callbacks should assume pg (and nothing else) is locked
- map<hobject_t, list<Context*> > callbacks_for_degraded_object;
+ map<hobject_t, list<Context*>, hobject_t::BitwiseComparator> callbacks_for_degraded_object;
map<eversion_t,
list<pair<OpRequestRef, version_t> > > waiting_for_ack, waiting_for_ondisk;
map<eversion_t,OpRequestRef> replay_queue;
void split_ops(PG *child, unsigned split_bits);
- void requeue_object_waiters(map<hobject_t, list<OpRequestRef> >& m);
+ void requeue_object_waiters(map<hobject_t, list<OpRequestRef>, hobject_t::BitwiseComparator>& m);
void requeue_op(OpRequestRef op);
void requeue_ops(list<OpRequestRef> &l);
struct PGLogEntryHandler : public PGLog::LogEntryHandler {
list<pg_log_entry_t> to_rollback;
- set<hobject_t> to_remove;
+ set<hobject_t, hobject_t::BitwiseComparator> to_remove;
list<pg_log_entry_t> to_trim;
// LogEntryHandler
SnapRollBacker rollbacker(j->soid, pg, t);
j->mod_desc.visit(&rollbacker);
}
- for (set<hobject_t>::iterator i = to_remove.begin();
+ for (set<hobject_t, hobject_t::BitwiseComparator>::iterator i = to_remove.begin();
i != to_remove.end();
++i) {
pg->get_pgbackend()->rollback_create(*i, t);
bool must_scrub, must_deep_scrub, must_repair;
// Maps from objects with errors to missing/inconsistent peers
- map<hobject_t, set<pg_shard_t> > missing;
- map<hobject_t, set<pg_shard_t> > inconsistent;
+ map<hobject_t, set<pg_shard_t>, hobject_t::BitwiseComparator> missing;
+ map<hobject_t, set<pg_shard_t>, hobject_t::BitwiseComparator> inconsistent;
// Map from object with errors to good peers
- map<hobject_t, list<pair<ScrubMap::object, pg_shard_t> > > authoritative;
+ map<hobject_t, list<pair<ScrubMap::object, pg_shard_t> >, hobject_t::BitwiseComparator> authoritative;
// digest updates which we are waiting on
int num_digest_updates_pending;
const hobject_t &begin, const hobject_t &end) = 0;
virtual void _scrub(
ScrubMap &map,
- const std::map<hobject_t, pair<uint32_t, uint32_t> > &missing_digest) { }
+ const std::map<hobject_t, pair<uint32_t, uint32_t>, hobject_t::BitwiseComparator> &missing_digest) { }
virtual void _scrub_clear_state() { }
virtual void _scrub_finish() { }
virtual void split_colls(
{
dout(10) << __func__ << dendl;
// clear temp
- for (set<hobject_t>::iterator i = temp_contents.begin();
+ for (set<hobject_t, hobject_t::BitwiseComparator>::iterator i = temp_contents.begin();
i != temp_contents.end();
++i) {
dout(10) << __func__ << ": Removing oid "
for (map<pg_shard_t, ScrubMap *>::const_iterator j = maps.begin();
j != maps.end();
++j) {
- map<hobject_t, ScrubMap::object>::iterator i =
+ map<hobject_t, ScrubMap::object, hobject_t::BitwiseComparator>::iterator i =
j->second->objects.find(obj);
if (i == j->second->objects.end()) {
continue;
const map<pg_shard_t,ScrubMap*> &maps,
bool okseed,
bool repair,
- map<hobject_t, set<pg_shard_t> > &missing,
- map<hobject_t, set<pg_shard_t> > &inconsistent,
- map<hobject_t, list<pg_shard_t> > &authoritative,
- map<hobject_t, pair<uint32_t,uint32_t> > &missing_digest,
+ map<hobject_t, set<pg_shard_t>, hobject_t::BitwiseComparator> &missing,
+ map<hobject_t, set<pg_shard_t>, hobject_t::BitwiseComparator> &inconsistent,
+ map<hobject_t, list<pg_shard_t>, hobject_t::BitwiseComparator> &authoritative,
+ map<hobject_t, pair<uint32_t,uint32_t>, hobject_t::BitwiseComparator> &missing_digest,
int &shallow_errors, int &deep_errors,
const spg_t& pgid,
const vector<int> &acting,
ostream &errorstream)
{
- map<hobject_t,ScrubMap::object>::const_iterator i;
- map<pg_shard_t, ScrubMap *>::const_iterator j;
- set<hobject_t> master_set;
+ map<hobject_t,ScrubMap::object, hobject_t::BitwiseComparator>::const_iterator i;
+ map<pg_shard_t, ScrubMap *, hobject_t::BitwiseComparator>::const_iterator j;
+ set<hobject_t, hobject_t::BitwiseComparator> master_set;
utime_t now = ceph_clock_now(NULL);
// Construct master set
}
// Check maps against master set and each other
- for (set<hobject_t>::const_iterator k = master_set.begin();
+ for (set<hobject_t, hobject_t::BitwiseComparator>::const_iterator k = master_set.begin();
k != master_set.end();
++k) {
object_info_t auth_oi;
virtual std::string gen_dbg_prefix() const = 0;
- virtual const map<hobject_t, set<pg_shard_t> > &get_missing_loc_shards()
+ virtual const map<hobject_t, set<pg_shard_t>, hobject_t::BitwiseComparator> &get_missing_loc_shards()
const = 0;
virtual const pg_missing_t &get_local_missing() const = 0;
virtual void dump_recovery_info(Formatter *f) const = 0;
private:
- set<hobject_t> temp_contents;
+ set<hobject_t, hobject_t::BitwiseComparator> temp_contents;
public:
// Track contents of temp collection, clear on reset
void add_temp_obj(const hobject_t &oid) {
temp_contents.insert(oid);
}
- void add_temp_objs(const set<hobject_t> &oids) {
+ void add_temp_objs(const set<hobject_t, hobject_t::BitwiseComparator> &oids) {
temp_contents.insert(oids.begin(), oids.end());
}
void clear_temp_obj(const hobject_t &oid) {
temp_contents.erase(oid);
}
- void clear_temp_objs(const set<hobject_t> &oids) {
- for (set<hobject_t>::const_iterator i = oids.begin();
+ void clear_temp_objs(const set<hobject_t, hobject_t::BitwiseComparator> &oids) {
+ for (set<hobject_t, hobject_t::BitwiseComparator>::const_iterator i = oids.begin();
i != oids.end();
++i) {
temp_contents.erase(*i);
const map<pg_shard_t,ScrubMap*> &maps,
bool okseed, ///< true if scrub digests have same seed our oi digests
bool repair,
- map<hobject_t, set<pg_shard_t> > &missing,
- map<hobject_t, set<pg_shard_t> > &inconsistent,
- map<hobject_t, list<pg_shard_t> > &authoritative,
- map<hobject_t, pair<uint32_t,uint32_t> > &missing_digest,
+ map<hobject_t, set<pg_shard_t>, hobject_t::BitwiseComparator> &missing,
+ map<hobject_t, set<pg_shard_t>, hobject_t::BitwiseComparator> &inconsistent,
+ map<hobject_t, list<pg_shard_t>, hobject_t::BitwiseComparator> &authoritative,
+ map<hobject_t, pair<uint32_t,uint32_t>, hobject_t::BitwiseComparator> &missing_digest,
int &shallow_errors, int &deep_errors,
const spg_t& pgid,
const vector<int> &acting,
we will send the peer enough log to arrive at the same state.
*/
- for (map<hobject_t, pg_missing_t::item>::iterator i = omissing.missing.begin();
+ for (map<hobject_t, pg_missing_t::item, hobject_t::BitwiseComparator>::iterator i = omissing.missing.begin();
i != omissing.missing.end();
++i) {
dout(20) << " before missing " << i->first << " need " << i->second.need
// The logs must overlap.
assert(log.head >= olog.tail && olog.head >= log.tail);
- for (map<hobject_t, pg_missing_t::item>::iterator i = missing.missing.begin();
+ for (map<hobject_t, pg_missing_t::item, hobject_t::BitwiseComparator>::iterator i = missing.missing.begin();
i != missing.missing.end();
++i) {
dout(20) << "pg_missing_t sobject: " << i->first << dendl;
dout(10) << "read_log checking for missing items over interval (" << info.last_complete
<< "," << info.last_update << "]" << dendl;
- set<hobject_t> did;
+ set<hobject_t, hobject_t::BitwiseComparator> did;
for (list<pg_log_entry_t>::reverse_iterator i = log.log.rbegin();
i != log.log.rend();
++i) {
const pg_missing_t& get_missing() const { return missing; }
- void missing_got(map<hobject_t, pg_missing_t::item>::const_iterator m) {
- map<hobject_t, pg_missing_t::item>::iterator p = missing.missing.find(m->first);
+ void missing_got(map<hobject_t, pg_missing_t::item, hobject_t::BitwiseComparator>::const_iterator m) {
+ map<hobject_t, pg_missing_t::item, hobject_t::BitwiseComparator>::iterator p = missing.missing.find(m->first);
missing.got(p);
}
missing.add(oid, need, have);
}
- void missing_rm(map<hobject_t, pg_missing_t::item>::const_iterator m) {
- map<hobject_t, pg_missing_t::item>::iterator p = missing.missing.find(m->first);
+ void missing_rm(map<hobject_t, pg_missing_t::item, hobject_t::BitwiseComparator>::const_iterator m) {
+ map<hobject_t, pg_missing_t::item, hobject_t::BitwiseComparator>::iterator p = missing.missing.find(m->first);
missing.rm(p);
}
protected:
static void split_by_object(
list<pg_log_entry_t> &entries,
- map<hobject_t, list<pg_log_entry_t> > *out_entries) {
+ map<hobject_t, list<pg_log_entry_t>, hobject_t::BitwiseComparator> *out_entries) {
while (!entries.empty()) {
list<pg_log_entry_t> &out_list = (*out_entries)[entries.front().soid];
out_list.splice(out_list.end(), entries, entries.begin());
map<eversion_t, hobject_t> *priors, ///< [out] target for new priors
LogEntryHandler *rollbacker ///< [in] optional rollbacker object
) {
- map<hobject_t, list<pg_log_entry_t> > split;
+ map<hobject_t, list<pg_log_entry_t>, hobject_t::BitwiseComparator > split;
split_by_object(entries, &split);
- for (map<hobject_t, list<pg_log_entry_t> >::iterator i = split.begin();
+ for (map<hobject_t, list<pg_log_entry_t>, hobject_t::BitwiseComparator>::iterator i = split.begin();
i != split.end();
++i) {
boost::optional<pair<eversion_t, hobject_t> > new_divergent_prior;
void ReplicatedBackend::check_recovery_sources(const OSDMapRef osdmap)
{
- for(map<pg_shard_t, set<hobject_t> >::iterator i = pull_from_peer.begin();
+ for(map<pg_shard_t, set<hobject_t, hobject_t::BitwiseComparator> >::iterator i = pull_from_peer.begin();
i != pull_from_peer.end();
) {
if (osdmap->is_down(i->first.osd)) {
dout(10) << "check_recovery_sources resetting pulls from osd." << i->first
<< ", osdmap has it marked down" << dendl;
- for (set<hobject_t>::iterator j = i->second.begin();
+ for (set<hobject_t, hobject_t::BitwiseComparator>::iterator j = i->second.begin();
j != i->second.end();
++j) {
assert(pulling.count(*j) == 1);
class RPGTransaction : public PGBackend::PGTransaction {
coll_t coll;
- set<hobject_t> temp_added;
- set<hobject_t> temp_cleared;
+ set<hobject_t, hobject_t::BitwiseComparator> temp_added;
+ set<hobject_t, hobject_t::BitwiseComparator> temp_cleared;
ObjectStore::Transaction *t;
uint64_t written;
const coll_t &get_coll_ct(const hobject_t &hoid) {
t = 0;
return _t;
}
- const set<hobject_t> &get_temp_added() {
+ const set<hobject_t, hobject_t::BitwiseComparator> &get_temp_added() {
return temp_added;
}
- const set<hobject_t> &get_temp_cleared() {
+ const set<hobject_t, hobject_t::BitwiseComparator> &get_temp_cleared() {
return temp_cleared;
}
written += to_append->written;
to_append->written = 0;
t->append(*(to_append->t));
- for (set<hobject_t>::iterator i = to_append->temp_added.begin();
+ for (set<hobject_t, hobject_t::BitwiseComparator>::iterator i = to_append->temp_added.begin();
i != to_append->temp_added.end();
++i) {
temp_cleared.erase(*i);
temp_added.insert(*i);
}
- for (set<hobject_t>::iterator i = to_append->temp_cleared.begin();
+ for (set<hobject_t, hobject_t::BitwiseComparator>::iterator i = to_append->temp_cleared.begin();
i != to_append->temp_cleared.end();
++i) {
temp_added.erase(*i);
to_continue.begin();
i != to_continue.end();
++i) {
- map<hobject_t, ReplicatedBackend::PullInfo>::iterator j =
+ map<hobject_t, ReplicatedBackend::PullInfo, hobject_t::BitwiseComparator>::iterator j =
bc->pulling.find(*i);
assert(j != bc->pulling.end());
if (!bc->start_pushes(*i, j->second.obc, h)) {
const pg_missing_t& missing,
const hobject_t &last_backfill,
interval_set<uint64_t>& data_subset,
- map<hobject_t, interval_set<uint64_t> >& clone_subsets)
+ map<hobject_t, interval_set<uint64_t>, hobject_t::BitwiseComparator>& clone_subsets)
{
dout(10) << "calc_head_subsets " << head
<< " clone_overlap " << snapset.clone_overlap << dendl;
const pg_missing_t& missing,
const hobject_t &last_backfill,
interval_set<uint64_t>& data_subset,
- map<hobject_t, interval_set<uint64_t> >& clone_subsets)
+ map<hobject_t, interval_set<uint64_t>, hobject_t::BitwiseComparator>& clone_subsets)
{
dout(10) << "calc_clone_subsets " << soid
<< " clone_overlap " << snapset.clone_overlap << dendl;
eversion_t _v = get_parent()->get_local_missing().missing.find(
soid)->second.need;
assert(_v == v);
- const map<hobject_t, set<pg_shard_t> > &missing_loc(
+ const map<hobject_t, set<pg_shard_t>, hobject_t::BitwiseComparator> &missing_loc(
get_parent()->get_missing_loc_shards());
const map<pg_shard_t, pg_missing_t > &peer_missing(
get_parent()->get_shard_missing());
- map<hobject_t, set<pg_shard_t> >::const_iterator q = missing_loc.find(soid);
+ map<hobject_t, set<pg_shard_t>, hobject_t::BitwiseComparator>::const_iterator q = missing_loc.find(soid);
assert(q != missing_loc.end());
assert(!q->second.empty());
dout(10) << __func__ << ": " << soid << " v" << oi.version
<< " size " << size << " to osd." << peer << dendl;
- map<hobject_t, interval_set<uint64_t> > clone_subsets;
+ map<hobject_t, interval_set<uint64_t>, hobject_t::BitwiseComparator> clone_subsets;
interval_set<uint64_t> data_subset;
// are we doing a clone on the replica?
interval_set<uint64_t> data_subset;
if (obc->obs.oi.size)
data_subset.insert(0, obc->obs.oi.size);
- map<hobject_t, interval_set<uint64_t> > clone_subsets;
+ map<hobject_t, interval_set<uint64_t>, hobject_t::BitwiseComparator> clone_subsets;
prep_push(obc, soid, peer,
obc->obs.oi.version, data_subset, clone_subsets,
const hobject_t& soid, pg_shard_t peer,
eversion_t version,
interval_set<uint64_t> &data_subset,
- map<hobject_t, interval_set<uint64_t> >& clone_subsets,
+ map<hobject_t, interval_set<uint64_t>, hobject_t::BitwiseComparator>& clone_subsets,
PushOp *pop)
{
get_parent()->begin_peer_recover(peer, soid);
void ReplicatedBackend::submit_push_complete(ObjectRecoveryInfo &recovery_info,
ObjectStore::Transaction *t)
{
- for (map<hobject_t, interval_set<uint64_t> >::const_iterator p =
+ for (map<hobject_t, interval_set<uint64_t>, hobject_t::BitwiseComparator>::const_iterator p =
recovery_info.clone_subset.begin();
p != recovery_info.clone_subset.end();
++p) {
virtual void dump_recovery_info(Formatter *f) const {
{
f->open_array_section("pull_from_peer");
- for (map<pg_shard_t, set<hobject_t> >::const_iterator i = pull_from_peer.begin();
+ for (map<pg_shard_t, set<hobject_t, hobject_t::BitwiseComparator> >::const_iterator i = pull_from_peer.begin();
i != pull_from_peer.end();
++i) {
f->open_object_section("pulling_from");
f->dump_stream("pull_from") << i->first;
{
f->open_array_section("pulls");
- for (set<hobject_t>::const_iterator j = i->second.begin();
+ for (set<hobject_t, hobject_t::BitwiseComparator>::const_iterator j = i->second.begin();
j != i->second.end();
++j) {
f->open_object_section("pull_info");
}
{
f->open_array_section("pushing");
- for (map<hobject_t, map<pg_shard_t, PushInfo> >::const_iterator i =
+ for (map<hobject_t, map<pg_shard_t, PushInfo>, hobject_t::BitwiseComparator>::const_iterator i =
pushing.begin();
i != pushing.end();
++i) {
}
}
};
- map<hobject_t, map<pg_shard_t, PushInfo> > pushing;
+ map<hobject_t, map<pg_shard_t, PushInfo>, hobject_t::BitwiseComparator> pushing;
// pull
struct PullInfo {
}
};
- map<hobject_t, PullInfo> pulling;
+ map<hobject_t, PullInfo, hobject_t::BitwiseComparator> pulling;
// Reverse mapping from osd peer to objects beging pulled from that peer
- map<pg_shard_t, set<hobject_t> > pull_from_peer;
+ map<pg_shard_t, set<hobject_t, hobject_t::BitwiseComparator> > pull_from_peer;
void sub_op_push(OpRequestRef op);
void sub_op_push_reply(OpRequestRef op);
SnapSet& snapset, const hobject_t& poid, const pg_missing_t& missing,
const hobject_t &last_backfill,
interval_set<uint64_t>& data_subset,
- map<hobject_t, interval_set<uint64_t> >& clone_subsets);
+ map<hobject_t, interval_set<uint64_t>, hobject_t::BitwiseComparator>& clone_subsets);
void prepare_pull(
eversion_t v,
const hobject_t& soid,
const hobject_t& soid, pg_shard_t peer,
eversion_t version,
interval_set<uint64_t> &data_subset,
- map<hobject_t, interval_set<uint64_t> >& clone_subsets,
+ map<hobject_t, interval_set<uint64_t>, hobject_t::BitwiseComparator>& clone_subsets,
PushOp *op);
void calc_head_subsets(ObjectContextRef obc, SnapSet& snapset, const hobject_t& head,
const pg_missing_t& missing,
const hobject_t &last_backfill,
interval_set<uint64_t>& data_subset,
- map<hobject_t, interval_set<uint64_t> >& clone_subsets);
+ map<hobject_t, interval_set<uint64_t>, hobject_t::BitwiseComparator>& clone_subsets);
ObjectRecoveryInfo recalc_subsets(
const ObjectRecoveryInfo& recovery_info,
SnapSetContext *ssc
missing_loc.recovered(soid);
publish_stats_to_osd();
dout(10) << "pushed " << soid << " to all replicas" << dendl;
- map<hobject_t, ObjectContextRef>::iterator i = recovering.find(soid);
+ map<hobject_t, ObjectContextRef, hobject_t::BitwiseComparator>::iterator i = recovering.find(soid);
assert(i != recovering.end());
// recover missing won't have had an obc, but it gets filled in
bool needs_recovery = missing_loc.needs_recovery(soid, &v);
assert(needs_recovery);
- map<hobject_t, ObjectContextRef>::const_iterator p = recovering.find(soid);
+ map<hobject_t, ObjectContextRef, hobject_t::BitwiseComparator>::const_iterator p = recovering.find(soid);
if (p != recovering.end()) {
dout(7) << "missing " << soid << " v " << v << ", already recovering." << dendl;
} else if (missing_loc.is_unfound(soid)) {
}
f->dump_int("num_missing", missing.num_missing());
f->dump_int("num_unfound", get_num_unfound());
- map<hobject_t,pg_missing_t::item>::const_iterator p = missing.missing.upper_bound(offset);
+ map<hobject_t,pg_missing_t::item, hobject_t::BitwiseComparator>::const_iterator p = missing.missing.upper_bound(offset);
{
f->open_array_section("objects");
int32_t num = 0;
}
assert(snapid == CEPH_NOSNAP || pg_log.get_missing().missing.empty());
- map<hobject_t, pg_missing_t::item>::const_iterator missing_iter =
+ map<hobject_t, pg_missing_t::item, hobject_t::BitwiseComparator>::const_iterator missing_iter =
pg_log.get_missing().missing.lower_bound(current);
vector<hobject_t>::iterator ls_iter = sentries.begin();
hobject_t _max = hobject_t::get_max();
}
assert(snapid == CEPH_NOSNAP || pg_log.get_missing().missing.empty());
- map<hobject_t, pg_missing_t::item>::const_iterator missing_iter =
+ map<hobject_t, pg_missing_t::item, hobject_t::BitwiseComparator>::const_iterator missing_iter =
pg_log.get_missing().missing.lower_bound(current);
vector<hobject_t>::iterator ls_iter = sentries.begin();
hobject_t _max = hobject_t::get_max();
}
// src_oids
- map<hobject_t,ObjectContextRef> src_obc;
+ map<hobject_t,ObjectContextRef, hobject_t::BitwiseComparator> src_obc;
for (vector<OSDOp>::iterator p = m->ops.begin(); p != m->ops.end(); ++p) {
OSDOp& osd_op = *p;
// verify there is in fact a flush in progress
// FIXME: we could make this a stronger test.
- map<hobject_t,FlushOpRef>::iterator p = flush_ops.find(obc->obs.oi.soid);
+ map<hobject_t,FlushOpRef, hobject_t::BitwiseComparator>::iterator p = flush_ops.find(obc->obs.oi.soid);
if (p == flush_ops.end()) {
dout(10) << __func__ << " no flush in progress, aborting" << dendl;
reply_ctx(ctx, -EINVAL);
}
proxyread_ops.erase(tid);
- map<hobject_t, list<OpRequestRef> >::iterator q = in_progress_proxy_reads.find(oid);
+ map<hobject_t, list<OpRequestRef>, hobject_t::BitwiseComparator>::iterator q = in_progress_proxy_reads.find(oid);
if (q == in_progress_proxy_reads.end()) {
dout(10) << __func__ << " no in_progress_proxy_reads found" << dendl;
return;
void ReplicatedPG::kick_proxy_read_blocked(hobject_t& soid)
{
- map<hobject_t, list<OpRequestRef> >::iterator p = in_progress_proxy_reads.find(soid);
+ map<hobject_t, list<OpRequestRef>, hobject_t::BitwiseComparator>::iterator p = in_progress_proxy_reads.find(soid);
if (p == in_progress_proxy_reads.end())
return;
}
if (requeue) {
- map<hobject_t, list<OpRequestRef> >::iterator p =
+ map<hobject_t, list<OpRequestRef>, hobject_t::BitwiseComparator>::iterator p =
in_progress_proxy_reads.begin();
while (p != in_progress_proxy_reads.end()) {
list<OpRequestRef>& ls = p->second;
* for this case we don't use DONTNEED.
*/
unsigned src_fadvise_flags = LIBRADOS_OP_FLAG_FADVISE_SEQUENTIAL;
- map<hobject_t, list<OpRequestRef> >::iterator q = in_progress_proxy_reads.find(obc->obs.oi.soid);
+ map<hobject_t, list<OpRequestRef>, hobject_t::BitwiseComparator>::iterator q = in_progress_proxy_reads.find(obc->obs.oi.soid);
if (q == in_progress_proxy_reads.end()) {
src_fadvise_flags |= LIBRADOS_OP_FLAG_FADVISE_DONTNEED;
}
MOSDOp *m = static_cast<MOSDOp*>(op->get_req());
ObjectContextRef obc = ctx->obc;
const hobject_t& soid = obc->obs.oi.soid;
- map<hobject_t,ObjectContextRef>& src_obc = ctx->src_obc;
+ map<hobject_t,ObjectContextRef, hobject_t::BitwiseComparator>& src_obc = ctx->src_obc;
// this method must be idempotent since we may call it several times
// before we finally apply the resulting transaction.
dout(10) << " taking ondisk_read_lock" << dendl;
obc->ondisk_read_lock();
}
- for (map<hobject_t,ObjectContextRef>::iterator p = src_obc.begin(); p != src_obc.end(); ++p) {
+ for (map<hobject_t,ObjectContextRef, hobject_t::BitwiseComparator>::iterator p = src_obc.begin(); p != src_obc.end(); ++p) {
dout(10) << " taking ondisk_read_lock for src " << p->first << dendl;
p->second->ondisk_read_lock();
}
dout(10) << " dropping ondisk_read_lock" << dendl;
obc->ondisk_read_unlock();
}
- for (map<hobject_t,ObjectContextRef>::iterator p = src_obc.begin(); p != src_obc.end(); ++p) {
+ for (map<hobject_t,ObjectContextRef, hobject_t::BitwiseComparator>::iterator p = src_obc.begin(); p != src_obc.end(); ++p) {
dout(10) << " dropping ondisk_read_lock for src " << p->first << dendl;
p->second->ondisk_read_unlock();
}
// handle hobject_t encoding change
if (bi.objects.size() && bi.objects.begin()->first.pool == -1) {
- map<hobject_t, eversion_t> tmp;
+ map<hobject_t, eversion_t, hobject_t::BitwiseComparator> tmp;
tmp.swap(bi.objects);
- for (map<hobject_t, eversion_t>::iterator i = tmp.begin();
+ for (map<hobject_t, eversion_t, hobject_t::BitwiseComparator>::iterator i = tmp.begin();
i != tmp.end();
++i) {
hobject_t first(i->first);
{
dout(10) << __func__ << " " << oid << " tid " << tid
<< " " << cpp_strerror(r) << dendl;
- map<hobject_t,CopyOpRef>::iterator p = copy_ops.find(oid);
+ map<hobject_t,CopyOpRef, hobject_t::BitwiseComparator>::iterator p = copy_ops.find(oid);
if (p == copy_ops.end()) {
dout(10) << __func__ << " no copy_op found" << dendl;
return;
// pass error to everyone blocked on this object
// FIXME: this is pretty sloppy, but at this point we got
// something unexpected and don't have many other options.
- map<hobject_t,list<OpRequestRef> >::iterator blocked_iter =
+ map<hobject_t,list<OpRequestRef>, hobject_t::BitwiseComparator>::iterator blocked_iter =
waiting_for_blocked_object.find(soid);
if (blocked_iter != waiting_for_blocked_object.end()) {
while (!blocked_iter->second.empty()) {
void ReplicatedPG::cancel_copy_ops(bool requeue)
{
dout(10) << __func__ << dendl;
- map<hobject_t,CopyOpRef>::iterator p = copy_ops.begin();
+ map<hobject_t,CopyOpRef, hobject_t::BitwiseComparator>::iterator p = copy_ops.begin();
while (p != copy_ops.end()) {
// requeue this op? can I queue up all of them?
cancel_copy((p++)->second, requeue);
if (blocking)
obc->start_block();
- map<hobject_t,FlushOpRef>::iterator p = flush_ops.find(soid);
+ map<hobject_t,FlushOpRef, hobject_t::BitwiseComparator>::iterator p = flush_ops.find(soid);
if (p != flush_ops.end()) {
FlushOpRef fop = p->second;
if (fop->op == op) {
{
dout(10) << __func__ << " " << oid << " tid " << tid
<< " " << cpp_strerror(r) << dendl;
- map<hobject_t,FlushOpRef>::iterator p = flush_ops.find(oid);
+ map<hobject_t,FlushOpRef, hobject_t::BitwiseComparator>::iterator p = flush_ops.find(oid);
if (p == flush_ops.end()) {
dout(10) << __func__ << " no flush_op found" << dendl;
return;
void ReplicatedPG::cancel_flush_ops(bool requeue)
{
dout(10) << __func__ << dendl;
- map<hobject_t,FlushOpRef>::iterator p = flush_ops.begin();
+ map<hobject_t,FlushOpRef, hobject_t::BitwiseComparator>::iterator p = flush_ops.begin();
while (p != flush_ops.end()) {
cancel_flush((p++)->second, requeue);
}
void ReplicatedPG::kick_object_context_blocked(ObjectContextRef obc)
{
const hobject_t& soid = obc->obs.oi.soid;
- map<hobject_t, list<OpRequestRef> >::iterator p = waiting_for_blocked_object.find(soid);
+ map<hobject_t, list<OpRequestRef>, hobject_t::BitwiseComparator>::iterator p = waiting_for_blocked_object.find(soid);
if (p == waiting_for_blocked_object.end())
return;
{
Mutex::Locker l(snapset_contexts_lock);
SnapSetContext *ssc;
- map<hobject_t, SnapSetContext*>::iterator p = snapset_contexts.find(
+ map<hobject_t, SnapSetContext*, hobject_t::BitwiseComparator>::iterator p = snapset_contexts.find(
oid.get_snapdir());
if (p != snapset_contexts.end()) {
if (can_create || p->second->exists) {
{
// Wake anyone waiting for this object. Now that it's been marked as lost,
// we will just return an error code.
- map<hobject_t, list<OpRequestRef> >::iterator wmo =
+ map<hobject_t, list<OpRequestRef>, hobject_t::BitwiseComparator>::iterator wmo =
waiting_for_unreadable_object.find(oid);
if (wmo != waiting_for_unreadable_object.end()) {
requeue_ops(wmo->second);
utime_t mtime = ceph_clock_now(cct);
info.last_update.epoch = get_osdmap()->get_epoch();
const pg_missing_t &missing = pg_log.get_missing();
- map<hobject_t, pg_missing_t::item>::const_iterator m =
+ map<hobject_t, pg_missing_t::item, hobject_t::BitwiseComparator>::const_iterator m =
missing_loc.get_needs_recovery().begin();
- map<hobject_t, pg_missing_t::item>::const_iterator mend =
+ map<hobject_t, pg_missing_t::item, hobject_t::BitwiseComparator>::const_iterator mend =
missing_loc.get_needs_recovery().end();
while (m != mend) {
const hobject_t &oid(m->first);
} else {
waiting_for_unreadable_object.clear();
}
- for (map<hobject_t,list<OpRequestRef> >::iterator p = waiting_for_degraded_object.begin();
+ for (map<hobject_t,list<OpRequestRef>, hobject_t::BitwiseComparator>::iterator p = waiting_for_degraded_object.begin();
p != waiting_for_degraded_object.end();
waiting_for_degraded_object.erase(p++)) {
if (is_primary())
p->second.clear();
finish_degraded_object(p->first);
}
- for (map<hobject_t,list<OpRequestRef> >::iterator p = waiting_for_blocked_object.begin();
+ for (map<hobject_t,list<OpRequestRef>, hobject_t::BitwiseComparator>::iterator p = waiting_for_blocked_object.begin();
p != waiting_for_blocked_object.end();
waiting_for_blocked_object.erase(p++)) {
if (is_primary())
else
p->second.clear();
}
- for (map<hobject_t, list<Context*> >::iterator i =
+ for (map<hobject_t, list<Context*>, hobject_t::BitwiseComparator>::iterator i =
callbacks_for_degraded_object.begin();
i != callbacks_for_degraded_object.end();
) {
recovering_oids.clear();
#endif
last_backfill_started = hobject_t();
- set<hobject_t>::iterator i = backfills_in_flight.begin();
+ set<hobject_t, hobject_t::BitwiseComparator>::iterator i = backfills_in_flight.begin();
while (i != backfills_in_flight.end()) {
assert(recovering.count(*i));
backfills_in_flight.erase(i++);
}
list<OpRequestRef> blocked_ops;
- for (map<hobject_t, ObjectContextRef>::iterator i = recovering.begin();
+ for (map<hobject_t, ObjectContextRef, hobject_t::BitwiseComparator>::iterator i = recovering.begin();
i != recovering.end();
recovering.erase(i++)) {
if (i->second) {
<< missing_loc_sources << dendl;
// filter missing_loc
- map<hobject_t, set<pg_shard_t> >::iterator p = missing_loc.begin();
+ map<hobject_t, set<pg_shard_t>, hobject_t::BitwiseComparator>::iterator p = missing_loc.begin();
while (p != missing_loc.end()) {
set<pg_shard_t>::iterator q = p->second.begin();
while (q != p->second.end())
}
dout(10) << __func__ << ": recover_object_replicas(" << soid << ")" << dendl;
- map<hobject_t,pg_missing_t::item>::const_iterator r = m.missing.find(soid);
+ map<hobject_t,pg_missing_t::item, hobject_t::BitwiseComparator>::const_iterator r = m.missing.find(soid);
started += prep_object_replica_pushes(soid, r->second.need,
h);
}
vector<boost::tuple<hobject_t, eversion_t,
ObjectContextRef, vector<pg_shard_t> > > to_push;
vector<boost::tuple<hobject_t, eversion_t, pg_shard_t> > to_remove;
- set<hobject_t> add_to_stat;
+ set<hobject_t, hobject_t::BitwiseComparator> add_to_stat;
for (set<pg_shard_t>::iterator i = backfill_targets.begin();
i != backfill_targets.end();
}
backfill_pos = MIN(backfill_info.begin, earliest_peer_backfill());
- for (set<hobject_t>::iterator i = add_to_stat.begin();
+ for (set<hobject_t, hobject_t::BitwiseComparator>::iterator i = add_to_stat.begin();
i != add_to_stat.end();
++i) {
ObjectContextRef obc = get_object_context(*i, false);
pgbackend->run_recovery_op(h, cct->_conf->osd_recovery_op_priority);
dout(5) << "backfill_pos is " << backfill_pos << dendl;
- for (set<hobject_t>::iterator i = backfills_in_flight.begin();
+ for (set<hobject_t, hobject_t::BitwiseComparator>::iterator i = backfills_in_flight.begin();
i != backfills_in_flight.end();
++i) {
dout(20) << *i << " is still in flight" << dendl;
backfill_pos : *(backfills_in_flight.begin());
hobject_t new_last_backfill = earliest_backfill();
dout(10) << "starting new_last_backfill at " << new_last_backfill << dendl;
- for (map<hobject_t, pg_stat_t>::iterator i = pending_backfill_updates.begin();
+ for (map<hobject_t, pg_stat_t, hobject_t::BitwiseComparator>::iterator i = pending_backfill_updates.begin();
i != pending_backfill_updates.end() &&
i->first < next_backfill_to_complete;
pending_backfill_updates.erase(i++)) {
return;
// just scan the log.
- set<hobject_t> did;
+ set<hobject_t, hobject_t::BitwiseComparator> did;
for (list<pg_log_entry_t>::const_reverse_iterator p = pg_log.get_log().log.rbegin();
p != pg_log.get_log().log.rend();
++p) {
void ReplicatedPG::_scrub(
ScrubMap &scrubmap,
- const map<hobject_t, pair<uint32_t, uint32_t> > &missing_digest)
+ const map<hobject_t, pair<uint32_t, uint32_t>, hobject_t::BitwiseComparator> &missing_digest)
{
dout(10) << "_scrub" << dendl;
bufferlist last_data;
- for (map<hobject_t,ScrubMap::object>::reverse_iterator p = scrubmap.objects.rbegin();
+ for (map<hobject_t,ScrubMap::object, hobject_t::BitwiseComparator>::reverse_iterator p = scrubmap.objects.rbegin();
p != scrubmap.objects.rend();
++p) {
const hobject_t& soid = p->first;
++scrubber.shallow_errors;
}
- for (map<hobject_t,pair<uint32_t,uint32_t> >::const_iterator p =
+ for (map<hobject_t,pair<uint32_t,uint32_t>, hobject_t::BitwiseComparator>::const_iterator p =
missing_digest.begin();
p != missing_digest.end();
++p) {
std::string gen_dbg_prefix() const { return gen_prefix(); }
- const map<hobject_t, set<pg_shard_t> > &get_missing_loc_shards() const {
+ const map<hobject_t, set<pg_shard_t>, hobject_t::BitwiseComparator> &get_missing_loc_shards() const {
return missing_loc.get_missing_locs();
}
const map<pg_shard_t, pg_missing_t> &get_shard_missing() const {
interval_set<uint64_t> modified_ranges;
ObjectContextRef obc;
- map<hobject_t,ObjectContextRef> src_obc;
+ map<hobject_t,ObjectContextRef, hobject_t::BitwiseComparator> src_obc;
ObjectContextRef clone_obc; // if we created a clone
ObjectContextRef snapset_obc; // if we created/deleted a snapdir
OpContext *ctx;
ObjectContextRef obc;
- map<hobject_t,ObjectContextRef> src_obc;
+ map<hobject_t,ObjectContextRef, hobject_t::BitwiseComparator> src_obc;
ceph_tid_t rep_tid;
}
// projected object info
- SharedLRU<hobject_t, ObjectContext> object_contexts;
+ SharedLRU<hobject_t, ObjectContext, hobject_t::BitwiseComparator> object_contexts;
// map from oid.snapdir() to SnapSetContext *
- map<hobject_t, SnapSetContext*> snapset_contexts;
+ map<hobject_t, SnapSetContext*, hobject_t::BitwiseComparator> snapset_contexts;
Mutex snapset_contexts_lock;
// debug order that client ops are applied
- map<hobject_t, map<client_t, ceph_tid_t> > debug_op_order;
+ map<hobject_t, map<client_t, ceph_tid_t>, hobject_t::BitwiseComparator> debug_op_order;
void populate_obc_watchers(ObjectContextRef obc);
void check_blacklisted_obc_watchers(ObjectContextRef obc);
}
void put_snapset_context(SnapSetContext *ssc);
- map<hobject_t, ObjectContextRef> recovering;
+ map<hobject_t, ObjectContextRef, hobject_t::BitwiseComparator> recovering;
/*
* Backfill
* - are not included in pg stats (yet)
* - have their stats in pending_backfill_updates on the primary
*/
- set<hobject_t> backfills_in_flight;
- map<hobject_t, pg_stat_t> pending_backfill_updates;
+ set<hobject_t, hobject_t::BitwiseComparator> backfills_in_flight;
+ map<hobject_t, pg_stat_t, hobject_t::BitwiseComparator> pending_backfill_updates;
void dump_recovery_info(Formatter *f) const {
f->open_array_section("backfill_targets");
}
{
f->open_array_section("backfills_in_flight");
- for (set<hobject_t>::const_iterator i = backfills_in_flight.begin();
+ for (set<hobject_t, hobject_t::BitwiseComparator>::const_iterator i = backfills_in_flight.begin();
i != backfills_in_flight.end();
++i) {
f->dump_stream("object") << *i;
}
{
f->open_array_section("recovering");
- for (map<hobject_t, ObjectContextRef>::const_iterator i = recovering.begin();
+ for (map<hobject_t, ObjectContextRef, hobject_t::BitwiseComparator>::const_iterator i = recovering.begin();
i != recovering.end();
++i) {
f->dump_stream("object") << i->first;
void recover_got(hobject_t oid, eversion_t v);
// -- copyfrom --
- map<hobject_t, CopyOpRef> copy_ops;
+ map<hobject_t, CopyOpRef, hobject_t::BitwiseComparator> copy_ops;
int fill_in_copy_get(
OpContext *ctx,
friend struct C_Copyfrom;
// -- flush --
- map<hobject_t, FlushOpRef> flush_ops;
+ map<hobject_t, FlushOpRef, hobject_t::BitwiseComparator> flush_ops;
/// start_flush takes ownership of on_flush iff ret == -EINPROGRESS
int start_flush(
const hobject_t &begin, const hobject_t &end);
virtual void _scrub(
ScrubMap &map,
- const std::map<hobject_t, pair<uint32_t, uint32_t> > &missing_digest);
+ const std::map<hobject_t, pair<uint32_t, uint32_t>, hobject_t::BitwiseComparator> &missing_digest);
void _scrub_digest_updated();
virtual void _scrub_clear_state();
virtual void _scrub_finish();
// -- proxyread --
map<ceph_tid_t, ProxyReadOpRef> proxyread_ops;
- map<hobject_t, list<OpRequestRef> > in_progress_proxy_reads;
+ map<hobject_t, list<OpRequestRef>, hobject_t::BitwiseComparator> in_progress_proxy_reads;
void do_proxy_read(OpRequestRef op);
void finish_proxy_read(hobject_t oid, ceph_tid_t tid, int r);
if (struct_v < 3) {
// Handle hobject_t upgrade
- map<hobject_t, item> tmp;
- for (map<hobject_t, item>::iterator i = missing.begin();
+ map<hobject_t, item, hobject_t::BitwiseComparator> tmp;
+ for (map<hobject_t, item, hobject_t::BitwiseComparator>::iterator i = missing.begin();
i != missing.end();
) {
if (!i->first.is_max() && i->first.pool == -1) {
missing.insert(tmp.begin(), tmp.end());
}
- for (map<hobject_t,item>::iterator it = missing.begin();
+ for (map<hobject_t,item, hobject_t::BitwiseComparator>::iterator it = missing.begin();
it != missing.end();
++it)
rmissing[it->second.need.version] = it->first;
void pg_missing_t::dump(Formatter *f) const
{
f->open_array_section("missing");
- for (map<hobject_t,item>::const_iterator p = missing.begin(); p != missing.end(); ++p) {
+ for (map<hobject_t,item, hobject_t::BitwiseComparator>::const_iterator p = missing.begin(); p != missing.end(); ++p) {
f->open_object_section("item");
f->dump_stream("object") << p->first;
p->second.dump(f);
bool pg_missing_t::is_missing(const hobject_t& oid, eversion_t v) const
{
- map<hobject_t, item>::const_iterator m = missing.find(oid);
+ map<hobject_t, item, hobject_t::BitwiseComparator>::const_iterator m = missing.find(oid);
if (m == missing.end())
return false;
const pg_missing_t::item &item(m->second);
eversion_t pg_missing_t::have_old(const hobject_t& oid) const
{
- map<hobject_t, item>::const_iterator m = missing.find(oid);
+ map<hobject_t, item, hobject_t::BitwiseComparator>::const_iterator m = missing.find(oid);
if (m == missing.end())
return eversion_t();
const pg_missing_t::item &item(m->second);
void pg_missing_t::add_next_event(const pg_log_entry_t& e)
{
if (e.is_update()) {
- map<hobject_t, item>::iterator missing_it;
+ map<hobject_t, item, hobject_t::BitwiseComparator>::iterator missing_it;
missing_it = missing.find(e.soid);
bool is_missing_divergent_item = missing_it != missing.end();
if (e.prior_version == eversion_t() || e.is_clone()) {
void pg_missing_t::rm(const hobject_t& oid, eversion_t v)
{
- std::map<hobject_t, pg_missing_t::item>::iterator p = missing.find(oid);
+ std::map<hobject_t, pg_missing_t::item, hobject_t::BitwiseComparator>::iterator p = missing.find(oid);
if (p != missing.end() && p->second.need <= v)
rm(p);
}
-void pg_missing_t::rm(const std::map<hobject_t, pg_missing_t::item>::iterator &m)
+void pg_missing_t::rm(const std::map<hobject_t, pg_missing_t::item, hobject_t::BitwiseComparator>::iterator &m)
{
rmissing.erase(m->second.need.version);
missing.erase(m);
void pg_missing_t::got(const hobject_t& oid, eversion_t v)
{
- std::map<hobject_t, pg_missing_t::item>::iterator p = missing.find(oid);
+ std::map<hobject_t, pg_missing_t::item, hobject_t::BitwiseComparator>::iterator p = missing.find(oid);
assert(p != missing.end());
assert(p->second.need <= v);
got(p);
}
-void pg_missing_t::got(const std::map<hobject_t, pg_missing_t::item>::iterator &m)
+void pg_missing_t::got(const std::map<hobject_t, pg_missing_t::item, hobject_t::BitwiseComparator>::iterator &m)
{
rmissing.erase(m->second.need.version);
missing.erase(m);
pg_missing_t *omissing)
{
unsigned mask = ~((~0)<<split_bits);
- for (map<hobject_t, item>::iterator i = missing.begin();
+ for (map<hobject_t, item, hobject_t::BitwiseComparator>::iterator i = missing.begin();
i != missing.end();
) {
if ((i->first.get_hash() & mask) == child_pgid.m_seed) {
if (struct_v < 2) {
if (!soid.is_max() && soid.pool == -1)
soid.pool = pool;
- map<hobject_t, interval_set<uint64_t> > tmp;
+ map<hobject_t, interval_set<uint64_t>, hobject_t::BitwiseComparator> tmp;
tmp.swap(clone_subset);
- for (map<hobject_t, interval_set<uint64_t> >::iterator i = tmp.begin();
+ for (map<hobject_t, interval_set<uint64_t>, hobject_t::BitwiseComparator>::iterator i = tmp.begin();
i != tmp.end();
++i) {
hobject_t first(i->first);
assert(valid_through == l.incr_since);
valid_through = l.valid_through;
- for (map<hobject_t,object>::const_iterator p = l.objects.begin();
+ for (map<hobject_t,object, hobject_t::BitwiseComparator>::const_iterator p = l.objects.begin();
p != l.objects.end();
++p){
if (p->second.negative) {
- map<hobject_t,object>::iterator q = objects.find(p->first);
+ map<hobject_t,object, hobject_t::BitwiseComparator>::iterator q = objects.find(p->first);
if (q != objects.end()) {
objects.erase(q);
}
// handle hobject_t upgrade
if (struct_v < 3) {
- map<hobject_t, object> tmp;
+ map<hobject_t, object, hobject_t::BitwiseComparator> tmp;
tmp.swap(objects);
- for (map<hobject_t, object>::iterator i = tmp.begin();
+ for (map<hobject_t, object, hobject_t::BitwiseComparator>::iterator i = tmp.begin();
i != tmp.end();
++i) {
hobject_t first(i->first);
f->dump_stream("valid_through") << valid_through;
f->dump_stream("incremental_since") << incr_since;
f->open_array_section("objects");
- for (map<hobject_t,object>::const_iterator p = objects.begin(); p != objects.end(); ++p) {
+ for (map<hobject_t,object, hobject_t::BitwiseComparator>::const_iterator p = objects.begin(); p != objects.end(); ++p) {
f->open_object_section("object");
f->dump_string("name", p->first.oid.name);
f->dump_unsigned("hash", p->first.get_hash());
};
WRITE_CLASS_ENCODER(item)
- map<hobject_t, item> missing; // oid -> (need v, have v)
+ map<hobject_t, item, hobject_t::BitwiseComparator> missing; // oid -> (need v, have v)
map<version_t, hobject_t> rmissing; // v -> oid
unsigned int num_missing() const;
void revise_have(hobject_t oid, eversion_t have);
void add(const hobject_t& oid, eversion_t need, eversion_t have);
void rm(const hobject_t& oid, eversion_t v);
- void rm(const std::map<hobject_t, pg_missing_t::item>::iterator &m);
+ void rm(const std::map<hobject_t, pg_missing_t::item, hobject_t::BitwiseComparator>::iterator &m);
void got(const hobject_t& oid, eversion_t v);
- void got(const std::map<hobject_t, pg_missing_t::item>::iterator &m);
+ void got(const std::map<hobject_t, pg_missing_t::item, hobject_t::BitwiseComparator>::iterator &m);
void split_into(pg_t child_pgid, unsigned split_bits, pg_missing_t *omissing);
void clear() {
object_info_t oi;
SnapSet ss;
interval_set<uint64_t> copy_subset;
- map<hobject_t, interval_set<uint64_t> > clone_subset;
+ map<hobject_t, interval_set<uint64_t>, hobject_t::BitwiseComparator> clone_subset;
ObjectRecoveryInfo() : size(0) { }
};
WRITE_CLASS_ENCODER(object)
- map<hobject_t,object> objects;
+ map<hobject_t,object, hobject_t::BitwiseComparator> objects;
eversion_t valid_through;
eversion_t incr_since;
pg_missing_t init;
pg_missing_t final;
- set<hobject_t> toremove;
+ set<hobject_t, hobject_t::BitwiseComparator> toremove;
list<pg_log_entry_t> torollback;
private:
};
struct LogHandler : public PGLog::LogEntryHandler {
- set<hobject_t> removed;
+ set<hobject_t, hobject_t::BitwiseComparator> removed;
list<pg_log_entry_t> rolledback;
void rollback(
}
{
- set<hobject_t>::const_iterator titer = tcase.toremove.begin();
- set<hobject_t>::const_iterator hiter = handler.removed.begin();
+ set<hobject_t, hobject_t::BitwiseComparator>::const_iterator titer = tcase.toremove.begin();
+ set<hobject_t, hobject_t::BitwiseComparator>::const_iterator hiter = handler.removed.begin();
for (; titer != tcase.toremove.end(); ++titer, ++hiter) {
EXPECT_EQ(*titer, *hiter);
}
class MapperVerifier {
PausyAsyncMap *driver;
boost::scoped_ptr< SnapMapper > mapper;
- map<snapid_t, set<hobject_t> > snap_to_hobject;
- map<hobject_t, set<snapid_t> > hobject_to_snap;
+ map<snapid_t, set<hobject_t, hobject_t::BitwiseComparator> > snap_to_hobject;
+ map<hobject_t, set<snapid_t>, hobject_t::BitwiseComparator> hobject_to_snap;
snapid_t next;
uint32_t mask;
uint32_t bits;
for (set<snapid_t>::iterator i = snaps.begin();
i != snaps.end();
++i) {
- map<snapid_t, set<hobject_t> >::iterator j = snap_to_hobject.find(*i);
+ map<snapid_t, set<hobject_t, hobject_t::BitwiseComparator> >::iterator j = snap_to_hobject.find(*i);
assert(j != snap_to_hobject.end());
j->second.insert(obj);
}
Mutex::Locker l(lock);
if (snap_to_hobject.empty())
return;
- map<snapid_t, set<hobject_t> >::iterator snap =
+ map<snapid_t, set<hobject_t, hobject_t::BitwiseComparator> >::iterator snap =
rand_choose(snap_to_hobject);
- set<hobject_t> hobjects = snap->second;
+ set<hobject_t, hobject_t::BitwiseComparator> hobjects = snap->second;
hobject_t hoid;
while (mapper->get_next_object_to_trim(snap->first, &hoid) == 0) {
assert(hobjects.count(hoid));
hobjects.erase(hoid);
- map<hobject_t, set<snapid_t> >::iterator j =
+ map<hobject_t, set<snapid_t>, hobject_t::BitwiseComparator>::iterator j =
hobject_to_snap.find(hoid);
assert(j->second.count(snap->first));
set<snapid_t> old_snaps(j->second);
Mutex::Locker l(lock);
if (hobject_to_snap.empty())
return;
- map<hobject_t, set<snapid_t> >::iterator obj =
+ map<hobject_t, set<snapid_t>, hobject_t::BitwiseComparator>::iterator obj =
rand_choose(hobject_to_snap);
for (set<snapid_t>::iterator i = obj->second.begin();
i != obj->second.end();
++i) {
- map<snapid_t, set<hobject_t> >::iterator j =
+ map<snapid_t, set<hobject_t, hobject_t::BitwiseComparator> >::iterator j =
snap_to_hobject.find(*i);
assert(j->second.count(obj->first));
j->second.erase(obj->first);
Mutex::Locker l(lock);
if (hobject_to_snap.empty())
return;
- map<hobject_t, set<snapid_t> >::iterator obj =
+ map<hobject_t, set<snapid_t>, hobject_t::BitwiseComparator>::iterator obj =
rand_choose(hobject_to_snap);
set<snapid_t> snaps;
int r = mapper->get_snaps(obj->first, &snaps);
projects / ceph.git / commitdiff