- Boost - lists.boost.org

Boost Storytellers: Unordered
by Christian Mazakas 21 Jun '23

21 Jun '23

Hey everyone, I figured I'd take some time to talk about Unordered and where it's at. At the time of writing, Unordered's develop branch has been updated to include a new container: `boost::concurrent_flat_map`. A high-level description of the container and its algorithms can be found here: https://www.boost.org/doc/libs/develop/libs/unordered/doc/html/unordered.ht… It's been an honor and a privilege to develop alongside our own Joaquín M López Muñoz and Peter Dimov. While the advancements done to the algorithms themselves are note-worthy, what's not often talked about is taming implementation complexity. After all, algorithms don't mean much until they're translated to code. Boost.Unordered offers several different containers, all each a similar flavor of one another. The broad categorization is closed-addressing containerss, open-addressing containers and finally the concurrent containers, which are in actuality a subset of the open-addressing ones. The closed-adressing (CA) containers are the most straight-forward to abstract over as an `unordered_map` and `unordered_multimap` only differ in terms of how insertion is performed. Internally, the CA containers simply wrap a `table` struct that's templated over a Types policy-like which is used for pulling relevant typedefs from. Though I must confess, the `table` itself does contain myriad member functions such as `equals_unique` and `equal_equiv` which are used when comparing the tables themselves via `operator==`. The open-addressing (OA) containers are spiritually similar to the CA containers in that they wrap a simple common table type with a type policy template parameter used for pulling typedefs from in the relevant spots. But what makes the OA containers a good bit more nuanced is that there's both a `unordered_flat_map` and a `unordered_node_map`. The implementation complexity increases a good amount here. The CA containers all operate in terms of a simple `node`-like type that contains the appropriate `value_type` but the OA containers must abstract away a good bit more. The flat OA containers store their `value_type`s directly in a contiguous allocation so that lookup operations benefit from spatial locality in addition to being much more simple to manage from an implementation perspective. To support `unordered_node_map`, we have to update the type that's stored to be a `unique_ptr`-like. This essentially further extends the type policies already used by the containers to abstract over the storage type, the actual value type and how those values are accessed from a pointer to the storage type. This includes construction, destruction and dereferencing. The concurrent map adds yet another layer of abstraction but this time, in a much different spot and required a much larger holistic refactor of the codebase. The fundamental differences in container types require abstracting over how the table reads and inserts elements itself so we introduce an extra table layer. Previously there was but a single table type that supported all of the OA containers but now there's two table types that instead wrap a common `table_core` which contains common table primitives. The `concurrent_table` is responsible for managing its own locking schemes and then dispatches internally to its `table_core` and similarly for the `table` used by the non-concurrent containers. The OA containers are essentially implemented in 3 layers with the `table_core` being the lowest layer and the user-facing containers as the highest, with the specific middle layer being responsible for managing atomicity for the concurrent map and for providing things like iterators for the flat/node containers (the concurrent map offers no iterators). On paper it sounds relatively complex but in practice, navigating the code with this kind of foresight is easy and straight-forward, even more so now that GitHub's UI allows you to view and jump to struct definitions. Taming such implementation complexity into a neat and organized set of traits was definitely something beyond my skilset so I'm happy Joaquin was able to navigate such waters and I have a humbled understanding of policy-based design and how powerful it can be when applied properly. There's a couple of other things to note about the implementation that Boost authors may like. One is that we do allocator-aware constrution of a stack-local in emplace(). This is so that we can avoid a heap-allocation when doing lookup in the node-based OA containers. Originally, we actually didn't allocator-construct the stack-local but this turned out to be wholly incorrect because we'd move the stack-local to the heap when the key wasn't present in the container. This could lead to subtle bugs like not passing the memory resource when a user is using `std::pmr`. Another interesting aspect is that we recently updated the `erase(const_iterator)` method of the OA containers to return a proxy type. For performance reasons, the signature was originally `void erase(const_iterator)` but users found this cumbersome and annoying to work with as they'd often times swap containers entirely via a typedef. We now return a proxy type that lazily increments the internal iterator via implicit conversion to the container's iterator type. To this end, we're able to essentially have our cake and eat it too at the cost of making always-auto subtly confusing. I'm more than happy to talk about any other implementation strategies or answer questions if anyone is interested in the nitty gritty and can offer potential optimizations. - Christian

1 0

Re: [boost] charconv for C++11
by Gero Peterhoff 05 Jun '23

05 Jun '23

Hi Matt, thanks for your efforts. I have a few questions though: - Will charconv be included in boost 1.83 or which release is planned ? - Could you still include support for C++23 FP types (std::floatN_t) ? - Would it be possible to implement the FP functions constexpr ? thx & regards Gero

2 1

Windows Develop Regression Tests Failing - Boost Build?
by Tom Kent 04 Jun '23

04 Jun '23

When trying to run the regression tests for the develop branch from windows, I'm getting the following error: C:/teeks99-09/run/boost_bb/src/build\project.jam:284: in find-jamfile from module project error: Unable to load Jamfile. error: Could not find a Jamfile in directory '../../C:/teeks99-09/run/boost_root'. error: Attempted to find it with pattern '[Bb]uild.jam [Jj]amfile.v2 [Jj]amfile [Jj]amfile. [Jj]amfile.jam'. error: Please consult the documentation at 'https://www.bfgroup.xyz/b2/'. C:/teeks99-09/run/boost_bb/src/build\project.jam:347: in load-jamfile from module project C:/teeks99-09/run/boost_bb/src/build\project.jam:64: in load from module project C:/teeks99-09/run/boost_bb/src/build\project.jam:105: in load-used-projects from module project C:/teeks99-09/run/boost_bb/src/build\project.jam:75: in load from module project C:/teeks99-09/run/boost_bb/src/build\project.jam:134: in load-parent from module project C:/teeks99-09/run/boost_bb/src/build\project.jam:538: in initialize from module project C:/teeks99-09/run/boost_bb/src/build\project.jam:373: in load-jamfile from module project C:/teeks99-09/run/boost_bb/src/build\project.jam:64: in load from module project C:/teeks99-09/run/boost_bb/src/build\project.jam:167: in project.find from module project C:/teeks99-09/run/boost_bb/src\build-system.jam:618: in load from module build-system C:/teeks99-09/run/boost_bb/src/kernel\modules.jam:294: in import from module modules C:/teeks99-09/run/boost_bb/src/kernel/bootstrap.jam:135: in module scope from module It looks like the last good run I had was on march 11, which corresponds to the same day as this commit to that project.jam: https://github.com/boostorg/build/commit/fda357a8f55a08535afff0a11eec50fca1… That file doesn't mean much to me, is it possible it is causing the issue? Thanks, Tom

3 4

Moving sp_thread_pause, sp_thread_sleep to Core
by Christian Mazakas 02 Jun '23

02 Jun '23

Unordered's concurrent flat map contains a hand-rolled spinlock (graciously provided by Peter Dimov) but it contains a dependency on SmartPtr for the following two headers: #include <boost/smart_ptr/detail/sp_thread_pause.hpp> #include <boost/smart_ptr/detail/sp_thread_sleep.hpp> I advocate that we move these to Core. They're small, self-contained and are useful in broader contexts. Anyone have thoughts or objections? - Christian

5 14

git hub discussions.
by Robert Ramey 31 May '23

31 May '23

As an experiment, I've added to github discussions for the safe_numerics library. The idea is to provide a place for feedback from users of the library. I'd be curious to hear other persons thoughts on this. https://github.com/boostorg/safe_numerics/discussions/133 Robert Ramey

4 5

Re: [boost] Boost.Compat
by Peter Dimov 31 May '23

31 May '23

Ruben Perez wrote: > > So my suggestion is to create a separate library/repo, Boost.Compat > > (boostorg/compat, namespace boost::compat) for them. > > > > Thoughts? (Be sure to read the discussion in the PR as well.) > > > > I'm in favor of this. I agree with not allowing extensions, too. > > I think a light review should take place before inclusion. The suggested repository is now ready for light review at https://github.com/boostorg/compat, complete with its first component, an implementation of std::latch by Christian Mazakas. Everyone's light reviews are welcome.

6 13

Sam review scheduled
by Ruben Perez 20 May '23

20 May '23

Hi all, I'm happy to announce that the Sam library, featuring asio-based synchronization primitives, is being proposed for Boost inclusion. Repo: https://github.com/klemens-morgenstern/sam Docs: https://klemens.dev/sam/ The library is being proposed by Klemens Morgenstern. The review will take place between May the 29th (Monday) and June the 8th (Thursday). I will be managing the review. Boost.Sam offers async asio-based synchronization primitives, similar to standard mutex, condition_variable, semaphore and barrier. It's geared towards library writers that require fine-grain control over their synchronization operations. You can contact both me and the author by mail or on the cpplang Slack. Kind regards, Ruben.

4 7

Re: [boost] boost 1.82.0
by John Maddock 16 May '23

16 May '23

On 16/05/2023 02:39, Prabhakar Bhatt via Boost wrote: > Hi All, > > Recently we upgraded to Boost 1.82.0. > > We compiled the boost as : > > ./bootstrap.sh > --with-libraries=filesystem,system,program_options,iostreams,log,regex,stacktrace,thread > --without-icu > > When we tried to use the regex library and build Avro product we are > getting following error: > > Boost/boost_1_82_0/include/boost/regex/v4/cpp_regex_traits.hpp:1117: > undefined reference to > `boost::scoped_static_mutex_lock::scoped_static_mutex_lock(boost::static_mutex&, > bool)' > > Please can you help us in addressing the issue. Regex is now header only, *unless* you are building with a C++03 compiler (which is now deprecated), and will require linking to the external libboost_regex. John.

1 0

Re: [boost] Determine socket is ipv4 or ipv6
by Gavin Lambert 16 May '23

16 May '23

On 16/05/2023 15:26, Tarun Batra wrote: > I have a code something like this: > > TcpConnection::pointer my_conn = GetConn(req); > > tcp::socket& my_socket = my_conn->getSocket(); > > tcp::resolver my_resolver(my_socket.get_executor()); > > > Is it possible to check if the my_socket is ipv4 socket or ipv6 socket? That depends exactly what you mean by that, but you're likely looking for something like: my_socket.remote_endpoint().address().is_v6() Doxygen doesn't do a very good job at navigating the type templates involved here; using your IDE's code completion is more successful.

1 0

Reference section of Boost.Any leads to Boost.PFR
by Antony Polukhin 15 May '23

15 May '23

Hi, Just noted that clicking on "->" arrow at the developer preview of Boost.Any https://www.boost.org/doc/libs/develop/doc/html/any/ValueType.html leads to Boost.PFR reference section. No idea how is that possible. I'd appreciate help

1 0