if (allocated_req && front_req && allocated) {
/* Push dispatch of the first allocated req to a wq */
m_work_queue.queue(new LambdaContext(
- [this, allocated_req](int r) {
+ [allocated_req](int r) {
allocated_req->dispatch();
}), 0);
allocated_req = nullptr;
/* This sync point will acquire no more sub-ops. Activation needs
* to acquire m_lock, so defer to later*/
later.add(new LambdaContext(
- [this, old_sync_point](int r) {
+ [old_sync_point](int r) {
old_sync_point->prior_persisted_gather_activate();
}));
}
* now has its finisher. If the sub is already complete, activation will
* complete the Gather. The finisher will acquire m_lock, so we'll activate
* this when we release m_lock.*/
- later.add(new LambdaContext([this, to_append](int r) {
+ later.add(new LambdaContext([to_append](int r) {
to_append->persist_gather_activate();
}));
std::lock_guard locker(m_lock);
auto write_req_sp = this;
if (sync_point->earlier_sync_point) {
- Context *schedule_append_ctx = new LambdaContext([this, write_req_sp](int r) {
+ Context *schedule_append_ctx = new LambdaContext([write_req_sp](int r) {
write_req_sp->schedule_append();
});
sync_point->earlier_sync_point->on_sync_point_appending.push_back(schedule_append_ctx);
log_entry->init(current_sync_gen, persist_on_flush, last_op_sequence_num);
if (persist_on_flush) {
this->on_write_append = new LambdaContext(
- [this, write_persist, write_append] (int r) {
+ [write_persist, write_append] (int r) {
write_append->complete(r);
write_persist->complete(r);
});