MongoDB World 2016: Implementing Async Networking in MongoDB 3.2
1 like814 views
Implementing Async Networking in MongoDB allows operations to complete out of order through asynchronous execution. The document discusses: 1) Using C++11 lambdas and asynchronous I/O to implement a work queue that executes tasks like connect, authenticate, send, receive, and done out of order. 2) Handling network errors on the primary execution path by returning from the async operation. 3) Handling cancellations by checking for a cancelled flag on the secondary execution path and ownership rules to end operations. 4) Ensuring safe concurrent access using mutex locks and shared pointers to operations.
 {
// body
};
…
lambda(); // runs body](https://image.slidesharecdn.com/samrittermongodbworld1-160708200959/85/MongoDB-World-2016-Implementing-Async-Networking-in-MongoDB-3-2-13-320.jpg)
 {
if (err) { return done(op); }
receive_task(op);
});
}](https://image.slidesharecdn.com/samrittermongodbworld1-160708200959/85/MongoDB-World-2016-Implementing-Async-Networking-in-MongoDB-3-2-15-320.jpg)
 {
if (err) { return done(op); }
receive_task(op);
});
}](https://image.slidesharecdn.com/samrittermongodbworld1-160708200959/85/MongoDB-World-2016-Implementing-Async-Networking-in-MongoDB-3-2-21-320.jpg)
 {
if (err) { return done(op); }
receive_task(op);
});
}](https://image.slidesharecdn.com/samrittermongodbworld1-160708200959/85/MongoDB-World-2016-Implementing-Async-Networking-in-MongoDB-3-2-25-320.jpg)
 {
if (err || op->cancelled)
return done(op);
receive_task(op);
});
}](https://image.slidesharecdn.com/samrittermongodbworld1-160708200959/85/MongoDB-World-2016-Implementing-Async-Networking-in-MongoDB-3-2-30-320.jpg)
MongoDB World 2016: Implementing Async Networking in MongoDB 3.2
- 1. Implementing Async Networking in MongoDB Samantha Ritter MongoDB Engineer
- 2. Why?
- 4. connect auth send recv done
- 6. connect auth send recv done
- 9. connect auth send recv done
- 10. {work queue B: send B: recv D: auth A: send F: done
- 11. C++11 lambdas
- 12. Constructs a closure: an unnamed function object capable of capturing variables in scope.
- 13. auto lambda = [capture list](params) { // body }; … lambda(); // runs body
- 14. send
- 15. // the “send” task void send_task(NetworkOp* op) { // pass a lambda to async_send async_send(op->socket, op->command, [op](error_code err) { if (err) { return done(op); } receive_task(op); }); }
- 17. Network Errors
- 19. Network errors are fine: they are on the primary path of execution
- 20. The primary path controls operation lifetime
- 21. // the “send” task void send_task(NetworkOp* op) { // pass a lambda to async_send async_send(op->socket, op->command, [op](error_code err) { if (err) { return done(op); } receive_task(op); }); }
- 22. {work queue B: send B: recv D: auth A: send F: done B: recv XNetwork Error! clean up B
- 23. Cancellations
- 25. // the “send” task void send_task(NetworkOp* op) { // pass a lambda to async_send async_send(op->socket, op->command, [op](error_code err) { if (err) { return done(op); } receive_task(op); }); }
- 26. Cancellations are NOT fine: they are on the secondary path of execution
- 27. On the secondary path we can’t make assumptions about lifetime
- 28. Only the primary path can end an operation Rule of ownership:
- 29. // Basic “network operation” class class NetworkOp { bool cancelled; }; // Primary path if (op->cancelled) { done(op); } // Secondary path cancel(NetworkOp *op) { op->cancelled = true; }
- 30. // the “send” task void send_task(NetworkOp* op) { // pass a lambda to async_send async_send(op->socket, op->command, [op](error_code err) { if (err || op->cancelled) return done(op); receive_task(op); }); }
- 33. // Secondary path cancel(NetworkOp *op) { // op could be a null pointer! op->cancelled = true; }
- 34. Operation access is protected Rule of cooperation:
- 35. // “network operation” class class NetworkOp { bool cancelled; }; // "access control" object class SafeOp { mutex lock; NetworkOp* op; };
- 36. shared_ptr
- 37. // Primary path done(shared_ptr<SafeOp> safe) { // lock before cleanup safe->lock.lock(); // cleanup safe->op = nullptr; safe->lock.unlock(); }
- 38. // Secondary path cancel(shared_ptr<SafeOp> safe) { // once we lock, can’t change under us safe->lock.lock(); if (safe->op) { safe->op->cancelled = true; } safe->lock.unlock(); }
- 40. Why?
- 43. 1. Iterate!
- 44. 2. Use language features where possible
- 45. 3. Use external libraries where appropriate
- 47. @SamWhoCodes
- 49. Thanks!