- Boost - lists.preview.boost.org

Re: [boost] Asynchronous library now in Boost Library Incubator
by Christophe Henry 29 Nov '16

29 Nov '16

Hi Vicente, >> In theory, the standard version would suffice, except for Thread. >> Boost.Thread provides interruption points, which the standard does not. >> With the standard version, I would not be able to offer task interruption. >Could you explain why task interruption is associated to thread >interruption? Ah already implementation details :) Tasks are executed in schedulers (uisually threadpools), which manage 1 to n threads. To interrupt a task from outside, the library interrupts the thread running the task. To be exact, the task will be interrupted the next interruption point in encounters. The thread executing the task does not terminate but instead recovers and pops the next task from its job queue. >> I rely for the other parts also on Boost because the standard version had >> bugs on earlier versions of compilers, and quite some projects are still >> stuck with gcc-4.9 or mingw. At some points, it seemed easier to maintain >> using Boost (which also happens to be faster than the standard, at least on >> my tests). >> >Whow, glad to hear Boost.Thread is working for you Henry. It is. I got no problem whatsoever. >I believe that Michael is however right. Boost libraries restricted to >C++11 should use the standard library as much as possible. Sure. At the moment I have no way around Boost.Thread though. If that changes, I'll probably want to switch to standard. The performance issue for the clock is not a huge one and by that time, the older compilers will hopefully have vanished. I could provide a macro to switch between boost / std. If one needn't interrupt tasks, the library would make no use of boost at all. >It would be great to have a specific C++11 (language and standard >library) version of your library. Well, if there is interest, why not? >Good luck with the review, >Vicente >P.S. I've in my todo's list implement thread interruption on top of the >standard as Anthony showed in his book, but I have no time to work on >this now. Oh, it would be great. This really is a fantastic feature. Thanks, Christophe

1 0

Re: [boost] Asynchronous library now in Boost Library Incubator
by Christophe Henry 29 Nov '16

29 Nov '16

Hi Michael, >Thank you for submitting this library to the the incubator in >preparation for a review. I saw your presentation in 2014 >and I believe that this library solves a common problem. >My first question: I see that the library is listed as C++11 and also >has dependencies on Boost.System, Boost.Thread, Boost.Chrono, >and Boost.DateTime. Much of the functionality provided by those >Boost libraries is now part of the C++11 or C++14 standard. >Can you comment on the specific Boost dependencies >and if the standard versions would suffice? A good question which deserves a rationale, which I will add. In theory, the standard version would suffice, except for Thread. Boost.Thread provides interruption points, which the standard does not. With the standard version, I would not be able to offer task interruption. I rely for the other parts also on Boost because the standard version had bugs on earlier versions of compilers, and quite some projects are still stuck with gcc-4.9 or mingw. At some points, it seemed easier to maintain using Boost (which also happens to be faster than the standard, at least on my tests). HTH, Christophe

2 1

[ssl] SSL handshake takes forever sometimes
by Shuchen He 28 Nov '16

28 Nov '16

Hi, I have an application written in boost with SSL. I noticed that when the client network is down for a while and come back again. The SSL handshake sometimes take forever. I tried to kill the client application and run it again, the problem still there. The only way to make it work again was to reboot my client device. I'm using boost 1.60 on the client side and 1.58 on the server side. The SSL handshake code was copied from Boost SSL server and client example I modified a bit to suit my application needs. Does anyone experience the similar issue? If so, can you please let me know how do you fix it? It would be much appropriated if you could help me out on this issue. Below is the SSL handshake code. chat_client(boost::asio::io_service& io_service, boost::asio::ssl::context& context, tcp::resolver::iterator endpoint_iterator) : io_service_(io_service), socket_(io_service, context) { filesize_=0; isfileopen_=false; socket_.set_verify_mode(boost::asio::ssl::verify_peer); socket_.set_verify_callback( boost::bind(&chat_client::verify_certificate, this, _1, _2)); boost::asio::async_connect(socket_.lowest_layer(), endpoint_iterator, boost::bind(&chat_client::handle_connect, this, boost::asio::placeholders::error)); } bool verify_certificate(bool preverified, boost::asio::ssl::verify_context& ctx) { char subject_name[256]; X509* cert = X509_STORE_CTX_get_current_cert(ctx.native_handle()); X509_NAME_oneline(X509_get_subject_name(cert), subject_name, 256); log_time(); fprintf(logfile,"%s: Verifying %s\n",logtime.c_str(), subject_name); return preverified; } void handle_connect(const boost::system::error_code& error) { if (!error) { socket_.async_handshake(boost::asio::ssl::stream_base::client, boost::bind(&chat_client::handle_handshake, this, boost::asio::placeholders::error)); } else { log_time(); fprintf(logfile, " %s Connect to server failed: %s\n ",logtime.c_str(), error.message().c_str()); fflush(logfile); delete this; } } void handle_handshake(const boost::system::error_code& error) { if (!error) { ssl_handshake_ok=1; do_read_header(); } else { log_time(); fprintf(logfile,"%s: Handshake failed:%s\n ",logtime.c_str(), error.message().c_str()); } }

1 0

[poly_collection] request for help at performance testing
by Joaquin M López Muñoz 28 Nov '16

28 Nov '16

Hi, Some days ago I published the first version of (candidate) Boost.PolyCollection at https://github.com/joaquintides/poly_collection Performance tests are available at http://rawgit.com/joaquintides/poly_collection/website/doc/html/poly_collec… but GCC and Clang were run in a Travis VM and the resulting figures are noisy and not sufficiently accurate. I'm looking for volunteers willing to run the performance suite in one or more of the following environments: * Recent GCC, 32 bit * Recent GCC, 64 bit * Recent Clang 32 bit * Recent Clang, 64 bit The full suite in one environment takes 1.5-2h to execute. If you're interested, please contact me privately (so that we don't pollute the mailing list) and I'll provide you with further instructions on how to do the testing. Thank you! Joaquín M López Muñoz

1 0

[iterator] Orbiting iterators
by Jeremy Murphy 27 Nov '16

27 Nov '16

Hi, just wondering what the mood in Boost.Iterator is for new features? At work we recently found use for an orbiting iterator, specifically a circular one, which effectively wraps at the start/end of a bounded range. (The domain is digital signal processing.) Implementation details aside, does this feature sound desirable to the library? I call it an "orbiting" iterator because it is a specific (and useful) case of the more general rho-shaped orbiting iterator. The theory behind it is in chapter 2 of Elements of Programming, which happens to be the free sample chapter available: http://elementsofprogramming.com/032163537X_Sample.pdf#page=6 Anyway, if there is interest, I'll make a pull request. Cheers. Jeremy

6 10

Re: [boost] [beast] Separation between parse and generation and asio
by Vinnie Falco 24 Nov '16

24 Nov '16

On Wed, Nov 23, 2016 at 10:45 PM, Felipe Magno de Almeida <felipe.m.almeida(a)gmail.com> wrote: > I'm trying Beast with avr-gcc to see how much footprint it would take > on embedded applications. Thank you for your interest in Beast! > Unfortunately, stream_concepts uses asio > types, which requires asio include which requires network includes > which will obviously fail in most microcontrollers. > > Would it be possible to make parse and read implementation less > dependent on each other? I see what you mean. Yes, I believe I can do that - would you mind creating a new issue here? https://github.com/vinniefalco/Beast/issues Thanks!

1 0

[outcome] Requesting pre-review of Boost.Outcome tutorial
by Niall Douglas 24 Nov '16

24 Nov '16

Dear Boost, I am hoping to bring Boost.Outcome, a C++ 14 library providing a factory and family of policy driven lightweight monadic value-or-error transports, into the Boost peer review queue by March 2017 followed shortly thereafter by an ACCU talk in April if my talk proposal passes their programme committee. To that end, I've written an explanation and a sort of tutorial explaining the history and purpose of Outcome at https://ned14.github.io/boost.outcome/ and I'd greatly appreciate if people could tell me: 1. Does it make sense? 2. Do you think you could use Outcome in your own code after reading it? 3. Do you think you would want to use Outcome in your own code after reading it? 4. Are there any missing parts which are showstoppers? My thanks in advance. Be aware the install stuff described at the start doesn't work yet. The reference documentation is also quite patchy thanks to doxygen not understanding CRTP. All that stuff and a fair bit more remains to fix before it's ready to enter the Boost peer review queue. Niall -- ned Productions Limited Consulting http://www.nedproductions.biz/ http://ie.linkedin.com/in/nialldouglas/

6 14

[beast] Separation between parse and generation and asio
by Felipe Magno de Almeida 24 Nov '16

24 Nov '16

Hello, I'm trying Beast with avr-gcc to see how much footprint it would take on embedded applications. Unfortunately, stream_concepts uses asio types, which requires asio include which requires network includes which will obviously fail in most microcontrollers. Would it be possible to make parse and read implementation less dependent on each other? Boost.Spirit x3 works very well on microcontrollers. I'd expect a different type for messages which could actually receive iterator pairs for strings with Beast might give a very good option for HTTP/WS implementation on microcontrollers. Regards, -- Felipe Magno de Almeida

1 0

[sort] Parallel sorting sub-library mini-review conclusion
by Christophe Henry 22 Nov '16

22 Nov '16

> I would like to know the memory used and the best, >normal and worst case of the Asynchronous sorting algorithms. The sort versions are mergesort so they use double memory. The quicksort versions require no extra memory while partitioning. When they degrade after some partitioning iterations, they require the extra memory used by the underlying sort algorithm (spreadsort, std:sort, intro_sort, etc.). Thank you Francisco for this interesting library which I shamelessly used into my own ;-) It's probably a bit late but I vote for acceptance. Cheers, Christophe

2 1

Re: [boost] [sort] Parallel sorting sub-library mini-review. Performance tests.
by Christophe Henry 22 Nov '16

22 Nov '16

>> >> OTOH the single-threaded ones are interesting, especially the stable_sort >> and intro_sort for cases where usage of spreadsort is not possible. >> >I challenge you to find a sorting problem where it isn't possible to use >spreadsort. string_sort can sort anything that std::sort can; > you just need to convert the sort key comparison sequence into a sequence of bytes > and feed string_sort the correct functors. That said, it may not be >efficient to sort some problems with string_sort, >and it'll probably be too much work to be worth the effort for many problems. This is what I meant. Sorry for the lack of precision. I'll add it to my performance tests, it might be an interesting variant as the algorithm is really fast. >> >> A short summary: >> >> 100000000 uint64_t elements already sorted: >> Boost parallel sort : 0.064965 secs >> >> Asynchronous parallel sort : 0.0167134 secs (same with other >> algorithms) >> >> Asynchronous provides a special optimization for this case. >> >If this optimization is practical to incorporate in Boost parallel sort, >it is a common case and your solution seems noticeably faster, >so I would like Francisco to consider it. That said, .06s isn't bad. Sure. >> >> I added this one: >> 100000000 uint64_t elements reverse sorted >> >> Boost parallel sort : 0.581381 secs >> >> Asynchronous parallel sort : 0.0478701 secs >> >> Asynchronous provides a special optimization for this case. >> I this the library should do it too. This one is pretty common and a >> popular DOS attack. >> > This optimization would be nice to have, if it's cheap. A parallel reverse is in O(n) so it's cheap compared to a sort. >> >> 100000000 uint64_t elements randomly filled >> >> Asynchronous parallel quickspreadsort: 0.587432 secs >> Asynchronous quick_intro_sort : 0.728393 secs >> >> This mixing of quicksort degrading into a spreadsort works here best. >I find this algorithm interesting; Frankly, there is nothing special. It's simply a parallel partition, which degrades into a "normal" parallel merge sort (in this case spreadsort) after a while. >have you considered using MSD radix-based sorting to break up the data > for the threads in parallel? >For example, take T threads, have each thread take 1/T of the data > and bucket it into N MSD-based buckets (just like Spreadsort), >where T < N <= ~2^11, then merge the equivalent buckets, >and as you merge them hand them off to another thread to sort. >This will probably divide better if you find the max and min before bucketing >using a parallel min/max search. I admit I didn't. But it sounds really interesting and I think I'll have a go at it. I'm not a sort expert though. I approached this from the parallel perspective. >> 10000000 strings randomly filled >> >> OMP parallel sort : 1.05803 secs >> Boost parallel sort : 0.933055 secs >> >> OMP parallel stable sort : 1.12269 secs >> Boost sample sort : 0.889216 secs >> Boost parallel stable sort : 1.56564 secs >> >> Asynchronous parallel quickspreadsort: 0.788856 secs >> Asynchronous quick_intro_sort : 0.893652 secs >> >> Asynchronous parallel stable sort : 1.23495 secs >> Asynchronous boost::stable sort : 1.21817 secs >> >> Similar results. >> >> >> Let's move on to big objects: >> >> 1562500 elements of size 512 randomly filled >> H E A V Y C O M P A R I S O N >> >> OMP parallel sort : 0.308923 secs >> Boost parallel sort : 0.342992 secs >> >> Asynchronous parallel_quicksort : 0.246709 secs >> Asynchronous quick_intro_sort : 0.269666 secs >> >> Both quicksorts are best, with a slight advantage to intro_sort. >> >> The light comparison is similar. >> >Do we have your permission to copy and/or adapt your quick_intro_sort >algorithm into the Boost.Sort library? Please feel free to copy whatever might be useful. The library has a Boost license as it's intended for inclusion in Boost.I also took the freedom of adding the single-thread versions of Fernando's algorithms as basis for my parallel versions. The algorithm is quite simple. It's the same as quick_spreadsort, a quicksort which degrades into Francisco's intro_sort after some iterations. I just found it interesting to add a wrapper to Francisco's algorithm for the mini-review. It was just a quick test (no time for cleverer algorithms) but I'm pretty satisfied with the result and I'll keep these versions. >How is the worst-case performance relative to Francisco's library? The sort versions have O(n log n) like any merge sort. The quicksort have O(n log n) to O(n^2) as expected from a quicksort. Cheers, Christophe

1 0

Re: [boost] [sort] Parallel sorting sub-library mini-review. Performance tests.
by Christophe Henry 22 Nov '16

22 Nov '16

Hi, > The threads are created only 1 time*. Have I missed something? I checked sample_sort and I saw several sets of calls to std::async which is likely to create and destroy threads several times. >*parallel_sort, sample_sort* : this algorithm is commonly accepted as the >fastest for the parallel stable sort. >The implementation is *notoriously faster than the provided by the GCC compiler* >( based on Open MP ) using less memory. TBB don?t >provide parallel stable sort, and only have an experimental code in their web pages Indeed, I found it highly interesting. Cheers, Christophe

1 0

[release] Boost 1.63.0 - fixes
by Oliver Kowalke 22 Nov '16

22 Nov '16

unfortunately beta 1 does not contain fixes from boost.context and boost.fiber. could you add the fixes to the 1.63 release, please? Oliver

3 4

[sort] Parallel sorting sub-library mini-review starts tomorrow, 11 November
by Steven Ross 22 Nov '16

22 Nov '16

Dear Boost community, The mini-review of Francisco Tapia's Parallel sorting library begins tomorrow November 11, and ends November 20th. The purpose of this review is to assess whether the sub-library is useful and up to Boost software standards. If the Boost community agrees on both, Francisco and I will integrate it into the existing Boost.sort library as a separate sub-library from Spreadsort. In doing so we'll integrate the documentation with the existing documentation for Boost.Sort, making it more consistent. If you review Francisco's library, please make sure you're using a compiler that supports C++11, and answer each of these questions: 1. Were you able to run it and see accurate and fast results? Please specify your compiler, OS, and processor type, and any problems (or slowdowns) encountered. 2. Would you use this library if accepted? Why or why not? 3. What is your evaluation of the design? 4. What is your evaluation of the implementation? 5. How much effort did you put into your evaluation? A glance? A quick reading? In-depth study? The library is here: https://github.com/fjtapia/sort_parallel This library provides both stable and unstable sorting algorithms, in single threaded and parallel versions. - All the algorithms have average and worst case runtime of O(NLogN). - These algorithms do not use any other library or utility. To compile and run these you will need a *C++11 compliant compiler.* - *This library is *include only, only requiring* the files in the boost/sort/parallel folder, with no external dependencies.* - The algorithms use a comparison object, in the same fashion as std::sort, defaulting to the std::less object, which uses the < operator internally for comparisons. - The algorithms are exception safe, meaning that the exceptions generated by the algorithms guarantee the integrity of the objects to sort, but not their relative order. If the exception is generated inside the objects (in the move or in the copy constructor) the results can be unpredictable. The library has a a new parallel_sort algorithm *( internally named Block Indirect)*, for processors connected with shared memory*,* invented for the library. This new algorithm combines the speed of algorithms like the GCC parallel sort (based on OpenMP), or the Microsoft parallel buffered sort, with the small memory consumption of algorithms like the TBB sort and the Microsoft parallel Sort. Results from running on an I7 5820 with 12 threads: GCC parallel_sort 1,25 secs 1560 MB TBB parallel_sort 1,64 secs 783 MB Boost parallel_sort 1,08 secs 786 MB In a separate repository (because it uses licence-restricted software like TBB and Microsoft parallel sort, and can’t be included in the Boost library), you can find all the code needed to run the benchmarks, the library code, the benchmark programs, and shell scripts to compile and run it on your machine in Linux and Windows. For the Linux benchmarks you will need to install TBB. (https://github.com/fjtapia/sort_parallel_benchmark) We look forward to your feedback!

4 5

Re: [boost] [sort] Parallel sorting sub-library mini-review. Performance tests.
by Christophe Henry 22 Nov '16

22 Nov '16

Hi Boost Community, I did not manage yet to write a full review. One week is a bit short so a few more days will be necessary. I provide some performance tests first. To check the library performance, I pitted it against my own versions of a parallel mergesort and quicksort provided by the asynchronous library ( https://github.com/henry-ch/asynchronous) which is now ready for review, so we have a stable state for testing. I also added a parallel version inside the asynchronous library using Francisco's single-thread implementations to compare with his parallel ones. I tested on a i7-5960X. Due to time limits, I could not test on more interesting NUMA platforms (I did not get the reviewed library to compile for my KNC) so the tests do not pretend to have value outside the i7 architecture. I linked with tbb_malloc_proxy to limit memory influence. In a nutshell. I'm not a big fan of the parallel version of the algorithms. It seems to be based on std::async, so that a lot of threads are started and joined at every call. I would suggest using a threadpool. OTOH the single-threaded ones are interesting, especially the stable_sort and intro_sort for cases where usage of spreadsort is not possible. Cheers, Christophe A short summary: 100000000 uint64_t elements already sorted: OMP parallel sort : 0.390899 secs Boost parallel sort : 0.064965 secs OMP parallel stable sort : 1.06128 secs Boost sample sort : 0.0695357 secs Boost parallel stable sort : 0.0662401 secs Asynchronous parallel sort : 0.0167134 secs (same with other algorithms) Asynchronous provides a special optimization for this case. I added this one: 100000000 uint64_t elements reverse sorted OMP parallel sort : 0.317039 secs Boost parallel sort : 0.581381 secs OMP parallel stable sort : 1.06448 secs Boost sample sort : 0.524746 secs Boost parallel stable sort : 0.73036 secs Asynchronous parallel sort : 0.0478701 secs Asynchronous provides a special optimization for this case. I this the library should do it too. This one is pretty common and a popular DOS attack. 100000000 uint64_t elements randomly filled OMP parallel sort : 1.03594 secs Boost parallel sort : 0.796447 secs OMP parallel stable sort : 1.28601 secs Boost sample sort : 0.818954 secs Boost parallel stable sort : 1.13604 secs Asynchronous parallel quickspreadsort: 0.587432 secs Asynchronous quick_intro_sort : 0.728393 secs This mixing of quicksort degrading into a spreadsort works here best. The parallel adaptation of intro_sort is not bad either and best of other library algorithms. Asynchronous parallel stable sort : 1.26141 secs Asynchronous boost::stable sort : 0.804814 secs Interesting. The stable version of the library easily beats std::stable_sort I used until now. 10000000 strings randomly filled OMP parallel sort : 1.05803 secs Boost parallel sort : 0.933055 secs OMP parallel stable sort : 1.12269 secs Boost sample sort : 0.889216 secs Boost parallel stable sort : 1.56564 secs Asynchronous parallel quickspreadsort: 0.788856 secs Asynchronous quick_intro_sort : 0.893652 secs Asynchronous parallel stable sort : 1.23495 secs Asynchronous boost::stable sort : 1.21817 secs Similar results. Let's move on to big objects: 1562500 elements of size 512 randomly filled H E A V Y C O M P A R I S O N OMP parallel sort : 0.308923 secs Boost parallel sort : 0.342992 secs Asynchronous parallel_quicksort : 0.246709 secs Asynchronous quick_intro_sort : 0.269666 secs Both quicksorts are best, with a slight advantage to intro_sort. The light comparison is similar. My test code (the modified benchmark.cpp provided by the library): https://github.com/henry-ch/asynchronous/blob/master/libs/asynchronous/test… The full test results: https://github.com/henry-ch/asynchronous/blob/master/libs/asynchronous/test…

3 2

[process] daemon ideas
by Dracon Pern 21 Nov '16

21 Nov '16

I am not sure if [process] is the right library, but I am thinking about building something to manage daemon install/uninstall across platforms, for example Windows's service, OS X's launchd, systemd, and SysV init. Every operating system offers some way to launch a daemon at boot, and also the ability to stop, recover, etc. The issue is they all do it slightly differently, unlike having a common main(). My thinking is to provide a thin layer for install/remove and service notification. I have looked at Boost.Application, but it's lacking install/uninstall, and also seems overly complicated. Thoughts? Thanks, -Eric

4 3

Re: [boost] [iterator] Orbiting iterators
by Jeremy Murphy 20 Nov '16

20 Nov '16

Hi Steve, On 21 Nov 2016 3:01 AM, "Steve M. Robbins" <steve(a)sumost.ca> wrote: > > On Sunday, November 20, 2016 8:25:20 PM CST Jeremy Murphy wrote: > > Hi, > > > > just wondering what the mood in Boost.Iterator is for new features? At work > > we recently found use for an orbiting iterator, specifically a circular > > one, which effectively wraps at the start/end of a bounded range. (The > > domain is digital signal processing.) > > That sounds like what CGAL calls a Circulator; c.f. http://doc.cgal.org/ > latest/Circulator/classCirculator.html Right, yeah. Unfortunately I can't view the documentation properly on my phone so I'll take a look later, but I imagine the principle is the same although the interface is not. > > Implementation details aside, does this feature sound desirable to the > > library? > > I've found these handy when iterating through graph edges incident on a > vertex, when you need to start on a specific edge. It's been ages since I've > used them so I can't recall the exact use case. Makes me wonder whether > something like this already exists in boost graph. As you pointed out with CGAL, domain-specific implementations do exist. Boost.Geometry has something too. I guess I'm interested in whether this need for circular iteration can be abstracted back to the plain old iterator. Cheers. Jeremy

1 0

[outcome] Requesting pre-review of Boost.Outcome tutorial
by Matus Chochlik 20 Nov '16

20 Nov '16

On Fri, Nov 11, 2016 at 8:27 PM, Niall Douglas <s_sourceforge(a)nedprod.com> wrote: > Dear Boost, > > I am hoping to bring Boost.Outcome, a C++ 14 library providing a > factory and family of policy driven lightweight monadic > value-or-error transports, into the Boost peer review queue by March > 2017 followed shortly thereafter by an ACCU talk in April if my talk > proposal passes their programme committee. To that end, I've written > an explanation and a sort of tutorial explaining the history and > purpose of Outcome at https://ned14.github.io/boost.outcome/ and I'd > greatly appreciate if people could tell me: > > 1. Does it make sense? > Yes, the explanation is useful and does make sense. > > 2. Do you think you could use Outcome in your own code after reading > it? > > 3. Do you think you would want to use Outcome in your own code after > reading it? > I'm already using something similar in my oglplus2 OpenGL wrapper and some other projects and I really like the technique. IMO the C++ community would benefit from having something like this in Boost. In my implementation the outcome is a pair of the "real" result and an "error info" which can be more elaborate than an error code + a policy which by default throws an exception from the error info when the outcome is destroyed. The function caller can explicitly cancel the throwing and just examine the error information. All functions returning outcome can be noexcept. > > 4. Are there any missing parts which are showstoppers? > I didn't try to use your implementation, but I don't see anything obvious. But a shorter initial tutorial would be helpful. > > > My thanks in advance. Be aware the install stuff described at the > start doesn't work yet. The reference documentation is also quite > patchy thanks to doxygen not understanding CRTP. All that stuff and a > fair bit more remains to fix before it's ready to enter the Boost > peer review queue. > BR, Matus

2 1

Info on Sprout libraries (related to Boost?)
by charleyb123 . 19 Nov '16

19 Nov '16

Looking at the (very impressive) Sprout libraries that distributes using the Boost license: Welcome to the Sprout C++ Libraries <http://bolero-murakami.github.io/Sprout/docs/index.html#welcome-to-the-spro…> C++11 constexpr based Containers, Algorithms, Random numbers, Parsing, Ray tracing, Synthesizer, and others. https://github.com/bolero-MURAKAMI/Sprout ...It appears to be actively maintained, and very interesting. Anybody know the background and roadmap on these libraries (they are not in Boost now, right?) I'm particularly interesting in more 'constexpr' and compile-time libraries showing up, where C++14 (and C++17) wholly "throws-open-the-door" on what you can do at compile time (for example, see the C++14 constexpr used as a full C compiler: https://github.com/kw-udon/constexpr-8cc ) Crazy stuff. --charley

3 2

[fiber] maintenance status
by Tatsuyuki Ishi 18 Nov '16

18 Nov '16

The fiber library seems to be still updated, but I can't get into the author to do a feature proposal or request a refactor. Please take a look at this: https://github.com/boostorg/fiber/issues/89 I have pinged Oliver 3 times, and also sent some emails to his git committer addresses (he uses two identities). If you (the maintainer) are aware of this issue, please respond; I'm willing to do code contributions, but I must have some opinions about that before I get on to the work.

2 1

BOOST_NO_CXX11_HDR_CODECVT confusion
by Robert Ramey 17 Nov '16

17 Nov '16

I use BOOST_NO_CXX11_HDR_CODECVT from config.hpp in order to selectively enable code which uses the built-in codecvt facets as opposed to the boost "home brew" one we've been using for a long time. I do similar things with other macros such as BOOST_NO_CXX11_HDR_FORWARD_LIST. Problems arise when I use a recent compiler such as gcc 6.2 with the switch -std=c++03 as in "/hpc-6.2/usr/local/bin/g++" -ftemplate-depth-128 -std=c++03 -O0 -fno-inline -Wall -g -dynamic -gdwarf-2 -fexceptions -fPIC -arch x86_64 -Wno-unused-variable -Wno-long-long -ftemplate-depth-255 -DBOOST_ALL_NO_LIB=1 -DBOOST_FILESYSTEM_DYN_LINK=1 -DBOOST_LIB_DIAGNOSTIC=1 -DBOOST_SERIALIZATION_DYN_LINK=1 -DBOOST_SYSTEM_DYN_LINK=1 -DBOOST_WSERIALIZATION_DYN_LINK=1 -I"../../.." -c -o "../../../bin.v2/libs/serialization/test/test_iterators.test/darwin-6.2~03/debug/test_iterators.o" "test_iterators.cpp" In this ease I would expect to find that BOOST_NO_CXX11_HDR_CODECVT is defined as C++ standard does not include <codecvt> headers for versions prior to C++ 11. But the test matrix http://www.boost.org/development/tests/develop/developer/output/Sandia-gcc-… for this compilers shows that BOOST_NO_CXX11_HDR_CODECVT is NOT defined when no -std=c++03 is used. OK - I see that for gcc 6.2 the default is C++ 14 if no switch is used. So the test matrix is OK. I'm not sure what the column is meant to test as it does specify a particular version as the other columns do. So I think the test for gcc 6.2 - and all the g++/clang compiler would be improved by specifying which version of the C++ standard they are actually testing. But I still have a problem. When I use the swithc -std=c++03 I expect that BOOST_NO_CXX11_HDR_CODECVT be defined as C++ versions prior to C++ 11 don't have header <codecvt>. Same goes for other headers required only for more recent compilers. But my expectations aren't realized as BOOST_NO_CXX11_HDR_CODECVT is not defined in this case. The leads to selection of library code which invokes an #error saying that it's not supported. Perhaps definition of BOOST_NO_CXX11_HDR_CODECVT is conditioned solely on the existence of <codecvt> rather than the existence of <codecvt> and the compiler running in C++ 11+ "mode". I think this is what is messing things up for me. I might be able to work around this if I config.hpp included a macro which indicated which standard version it's intended to support. It doesn't have this. But I wouldn't need it if the BOOST_NO... worked as I would expect. Robert Ramey

3 3

MSVC opensource deployment.
by Robert Ramey 16 Nov '16

16 Nov '16

This just showed up in my junk mail box. Vcpkg updates: Static linking is now available https://github.com/Microsoft/vcpkg With 90+ libraries in its catalog, Vcpkg makes it easier to find the right open source library for Visual C++ 2015. The latest update now supports static linking. This kind of interesting: a) Does this constitute and open-source source code deployment system that perhaps we might learn from/exploit? b) I'm intrigued with the comment under "License": "Code licensed under MIT License" Boost is in this repository - I don't remember changing the Boost license. Robert Ramey

4 5

[Sort] Parallel Sorting Mini review ends November 20th (Need reviewers)
by Francisco José Tapia 16 Nov '16

16 Nov '16

Dear Boost community, The mini-review of Francisco Tapia's Parallel sorting library began in November 11, and ends November 20th. The purpose of this review is to assess whether the sub-library is useful and up to Boost software standards. If the Boost community agrees on both, Francisco and I will integrate it into the existing Boost.sort library as a separate sub-library from Spreadsort. In doing so we'll integrate the documentation with the existing documentation for Boost.Sort, making it more consistent. If you review Francisco's library, please make sure you're using a compiler that supports C++11, and answer each of these questions: 1. Were you able to run it and see accurate and fast results? Please specify your compiler, OS, and processor type, and any problems (or slowdowns) encountered. 2. Would you use this library if accepted? Why or why not? 3. What is your evaluation of the design? 4. What is your evaluation of the implementation? 5. How much effort did you put into your evaluation? A glance? A quick reading? In-depth study? The library is here: https://github.com/fjtapia/sort_parallel This library provides both stable and unstable sorting algorithms, in single threaded and parallel versions. - All the algorithms have average and worst case runtime of* O(NLogN).* - These algorithms *do not use any other library or utility*. To compile and run these you will need a *C++11 compliant compiler.* - This library is *include only*, only requiring the files in the boost/sort/parallel folder, with no external dependencies. - The algorithms *use a comparison object*, in the same fashion as std::sort, defaulting to the std::less object, which uses the < operator internally for comparisons. - The algorithms are *exception safe*, meaning that the exceptions generated by the algorithms guarantee the integrity of the objects to sort, but not their relative order. If the exception is generated inside the objects (in the move or in the copy constructor) the results can be unpredictable. The library has a a* new parallel_sort algorithm ( internally named Block Indirect)*, for processors connected with shared memory, *invented for the library*. This new algorithm combines the speed of algorithms like the GCC parallel sort (based on OpenMP), or the Microsoft parallel buffered sort, with the small memory consumption of algorithms like the TBB sort and the Microsoft parallel Sort. Results from running on an I7 5820 with 12 threads: - GCC parallel_sort 1,25 secs 1560 MB - TBB parallel_sort 1,64 secs 783 MB - Boost parallel_sort 1,08 secs 786 MB In a *separate repository* (because it uses licence-restricted software like TBB and Microsoft parallel sort, and can’t be included in the Boost library), you can find *all the code needed to run the benchmarks*, the library code, the benchmark programs, and shell scripts to compile and run it on your machine in Linux and Windows. For the Linux benchmarks you will need to install TBB. (https://github.com/fjtapia/sort_parallel_benchmark) We look forward to your feedback!

1 0

[MPL] A Proposal
by Bruno Dutra 16 Nov '16

16 Nov '16

Dear Community, About a year ago today, there was a proliferation of threads [1][2][3] in this mailing list concerning the future of Boost.MPL, or even whether it had a future at all, and opinions diverged widely on the matter. Many have expressed concerns about the fact Boost.MPL was long outdated and proposed major changes to open path for modernization, while some others argued against it, fearing unexpected and disastrous side-effects could propagate throughout the rest of Boost. A few questioned if it was worth it at all to spend any further resources on Boost.MPL given the fact new alternatives were coming up, such as Boost.Hana, which departed entirely from template metaprogramming, yet some argued TMP remained a competitive alternative for type computations in C++14 as it has been demonstrated by Peter Dimov in his impressive articles [4] on modern TMP. Amidst all this, a proposal by Robert Ramey [5] caught my attention and inspired me to develop what I call Metal [6], a template metaprogramming library designed on the same core principles as Boost.MPL, but written from the very beginning to take full advantage of C++11. Metal was not designed to be a strict drop in replacement for Boost.MPL though, it was rather meant to be regarded as a modern version of Boost.MPL's original API, diverging only where it could really benefit from modern C++ and that essentially means gains of several orders of magnitude in performance** and lower memory consumption. At this point Metal is very close to where I originally intended to bring it and I think it's time I gauge interest from the community on a modest proposal I've been maturing along the past year. As a modern approach to the same task that Boost.MPL was meant to address, I don't believe Boost would benefit at all from yet another TMP library that would essentially compete with Boost.MPL and even Boost.Hana in some cases, specially as maintainers of older code that depends on Boost.MPL would have to go through major refactoring efforts in order to benefit from such an addition to Boost. I would like to propose something different instead. My proposal is to make Metal officially into a new revision of Boost.MPL's API, essentially MPL2 as the original proposal by Robert Ramey put it, merging both into one single TMP library. The idea would be to provide a thin proxy for the current Boost.MPL API which would have two backends configurable by preprocessor switches: the original implementation and a another one based on Metal. This way older code using Boost.MPL could see immediate gains on performance by selecting the newer backend on supported compilers, while at the same time legacy code maintained on older compilers could still rely on Boost.MPL's impressive ability to run virtually anywhere. On the other hand, newer projects interested on pure type computations would have the newer API entirely available to them. This proposal also overcomes the problem of dealing with the maintainability of Boost.MPL, since it provides a way for smooth transition from legacy hacks required by ancient compilers into a cleaner and easier to maintain C++11 codebase, besides avoiding any breaking changes within existing code in the process. Furthermore, should this proposal make it into Boost, I would be naturally willing to take responsibility for the maintenance of Boost.MPL, which AFAIK has been maintained by the CMT for quite some time now, often with limited resources. Comparing Metal and Boost.MPL there are a few noteworthy differences. Metafunction Classes have proven themselves entirely unnecessary and have thus been removed altogether in favour of pure Lambdas (in the Boost.MPL sense). Moreover, iterators make little sense in a functional world, so these too have been removed despite the fact they may easily be emulated in the new design. Moreover Metal develops the concept of optionals, that is, its metafunctions only have a nested ::type defined when they may be successfully computed, what may be safely tested using metal::is_just and may also be used to SFINAE out of miscomputations. Finally I'd like to point out that Metal was designed to be portable across as many compilers as possible and three of the most popular ones are continuously tested using Travis and Appveyor: Clang 3.5+, GCC 4.8+ and MSVC 14 (2015). I hope this is a reasonable proposal and I look forward into your opinions about it. ** Even though I haven't published any benchmarks yet, an example follows just to back my claims regarding performance (just tested on my personal laptop running linux): //Generate a list containing 10 thousand instances of std::integral_constant, from 0 to 9999 using l = metal::enumerate_t<metal::integer<10000>>; // GCC 5.3 ~0.4 s // Clang 3.7 ~0.5 s //Transform a list containing 5 thousand numbers by squaring each element using l1 = metal::enumerate_t<metal::number<long long, 5000>>; using l2 = metal::transform_t<metal::pow<metal::_1, metal::integer<2>>, l1>; // GCC 5.3 ~5.6 s // Clang 3.7 ~3.0 s [1]: http://thread.gmane.org/gmane.comp.lib.boost.devel/257680 [2]: http://thread.gmane.org/gmane.comp.lib.boost.devel/257983 [3]: http://thread.gmane.org/gmane.comp.lib.boost.devel/258843 [4]: http://pdimov.com/cpp2/simple_cxx11_metaprogramming.html [5]: http://rrsd.com/blincubator.com/bi_suggestion/mpl-lite-or-mpl2/ [6]: http://brunocodutra.github.io/metal/ Regards, Bruno Dutra

12 48

Re: [boost] [MPL] A Proposal
by Bruno Dutra 16 Nov '16

16 Nov '16

On Nov 15, 2016 23:57, "Peter Dimov" <lists(a)pdimov.com> wrote: > > Bruno Dutra wrote: > >> Meanwhile, following Rene's suggestion to move away from Travis' container based infrastructure, I was also able to run tests on Clang 3.9 and even on what seems to be nightly snapshots of Clang 4.0: >> >> https://github.com/brunocodutra/metal/blob/develop/.travis.yml. > > > I don't care that much for 3.9 and 4.0, but the -stdlib=libc++ option is intriguing. Does it require sudo? I just checked and libc++-dev is whitelisted on Precise images, so it shouldn't require sudo. That said, the version of libc++ available on such an old version of Ubuntu might not fit your needs (it didn't mine) so you might need to upgrade to Trusty, in which case I believe it requires sudo, because it doesn't seem to be whitelisted yet.

1 0

[fiber] destruction order fiasco
by Tatsuyuki Ishi 15 Nov '16

15 Nov '16

The fiber still makes use of the scheduling algorithm after main context exits, which is a problem for my case that puts a stack-allocated shared data to the algorithm. Some points: https://github.com/boostorg/fiber/blob/master/src/context.cpp#L52 I doubt if the schwarz counter is needed; isn't it only one? https://github.com/boostorg/fiber/blob/master/src/scheduler.cpp#L137 I don't think there's a need to wake it up; if it's sleeping, the thread is blocked and it never enters here. This is the main problem: use-after-free. Anyway, what I think is ideal is that just making the algorithm a reference and assign it from the main context. An example of this approach is Qt's Q*Application.

1 0