unsigned in_flight;
map<ghobject_t, Object> contents;
set<ghobject_t> available_objects;
+ set<ghobject_t>::iterator next_available_object;
set<ghobject_t> in_flight_objects;
ObjectGenerator *object_gen;
gen_type *rng;
unsigned max_write,
unsigned alignment)
: cid(cid), write_alignment(alignment), max_object_len(max_size),
- max_write_len(max_write), in_flight(0), object_gen(gen),
- rng(rng), store(store) {}
+ max_write_len(max_write), in_flight(0),
+ next_available_object(available_objects.end()),
+ object_gen(gen), rng(rng), store(store) {}
int init() {
ObjectStore::Transaction t;
return queue_transaction(store, ch, std::move(t));
}
void shutdown() {
+ ghobject_t next;
while (1) {
vector<ghobject_t> objects;
- int r = store->collection_list(ch, ghobject_t(), ghobject_t::get_max(),
- 10, &objects, 0);
+ int r = store->collection_list(ch, next, ghobject_t::get_max(),
+ 10, &objects, &next);
ceph_assert(r >= 0);
- if (objects.empty())
- break;
+ if (objects.size() == 0)
+ break;
ObjectStore::Transaction t;
+ std::map<std::string, ceph::buffer::list> attrset;
for (vector<ghobject_t>::iterator p = objects.begin();
- p != objects.end(); ++p) {
- t.remove(cid, *p);
+ p != objects.end(); ++p) {
+ t.remove(cid, *p);
}
queue_transaction(store, ch, std::move(t));
}
return ret;
}
+ ghobject_t get_next_object(std::unique_lock<ceph::mutex>& locker) {
+ cond.wait(locker, [this] {
+ return in_flight < max_in_flight && !available_objects.empty();
+ });
+
+ if (next_available_object == available_objects.end()) {
+ next_available_object = available_objects.begin();
+ }
+
+ ghobject_t ret = *next_available_object;
+ ++next_available_object;
+ return ret;
+ }
+
void wait_for_ready(std::unique_lock<ceph::mutex>& locker) {
cond.wait(locker, [this] { return in_flight < max_in_flight; });
}
return status;
}
+ int set_fixed_attrs(size_t entries, size_t key_size, size_t val_size) {
+ std::unique_lock locker{ lock };
+ EnterExit ee("setattrs");
+ if (!can_unlink())
+ return -ENOENT;
+ wait_for_ready(locker);
+
+ ghobject_t obj = get_next_object(locker);
+ available_objects.erase(obj);
+ ObjectStore::Transaction t;
+
+ map<string, bufferlist> attrs;
+ set<string> keys;
+
+ while (entries--) {
+ bufferlist name, value;
+ filled_byte_array(value, val_size);
+ filled_byte_array(name, key_size);
+ attrs[name.c_str()] = value;
+ contents[obj].attrs[name.c_str()] = value;
+ }
+ t.setattrs(cid, obj, attrs);
+ ++in_flight;
+ in_flight_objects.insert(obj);
+ t.register_on_applied(new C_SyntheticOnReadable(this, obj));
+ int status = store->queue_transaction(ch, std::move(t));
+ return status;
+ }
+
void getattrs() {
EnterExit ee("getattrs");
ghobject_t obj;
}
}
-TEST_P(StoreTestSpecificAUSize, ExcessiveFragmentation) {
- if (string(GetParam()) != "bluestore")
- return;
-
- SetVal(g_conf(), "bluestore_block_size",
- stringify((uint64_t)2048 * 1024 * 1024).c_str());
-
- ASSERT_EQ(g_conf().get_val<Option::size_t>("bluefs_alloc_size"),
- 1024 * 1024U);
-
- size_t block_size = 0x10000;
- StartDeferred(block_size);
-
- int r;
- coll_t cid;
- ghobject_t hoid1(hobject_t(sobject_t("Object 1", CEPH_NOSNAP)));
- ghobject_t hoid2(hobject_t(sobject_t("Object 2", CEPH_NOSNAP)));
- auto ch = store->create_new_collection(cid);
-
- {
- ObjectStore::Transaction t;
- t.create_collection(cid, 0);
- r = queue_transaction(store, ch, std::move(t));
- ASSERT_EQ(r, 0);
- }
- {
- // create 2x400MB objects in a way that their pextents are interleaved
- ObjectStore::Transaction t;
- bufferlist bl;
-
- bl.append(std::string(block_size * 4, 'a')); // 256KB
- uint64_t offs = 0;
- while(offs < (uint64_t)400 * 1024 * 1024) {
- t.write(cid, hoid1, offs, bl.length(), bl, 0);
- t.write(cid, hoid2, offs, bl.length(), bl, 0);
- r = queue_transaction(store, ch, std::move(t));
- ASSERT_EQ(r, 0);
- offs += bl.length();
- if( (offs % (100 * 1024 * 1024)) == 0) {
- std::cout<<"written " << offs << std::endl;
- }
- }
- }
- std::cout<<"written 800MB"<<std::endl;
- {
- // Partially overwrite objects with 100MB each leaving space
- // fragmented and occuping still unfragmented space at the end
- // So we'll have enough free space but it'll lack long enough (e.g. 1MB)
- // contiguous pextents.
- ObjectStore::Transaction t;
- bufferlist bl;
-
- bl.append(std::string(block_size * 4, 'a'));
- uint64_t offs = 0;
- while(offs < 112 * 1024 * 1024) {
- t.write(cid, hoid1, offs, bl.length(), bl, 0);
- t.write(cid, hoid2, offs, bl.length(), bl, 0);
- r = queue_transaction(store, ch, std::move(t));
- ASSERT_EQ(r, 0);
- // this will produce high fragmentation if original allocations
- // were contiguous
- offs += bl.length();
- if( (offs % (10 * 1024 * 1024)) == 0) {
- std::cout<<"written " << offs << std::endl;
- }
- }
- }
- {
- // remove one of the object producing much free space
- // and hence triggering bluefs rebalance.
- // Which should fail as there is no long enough pextents.
- ObjectStore::Transaction t;
- t.remove(cid, hoid2);
- r = queue_transaction(store, ch, std::move(t));
- ASSERT_EQ(r, 0);
- }
-
- auto to_sleep = 5 *
- (int)g_conf().get_val<double>("bluestore_bluefs_balance_interval");
- std::cout<<"sleeping... " << std::endl;
- sleep(to_sleep);
-
- {
- // touch another object to triggerrebalance
- ObjectStore::Transaction t;
- t.touch(cid, hoid1);
- r = queue_transaction(store, ch, std::move(t));
- ASSERT_EQ(r, 0);
- }
- {
- ObjectStore::Transaction t;
- t.remove(cid, hoid1);
- t.remove(cid, hoid2);
- t.remove_collection(cid);
- cerr << "Cleaning" << std::endl;
- r = queue_transaction(store, ch, std::move(t));
- ASSERT_EQ(r, 0);
- }
-}
-
#endif //#if defined(WITH_BLUESTORE)
TEST_P(StoreTest, KVDBHistogramTest) {
EXPECT_EQ(store->umount(), 0);
EXPECT_EQ(store->mount(), 0);
}
+ ch = store->open_collection(cid);
cerr << "Injecting CRC error with no retry, expecting EIO" << std::endl;
SetVal(g_conf(), "bluestore_retry_disk_reads", "0");
gen_type rng(time(NULL));
coll_t cid(spg_t(pg_t(0, 447), shard_id_t::NO_SHARD));
- SyntheticWorkloadState test_obj(store, &gen, &rng, cid, 40 * 1024, 4 * 1024, 0);
+ SyntheticWorkloadState test_obj(store, &gen, &rng, cid, 0, 0, 0);
test_obj.init();
- for (int i = 0; i < 1500; ++i) {
+ size_t object_count = 256;
+ for (size_t i = 0; i < object_count; ++i) {
if (!(i % 10)) cerr << "seeding object " << i << std::endl;
test_obj.touch();
}
- for (int i = 0; i < 10000; ++i) {
+ for (size_t i = 0; i < object_count; ++i) {
if (!(i % 100)) {
cerr << "Op " << i << std::endl;
test_obj.print_internal_state();
}
- boost::uniform_int<> true_false(0, 99);
- test_obj.setattrs();
+ test_obj.set_fixed_attrs(1024, 64, 4096); // 1024 attributes, 64 bytes name and 4K value
}
test_obj.wait_for_done();
+ std::cout << "done" << std::endl;
+ do_check_fn(store);
AdminSocket* admin_socket = g_ceph_context->get_admin_socket();
ceph_assert(admin_socket);
ceph::bufferlist in, out;
ostringstream err;
- bool b = admin_socket->execute_command(
- { "{\"prefix\": \"bluestore bluefs stats\"}" },
+ auto r = admin_socket->execute_command(
+ { "{\"prefix\": \"bluefs stats\"}" },
in, err, &out);
- if (!b) {
- cerr << "failure querying " << std::endl;
+ if (r != 0) {
+ cerr << "failure querying: " << cpp_strerror(r) << std::endl;
+ } else {
+ std::cout << std::string(out.c_str(), out.length()) << std::endl;
}
- std::cout << std::string(out.c_str(), out.length()) << std::endl;
do_check_fn(store);
test_obj.shutdown();
}
BlueStore* bstore = dynamic_cast<BlueStore*> (_store);
ceph_assert(bstore);
+ bstore->compact();
const PerfCounters* logger = bstore->get_bluefs_perf_counters();
//experimentally it was discovered that this case results in 400+MB spillover
//using lower 300MB threshold just to be safe enough
- ASSERT_GE(logger->get(l_bluefs_slow_used_bytes), 300 * 1024 * 1024);
+ std::cout << "db_used:" << logger->get(l_bluefs_db_used_bytes) << std::endl;
+ std::cout << "slow_used:" << logger->get(l_bluefs_slow_used_bytes) << std::endl;
+ // Disabling any validation/assertion for now as it looks like
+ // we're unable to 100% force RocksDB to spillover.
+ // Leaving test case hoping to fix that one day though.
+ //ASSERT_GE(logger->get(l_bluefs_slow_used_bytes), 16 * 1024 * 1024);
}
);
}
BlueStore* bstore = dynamic_cast<BlueStore*> (_store);
ceph_assert(bstore);
+ bstore->compact();
const PerfCounters* logger = bstore->get_bluefs_perf_counters();
ASSERT_EQ(0, logger->get(l_bluefs_slow_used_bytes));
}
BlueStore* bstore = dynamic_cast<BlueStore*> (_store);
ceph_assert(bstore);
+ bstore->compact();
const PerfCounters* logger = bstore->get_bluefs_perf_counters();
ASSERT_LE(logger->get(l_bluefs_slow_used_bytes), 300 * 1024 * 1024); // see SpilloverTest for 300MB choice rationale
}
projects / ceph.git / blobdiff