December 2018 - Boost - lists.boost.org

ASIO TCP socket scalability for large scale connections
by hh h 24 Dec '18

24 Dec '18

Hi, In regard to ASIO TCP socket implementation, for each connections the server needs to open and to maintain a session, obviously there need be adequate RAM and CPU resources for supporting large connections, but does ASIO TCP socket itself has any limitation for connecting to large clients which could be over 10000 or more simultaneously? What will be the maximum connections a single ASIO TCP socket server can handle? Thank you.

3 5

Re: [boost] Should pass boost::asio::io_service by raw pointer or smart pointer?
by Vinnie Falco 24 Dec '18

24 Dec '18

On Thu, Dec 20, 2018 at 6:45 PM Richard Hodges <hodges.r(a)gmail.com> wrote: > ...even with Vinnie's easy to follow guide, it requires a hundred lines of > boilerplate to implement what amounts to one async method. Yes, that is kind of irritating. I've been working on some tools to make it easier. The function wrap_handler returns a new completion handler which wraps your function object (lambda) and inherits the allocator and executor of another completion handler: <https://github.com/vinniefalco/beast/blob/8afbc6090bded0cdfda46871d829ea778…> The class template base_handler<> is meant as a base class for composed operations, it holds the handler for you and it provides all the hooks. I notice that you didn't include an overload for asio_handler_invoke in your example, which will certainly cause undefined behavior in some cases: <https://github.com/vinniefalco/beast/blob/8afbc6090bded0cdfda46871d829ea778…> You can see both wrap_handler and handler_base used together to implement a composed operation, a flavor of async_read_some which has a built-in timeout: <https://github.com/vinniefalco/beast/blob/8afbc6090bded0cdfda46871d829ea778…> In particular, handler_base let me leave out all of the boilerplate which is nice. It is possible that with some adaptation these utilities can be used to achieve the result you desire. These experimental features will appear in Boost.Beast version 1.70.0. Regards

4 7

GitHub testing issues
by Cromwell Enage 22 Dec '18

22 Dec '18

Hi, everyone! Starting yesterday, I experienced failures on all my test builds. Their logs contain the following message: travis_time:end:1a83bdea:start=1545229245463720000,finish=1545229258317024000,duration=12853304000 [0Ktravis_fold:end:install.10 [0Ktravis_fold:start:install.11 [0Ktravis_time:start:04d79bf0 [0K$ ./b2 headers boost-install.jam: No such file or directory Jamroot:307: in boost-install ERROR: rule "boost-install.boost-install" unknown in module "Jamfile</Users/travis/build/CromwellEnage/boost-root>". libs/atomic/build/Jamfile.v2:38: in modules.load /Users/travis/build/CromwellEnage/boost-root/tools/build/src/build/project.jam:372: in load-jamfile /Users/travis/build/CromwellEnage/boost-root/tools/build/src/build/project.jam:64: in load /Users/travis/build/CromwellEnage/boost-root/tools/build/src/build/project.jam:89: in load-used-projects /Users/travis/build/CromwellEnage/boost-root/tools/build/src/build/project.jam:75: in load /Users/travis/build/CromwellEnage/boost-root/tools/build/src/build/project.jam:142: in project.find /Users/travis/build/CromwellEnage/boost-root/tools/build/src/build-system.jam:618: in load /Users/travis/build/CromwellEnage/boost-root/tools/build/src/kernel/modules.jam:295: in import /Users/travis/build/CromwellEnage/boost-root/tools/build/src/kernel/bootstrap.jam:139: in boost-build /Users/travis/build/CromwellEnage/boost-root/boost-build.jam:17: in module scope travis_time:end:04d79bf0:start=1545229258327432000,finish=1545229259660893000,duration=1333461000 [0K [31;1mThe command "./b2 headers" failed and exited with 1 during . [0m It's also happening on Appveyor, and just from looking at < https://github.com/boostorg/graph/pull/144>, I'm not the only one who is encountering these errors. Any help would be appreciated. Thanks! Cromwell D. Enage

7 11

New library proposal: Autodiff
by Matt Pulver 21 Dec '18

21 Dec '18

Hello, An automatic differentiation <https://en.wikipedia.org/wiki/Automatic_differentiation> C++ library - Autodiff - is released under the Boost License and is proposed for inclusion into Boost: - Github: https://github.com/pulver/autodiff - Boost Library Incubator: http://blincubator.com/bi_library/autodiff-2/?gform_post_id=1716 Features: - Instances of autodiff variables satisfy Boost's Conceptual Requirements for Real Number Types <https://www.boost.org/doc/libs/1_69_0/libs/math/doc/html/math_toolkit/real_…>. In fact the class and function template definitions are based upon the tables in this page. - No use of dynamic memory. The only member variable is a std::array<>. - Consistent with Boost's type promotion templates. When adding/multiplying/etc. variables of differing dimension number and sizes, the resulting data type is calculated at compile-time. - Single header-only file. - Intuitive and minimal API. Requirements: - C++17 compiler that supports constexpr if statements. There are a fair amount of calculations done at compile-time which would require messy SFINAE hacks to make this C++14-compatible. Todo: - A github build matrix that also includes clang and MSVC. - Additional documentation, including the mathematics. Feedback and endorsements for Boost Library inclusion are welcome and requested. Best regards, Matt

8 11

[parameter] Helping user libraries adjust to recent changes in GitHub develop branch
by Cromwell Enage 20 Dec '18

20 Dec '18

Hi, everyone! I've been contributing upgrades to Boost.Parameter functionality and documentation in the GitHub develop branch for the past couple of months. These upgrades include the addition of code generation macros for Boost.Parameter-enabled function call operators and support for perfect forwarding, and more upgrades are yet to come. It's been an enjoyable experience so far, but understandably there are some growing pains. I've taken pains to ensure that as long as user libraries access only the public interface of Boost.Parameter, they won't be affected by the changes. However, there are several notable libraries that currently use non-public portions of Boost.Parameter, so whenever possible I've submitted PRs to those libraries that either change the usage to access only public portions (preferred) or make quick fixes (temporary). I'm drawing off Peter Dimov's page < https://pdimov.github.io/boostdep-report/develop/parameter.html> as a guide to focus my efforts. As of this writing, I have active PRs for the following libraries: Boost.Convert Boost.Graph Boost.Lockfree I also have my eye on the following libraries, which I know have been broken by the latest changes: Boost.Accumulators Boost.Log I'm willing to help the library maintainers resolve these issues as quickly as possible. This post can serve as a discussion starting point, and I should be able to answer any questions you have about the changes to Boost.Parameter. Cromwell D. Enage

1 0

Feature/cmake-config merged to develop; yml files need to be updated
by Peter Dimov 19 Dec '18

19 Dec '18

I've just merged the superproject branch feature/cmake-config to develop. This updates `b2 install` to export CMake configuration files into the `cmake` subdirectory of the library directory. These configuration files enable a Boost installation to be used from CMake via `find_package(boost_filesystem)`, without relying on FindBoost. Unfortunately, this change adds two necessary submodules to the superproject, `tools/boost_install` and `libs/headers`. As a result, all .travis.yml and appveyor.yml files that rely on a partial checkout need to be updated to perform git submodule update --init tools/boost_install git submodule update --init libs/headers in addition to the usual git submodule update --init tools/build git submodule update --init libs/config I'm sorry for the inconvenience this will cause, or perhaps already has caused.

5 7

Ignoring unused type aliases in concepts
by Mateusz Loskot 18 Dec '18

18 Dec '18

Hi, In concepts, such unused type aliases are not uncommon. What is the best way to ignore compiler warnings about those? Options I'm aware of are: 1. Adjust compile options in build configuration (Jamfile) 2. Use #pragma in headers 3. Use boost::ignore_unused_variable_warning(alias{}) (or little brother boost::ignore_unused) 4. Ignore ignoring them. The options 1 and 2 are mentioned on https://svn.boost.org/trac10/wiki/Guidelines/WarningsGuidelines The option 3 is not and is there any particular reason why? Best regards, -- Mateusz Loskot, http://mateusz.loskot.net

5 16

Error to convert to boost::asio::streambuf to raw buffer char *buffer
by hh h 18 Dec '18

18 Dec '18

boost::asio::streambuf sb; char *raw = sb; error: cannot convert ‘boost::asio::streambuf {aka boost::asio::basic_streambuf<>}’ to ‘char*’ in initialization I've checked the boost::asio::streambuf reference, but could not find anything to fix it, appreciate any clues.

3 3

[cmake] Has the latest effort stalled?
by Andrey Semashev 17 Dec '18

17 Dec '18

Hi everyone, hi Robert, I've been informed[1] that the latest effort to call for CMake submissions and then review them collectively in February has stalled or failed. Is this true? What is the status of this effort, and if it's still on track, what is the current schedule? I'm asking because there is an ongoing effort by Mike-Devel (sorry, don't know your full name) to add minimalistic support for CMake across a number of Boost libraries, including those I maintain, and I've been holding off his submissions until after the review according to Robert's plan. If that plan is no longer in force, I might as well accept Mike's PRs and we (Boost as a whole) might as well accept his solution as the only one we have close to implementation. [1] https://github.com/boostorg/winapi/pull/73#issuecomment-447760554

2 1

Mixing async/sync code thanks to boost::context
by Christophe Bailly 16 Dec '18

16 Dec '18

Hello, I am new in this mailing list, I hope this is the right list to post my issue. Context: I often have to deal with some code which is originally synchronous. When we introduce an asynchronous call, all the callers must be made asynchronous with async/await everywhere. Let's take a concrete example: Suppose we have an existing synchronous library which makes computation. Suppose we can give a custom function to this library to compute a part of the calculation. We decide that this function will call a server... We may wish the main compute function to become asynchronous... Now the big question: Why isn't it possible so far to do this without changing all the functions ?? I find this really ugly, this is really difficult to make a good design. With asymetric async calls, I doubt this is possible, so I tried boost::context. In my example, the "library" is represented by the function calculate which is synchronous. It calls a function call_server which simulates the call to a server, in fact it will just wait for 5 seconds but in a asynchronous way. The main function will do a computation in parallel while the server will be called. You will find the code at the end of the mail. This sounds too good to be true but in this case, where did I miss something ? I haven't implemented a socket with a select but this would work, right ? The library can still be used in an asynchronous or synchronous context (with no extra cost). To help the understanding of the code, we have 3 tasks, the continuation are stored in the tasks vector. task are identified thanks to their indice in the vector: - 0: main task (id_main) - 1: reactor(id_reactor) - 2; computation_task (id_computation) I implement a kind of future, whose value is retrieved at the end of the main function and which launches a task to compute the value. Remarks: 1/ This is not optimised, we could make fewer context switches. There is no need for a specific task for the reactor, it could be called directly. 2/ The call_server function could detect automatically the sync or async context, if the reactor is not active (no waiting tasks to be run), then it would run i a synchronous way. 3/ This solution is based on a singleton for the reactor, but this is what we want, 4/ This could be certainly better coded, I am not an expert, I use to code more in Python and wanted to use C++ to see if I could solve these designs problems. I am curious to read what you think about this, I certainly missed something so please clarify and tell me if a clean solution is possible. Thanks a lot for reading. Regards, Chris #include <boost/lambda/lambda.hpp> #include <iostream> #include <iterator> #include <boost/context/continuation.hpp> #include <iostream> #include <string> #include <vector> #include <tuple> #include <queue> #include <time.h> int a = 0; int result = 0; namespace ctx = boost::context; std::vector<ctx::continuation> tasks; std::queue<int> tasks_to_run; std::vector<int> end_tasks; // list of tasks which ended using clock_info = std::tuple<int, time_t, int>; // task, start_time, duration using wait_info = std::tuple<int, int>; // source, target: source wainting for target to end std::queue<clock_info> clocks; // timer to wake up tasks std::queue<wait_info> waits; const int id_main = 0; const int id_reactor = 1; const int id_computation = 2; void add_clock(int task, int duration) { time_t start; time(&start); clocks.push(std::make_tuple(task, start, duration)); } void wait_for(int source, int target) { waits.push(std::make_tuple(source, target)); } void end(int task) { end_tasks.push_back(task); } ctx::continuation reactor(ctx::continuation && main_continuation) { ctx::continuation task; std::cout << "start reactor" << std::endl; tasks.push_back(std::move(main_continuation)); // add main continuation to list of tasks tasks_to_run.push(id_main); unsigned int k; time_t end_time; for (;;) { if (tasks_to_run.size()) { int id_task = tasks_to_run.front(); tasks_to_run.pop(); tasks[id_task] = tasks[id_task].resume(); } time(&end_time); for (k = 0; k < clocks.size(); k++) { clock_info clock = clocks.front(); int elapsed = end_time - std::get<1>(clock); if (elapsed > std::get<2>(clock)) { tasks_to_run.push(std::get<0>(clock)); } else clocks.push(clock); clocks.pop(); } for (k = 0; k < waits.size(); k++) { wait_info wait = waits.front(); if (std::find(end_tasks.begin(), end_tasks.end(), std::get<1>(wait)) != end_tasks.end()) { tasks_to_run.push(std::get<0>(wait)); } else waits.push(wait); waits.pop(); } } return std::move(main_continuation); } struct int_future { std::function<int()> func; int future_result; int_future(std::function<int()> f) :func(f) {} auto make_task() { return [this](ctx::continuation && main_cont) { tasks[id_reactor] = main_cont.resume(); future_result = this->func(); end(id_computation); tasks[id_reactor] = tasks[id_reactor].resume(); return std::move(main_cont); }; } int get() { wait_for(id_main, id_computation); tasks[id_reactor] = tasks[id_reactor].resume(); return future_result; } }; int call_server() { std::cout << "waiting for server results" << std::endl; add_clock(id_computation, 5); tasks[id_reactor] = tasks[id_reactor].resume(); result = 5; std::cout << "server returned result " << result << std::endl; return result; } int calculate() { return 1 + call_server(); } int main() { ctx::continuation task; tasks.push_back(ctx::callcc(reactor)); std::cout << "launch computation task" << std::endl; int_future fut(calculate); tasks.push_back(ctx::callcc(fut.make_task())); tasks_to_run.push(id_computation); tasks_to_run.push(id_main); tasks[id_reactor] = tasks[id_reactor].resume(); std::cout << "main task running" << std::endl; for (int j = 0; j < 10; ++j) { std::cout << a << " "; } std::cout << std::endl; std::cout << "wait for future" << std::endl; std::cout << "future result:" << fut.get() << std::endl; }

4 6