Folly VS cppcoro

Compare Folly vs cppcoro and see what are their differences.

Folly

An open-source C++ library developed and used at Facebook. (by facebook)

cppcoro

A library of C++ coroutine abstractions for the coroutines TS (by lewissbaker)
Our great sponsors
  • WorkOS - The modern identity platform for B2B SaaS
  • InfluxDB - Power Real-Time Data Analytics at Scale
  • SaaSHub - Software Alternatives and Reviews
Folly cppcoro
88 24
26,949 3,190
1.0% -
9.8 0.0
about 13 hours ago 3 months ago
C++ C++
Apache License 2.0 MIT License
The number of mentions indicates the total number of mentions that we've tracked plus the number of user suggested alternatives.
Stars - the number of stars that a project has on GitHub. Growth - month over month growth in stars.
Activity is a relative number indicating how actively a project is being developed. Recent commits have higher weight than older ones.
For example, an activity of 9.0 indicates that a project is amongst the top 10% of the most actively developed projects that we are tracking.

Folly

Posts with mentions or reviews of Folly. We have used some of these posts to build our list of alternatives and similar projects. The last one was on 2024-02-29.
  • A lock-free ring-buffer with contiguous reservations (2019)
    9 projects | news.ycombinator.com | 29 Feb 2024
    My interpretation is that with release semantics for the store, the 2nd read (load) in Thread 1 is actually allowed to be reordered before the release store to the hazard pointer. But they are not very explicit about it.

    > So if thread 2 removing the pointer happens first, thread 1 will see a different value on its second read and not attempt to dereference it.

    Thread 1 will see thread 2's remove even with release semantics for that store -- the store has a data dependency on the first load; they cannot be reordered.

    > If thread 1 writes to its hazard pointer first, the garbage collector is guaranteed to see that value and not delete the node.

    Yeah, this must be it. Thread 1 fails to notice the GC happened while it was writing its HP because its second load actually happened before the HP store.

    Folly's hazard pointer implementation uses a release store to update the hazard pointer (here: reset_protection()), but uses some sort of SeqCst barrier between the store and the 2nd load (with acquire semantics): https://github.com/facebook/folly/blob/main/folly/synchroniz...

    9 projects | news.ycombinator.com | 29 Feb 2024
    To set a HP on Linux, Folly just does a relaxed load of the src pointer, release store of the HP, compiler-only barrier, and acquire load. (This prevents the compiler from reordering the 2nd load before the store, right? But to my understanding does not prevent a hypothetical CPU reordering of the 2nd load before the store, which seems potentially problematic!)

    Then on the GC/reclaim side of things, after protected object pointers are stored, it does a more expensive barrier[0] before acquire-loading the HPs.

    I'll admit, I am not confident I understand why this works. I mean, even on x86, loads can be reordered before earlier program-order stores. So it seems like the 2nd check on the protection side could be ineffective. (The non-Linux portable version just uses an atomic_thread_fence SeqCst on both sides, which seems more obviously correct.) And if they don't need the 2nd load on Linux, I'm unclear on why they do it.

    [0]: https://github.com/facebook/folly/blob/main/folly/synchroniz...

    (This uses either mprotect to force a TLB flush in process-relevant CPUs, or the newer Linux membarrier syscall if available.)

  • Appending to an std:string character-by-character: how does the capacity grow?
    2 projects | news.ycombinator.com | 26 Oct 2023
    folly provides functions to resize std::string & std::vector without initialization [0].

    [0] https://github.com/facebook/folly/blob/3c8829785e3ce86cb821c...

  • A Compressed Indexable Bitset
    6 projects | news.ycombinator.com | 1 Jul 2023
    > How is that relevant?

    Roaring bitmaps and similar data structures get their speed from decoding together consecutive groups of elements, so if you do sequential decoding or decode a large fraction of the list you get excellent performance.

    EF instead excels at random skipping, so if you visit a small fraction of the list you generally get better performance. This is why it works so well for inverted indexes, as generally the queries are very selective (otherwise why do you need an index?) and if you have good intersection algorithms you can skip a large fraction of documents.

    I didn't follow the rest of your comment, select is what EF is good at, every other data structure needs a lot more scanning once you land on the right chunk. With BMI2 you can also use the PDEP instruction to accelerate the final select on a 64-bit block: https://github.com/facebook/folly/blob/main/folly/experiment...

    6 projects | news.ycombinator.com | 1 Jul 2023
    The EF core algorithm implemented in folly [3] may be a bit faster, and implementing partitioning on top of that is relatively easy.

    It would definitely compress much better than roaring bitmaps. In terms of performance, it depends on the access patterns. If very sparse (large jumps) PEF would likely be faster, if dense (visit a large fraction of the bitmap) it'd be slower.

    It is possible to squeeze a bit more compression out of PEF by introducing a chunk type for Elias-Fano of the chunk complement (for very dense chunks), but you lose the operation of skipping to a given position, which is however not needed in inverted indexes (you only need to skip past a given id, and that can be supported efficiently). That is not mentioned in the paper because at the time I thought the skip-to-position operation was a non-negotiable.

    [1] https://github.com/ot/ds2i/

    [2] https://github.com/pisa-engine/pisa

    [3] https://github.com/facebook/folly/blob/main/folly/experiment...

  • How a Single Line of Code Made a 24-Core Server Slower Than a Laptop
    4 projects | news.ycombinator.com | 17 Jun 2023
    Can't speak for abseil and tbb, but in folly there are a few solutions for the common problem of sharing state between a writer that updates it very infrequently and concurrent readers that read it very frequently (typical use case is configs).

    The most performant solutions are RCU (https://github.com/facebook/folly/blob/main/folly/synchroniz...) and hazard pointers (https://github.com/facebook/folly/blob/main/folly/synchroniz...), but they're not quite as easy to use as a shared_ptr [1].

    Then there is simil-shared_ptr implemented with thread-local counters (https://github.com/facebook/folly/blob/main/folly/experiment...).

    If you absolutely need a std::shared_ptr (which can be the case if you're working with pre-existing interfaces) there is CoreCachedSharedPtr (https://github.com/facebook/folly/blob/main/folly/concurrenc...), which uses an aliasing trick to transparently maintain per-core reference counts, and scales linearly, but it works only when acquiring the shared_ptr, any subsequent copies of that would still cause contention if passed around in threads.

    [1] Google has a proposal to make a smart pointer based on RCU/hazptr, but I'm not a fan of it because generally RCU/hazptr guards need to be released in the same thread that acquired them, and hiding them in a freely movable object looks like a recipe for disaster to me, especially if paired with coroutines https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2020/p05...

  • Ask HN: What are some of the most elegant codebases in your favorite language?
    37 projects | news.ycombinator.com | 17 Jun 2023
    Not sure if it's still the case but about 6 years ago Facebook's folly C++ library was something I'd point to for my junior engineers to get a sense of "good" C++ https://github.com/facebook/folly
  • DynaMix 2.0.0 Released
    8 projects | /r/cpp | 13 Apr 2023
    https://github.com/facebook/folly/blob/master/folly/docs/Poly.md Folly.Poly
  • Deduplicating a Slice in Go
    3 projects | news.ycombinator.com | 12 Apr 2023
    Most modern hash map designs don't do this weird shuffle with buckets and linked lists because pointer chasing is super expensive.

    https://doc.rust-lang.org/std/collections/struct.HashMap.htm...

    Because it's documenting the actual API in the standard this even spells out that the result has "at least the specified capacity"

    https://github.com/facebook/folly/blob/main/folly/container/...

    F14 is a linear map but I couldn't immediately find actual API documentation, however it should have the same property where if you ask for an F14 with specific capacity or you reserve enough capacity, that's an "at least" promise not an approximate one.

  • rust-like traits on plain C++ with short macro (type erasure actually)
    5 projects | /r/cpp | 7 Apr 2023
    Or dyno or Poly or Not-Actually-Boost.TE or ...

cppcoro

Posts with mentions or reviews of cppcoro. We have used some of these posts to build our list of alternatives and similar projects. The last one was on 2023-05-13.
  • Struggle with C++ 20 Coroutines
    2 projects | /r/cpp_questions | 13 May 2023
    PS: Take a look at cppcoro; this might help as well, especially generator<>, if you're looking to generate numbers, and stuff;
  • Stop Comparing Rust to Old C++
    10 projects | /r/cpp | 31 Jan 2023
    Kind of sounds like whatever library you were using provided leaky abstractions. Something like cppcoro provides really good abstractions for coroutines, the user really doesn't need to understand why any of it works.
  • Sane coroutine imitation with macros; copyable, serializable, and with reflection
    4 projects | /r/cpp | 22 Jan 2023
    Is there a usecase for copying/serializing such coroutines? If not, I would use the normal C++20 coroutines (cppcoro?).
    4 projects | /r/cpp | 22 Jan 2023
    The goal wasn't as much to simplify C++20 coroutines (then one would build on top of them, e.g. see cppcoro), but to bring copyability and reflection to coroutines: hence a custom reimplementation.
  • My experience with C++ 20 coroutines
    7 projects | /r/cpp | 1 Aug 2022
  • My thoughts and dreams about a standard user-space I/O scheduler
    4 projects | /r/cpp | 28 Apr 2022
    Because the whole application is running under a single thread there is no need for atomic operations in synchronization primitives(which most of the time requires seq_cst memory order and CMPXCHG which is an expensive instruction in CPU). for example what async_mutex would look like if it knows it's running in a single-threaded scheduler (a non-atomic state variable and waiters queue).
  • [Discussion] What are some old C++ open source projects you wish were still active?
    10 projects | /r/cpp | 5 Apr 2022
    Maybe not old, but I wish cppcoro was still updated. It was such a nice start!
  • A high-level coroutine explanation
    2 projects | /r/cpp | 21 Jan 2022
    You can get generator<> from https://github.com/lewissbaker/cppcoro
  • C++ Coroutines Do Not Spark Joy
    6 projects | news.ycombinator.com | 1 Nov 2021
    It is possible to compose them more easily than described in the article; Lewis Baker's cppcoro library for example provides a recursive_generator<> type[0] that allows this without using any macros. It's up to the library part of coroutines to make things easy, end users are not expected to write low-level coroutine code themselves.

    I wonder about the allocation elision. Return value optimization became mandatory, and some compilers can already elide calls to new/delete and malloc()/free() in normal code, so perhaps it will be possible to guarantee allocation elision in the future in the most used cases.

    [0]: https://github.com/lewissbaker/cppcoro#recursive_generatort

    6 projects | news.ycombinator.com | 1 Nov 2021
    This article discusses things that are totally irrelevant to someone who will actually use coroutines, because they will use https://github.com/lewissbaker/cppcoro or wait for C++23 to give them the library support for coroutines, which will make usage simple, like the first code snippet from the article.

What are some alternatives?

When comparing Folly and cppcoro you can also consider the following projects:

abseil-cpp - Abseil Common Libraries (C++)

Boost - Super-project for modularized Boost

Seastar - High performance server-side application framework

parallel-hashmap - A family of header-only, very fast and memory-friendly hashmap and btree containers.

libunifex - Unified Executors

EASTL - Obsolete repo, please go to: https://github.com/electronicarts/EASTL

Qt - Qt Base (Core, Gui, Widgets, Network, ...)

OpenFrameworks - openFrameworks is a community-developed cross platform toolkit for creative coding in C++.

drogon - Drogon: A C++14/17/20 based HTTP web application framework running on Linux/macOS/Unix/Windows

C-Coroutines - Coroutines for C.

Cinder - Cinder is a community-developed, free and open source library for professional-quality creative coding in C++.

Flow - Flow is a software framework focused on ease of use while maximizing performance in closed closed loop systems (e.g. robots). Flow is built on top of C++ 20 coroutines and utilizes modern C++ techniques.