December 2016 - Boost - lists.preview.boost.org

[test] Really deactivate test
by Florian Lindner 19 Dec '16

19 Dec '16

Hello, I need to conditionally decativate tests and use a custom decorator for that, like that: virtual void apply(bt::test_unit& tu) { [...] if (std::find(_ranks.begin(), _ranks.end(), rank) == _ranks.end()) { std::cout << rank << " Disable, because of rank, test: " << tu.full_name() << std::endl; tu.p_default_status.value = bt::test_unit::RS_DISABLED; return; } } (i'm happy to provide full source code, if anyone is interested) As you can see it's deativated on some MPI ranks only. However, if a user uses -t "testname" it is activated again. Is there a way to really deactivate the test? Or delete it from the test tree? Thanks, Florian

2 5

[variant] gcc crash
by Igor R 18 Dec '16

18 Dec '16

Consider the following snippet (trying to compile with Boost 1.62): ///////////////////////////////////////////////////////////// #include <boost/variant.hpp> template<class Node> struct node1_type; struct var_type; using var_base = boost::variant<int, boost::recursive_wrapper<node1_type<var_type>> >; template<class Node> struct node1_type { Node child; }; struct var_type : var_base { using var_base::var_base; }; int main() { var_type v1 = 1; } /////////////////////////////////////////////////////////////////// It crashes GCC: http://melpon.org/wandbox/permlink/A6BuYqqrG4COcfFl and produces compilation error with any released version of Clang: http://melpon.org/wandbox/permlink/1JQ7OVLV3crERRJX (Although it does compile with Clang-4 trunk). I'd appreciate if Variant maintainers could take a look at it. Thanks.

3 2

Re: [boost] [Boost-users] Stacktrace library starts review today 14th Dec
by Antony Polukhin 18 Dec '16

18 Dec '16

2016-12-15 3:44 GMT+03:00 Edward Diener <eldiener(a)tropicsoft.com>: > In the documentation for stacktrace I do not see anything about what level > of C++ is required for a compiler using the stacktrace library or any > information on what compilers have been tested when using the library. It's C++98. Tested on latest clang(c++03, c++11), gcc(c++98, c++11, c++1y), msvc. > In the section of "Build, Macros and Backends" I do not think there is > enough information about using a particular backend, other than saying that > you need to link with such-and-such. Does stacktrace "automatically" find > the header files it needs from these backends ? Even so I think some > information about where it looks for the backend header files need to be > given. I also think that some information of what libraries it looks to link > with needs to be given. I am assuming it links with the static versions of > these backend libraries unless I define either BOOST_STACKTRACE_LINK and > BOOST_ALL_DYN_LINK, or BOOST_STACKTRACE_DYN_LINK. What if I want to use the > header-only version but I want to link with the shared library backend ? I > also assume that if I link with the static library backend I should probably > be linking with the RTL static library, while if I link with the shared > library backend I should also be linking with the RTL shared library. > > What about 32-bit versus 64-bit use of stacktrace ? Do they both work as > advertised with the correct backends, whether static or shared ? I think the > "Build, Macros and Backends" need rto be expanded to cover alol these > topics. All the headers are found automatically and the library is header only if you do not define BOOST_STACKTRACE_LINK or BOOST_STACKTRACE_DYN_LINK. Backend is chosen automatically in header only mode. You need to do nothing, unless you encounter some problems on default setup (like you OS is POSIX but not LSB Core Specification 4.1) or unless you wish to disable stacktraces. If you define BOOST_STACKTRACE_LINK or BOOST_STACKTRACE_DYN_LINK you have to manually link with one of the backends. I'll try to improve the "Build, Macros and Backends" section to be more clear. -- Best regards, Antony Polukhin

3 3

[iterator][type_traits] A test is failing with gcc in c++03 mode
by Edward Diener 17 Dec '16

17 Dec '16

The zip_iterator_test_std_pair is failing with gcc in c++-03 mode. The problem reduces viqa Boost type traits to the fact that in gcc c++03 mode the expression: __is_abstract(std::pair<int&, std::string&>) where __is_abstract is a compiler intrinsic, gives an error of: error: forming reference to reference type 'std::__cxx11::basic_string<char>&' pair(const _T1& __a, const _T2& __b) ^~~~ Is this a valid error according to the C++ 2003 standard ? The test works in c++11 or c++14 mode.

4 8

Synapse library review result
by Edward Diener 14 Dec '16

14 Dec '16

The Decision --- -------- There were a total of 9 people, outside of the library author Emil Dotchevski, who reviewed/commented about the Synapse library during the review period and the Monday following where I accepted a late review and people's responses to that late review. The voting in the Synapse review is: 0 for YES 2 for NO, with one of the two a provisional NO. Among the other people who commented but did not vote I have 2 people who said they definitely liked the library and 2 people who said they definitely did not like the library. Among other commenters I interpreted 2 other people as probably approving of the library as it now is and 1 other person as probably not approving of the library as it now is. Given the actual YES or NO vote, and the small amount of people who took part in the review, and the even smaller amount of people who decided to vote YES or NO for the library, the Synapse library is NOT accepted into Boost. My decision as review manager is based on the review of the library by others and not on my own personal view of whether the library should be accepted or not. Issues ------ I want to use the next part of this decision to summarize the issues brought up largely, but not exclusively, by those who did not see the Synapse library as currently being worthwhile to become a part of Boost. This issues I summarize below may or may not be seen as relevant or not by others but they do represent the areas of criticism of the library made during the review. All the issues were answered by Emil during the review, and I think he did an excellent job of answering reviewers based on how he sees these issues. Some of these issues may be seen as unimportant or trivial or already well answered, but I want to list them all nonetheless. The issues are presented in no particular order of importance. I will refrain from making my own comments about these issues until my own general summary at the end of this review decision: 1) The current Boost signals/signals2 library is adequate for signal/slot processing and another signal/slot library such as Synapse does not provide enough of a usage argument to be added to Boost along with what already exists. 2) The documentation needs to be more expansive on the difference between Boost signals/signals2 and the Synapse library. 3) The end-user should have some sort of control where Synapse stores its information regarding the connection between signal emitters and slots ( signals handlers ). 4) Since Synapse is a C++11 library it should use C++11 standard library constructs across the board rather than their Boost equivalents. 5) There should be some "natural" way in which slots can return a value, ala the signals2 library. 6) A more flexible way of handling the slot lifetimes should be created as an addition to the shared_ptr/weak_ptr way the library currently employs. 7) A means by which a particular thread can be specified ( thread-affinity ) for a particular slot when connected should be created; or a dispatching mechanism, perhaps using asio, for connecting a slot to an emitter. 8) The ability to have signals emitted with more than four parameters should be created. 9) The fact that emitters are identified strictly by address was seen as a weakness in the design since at least theoretically, if not very often practically, it is possible for two different variables to have the same address. Connected to this is that the address of emitters is noted with a "void *" in the public interface, and that was criticized as not C++-like. 10) Connection objects should be movable rather than using shared_ptr. 11) The central dispatching mechanism is too slow for large scale continuous changes which emit signals to be handled by slots in some systems ( a stock market changes type of application was brought up as such an example ). 12) The use of only Boost function as a callable slot is too inflexible. 13) The signal type ( pointer to function whose return type identifies signals ) was seen both as cryptic and inflexible, and a deduced signal type was suggested. 14) Having more than one signal type in Boost in general was seen as a bad situation. 15) More specific information on which compilers should work with Synapse. Summary ------- First of all, thanks to everyone who participated in the review and for Emil for answering and providing explanations for his design and coding decisions. I cannot say it enough but I really hope that more people can be encouraged to look at libraries up for review and make comments, even if they do not want to make an official vote or comment on any particular area in which they do not feel they have adequate knowledge. All comments and personal or technical evaluations are important and help a review manager make a final decision, as well as telling a library author what others think of what he has done. With that said I will not try to hide the fact that I personally view the Synapse approach to signal/slot processing as different enough, and useful enough due to its non-intrusive nature, from signals/signals2 to be a valuable addition to Boost, even while I recognize that there was not enough of a consensus or enough of an interest among others during the review to have that happen now. Among the issue brought forth by others my personal view for possibly improving Synapse to where it might be more acceptable to reviewers and might draw more people's interest as a possibly Boost library in the future pending another review, lies mainly in these numbered issues above: 2), 4), 5), 7), 8), 12), 15). I also feel having the documentation discuss in more detail the major concepts of the library, as a bridge between the Tutorial and the Synopsis, would be very helpful for interesting programmers In Synapse. Of course other people's views may vary greatly, and further discussion of Synapse on the Boost developers mailing list or the Boost users mailing list is, I am sure, welcome to the author of Synapse Emil Dotchevski.

1 0

[root_ptr] documentation fix
by Phil Bouchard 14 Dec '16

14 Dec '16

Greetings, I just realized that root_ptr is "container-oriented" and therefore I added this information to the documentation: http://philippeb8.github.io/root_ptr/root_ptr/intro.html#root_ptr.intro.roo… I think this summarizes it all with these few keywords and at some point people will get tired of the garbage collectors and "click" ;) Sincerely, -Phil www.fornux.com www.finitetheory.com www.loaapu.com (in progress)

1 0

[synapse] Review
by David Sankel 14 Dec '16

14 Dec '16

On Fri, Dec 2, 2016 at 9:19 AM, Edward Diener <eldiener(a)tropicsoft.com> wrote: > > For your review you may wish to consider the following questions: > > - What is your evaluation of the design? > The design looks reasonable. > - What is your evaluation of the implementation? > I found the use of typedef's to functions returning inline struct definitions to be overly clever and cryptic to new C++ developers. I also found the lack of static type checking in certain places to be objectionable. The unusual formatting is an important subjective turnoff to potential users. Presumably the goal of the library is to enable users to get the functionality they've been missing. The hurdle of a new formatting style to get used to goes against this goal. Fortunately, this is something easily remedied. > - What is your evaluation of the documentation? > Looked reasonable. > - What is your evaluation of the potential usefulness of the > library? > Given the prior existence of Boost.Signals I wouldn't find this library to be useful. There is an important aspect to this review that I want to call out. A signal is a "vocabulary type" in that it is pervasive through systems and frequently used in public interfaces. One of the most important qualities of a vocabulary type is that there be only one of them. Imagine the confusion if we had one thread-safe shared pointer class and another one optimized for single threaded usage, or if we had an suite of different variant types with different tradeoffs. No, there should only be one signal type and Boost.Signal made the correct choice of using a so-called intrusive design. - Did you try to use the library? > Nope. > - How much effort did you put into your evaluation? A glance? A > quick reading? In-depth study? > I spent a few hours on the review. A small amount of time was reading the documentation and a much longer amount of time was spent pondering the implications of incorporating the library into Boost. - Are you knowledgeable about the problem domain? > Yes. I've used Qt signals, Boost.Signals1, and Boost.Signals2 extensively in various projects. > - Do you think the library should be accepted as a Boost library? > No. -- David Sankel

4 6

[algorithm] split_copy
by Chambers, Matthew 13 Dec '16

13 Dec '16

I like the simplicity and flexibility of boost::algorithm::split, but whenever I do some one-off, trivial split with it where performance isn't an issue, I find myself wishing that I didn't have to predeclare the result container. That is, I want a split_copy which returns the result container by value, analogous to the many other *_copy functions in boost::algorithm. This turns the split into an easy to read one-liner. Is there a technical reason that this doesn't exist, or just something the boost::algorithms developer didn't think was sufficiently sweet (syntactic-sugar-wise) to add? Thanks, -Matt

2 2

Synapse library review starts today December 2
by Edward Diener 13 Dec '16

13 Dec '16

The formal review of the Synapse library by Emil Dotchevski starts today, December 2, and is scheduled to continue through December 11. This gives two full weekends and the week in between for the formal review. Synapse is a signal programming library, similar to Boost Signals2 and the signals-slots system in Qt. The main difference is that Synapse is non-intrusive: the address of any object of any static type whatsoever can be passed to synapse::emit to emit a signal. This makes it possible to emit Synapse signals from objects of third-party types as well as system objects (e.g. standard FILE pointers, HWNDs, etc.) or any other object that can be converted to a pointer. The library has been formatted to fit the Boost directory and namespace structure. To get Synapse, clone 'https://github.com/zajo/boost-synapse.git' into a directory called 'synapse' under your boost/libs directory. See the tutorial at 'http://zajo.github.io/boost-synapse/Tutorial.html', or read full documentation at 'http://zajo.github.io/boost-synapse/index.html'. You can also view the documentation locally from your clone of the library at boost/libs/synapse/doc/index.html. Review guidelines ================= Reviews should be submitted to the developer list (boost(a)lists.boost.org) preferably with '[synapse]' in the subject. Or if you don't wish to for some reason or are not subscribed to the developer list you can send them privately to me at 'eldiener at tropicsoft dot com'. If so, please let me know whether or not you'd like your review to be forwarded to the list. For your review you may wish to consider the following questions: - What is your evaluation of the design? - What is your evaluation of the implementation? - What is your evaluation of the documentation? - What is your evaluation of the potential usefulness of the library? - Did you try to use the library? With what compiler? Did you have any problems? - How much effort did you put into your evaluation? A glance? A quick reading? In-depth study? - Are you knowledgeable about the problem domain? And finally, every review should attempt to answer this question: - Do you think the library should be accepted as a Boost library? Be sure to say this explicitly so that your other comments don't obscure your overall opinion. Even if you do not wish to give a full review any technical comment regarding the library is welcome as part of the review period and will help me as the review manager decide whether the library should be accepted as a Boost library. Any questions about the use of the library are also welcome. I encourage all programmers with an interest or knowledge of signal/slot processing to be part of the review or discussion of the Synapse library as your time permits.

8 27

[spirit] [qi] What's the differences between qi::uint_parser<int>() and qi::uint_parser<unsigned int>()?
by Han Wang 13 Dec '16

13 Dec '16

Both of them are the same as qi::uint_(parsing integers from 0 to UINT_MAX). For qi::uint_parser<int>, the required maximum value of numeric base type int is not used at all.

2 1

[release 1.63] required bugfixes
by Oliver Kowalke 13 Dec '16

13 Dec '16

Hi, during the test of boost-1.63 rc 1 some problems occurred (see Marshall's and Stephan's postings). I request to merge my last commits (on branch master) from boost.context and boost.fiber into boost-1.63 (rc 2?) - as well as commit 13f5d9c88ae5363fe547f04c1d272b2a772a8b4d from boost.config. Otherwise the build will fail for gcc-7.1, clang-4.0 and mingw64. best regards, Oliver

1 0

[fiber] Boost.Fiber 1.63.0 RC1 tries to use std::mutex which MinGW doesn't have
by Stephan T. Lavavej 13 Dec '16

13 Dec '16

In both 1.62.0 and 1.63.0 RC1, building Boost.Fiber with my MinGW-w64 distro fails. That's because libstdc++ doesn't natively support the Clause 30 multithreading headers (std::mutex etc.) on Windows, and I make no attempt to build wrappers between the Windows and POSIX APIs (which is my personal choice). Boost's build system should detect this, and use the perfectly valid Boost.Thread implementation. Indeed, "C++11 mutex : no" is printed during the build's configuration, but Fiber's build fails anyways. My configuration output, and the errors emitted by a typical translation unit, are recorded here: https://github.com/StephanTLavavej/mingw-distro/issues/28 Thanks, STL

1 0

copied boost files in other projects
by Oliver Kowalke 12 Dec '16

12 Dec '16

I encountered some projects that have copied files from boost and replaced the copyright and license notice by their own. Other projects have added their own license (for isntance MIT, LGPL ...) beside the Boost license notice in the copied files - does this mean that the code is dual licensed now?. How does the boost community deal with this? Oliver

9 16

Review period has ended for the Synapse library
by Edward Diener 12 Dec '16

12 Dec '16

The review period has officially ended for the Synapse library by Emil Dotchevski. I have received one e-mail specifying a review that will come sometime today and therefore will wait before making my decision as Review Manager for that review and Emil's possible response. I would like to thank all those who took part in the review during the review period, and Emil for responding to the remarks of those who have participated. I know another library will shortly begin its review, but I will not rush my final analysis and decision regarding Synapse and intend to make it sometime by the end of this week. Edward Diener, review manager

1 0

Re: [boost] [synapse] Synapse library review starts today December 2
by Barrett Adair 12 Dec '16

12 Dec '16

On Fri, Dec 2, 2016 at 8:19 AM, Edward Diener <eldiener(a)tropicsoft.com> wrote: > - What is your evaluation of the design? I don't know anything about Signals2, but I find the "non-intrusive" argument to be compelling. I don't like that the invocation mechanism is single-threaded by default. I think the thread_local approach is interesting, but it sounds ripe for confusion in application code. > - What is your evaluation of the implementation? This code style is quite foreign to me, but it seems consistent. The mix of Boost and std libraries seems arbitrary (e.g. boost::shared_ptr and <thread>). The Boost.Function dependency appears redundant. The callback is effectively being erased twice. std::invoke or equivalent could serve as a replacement. I don't much like signal_traits.hpp and the limitations it imposes. Arity is capped at 4 parameters, and the signal type must be passed explicitly. The latter is surely good for compile times, but I think it would be nice to have a deduced signal type version that could still support stateful lambdas and member functions. I browsed the test cases, and they seem rather in-depth. I think some comments in this code are warranted. > - What is your evaluation of the documentation? The tutorial is very well done. Overall, the documentation is very solid. I enjoyed reading it. Quickbooks and syntax highlighting would be nice. This line was disappointing: "requires compiler support for the following C++11 features" I have seen this in existing Boost library documentation, so there is precedent, but I do not like it at all. I much prefer to see a range of tested compiler versions, even if it's only a couple. Continuous integration services like Travis and Appveyor are free, and very useful toward this end. > - What is your evaluation of the potential usefulness of the > library? It appears that it could be useful to Qt users. I personally would not find this useful. > - Did you try to use the library? With what compiler? Did you > have any problems? I ran the logger example with GCC 5.3 on Ubuntu 16.04. No problems. > - How much effort did you put into your evaluation? A glance? A > quick reading? In-depth study? 4 hours combined of reading the documentation and playing around with the implementation code. > - Are you knowledgeable about the problem domain? My experience with C++ signal libraries is limited. I am comfortable using the Intel TBB flow graph library, which has some degree of overlap. I have a bit of experience with event-driven programming in other languages. I am knowledgeable about C++ callable types and compiler support for their variations. > - Do you think the library should be accepted as a Boost library? This is my first formal review participation, I don't have a library in Boost, I'm not familiar with Signals2, and I do not have a use case for Synapse, so I'm not going to answer this question. Please consider this message as a "technical comment" instead. P.S. For whatever it's worth, I did fork the Synapse code and implement tentative variadic support in connect.hpp and emit.hpp (though I did not get around to translate.hpp). https://github.com/zajo/boost-synapse/compare/master...badair:master It appears to work as-is with the logger example, but similar work would need to be done in translate.hpp to make it fully variadic. I used my proposed CallableTraits library with the intention of implementing deduced signal types, but I ran out of willpower. Please forgive the aggressive formatting.

2 1

Boost.IOStreams mapped_file_sink missing flush() functionality
by AB 11 Dec '16

11 Dec '16

Hello, I wish to bring to your attention two issues regarding mapped_file_sink from Boost.IOStreams (release 1.62.0): 1. There is no member function `mapped_file_sink::flush()` which I would like to use in my program. I believe it could be implemented portably by using `msync()` for POSIX and `FlushViewOfFile()` for Windows; was the omission of this function a deliberate choice or a minor oversight? 2. The member functions `begin()` and `end()` are implemented for mapped_file_sink but are not documented! This will lead to programmers relying strictly on the docs to use `data()` and `data()+size()` instead. Please update the documentation for the next release 1.63.0.

3 3

[1.63.0] Master is closed for beta release + release notes
by Daniel James 10 Dec '16

10 Dec '16

Hello everyone, The master branch is now closed for the beta release. Please can you add any remaining entries to the release notes, either by emailing me, or by creating a pull request at: https://github.com/boostorg/website/blob/master/feed/history/boost_1_63_0.q… To do so, click on the little pencil icon at the top right of the code. thanks, Daniel

4 3

Synapse library review final 2 days
by Edward Diener 10 Dec '16

10 Dec '16

Today and tomorrow are the last 2 days of the review of the Synapse library by Emil Dotchevski. If anybody intends to review the Synapse library but cannot finish their review this weekend, but will be able to finish their review by this coming Monday, please e-mail me and I will take into account your review when making my decision as Review Manager. I encourage all those who are interested in signal/slot programming to look at Synapse and make a review. Synapse is a signal programming library, similar to Boost Signals2 and the signals-slots system in Qt. The main difference is that Synapse is non-intrusive: the address of any object of any static type whatsoever can be passed to synapse::emit to emit a signal. This makes it possible to emit Synapse signals from objects of third-party types as well as system objects (e.g. standard FILE pointers, HWNDs, etc.) or any other object that can be converted to a pointer. The library has been formatted to fit the Boost directory and namespace structure. To get Synapse, clone 'https://github.com/zajo/boost-synapse.git' into a directory called 'synapse' under your boost/libs directory. See the tutorial at 'http://zajo.github.io/boost-synapse/Tutorial.html', or read full documentation at 'http://zajo.github.io/boost-synapse/index.html'. You can also view the documentation locally from your clone of the library at boost/libs/synapse/doc/index.html.

1 0

[stacktrace] Prereminder of Boost.Stacktrace review starting 14th
by Niall Douglas 10 Dec '16

10 Dec '16

I know we are all likely feeling a bit of tired of reviewing potential new Boost libraries, but I just wanted to remind everyone that Antony's Stacktrace library will start its peer review this coming Wednesday Dec 14th with the review lasting until just before Christmas, Dec 23rd. I appreciate this reminder is a little early given the Synapse review doesn't finish until tomorrow, but today I have the time to do email using both hands, and I likely won't get the time again until next weekend (newborns force a lot of single handed typing with your neck twisted hard to the side. Very slow). Edward I hope this doesn't get in the way of concluding your very interesting review. Antony's Stacktrace library adds a long overdue facility to Boost, a formal portable API for obtaining and parsing the call stack of a thread of execution. It has three user selectable backends, tries to provide a maximum performance (nomalloc) stack capture and I think by now can serialise stacktraces to storage. I'll be honest in saying I sent a long list of fairly strong concerns I had with the design and implementation to Antony last month, but I'll defer in the review to whatever the community votes (increasingly me and the Boost consensus seem to be diverging on what makes for good design and practice). I'll make the formal review announcment on Wednesday, but for those wanting to get started early go to: Github: https://github.com/apolukhin/stacktrace Docs: http://apolukhin.github.io/stacktrace/index.html Regards, Niall -- ned Productions Limited Consulting http://www.nedproductions.biz/ http://ie.linkedin.com/in/nialldouglas/

1 0

[fusion] Compilation errors on Intel compiler (C++14)
by Andrey Semashev 08 Dec '16

08 Dec '16

Hi, I'm seeing compilation errors coming from Boost.Fusion headers on Sandia-intel-17.0-c++14: http://www.boost.org/development/tests/develop/developer/output/Sandia-inte… Notably, the same tests compile fine in C++11 mode on the same compiler, which makes me think that is related to C++14 mode specifically. Looking at the code, it seems the compiler makes constexpr functions implicitly const-qualified even though it shouldn't in C++14 mode, so it's likely a compiler bug. Still, is it possible to add a workaround?

3 3

Solaris Boost Install headaches
by Paluzzi, Aaron 08 Dec '16

08 Dec '16

Hello, I'm currently banging my head against a Boost install on Solaris 10 Sparc. I started with a 1.57 download and install. This had mild success using the "Getting started" documentation with some compilation errors. I've been asked to upgrade this to 1.62, and now I'm getting errors as follows when I run ./bootstrap.sh $ ./bootstrap.sh -n Building Boost.Build engine with toolset ... Failed to build Boost.Build build engine Consult 'bootstrap.log' for more details In the Bootstrap.log file I get the following: ./build.sh: syntax error at line 135: `machine=$' unexpected I've been unable to find any further documentation on this error. Any assistance would be appreciated. Actually an in depth install guide for Solaris would be appreciated. I've had no issues on Windows, but Solaris is giving me migraines.

2 1

Synapse library review ongoing
by Edward Diener 07 Dec '16

07 Dec '16

We are in our final 5 days of the review of the Synapse library. We have had some good discussions about Synapse for those willing to review the library, but we really need much more from those who are, or might be, interested. Without wishing in any way to limit reviews or discussions to specific topics I would like to suggest to those interested in the library that they might address soem of these particular questions about Synapse in their commenst or review: 1) Is the documentation understandable for programming with Synapse ? 2) Does the library successfully achieve what it says it can do, providing a non-intrusive signal/slot system ? 3) Is the Synapse syntax easy enough for a programmer to use ? 4) Does testing show that Synapse works with user's code ? 5) Is the design of the library clear enough and flexible enough to make working with it viable ? While I realize that much of the discussion has been about particular end-user's preferences for a signal/slot library or Synapse's way of doing signal/slot programming versus Boost Signals/Signals2, all important topics in a review, it would be helpful if reviewers or commenters would consider Synapse for what it does do, even if they might not personally find a use for it in their programming tasks. ----------------------------------------------------------------------- Synapse is a signal programming library, similar to Boost Signals2 and the signals-slots system in Qt. The main difference is that Synapse is non-intrusive: the address of any object of any static type whatsoever can be passed to synapse::emit to emit a signal. This makes it possible to emit Synapse signals from objects of third-party types as well as system objects (e.g. standard FILE pointers, HWNDs, etc.) or any other object that can be converted to a pointer. The library has been formatted to fit the Boost directory and namespace structure. To get Synapse, clone 'https://github.com/zajo/boost-synapse.git' into a directory called 'synapse' under your boost/libs directory. See the tutorial at 'http://zajo.github.io/boost-synapse/Tutorial.html', or read full documentation at 'http://zajo.github.io/boost-synapse/index.html'. You can also view the documentation locally from your clone of the library at boost/libs/synapse/doc/index.html.

1 0

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

07 Dec '16

>boost.asynchronous looks to have many of the same features/functionality as HPX. >Can I ask why you chose to reimplement futures/lightweight thread pools/parallel STL/etc, >rather than working on improving HPX to suit your needs? I don't think the libraries have the same goals (or at least it seems to me so). Asynchronous is first of all an architecture tool focusing on organizing a whole application into thread worlds. The libraries also do not have the same design / tradeoffs. Asynchronous can make use of futures but encourages callbacks and tries to make these as safe as possible. The goal is to be as asynchronous (meaning non-blocking) as possible. It is no coincidence that I'm also the author of Boost.MSM. The encouraged design is a whole lot of state machines, each in its own thread (possibly sharing a thread), sending tasks to threadpools, TCP connections, etc. and waiting for callbacks. Future-based designs do not mix well with state machines' run-to-completion. The reason for the non-blocking focus is that I'm using the library at work in an industrial 24/7 application. When working on the production line, blocking is a disaster. If an algorithm goes astray, or simply takes longer than usually, blocking the production line results in huge costs. Crashes due to races also. Asynchronous provides ways to avoid both. >JB >Disclaimer : I have contributed o HPX, but I'm not one of the "German HPC Guys" :) . No hard feeling. I'm grateful for participation and the chance to explain the underlying ideas of the library. Thanks, Christophe

4 25

[serialization][test] failures in serialization causing regressions
by Barend Gehrels 06 Dec '16

06 Dec '16

> The regression matrix in develop of Boost.Geometry contains many new > compilation failures due to: > > > 1) : D:\t08\run\boost_root\boost/serialization/array.hpp(25) : error C2039: 'array' : is not a member of 'std' > > 2): > ../boost/numeric/ublas/storage.hpp: In member function ???void boost::numeric::ublas::unbounded_array<T, ALLOC>::serialize(Archive&, unsigned int)???: > ../boost/numeric/ublas/storage.hpp:331:18: error: ???make_array??? is not a member of ???boost::serialization??? > ar & serialization::make_array(data_, s);and a > > > The master is still OK. > > Can this be solved? Ping! This is still the case! Robert, can you explain this? It is (of course) not only geometry failing, also ublas or (if there are) other libraries with ublas dependencies: http://www.boost.org/development/tests/develop/developer/numeric-ublas.html All yellow! Thanks, Barend

3 8

Re: [boost] [process] Formal Review starts today, 27 October
by Bjorn Reese 04 Dec '16

04 Dec '16

On 10/27/2016 08:26 AM, Antony Polukhin wrote: > - Whether you believe the library should be accepted into Boost > * Conditions for acceptance I withhold judgement for now to give the author an opportunity to respond. At the moment I am unsure whether to vote for conditional acceptance or rejection. > - Your knowledge of the problem domain Advanced on Unix. > You are strongly encouraged to also provide additional information: > - What is your evaluation of the library's: > * Design I have a couple of serious concerns. My first concern is about the use of tagged arguments, and especially the redirection operators, in constructors. Instead I propose that the library uses the Named Parameter idiom (see [1], not to be confused with what Niall labelled "tagged name parameter" idiom.) The bp::child object should not execute in the constructor, but rather via operator(). That way we can use the named parameter idiom to build up redirections and similar modifications. For example: auto compile = bp::child("c++").output(bp::null); compile("main.cpp"); // Executes My second concern is about deadlocking. The FAQ shows two ways of deadlocking. I would expect the latter (the ls example) to work without further ado because that is how any newcomer would write their code. My third concern is about the chaining of pipes between processes. The tutorial shows an example where the output of the nm command is forwarded to the c++filt command. However, the forwarding is not done directly from the nm process to the c++filt process, but goes via the parent process. This can incur a performance degradation when nm generates much output. Is it possible to chain them directly? Besides "nm myfile | c++filt" that is. I also have the following minor comments / questions. Is it possible to redirect stderr to stdout? (like 2>&1). The reference documentation only mentions this under asynchronous pipe output. The bp::starting_dir should be renamed to bp::current_path to be consistent with Boost.Filesystem. Consider renaming bp::spawn to avoid confusion with boost::asio::spawn which is how you launch coroutines with Boost.Asio. I am missing a this_process::get_id() function to return the current process identifier. > * Implementation My major concern with the implementation is that the library is only header-only, so I cannot compile it as a static library if I wish to. There are several Boost header-only libraries that allows you to do that. The reason why I find this important for Boost.Process is because I want to avoid getting platform-specific C header files included into my project when I include a Boost.Process header. The library should throw its own process_error exception which inherits from system_error, similar to Boost.Filesystem. I did not investigate the implementation in greater detail. > * Documentation The documentation is lacking an entire chapter with an overall description of the library and the concepts used. For instance: * What are processes and pipes? * What are the possible invocation mechanisms? Some of this is mentioned in the Design Rationale, but that is not the place where developers seek their information. * How to set search paths or the current working directory. * How to use environment variables. * this_process Tutorial / Synchronous I/O: What is the default behaviour when I/O redirections are not specified? Tutorial / Asynchronous I/O: Consider including an example with boost::asio::spawn as a way to obtain the yield context. Reference / child: Does not mention how the life-time of the object and the child process are related. For instance, the documentation on the destructor only mentions that it is a destructor. Reference / cmd: bp::cmd will parse the input string as a sequence of space-separated arguments. Is it spaces or whitespaces? Is it possible to have escapes for arguments that do contain spaces? > * Tests Did not investigate. > * Usefulness A process library is a very useful addition to Boost. > - Did you attempt to use the library? If so: > * Which compiler(s) > * What was the experience? Any problems? Did not try. > - How much effort did you put into your evaluation of the review? About 4-5 hours (one of which was gratuitously donated by daylight saving time.) [1] https://en.wikibooks.org/wiki/More_C%2B%2B_Idioms/Named_Parameter

11 49

API/ABI changes report for Boost
by Ponomarenko Andrey 02 Dec '16

02 Dec '16

Hello, The report on API/ABI changes in the latest releases of Boost: https://abi-laboratory.pro/tracker/timeline/boost/ The report is generated by the open-source abi-tracker tool and updated three times a week. Hope it will be helpful for users and maintainers of the library. Thank you.

1 0

[poly_collection] Request for comments: fast polymorphic collections
by Joaquin M López Muñoz 02 Dec '16

02 Dec '16

A couple of years ago I wrote two blog entries about high-performance data structures for polymorphic objects: http://bannalia.blogspot.com/2014/05/fast-polymorphic-collections.html http://bannalia.blogspot.com/2014/05/fast-polymorphic-collections-with.html that spurred some interest in the community. Now I've had the time to turn these ideas into something resembling a full-fledged library: https://github.com/joaquintides/poly_collection http://rawgit.com/joaquintides/poly_collection/website/doc/html/index.html and I'd be very grateful if people could give their opinion on usefulness, design, etc. so as to determine potential interest in an eventual official submission to Boost. Thank you, Joaquín M López Muñoz

6 21

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

01 Dec '16

>After having a deeper dive into the documentation and examples, one >pattern I see popping up quite >frequently is this: >future<R> fut = my_promise.get_future(); >post_callback(some_work, [this](expected<R> r) { >this->my_promise.set_value(r.get()); }); >return fut; This is simply to make examples easier to run (it finishes the example). It demonstrates that the only one which blocks in an application built on Asynchronous is main(). This might be more confusing than useful and I probably should get rid of this. >Is there any performance/usability drawback from this (might have gotten >the syntax wrong here): >return post_future(pool, some_work); > >Why is the former to be preferred to the latter, or vice versa? post_future is the preferred for simple applications or examples. It is similar to std::async (without the problem of blocking futures and with different continuations). post_callback is the design the library seeks to promote for bigger applications: post a task to a threadpool, get a callback posted to the queue of the caller's thread world. >Regarding the documentation overall, >it seems to miss a proper reference section. >For example, boost::asynchronous::expected is used almost >everywhere, but not documented. My bad. Will be corrected. Thanks, Christophe

2 2

Asynchronous library now in Boost Library Incubator
by Christophe Henry 01 Dec '16

01 Dec '16

Dear Community, The Asynchronous library is now listed in the Boost Library Incubator ( http://blincubator.com/bi_library/asynchronous-2/?gform_post_id=1654) I took a lot of time since first presenting it in C++ Now 2014 in order to extend the scope and intensively test the library. The library has been in use in production code for already 1.5 years, has survived billions of calls and usage 24/7, so its core is stable and quite tested. All algorithms have not been used though so that bugs are possible there. The reason for using the Incubator is, the library is quite big and 2 weeks review will not be sufficient so I hope for comments, discussions or pre-reviews earlier on. Asynchronous is first of all an architecture tool. It allows organizing a complete application into Thread Worlds, each world having the possibility to use the same or different threadpools for long-lasting tasks. The library provides an implementation of the Active Object pattern, extended to allow many Active Objects to live in the same World. It provides several Threadpools and many parallel algorithms making use of them. And most important of all, it allows simple, blocking-free asynchronous programming based on thread-safe callbacks. It also provides very useful logging and HTML diagnostics (see https://htmlpreview.github.io/?https://raw.githubusercontent.com/henry-ch/a…) to allow better understanding of code. I look forward to an interesting and lively discussion. Christophe

6 7

Upcoming review of the Synapse library starting tomorrow
by Edward Diener 01 Dec '16

01 Dec '16

The formal review of the Synapse library by Emil Dotchevski starts tomorrow, December 2 and is scheduled to continue through December 11. I will be making an official announcement tomorrow, but I want to give the following information today for anyone wishing to acquaint themselves with the library. As explained previously by Emil Dotchevski when requesting that Synapse be put on the Boost Review list, Synapse is a signal programming library, similar to Boost Signals2 and the signals-slots system in Qt. The main difference is that Synapse is non-intrusive: the address of any object of any static type whatsoever can be passed to synapse::emit to emit a signal. This makes it possible to emit Synapse signals from objects of third-party types as well as system objects (e.g. standard FILE pointers, HWNDs, etc.) or any other object that can be converted to a pointer. The library has been formatted to fit the Boost directory and namespace structure. To get Synapse, clone 'https://github.com/zajo/boost-synapse.git' into a directory called 'synapse' under your boost/libs directory. See the tutorial at http://zajo.github.io/boost-synapse/Tutorial.html, or read full documentation at http://zajo.github.io/boost-synapse/index.html. The documentaion can also be viewed from the local clone at boost/libs/synapse/doc/index.html. I would urge anyone who may be interested in signal/slot processing in C++ to take a good look at the Synapse library. Edward Diener, review manager

1 0

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

01 Dec '16

>I'm trying to digest the docs for this monster work. > >One things that strikes me immediately is that the doc preparation >does not use code snippets, and so code is in boring old >black'n'white rather than colored syntax. >For me, that makes it significantly harder to read (and understand) the code examples. Ok, I'll see if I can improve this. >It also means that one doesn't have the assurance that 'What You See is What Compiles'. For most features, the doc provides a link to an example, which I regularly compile. >(I've also having trouble finding things in all the plentiful 'good stuff'. >But that's a common (and largely still unsolved) >problem with all documentation.) >Paul Please let me know what is the "good stuff" for you and I'll make it more visible. Cheers, Christophe

2 1

[compute] Remove boost::chrono lib dependencie
by Viktor Sehr 01 Dec '16

01 Dec '16

Hi, Would it be possible to remove the dependency for boost/chrono is boost/compute/detail/duration.hpp. As it already supports std::chrono via a macro, couldn't the inclusion of boost/chrono.hpp be excluded? As it is now, boost compute is dependent on having libboost_chrono-vc140-mt-gd-1_62.lib built. /Viktor

4 4