Downloaded 15 times
 { // body }; … lambda(); // runs body](https://image.slidesharecdn.com/samrittermongodbworld1-160708200959/75/MongoDB-World-2016-Implementing-Async-Networking-in-MongoDB-3-2-13-2048.jpg)
 { if (err) { return done(op); } receive_task(op); }); }](https://image.slidesharecdn.com/samrittermongodbworld1-160708200959/75/MongoDB-World-2016-Implementing-Async-Networking-in-MongoDB-3-2-15-2048.jpg)
 { if (err) { return done(op); } receive_task(op); }); }](https://image.slidesharecdn.com/samrittermongodbworld1-160708200959/75/MongoDB-World-2016-Implementing-Async-Networking-in-MongoDB-3-2-21-2048.jpg)
 { if (err) { return done(op); } receive_task(op); }); }](https://image.slidesharecdn.com/samrittermongodbworld1-160708200959/75/MongoDB-World-2016-Implementing-Async-Networking-in-MongoDB-3-2-25-2048.jpg)
 { if (err || op->cancelled) return done(op); receive_task(op); }); }](https://image.slidesharecdn.com/samrittermongodbworld1-160708200959/75/MongoDB-World-2016-Implementing-Async-Networking-in-MongoDB-3-2-30-2048.jpg)
Uploaded byMongoDB
MongoDB World 2016: Implementing Async Networking in MongoDB 3.2
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.
MongoDB World 2016: Implementing Async Networking in MongoDB 3.2
- 1. Implementing Async Networking inMongoDB Samantha Ritter MongoDB Engineer
- 2.
- 3.
- 4. connect auth sendrecv done
- 5.
- 6. connect auth sendrecv done
- 7.
- 8.
- 9. connect auth sendrecv done
- 10. {work queue B: send B: recv D:auth A: send F: done
- 11.
- 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.
- 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); }); }
- 16.
- 17.
- 18.
- 19. Network errors arefine: they are on the primary path of execution
- 20. The primary pathcontrols 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.
- 24.
- 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 NOTfine: they are on the secondary path of execution
- 27. On the secondarypath we can’t make assumptions about lifetime
- 28. Only the primarypath can end an operation Rule of ownership:
- 29. // Basic “networkoperation” 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); }); }
- 31.
- 32.
- 33. // Secondary path cancel(NetworkOp*op) { // op could be a null pointer! op->cancelled = true; }
- 34. Operation access isprotected Rule of cooperation:
- 35. // “network operation”class class NetworkOp { bool cancelled; }; // "access control" object class SafeOp { mutex lock; NetworkOp* op; };
- 36.
- 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(); }
- 39.
- 40.
- 41.
- 42.
- 43.
- 44. 2. Use language featureswhere possible
- 45. 3. Use externallibraries where appropriate
- 47.
- 48.
- 49.