Tweets

You blocked @lewissbaker

Are you sure you want to view these Tweets? Viewing Tweets won't unblock @lewissbaker

  1. Retweeted
    Jan 31

    A Universal I/O Abstraction for C++ New blog post about executors, asynchronous I/O, io_uring, coroutines and more ! ➡️ ⬅️

    Undo
  2. Retweeted
    Jan 20

    This paper by should go a long way toward answering the question: Is the sender/receiver pattern from p0443 fast? Answer: Yes, definitely. Many thanks to Niall for demonstrating how to max out an OS's low-level IO with sender/receiver.

    Undo
  3. Retweeted
    1 Nov 2019

    New Blog Post A Universal Async Abstraction for C++

    Show this thread
    Undo
  4. Retweeted
    23 Oct 2019

    Here are a couple of papers aiming to improve customization points in C++ - - (also ) Ship it. Ship _something_ . The current state of affair is unwieldy 😢

    Undo
  5. Retweeted

    Among the best and most enlightening presentations I've ever seen. Anyone interested in asynchronous programming should give this a watch. Great work and !

    Undo
  6. 5 Oct 2019

    Great talk by and on “A Unifying Abstraction for Async in C++”. Explains why eager futures are slow and why using lazy futures can be more efficient. Also one of the clearest explainations of concurrency vs parallelism.

    Undo
  7. Retweeted
    3 Oct 2019

    CppCon 2019: Adi Shavit “Generators, Coroutines and Other Brain Unrolling Sweetness”

    Undo
  8. 2 Oct 2019

    Treating an executor transition as just another async operation allows us to compose executor transitions with other async operations in a generic way. We can use the same tools available for working with any async operations. We don’t need to treat executors differently.

    Show this thread
    Undo
  9. 2 Oct 2019

    In some sense, any abstraction over a queue of items is a “kind” of executor. e.g. An async_mutex holds a queue of continuations waiting to acquire the lock. Its “schedule” operation happens to be named m.lock_async() and the next item is dequeued when someone calls m.unlock().

    Show this thread
    Undo
  10. 2 Oct 2019

    Executors can be thought of as a queue. They provide an async operation, “schedule”, that enqueues an item when launched. The “schedule” operation completes when some thread dequeues the item and calls the operation’s continuation, which is now running on the executor’s thread.

    Show this thread
    Undo
  11. 19 Jul 2019
    Undo
  12. Retweeted

    Third and final talk is: Eric Niebler () - A Unifying Abstraction for Async in C++ (June 11th 18:40 CEST)

    Show this thread
    Undo
  13. Retweeted

    Next week I'm organizing next in Prague! This time with and ! We will talk about modules and async. The event will be streamed (with links provided on the meetup twitter page soon). If you are in the area, visit us!

    Undo
  14. 20 Jun 2019

    Hot Take: co_await == (call/cc) An awaitable object is like a function that is invoked with the continuation of the call expression. The coroutine_handle is like a callback that when invoked resumes the coroutine using the callback argument as the result of co_await expression.

    Undo
  15. 25 Mar 2019
    This Tweet is unavailable.
    Undo
  16. Retweeted
    11 Mar 2019

    Join us live, tomorrow, at 9pm GMT/ 2pm PDT, as we chat with about Coroutines, as has just been merged into the C++20 working draft.

    Undo
  17. 7 Dec 2018

    From the C++ WD [except.ctor]: > ... If an exception is thrown during the destruction of temporaries or local variables for a return statement, the destructor for the returned object (if any) is also invoked. ...

    Show this thread
    Undo
  18. 5 Dec 2018

    For some context - I was wondering what the behaviour should be if an exception is thrown during destruction/cleanup of local state in a coroutine after a co_return. I thought it should be consistent with normal functions. Now I'm not so sure...

    Show this thread
    Undo
  19. 4 Dec 2018

    MSVC calls the destructor for the return-value in the first case, but not in the second. Is this a bug in three major compilers or am I just entering UB territory by throwing from a destructor?

    Show this thread
    Undo
  20. 4 Dec 2018

    What should happen in if an exception is thrown from a local variable destructor called after executing a return statement? What if the exception is caught and a new value returned? GCC/Clang doesn't destruct first return-value in both cases:

    Show this thread
    Undo

Loading seems to be taking a while.

Twitter may be over capacity or experiencing a momentary hiccup. Try again or visit Twitter Status for more information.

    You may also like

    ·