- Boost-users - lists.preview.boost.org

Please remove me from this list
by Vitaly Budovski 03 Jul '23

03 Jul '23

The web and email unsubscribe methods do not seem to work.

1 0

[python][shared_ptr_from_python.hpp] looks like copy/paste or merge error
by Ran Regev 29 Jun '23

29 Jun '23

Hi, The code in construct() seems to surfer from copy/paste or merge error. It seems as though the following lines are duplicated in the else clause: void *const storage = ((converter::rvalue_from_python_storage<SP<T> >*)data)->storage.bytes; // Deal with the "None" case. if (data->convertible == source) new (storage) SP<T>(); Please take a look at: https://www.boost.org/doc/libs/1_82_0/boost/python/converter/shared_ptr_fro… Ran.

1 0

[multiprecision] why 128 bit numbers isn't used in msvc?
by shar yashuv Giat 29 Jun '23

29 Jun '23

msvc added 128 bit numbers(in the header __msvc_int128.hpp). I know multiprecision uses __128 to improve performance so why doesn't it use msvc version? it's seems easy to change and will probably improve performance.

2 1

assign a large integer to a cpp_int
by Matthew Mawson 27 May '23

27 May '23

I want to assign a large number to a cpp_int variable like this: cpp_int large = 30414093201713378043612608166064768844377641568960512000000000000; and I get this: error: integer literal is too large to be represented in any integer type. Thanks!

2 1

Abwesenheitsnachricht: assign a large integer to a cpp_int
by Sören Textor 27 May '23

27 May '23

Derzeit bin ich nicht im Hause Ihre E-Mail wird nicht weitergeleitet. In dringenden Fällen bitte support(a)ditec-gmbh.de oder Telefonhotline +49-6221-31698-110 oder die Zentrale +49-6221-31698-0 kontaktieren. Mit freundlichen Grüßen Dr. Sören Textor ----------------------------------------------- DiTEC Dr. Siegfried Kahlich & Dierk Langer GmbH Im Breitspiel 19 | 69126 Heidelberg | Germany Handelsregister | Mannheim | HRB 341229 Dieses Dokument ist vertraulich zu behandeln. Die Weitergabe, sowie Vervielfältigung, Verwertung und Mitteilung seines Inhalts ist nur mit unserer ausdrücklichen Genehmigung gestattet. Alle Rechte vorbehalten, insbesondere für den Fall der Schutzrechtsanmeldung. This document has to be treated confidentially. Its contents are not to be passed on, duplicated, exploited or disclosed without our express permission. All rights reserved, especially the right to apply for protective rights.

1 0

[boost::locale::generator] Calling boost::locale::generator results in an exception in EnterCriticalSection
by M L 24 May '23

24 May '23

Hello, calling boost::locale::generator results in an exception in EnterCriticalSection. Does anybody have a hint to the cause of this problem? Every small clue is welcome. What could be a possible workaround? What is usually the reason for an exception in EnterCriticalSection? Code snippet: boost::locale::generator generator; generator.add_messages_path("..."); generator.add_messages_domain(".."); std::string lngCode = "en"; std::locale = generator(lngCode + ".WINDOWS-1252"); // this line crashes -> 0x0000005 EnterCriticalSection Boost Version: (boost_1_60_0) Visual Studio 2013 Some more hints: - it seems that there is a problem reading the translation file, which works fine in other applications. - there are no threads in the code - the problem is project dependent. Same code works in a different project. - the problem only appears if a specific header is included, but nothing in this header is ever executed before the crash. Removing the header/cpp removes the problem. - some C code is present in the code - the problem even appears when moving the snipped in main. Thanks for help.

2 1

Boost ASIO: Problems building a conditional variable using io_context / strand
by Suraaj K S 23 May '23

23 May '23

Hi all, In boost-asio, I realized that there was no easy way to have something that resembles a condition variable. However, I realized that I could get something very similar using stackful coroutines ( https://www.boost.org/doc/libs/1_66_0/doc/html/boost_asio/overview/core/spa…), while using an io_context as a 'queue' for completion tokens. Below is my approach: *#include "asio_types.hpp"#include <atomic>#include <iostream>class async_pending_queue {public: async_pending_queue() : pending_handlers_(0), strand_(pending_queue_), wg_(asio::make_work_guard(pending_queue_)) {} template <typename CompletionToken> auto async_submit( CompletionToken &&token, std::function<void(void)> atomic_action = [] {}) { auto init = [this, &atomic_action](auto completion_handler) { auto posted_lambda = [handler = std::move(completion_handler), this]() mutable { pending_handlers_--; asio_sys_err ec; handler(ec); }; post(strand_,std::move(posted_lambda)); pending_handlers_++; atomic_action(); }; return asio::async_initiate<CompletionToken, void(asio_sys_err)>(init, token); } int pending_count() { return pending_handlers_.load(); } // It may not run 1 and run 0 bool try_run_one() { auto cnt = pending_queue_.poll_one(); std::cout << "completion token result" << cnt << std::endl; bool ret = (cnt == 1); return ret; }private: std::atomic<unsigned int> pending_handlers_; asio_ioctx pending_queue_; asio_ioctx::strand strand_; decltype(asio::make_work_guard(pending_queue_)) wg_;};* Here, one simply uses calls `my_async_pending_queue.async_submit(yield)`, if calling from a stackful coroutine. The coroutine can be continued by calling `my_async_pending_queue.try_run_one()`. Using this, I wanted to build a 'memory checker'. It has two functions -> `request_space` and `free_space`. A coroutine calls `request_space`, which may block if there is no space left. Meanwhile, another thread / coroutine can call `free_space`, which will run blocked coroutines if possible. I built a toy memory checker wrapper as follows: *#ifndef MEM_CHECK_HPP#define MEM_CHECK_HPP#include <cstddef>#include <mutex>#include <queue>#include <boost/asio.hpp>#include <boost/asio/spawn.hpp>namespace asio = boost::asio;using asio_ioctx = asio::io_context;using asio_sys_err = boost::system::error_code;using asio::yield_context;#include "async_pending_queue.hpp"class MemoryChecker {public: using bytes_cnt = size_t; MemoryChecker(asio_ioctx &ioctx, bytes_cnt total_mem = 1024, bytes_cnt initial_fill = 0); // This requests some space, and possibly yields; void request_space(bytes_cnt cnt, yield_context yield); void free_space(bytes_cnt cnt);private: bytes_cnt get_available_mem(); const bytes_cnt total_mem_; bytes_cnt mem_used_; std::queue<bytes_cnt> request_queue_; async_pending_queue request_routines_; std::mutex lock_; asio_ioctx::strand fifo_strand_; asio_ioctx &completion_ioctx_;};inline MemoryChecker::MemoryChecker(asio_ioctx &ioctx, bytes_cnt total_mem, bytes_cnt initial_fill) : total_mem_(total_mem), mem_used_(initial_fill), request_queue_{}, lock_{}, request_routines_{}, completion_ioctx_(ioctx), fifo_strand_(ioctx) {}inline MemoryChecker::bytes_cnt MemoryChecker::get_available_mem() { assert(total_mem_ >= mem_used_); return total_mem_ - mem_used_;}inline void MemoryChecker::request_space(bytes_cnt cnt, yield_context yield) { // if (cnt > total_mem_) throw logic_error lock_.lock(); assert(cnt <= total_mem_); assert(cnt > 0); if (request_queue_.empty()) { assert(request_routines_.pending_count() == 0); if (get_available_mem() >= cnt) { // We bypass the pending queue mem_used_ += cnt; lock_.unlock(); return; } } assert(request_queue_.size() == request_routines_.pending_count()); std::cout << "Pushing " << cnt << std::endl; request_queue_.push(cnt); auto wg = asio::make_work_guard(completion_ioctx_); request_routines_.async_submit(yield, [this] { lock_.unlock(); }); auto oldest_req{request_queue_.front()}; assert(cnt == oldest_req); request_queue_.pop(); mem_used_ += cnt; assert(request_queue_.size() == request_routines_.pending_count()); asio::post(fifo_strand_, yield);}inline void MemoryChecker::free_space(bytes_cnt cnt) { { std::lock_guard<std::mutex> lg{lock_}; mem_used_ -= cnt; // Here, we own the lock, and free as many coroutines as we can while (true) { if (request_queue_.size() == 0) { std::cout << "No pending requests. Bailing" << std::endl; break; } assert(request_queue_.size() == request_routines_.pending_count()); auto oldest_req{request_queue_.front()}; auto available_mem{get_available_mem()}; if (available_mem < oldest_req) { std::cout << "Oldest request is larger than available_mem. Bailing" << std::endl; break; } assert(request_routines_.try_run_one() == true); } }}#endif /* MEM_CHECK_HPP */* Here is a test program that can run it: *#include "mem_check.hpp"#include <thread>#include <unistd.h>constexpr size_t mc_size{4};asio_ioctx ioctx;size_t total{0};MemoryChecker mc{ioctx, mc_size};void requestor_coroutine(size_t rq,yield_context yield) { asio::steady_timer t(ioctx); while (true) { total += rq; mc.request_space(rq, yield); std::cout << "Got requested space "; asio_sys_err ec; }}int main() { asio::spawn(ioctx, [](yield_context yield) { requestor_coroutine(1,yield); }); asio::spawn(ioctx, [](yield_context yield) { requestor_coroutine(2,yield); }); asio::spawn(ioctx, [](yield_context yield) { requestor_coroutine(3,yield); }); asio::spawn(ioctx, [](yield_context yield) { requestor_coroutine(4,yield); }); std::thread t([] { ioctx.run(); }); while (true) { getchar(); std::cout << total << std::endl; if (total > 0) { std::cout << "freeing" << std::endl; mc.free_space(1); total -= 1; } } t.join();}* Finally, the problem we face is as follows. When we run the program, the assertion `total_mem >= mem_used_` fails. On some further investigation, I realized that our completion token was being called even when we do not call `try_run_one`, which was very weird. Finally, somewhat more surprisingly, If I replace *post(stand_,std::move(posted_lambda));* by *post(pending_queue_,std::move(posted_lambda));*, things seem to work. However, the asio documentation says that only strands guarantee a FIFO execution order. I am not sure if using a simple `io_context` will work as a FIFO queue (even though it seems to in these examples). Any inputs would be helpful - I am happy to hear the problem in this implementation, as well as other implementations (for example, using a std::queue as a proper queue instead of this io_context hack). This question has also been posted here: https://stackoverflow.com/questions/76310252/c-boost-asio-building-a-condit… . Thanks, Suraaj

3 2

Re: [Boost-users] New Website !
by Vinnie Falco 11 May '23

11 May '23

On Thu, May 11, 2023 at 8:08 AM Damien via Boost-users <boost-users(a)lists.boost.org> wrote: > This looks really good. Congratulations to the team. Thank you very much for the kind words! Regards

1 0

Re: [Boost-users] New Website !
by Damien 11 May '23

11 May '23

This looks really good. Congratulations to the team. Damien

1 0

New Website !
by Vinnie Falco 11 May '23

11 May '23

Hey, it’s Vinnie here again! I have some very exciting news to share with you. The renovated website for Boost that we’ve been working on for far too long is now going into its Public Beta phase! Feel free to poke around and kick the tires but keep in mind this is a piece of software and it is still under development. Some parts are missing, incomplete,or buggy. Without further ado: https://boost.revsys.dev This public beta will extend for at least 10 weeks as we finish the last remaining features, and put a few more rounds of polish on the artwork, visual styling, and user interface. After that if you like what you see then we will reset the database, move the repositories and the site to their new homes, and then deploy it for real! If you have suggestions or wish to report problems please feel welcome to open an issue here: https://github.com/cppalliance/temp-site/issues This is a Django site written and maintained in Python by a great group of folks from https://www.revsys.com/. The project is coordinated by Frank Wiles (https://www.revsys.com/about/bio/frankwiles), who shares the same deep commitment to open source that we Boost people do. We chose Django because it is well understood and supported, and because Python composes well with ease of maintenance. This technology stack allows us to execute on our future plans with confidence. Some cool things about this website include: * Log in with GitHub or Google * Light and Dark themes with selector * Asciidoc markdown for dynamic content * Antora content sources for site documentation * Data-driven dynamic pages for libraries and releases * Integrated control panel for producing Boost releases * Full-text search across the documentation and library headers * Professionally designed logo to evoke identity and instant recognition The layout of the site is carefully thought out to make sure that information can be found quickly. Fundamental topics each get a dedicated word in the top level navigation, visible on every page including the site and library documentation. Most of the information which is not library-specific is warehoused in “site docs” which is a collection of individual Antora content sources each authored in Asciidoc. Anyone can update the information on the website simply by contributing to the site-docs via pull request: https://github.com/cppalliance/site-docs Antora and Asciidoc are potent technologies that offer Boost plenty of room to grow to make our site documentation and library documentation more effective for users. While the initial release of the website after the beta will only have the basic functionality, we have many future plans. Some of these you have heard about already and some are new: * A web-based forum which interacts seamlessly with the mailing list * Polls and surveys for measuring the sentiment of Boost users and stakeholders * News section for aggregating off-site links, blog posts, and release progress messages * Integrated Review process. Outcomes go in the database and become dynamic content. * User Profiles record and show activity such as review participation or library submission We’re all very excited and proud of the work that went into this thing and hope that it really fulfills the positive impact that we intended. Thanks! Vinnie

1 0