- Boost - lists.preview.boost.org

[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

[docs] Building docs for release?
by John Maddock 15 Dec '18

15 Dec '18

Is there now a way for quickbook docs that aren't integrated under /doc/ to be built automatically for each release? And if so, what's the magic incantation to test this? Many thanks! John. --- This email has been checked for viruses by Avast antivirus software. https://www.avast.com/antivirus

2 1

Windows quarantines boost_1_68_0.7z
by Miguel Ojeda 15 Dec '18

15 Dec '18

Quick note: it seems that Windows currently quarantines boost_1_68_0.7z. Could someone from Boost please contact Microsoft to whitelist it? Thanks, Miguel

5 11

C++Now (BoostCon) 2019 Call for Submissions
by Jon Kalb 14 Dec '18

14 Dec '18

The C++Now (formerly BoostCon) 2019 Call for Submissions is now open. http://cppnow.org/announcements/2018/12/2019-call-for-submissions/ C++Now will be held in Aspen, Colorado on May 5th - 10th. Colorado has become trendy for C++ conferences, but BoostCon was here first. If you are interested in Boost Libraries and have never attended C++Now, you owe it to yourself to have the BoostCon experience. The best way to get your company to send you is to have an accepted submission. The deadline is early in the new year, so don’t delay. Jon Kalb Conference Chair C++Now

1 0

Let's discuss dropping support for msvc <= 9.0 (2008), gcc < 4.6, clang < 3.4
by James E. King III 13 Dec '18

13 Dec '18

During the Boost 1.69.0 release there was a regression on Visual Studio 2005 (msvc-8.0). Microsoft ended support for msvc-8.0 on December 4, 2016. I was going to argue we let it happen, but it wasn't the right time to discuss that sort of change. Boost has a very large compatibility matrix which increases the effort required, and sometimes limits solutions development, to get out a quality release. The boost project as a whole agreed in summer 2018 that if repository maintainers wanted to drop C++03 support per repository to make substantial improvements or simplifications, or to ease maintenance then they are able to do so. *Folks who need support for older language levels and older compilers can always download an older version of Boost.* The compilers I mentioned in the subject have trouble with C++11 and are no longer maintained. msvc-8.0 (Visual Studio 2005) ended support Dec 10 2016 msvc-9.0 (Visual Studio 2018) ended support April 10 2018 The last release of gcc 4.6 was April 12, 2013 The last release of gcc 4.5 was July 02, 2012 The last release of gcc 4.4 was March 13, 2012 The compilers by default in Ubuntu Trusty 14.04.5 LTS, supported through April 2019, is gcc-4.8, currently at gcc-4.8.2, and clang 3.4 (however clang-3.8 is available). My argument is that this is a huge project, and maintaining backwards compatibility is not always efficiently possible. We spend build matrix resources testing and analyzing those tests. We find and develop fixes and workarounds. In some cases we hobble potential solutions to cater to decade-old compilers. Given the summer 2018 discussions about language level, and the aging vendor support matrix, I'd like us to consider dropping support for msvc <= 9.0 (2008), gcc < 4.6, clang < 3.4. What does this mean exactly? 1. We no longer test these compilers in the post-commit build matrix. 2. We no longer test these compilers in continuous integration. 3. We no longer develop fixes for issues that affect these compilers. 4. We are allowed, over time, to remove workarounds for these compilers. 5. We no longer block releases due to incompatibility with these compilers. 6. We remove these compilers from the documented environments in the release notes. 7. We direct anyone looking for support of these compilers to download a previous release of Boost that given them that support. 8. We do not update older Boost releases to fix issues with older compiler support. What would we remove from the release notes as a result? primary: linux: clang: c++03: 3.0 c++0x: 3.0 c++11: 3.0, 3.1, 3.2, 3.3 gcc: c++03: 4.4.7, 4.5.3 c++0x: 4.4.7 windows: gcc: c++03: 3.4.5, 4.1.2, 4.2.4, 4.3.3, 4.4.0, 4.5.4 msvc: - msvc-7.0 (Visual C++ 7.1) - msvc-8.0 (Visual Studio 2005) - msvc-9.0 (Visual Studio 2008) additional: linux: clang: c++03: 3.0, 3.8.1, 3.9.1, 4.0.1 c++0x: 3.0 c++11: 3.0, 3.1, 3.2, 3.3 gcc: c++03: 4.4.7, 4.5.3 c++0x: 4.4.7 windows: gcc: c++03: 3.4.5, 4.1.2, 4.2.4, 4.3.3, 4.4.0, 4.5.4 msvc: - msvc-7.0 (Visual C++ 7.1) - msvc-8.0 (Visual Studio 2005) - msvc-9.0 (Visual Studio 2008) The release notes section on compiler compatibility should probably be updated to match the current state of the post-commit matrix and duplicates in the "additional" section that are present in the "primary" section should be removed, or simply merge them. Why do we have a distinction here? Thanks for your consideration, Jim

12 16

Is disabling boost log auto flush the only way to control the log flush? Or can you change log auto flush rate?
by hh h 13 Dec '18

13 Dec '18

Hi, I use boost log in an embedded system where flushing log message to flash storage need be controlled. I could not find how to change log auto flush rate, is it the only way to disable auto flush boost::log::keywords::auto_flush = false? I think there must be a way to change a desired log flush rate value without disabling auto flush, appreciate any tips. Thank you. JHH

2 2

[coroutine] Boost.Coroutine 1.0 Deprecation Warning
by Vinnie Falco 13 Dec '18

13 Dec '18

Can we please turn off this deprecation warning for now? At least when Boost.Coroutine is being included to work with Asio? I get neverending complaints from users about this warning in Beast: <https://travis-ci.org/vinniefalco/beast/jobs/466272022#L1091> I am of course defining BOOST_COROUTINES_NO_DEPRECATION_WARNING: <https://github.com/boostorg/beast/blob/010fb4b08c05ce82cf4a87d9985c5b4998d9…> But this warning happens when building the coroutine library not when compiling Beast's tests and examples. Regards

3 2

[release] 1.70.0 open for merging
by Marshall Clow 12 Dec '18

12 Dec '18

The master branch is open for merging all stable changes from develop, including bug fixes and major upgrades to existing libraries. Breaking changes should be coordinated via the mailing list with the developers of the other libraries affected. New libraries may be added, but require permission of a release manager. In other words, merging does not require permission from a release manager, except for new libraries. Boost Calendar with the release schedule: http://www.boost.org/development/index.html Release schedule explanation: https://github.com/boostorg/boost/wiki/Release-Schedule Release practices for developers: http://svn.boost.org/trac/boost/wiki/ImprovingPractices -- The Boost Release Team

2 1

GSOC-19 Ideas
by Arihant Samar 12 Dec '18

12 Dec '18

Dear Boosters, I am new to the community. I wanted to ask if there will be any new suggested GSOC ideas for 2019. I went through the suggested proposals of 2018 but projects have already been done on most of them so It will be helpful if you could give some starting points. Sent from Mail for Windows 10 --- This email has been checked for viruses by Avast antivirus software. https://www.avast.com/antivirus

2 2