November 2018 - Boost - lists.preview.boost.org

[asio][coroutine] forbid_suspend blocks
by Vinícius dos Santos Oliveira 07 Aug '19

07 Aug '19

I've implemented a dumb linter using Python + clang API that allows you to mark certain blocks as “atomic in respect to coroutines” using C++11 attributes. Usage example follows: void f() { int yield; g(yield); [[bt::forbid_suspend]] { // Comment this call to make linter accept the code g(yield); t(); } } You can change bt::forbid_suspend to another identifier by tuning settings on the beginning of the script. The prefix forbid was inspired by Rust's linters[1] as you cannot disallow the linter from inside the forbid_suspend block. Some limitations follow: - A suspend point is identified by looking references to any id equals to yield in the last argument passed to function calls. It means that yield[ignored_ec] and alike will be correctly identified, but it needs to be named yield and it needs to be the last argument to the function call. - I haven't found a way to extract attributes related to COMPOUND_STMT nodes with clang API, so I manually look for token gaps and do a simple regex. It means you cannot use macros to [[bt::forbid_suspend]] as the macro won't be expanded. - You better call the script with '-x c++' and also ' -I/usr/lib/clang/5.0.1/include'. Like I've said in the beginning of the email, it's a *dumb* linter, which means it doesn't try to handle all cases. Therefore, I don't hope to do many changes to it or maintain it to work against newer releases of clang and I'm only uploading it to gist (not fullblow Github): < https://gist.github.com/vinipsmaker2/d930fbe5b7597432b021effe618da171>. It should also be easy to hack as it is very small. I'm releasing the linter under public domain. Enjoy. I have been using fibers in a daily basis on the last months of my job to solve networking problems on a gateway project. Some of the technologies I use are: - Boost.Asio and its spawn function. - A few custom synchronization primitives for the fibers (e.g. mutex, semaphore). - Eventually I'll have to write a custom spawn function that returns a joinable handle so I can kill the usage of a fiber::barrier in a few places. I've been using the linter for about a week already and looks fine. My use case are: - To prevent iterator invalidation in regions accessing shared variables. - To guarantee events order in algorithms that handle races (cannot yield while task YYY hasn't finished). The project I use it in is not an open source project, so I cannot talk much more about it. Also, I don't claim my solution is original. I wouldn't be surprised if the very same solution exists in the wild (please let me know if you know of a similar approach). This is not a new problem. It is know for some time. For instance, in P0171, Gor Nishanov noted this same problem: “In coroutines the suspend point is clearly marked with await, which tells the reader that something unusual happens in this function and allows the reader, for example, to confirm whether the lifetimes of the objects of interest align with the lifetime of the coroutine or not, whether some locks need to be acquired to protect some concurrently accessed data, and whether some locks need to be released before the execution reaches the suspend point.” — <http://open-std.org/jtc1/sc22/wg21/docs/papers/2015/p0171r0.html>, 2015 However, the solution he presented was to manually examine whole blocks of code without help from the compiler. I argue that the solution he presented is as error-prone as manually looking for exit paths that don't free acquired resources in languages lacking RAII. And I've been spoiled too much by RAII. Furthermore, I take this comment of his with highly suspicious look: “Since we are on the subject of maintenance nightmares, we would like to offer a conjecture that the absence of the await in P0114 is a likely source of many maintenance nightmares. Without a syntactic marker to signal to the person reading the code that something funny is going on, it is impossible to tell whether the following code is correct or not” — http://open-std.org/jtc1/sc22/wg21/docs/papers/2015/p0171r0.html If I had to give a vote to the proposal he was defending or Chris' proposal, I'd probably have chosen Chris'. [1] https://doc.rust-lang.org/reference/attributes.html# lint-check-attributes -- Vinícius dos Santos Oliveira https://vinipsmaker.github.io/

2 3

Non-ASCII Path Names in Repo
by Tom Kent 25 May '19

25 May '19

In the last few days we've had a non-ASCII path name added to the repo: tools/boostdep/test/utf8-test-ßµ™∃ Which came with commit 8893d1c57951a [1] I noticed this because a python 2 script (calling shutil.copytree) I had running on windows that copied the repo around started to fail. I've long needed to update that script to python 3, and am working on this. However, I wanted to point this out to the list so we could discuss if there are any other ramifications of having a non-ascii path. I vaguely remember some discussion about something like this in the past, but couldn't find it via search. If this is already a settled topic, that's great. Tom [1] https://github.com/boostorg/boostdep/commit/8893d1c57951a4a83705ed203005576…

2 1

Re: [boost] [ Interest? ] [ out_ptr ] Tiny C++ Abstraction for C-Style Output Pointers
by Bjorn Reese 12 May '19

12 May '19

On 06/28/18 21:03, ThePhD via Boost wrote: > out_ptr is a small abstraction for making types such as > std::unique_ptr, std::shared_ptr, boost::shared_ptr, and the upcoming > std::retain_ptr > <http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0468r0.html> work > work C-Style output functions as a parameter, addressing the need of > wanting to be able to do "my_c_api_init( foo, bar, &my_smart_ptr );". It's Does out_ptr have other use-cases than C interoperability?

7 14

[thread] compiler error gcc 7.3 on cygwin
by James E. King III 06 May '19

06 May '19

Getting an internal compiler error with gcc 7.3 but only on cygwin 64-bit. Jim@pulsar /cygdrive/c/boost/libs/thread $ ../../b2 --abbreviate-paths toolset=gcc cxxstd=11 define=_POSIX_C_SOURCE=200112L define=__USE_ISOC99 threadapi=pthread address-model=64 variant=release -q ... gcc.compile.c++ ../../bin.v2/libs/thread/test/test_10963_c.test/gcc-7.3.0/rls/cxstd-11-iso/thrd-mlt/vsblt-hdn/test_10963_c.o In file included from ../../boost/thread/detail/invoker.hpp:30:0, from ../../boost/thread/future.hpp:31, from ../../libs/thread/test/test_10963.cpp:13: ../../boost/thread/detail/invoke.hpp: In function ‘decltype (*(forward<A0>)(boost::detail::invoke::a0).*boost::detail::invoke::f) boost::detail::invoke(Fp&&, A0&&) [with Fp = void (boost::executors::basic_thread_pool::*)(); A0 = boost::executors::basic_thread_pool*]’: ../../boost/thread/detail/invoke.hpp:102:43: internal compiler error: in gimplify_expr, at gimplify.c:12006 return (*boost::forward<A0>(a0)).*f; ^ Please submit a full bug report, with preprocessed source if appropriate. See <https://gcc.gnu.org/bugs/> for instructions. "g++" -std=c++11 -fvisibility-inlines-hidden -m64 -mthreads -O3 -finline-functions -Wno-inline -Wall -pedantic -fvisibility=hidden -Wextra -Wno-long-long -Wno-unused-parameter -Wunused-function -pedantic -DBOOST_ALL_NO_LIB=1 -DBOOST_THREAD_THROW_IF_PRECONDITION_NOT_SATISFIED -DNDEBUG -D_POSIX_C_SOURCE=200112L -D__USE_ISOC99 -I"../.." -c -o "../../bin.v2/libs/thread/test/test_10963_c.test/gcc-7.3.0/rls/cxstd-11-iso/thrd-mlt/vsblt-hdn/test_10963_c.o" "../../libs/thread/test/test_10963.cpp" ...failed gcc.compile.c++ ../../bin.v2/libs/thread/test/test_10963_c.test/gcc-7.3.0/rls/cxstd-11-iso/thrd-mlt/vsblt-hdn/test_10963_c.o... If I change the C++ language level to 03 the problem goes away. I also cannot reproduce it on linux with the same version of compiler (but it probably isn't the exact same compiler code). Should I go ahead and file that gcc bug? - Jim

2 1

[test] unit test command-line handling
by Stefan Seefeld 22 Mar '19

22 Mar '19

Hello, this is a question concerning the Boost.Test framework. I'd like to pass command-line arguments to my tests, and I'm unsure of how to proceed. I have found https://www.boost.org/doc/libs/1_68_0/libs/test/doc/html/boost_test/adv_sce…, which shows how to access the command-line programmatically, but that's declared obsolete, and it's also lacking some important info, such as how I should handle the argv vector. Are there any examples that demonstrate this use case ? Specifically: * What (non-deprecated) API can I use to access command-line arguments during test initialization ? * How does my own handling of command-line arguments interact with Boost.Test's own command-line argument handling ? Thanks, Stefan -- ...ich hab' noch einen Koffer in Berlin...

3 8

[Website] Revised $Date$
by Olaf van der Spek 11 Dec '18

11 Dec '18

Hi, I don't think this is what it's supposed to be. > Revised $Date$ https://www.boost.org/development/index.html -- Olaf

1 1

Reminder: 1.69 closes for major changes Wednesday
by Marshall Clow 10 Dec '18

10 Dec '18

Upcoming dates: * 31-Oct: Boost 1.69.0 closed for major code changes * 7-Nov: Boost 1.69.0 closed for beta * 14-Nov: Boost 1.69.0 beta 1 * 5-Dec: Boost 1.69.0 closed for release * 12-Dec: Boost 1.69.0 release -- The Boost Release Team

4 3

[histogram] should some_axis::size() return unsigned or int?
by Hans Dembinski 04 Dec '18

04 Dec '18

Dear community (especially the reviewers of boost.histogram), I am still working on finishing the library based on the excellent reviews I got in September. I cannot make up my mind about a specific detail of the library interface and would like to ask for your input. Every axis type is required to have a size() method, which returns the number of bins along that axis (without counting extra bins for under- and overflow). Should this method return `unsigned` or `int`? = The case for `unsigned` = The size of an axis is non-negative, so the return type should reflect this. All the STL containers return their size as an unsigned integer. Naturally, boost.histogram should be as consistent as possible with the STL, so you don't have think about exceptions from the general rule. Whether `size()` returns a signed or unsigned type matters even in times of `auto`, since compilers like to warn about comparisons between signed and unsigned integers. These warnings and the STL have slowly thought people to write indexed loops with unsigned integers, like so: ``` auto h = make_histogram(…); // 1D histogram for (unsigned i = 0; i < axis.size(); ++i) { auto x = h[i]; // do something with bin } ``` We don't want to break this painfully learned habit by letting `size()` return a signed integer, because it would generate a warning in this naive loop. = The case for `int` = The type of the bin index returned by an axis is `int`, because it can be negative. An axis is required to return -1 when the axis represents an ordered range and the value fall below the low edge of the first bin. So the index must be signed. The size of an axis is highest index + 1. It would be natural to use the same type for `size()` and for the returned index. Internally in the library, there are many less-than comparisons between the index and the size of the axis. If the type of the latter is unsigned, the size must be cast to `int` in all these comparisons to avoid compiler warnings, which is adding code clutter in the implementation. The library provides a range adaptor, called `indexed`, which allows one to iterate over the bins of a histogram with a special proxy, that can return the current bin index and the accumulated value for that bin. The following naive code to ignore under/overflow bins while iterating will generate a warning when `size()` returns `unsigned` ``` auto h = make_histogram(…); // 1D histogram // iterate over indexed bin range, ignore indices < 0 and indices > size (= underflow/overflow bins) for (auto x : indexed(h)) { if (x[0] < 0 || x[0] >= h.axis().size()) // without warning only when x[0] and h.axis().size() both return `int` continue; // do something with bin } ``` People are supposed to use the indexed range to iterate over the bins and not a combination of simple loops like in the first listing, because it scales nicely to multi-dimensional histograms. In multiple dimensions, it is also potentially more efficient. The `indexed` range adaptor automatically moves sequentially in memory, which this is not guaranteed if the index is created by looping manually over several indices, like so ``` for (unsigned i = 0; i < h.axis(0).size(); ++i) for (unsigned j = 0; j < h.axis(1).size(); ++j) { auto x = h.at(i, j); // this may jump around in memory, causing cache misses } ``` How the linear index is generated from the multi-dimensional index is an implementation detail (although the implementation should probably anticipate these naive loops…) So, if `indexed` is anyway the default recommended way of iterating over a histogram, then size() should return `int` to be compatible with the index type, which is also `int`, because it makes naive code work better. Sorry for the long email, I would really appreciate your input. Best regards, Hans

6 13

Re: [boost] [histogram] should some_axis::size() return unsigned or int?
by Hans Dembinski 01 Dec '18

01 Dec '18

Dear Jim, > On 29. Nov 2018, at 13:31, Jim Pivarski <jpivarski(a)gmail.com> wrote: > > It seems to me that if other C++ containers use unsigned integers for size(), you should too, for minimal surprise. The issue you raise about the "which bin?" function returning -1 would be solved in a very-strongly typed language like Haskell as an optional<int>. I know that C++ has optional types now, but I don't know how widely they're used or if there's a significant performance penalty. If this wouldn't look too weird in a C++ program and wouldn't slow it down (or needlessly complicate the code), an optional type would describe your intent more fully than -1. there is boost::optional, which has the semantics of a pointer and can be used to represent a type that stores a value or not. ``` boost::optional o = some_fickle_function(); if (o) { // optional has a value? auto value = *o; // "dereference" to get the value } else { // handle case where value is missing } ``` This is not a good match here, because -1 here does not have the meaning of "value is missing", but it really is the logical index for the virtual bin that spans from -infinity to the lower edge of the first bin in the axis. Value arrow: -inf ——————— | ——————— | —————— | —————— |—————————> +inf bin -1 bin 0 bin 1 bin 2 bin 3 I think representing the underflow bin with -1 and the overflow bin with the value returned by size() is very intuitive and elegant. Best regards, Hans

5 10

C++ project suggestion for Google summer of code (summer, 2019 )
by Ahmed Hussein 30 Nov '18

30 Nov '18

Dear boost , My name is Ahmed Mohamed Ahmed. I ‘m an Egyptian second year electrical engineering student (this is my third year but in Egypt we count 0,1,2,3,4). This my first time ever getting involved in open source. Nevertheless, I am eager to contribute to the vast open source community . I would love to create a C++ library under your supervision and guiding in the next Google summer of code (summer,2019). The attached document is an overview of the library, it is not a proposal with a time line but it answers questions regarding: How is this library going to benefit the open source community? What facilities will be provided by that library? What kind of libraries can be built by fellow programmers using this library? How can this library be extended in the future, whether by me or others? Thank you for your time . Sincerely Advanced mathematics for engineering applications <https://docs.google.com/document/d/1hxKHm0vv5nvia-d_OcGd3SG07gCf2ZtMQvDn_LF…>

1 0

Current Guidance on Compiler Warnings?
by Brian Kuhl 29 Nov '18

29 Nov '18

I'd like to confirm the guidance on Warnings I find here https://svn.boost.org/trac10/wiki/Guidelines/WarningsGuidelines is still considered current? context ... At Wind River we are in the process of working with Boost 1.68 and VxWorks 7 (with Dinkum 7.00 with and Clang 6.0 for ARM and IA boards and GCC 8.1 for PowerPC ) with the hope of bundling Boost with our product. Many of our customers make certified systems ( Planes, Trains, Medical Equipment, Factory Automation, etc. ) and the trend in theses industries is to be pedantic about eliminating all compiler warnings. While we have not traditionally required zero warnings in open source code shipped with our product, there is pressure on us to move in that direction, and as result we will probably be contributing pull requests specifically to fix or suppress compiler warnings over the coming years. I'd like to establish clear guidelines for my team as to what is an appropriate "coding standard" for Boost in regards to compiler warnings. While it is simple to say, everything displayed by -Wall, in practice there are many edge cases, e.g. is an unused parameter acceptable in test code? So I'd like to get the maintainers guidance. Many thanks Brian Kuhl

23 103

[graph] Tree data structure
by Jeremy Murphy 28 Nov '18

28 Nov '18

Dear Boost community, long ago, back in 2002 and 2009, Kasper Peeters proposed adding his tree data structure to Boost. http://tree.phi-sci.com/ There was a lot of discussion but nothing eventuated (so far as I am aware). There are links to the historical discussions on his website. ...2018.... Recently, a Boost.Graph user suggested adding a tree class to it, and I was like, "No, no, a tree is just a graph that satisfies certain constraints: a tree class won't yield better performance." But I also happen to be re-reading for nth time, Element of Programming, which touches ever so briefly but intensely on binary trees, and I realized "Oh, hold on, there is a world of conceptual difference between an arbitrary tree, and a k-ary tree." That discussion is here: https://github.com/boostorg/graph/issues/123 It seems very awkward to even try to represent a k-ary tree in existing Boost.Graph data structures, let alone a mutable k-ary tree. So I made a proof-of-concept, a mutable k-ary tree data structure with specialized implementations of depth-first search and isomorphism. Unless I've made a terrible mistake (which is possible), the performance gains are huge, and the ease of use in an existing library is also huge. OK, so huge things aside, this is really early days, exploratory work. And I'm no Boost.Graph expert. I'm interested in what people think, particularly whether they think it is an idea worth pursuing. I do. But I basically need help from people smarter and more experienced. I have made a PR for the sake of discussion, not for actually merging: https://github.com/boostorg/graph/pull/139 Cheers. Jeremy

1 0

[threads] Launch deferred for async
by Stephan Menzel 28 Nov '18

28 Nov '18

Hello all, I am using boost::async() to create futures from tasks in order to wrap some behavior that may or may not be sync. This behavior is implemented behind an interface and can be small and fast operations or longer running and blocking things. All return a future as a result type, so I can hide the ugly truth. For the smaller stuff I'd like to use launch::deferred to avoid threading altogether and just execute the task when the user get()s the future. boost::future<bool> ret = boost::async(boost::launch::deferred, [this] () -> bool { // do some small cpu only impl return result; }); But when i get the result: const bool result = ret.get(); ...the application crashes. Debugging this I came to this in boost/thread/future.hpp:9373 } else if (underlying_cast<int>(policy) & int(launch::deferred)) { std::terminate(); //BOOST_THREAD_FUTURE<R> ret; //return ::boost::move(ret); // return boost::detail::make_future_deferred_shared_state<Rp>( // BF( // thread_detail::decay_copy(boost::forward<F>(f)) // ) // ); } else { To me this sounds like the application will always std::terminate() when launch::deferred is chosen. Why is that? When I use launch::any it seems to work but why is there a parameter that always yields unwanted results. What is the reason behind it? Can I get launch::deferred as it is described (not threading, just executing the task sync when get() is called) somehow? Platform is x64 Windows 10, MSVC14.1. Cheers, Stephan

2 4

[release] 1.69.0 post-beta merges
by Marshall Clow 26 Nov '18

26 Nov '18

The master branch is is now open for post-beta merges, but only as described in the Post-Beta Merge Policy. See < https://github.com/boostorg/boost/wiki/Release-Beta-Merge-Policy> The master branch will close for the 1.69.0 release on 5-December. The release calendar is at https://www.boost.org/development/index.html -- The Boost release team.

8 17

[release] 1.69.0 post-beta merges
by Oliver Kowalke 26 Nov '18

26 Nov '18

Hi, boost.context needs a post-beta merge in order to fix some issue on ELF asm. Do I get permission to merge to master? best, Oliver

2 1

Guidence on #pragma once
by Robert Ramey 25 Nov '18

25 Nov '18

In the safe numerics library my *.hpp files start with the following boiler plate: #ifndef BOOST_NUMERIC_AUTOMATIC_HPP #define BOOST_NUMERIC_AUTOMATIC_HPP // MS compatible compilers support #pragma once #if defined(_MSC_VER) && (_MSC_VER >= 1020) # pragma once #endif ... I would like to replace all this in every file with just #pragma once according to https://en.wikipedia.org/wiki/Pragma_once#cite_note-9 this should be possible while supporting almost all which claim to be C++ 14 conformant. The exception noted is C++ for Cray. I realize that strictly speaking I shouldn't do this. But it would instantaneously remove some cruft from my code as long as the occasional error from repeating the same include guard text in multiple files. It might have some performance benefits and some other repercussions related to pre-compiled headers. Who knows what else. It would be interesting to know what others might have to say about this. Robert Ramey

10 10

[Boost][DoubleEnded] Status?
by degski 25 Nov '18

25 Nov '18

We had the review of this library proposal/addition quite a while back and ever since I've been [eagerly] waiting for its official entry into Boost. https://github.com/erenon/double_ended does not show any activity and there is nothing in the Boost.Container going on either. What is the status? degski -- *“If something cannot go on forever, it will stop" - Herbert Stein*

4 6

Geometry path length breaking windows regression runs
by Tom Kent 23 Nov '18

23 Nov '18

There has been a change to the geometry library, sometime around Nov 14, that is causing the windows regression runners I manage to crash. The issue is that it is creating *very* long filesystem paths, even with the regression --abbreviate-paths option set. There are a bunch of files such as: D:\teeks99-08\run\results\boost\bin.v2\libs\geometry\test\self_contained_headers\self-contained-algorithms-detail-buffer-buffered_piece_collection~hpp.test\msvc-14.1\dbg\adrs-mdl-64\async-excpt-on\thrd-mlt\self-contained-algorithms-detail-buffer-buffered_piece_collection~hpp.obj.rsp That seem to be created alright, but when I try to cleanup the run afterwards, windows doesn't allow me to delete the files. Tom

5 4

Help - my disk is full! (of bin.v2 stuff)
by Paul A. Bristow 21 Nov '18

21 Nov '18

I note with surprise (and alarm) that my Boost-stuff disk partition is nearly full! Closer inspection reveals that I have a bin.v2 folder of over 50 GB. Obviously, I need to delete something. What are the implications of deleting things? What is the best option? Should I simply delete the whole folder bin.v2 (I have, in desperation, gone nuclear some time ago) or just bin/v2/libs or ? Expert advice welcome. Thanks Paul --- Paul A. Bristow Prizet Farmhouse Kendal UK LA8 8AB +44 (0) 1539 561830

5 4

Rotating on-call review managers
by Zach Laine 19 Nov '18

19 Nov '18

Boost was originally created to incubate libraries that target eventual standardization. When new libraries are proposed, many of the Boost community members that participate in C++ Standard Committee (WG21) meetings ask "How many users does this have, and did you consider Boost first?" Often the answer is that they considered Boost but could not figure out what they were supposed to do to make that happen, or that they had difficulty finding a review manager. There are other things that can be done to make getting a library Boost-review-ready, but most of them require a bit of work up front. The review manager requirement is relatively easier to satisfy. This volunteer effort is to better facilitate Boost's value in the ISO C++ standardization process and so the reviewers would need to recognize intent to standardize the proposed libraries. Submissions that are supported with a paper in a mailing or a draft will make it easier to source a review manager from this queue, but authors without either are encouraged to get in contact with reviewers on this list to find out what that entails. This is the list of volunteers: Zach Laine Micheal Caisse Matt Calabrese Louis Dionne Vinnie Falco Glen Fernandes Jeff Garland David Sankel The list will rotate; the first person on the list will be "on-call". If you'd like to help, let me know and I'll add your name to the list. Also, I've made a PR that adds this list and a note like the description above to https://www.boost.org/development/submissions.html (#6 Seek a Review Manager): https://github.com/boostorg/website/pull/387 Zach

2 2

[release] Boost 1.69.0 Beta 1 Release Candidate 1
by Marshall Clow 19 Nov '18

19 Nov '18

The release candidates for the first 1.69.0 beta release are now available at: <https://dl.bintray.com/boostorg/beta/1.69.0.beta.1.rc1/source/> The release notes are not yet available. The updated documentation is not yet available. [ They will be available in a day or two. ] The SHA256 checksums are as follows: db6b346389714647490d6503db881e4178dd8cd498f850999bebf72cacd4c4ed boost_1_69_0_b1_rc1.7z d128c82351becbd37a02b9b4818994d3f66ff8bdbc0a18838206f4c070db97af boost_1_69_0_b1_rc1.tar.bz2 4df6262db53cfd0d0f934cb126f7e48e94872fe4441cbac6bf72a43bfb136a45 boost_1_69_0_b1_rc1.tar.gz e2908e33cc15f92cda06ddde6a3da43b18967a83105355571fc3cf6e75820c7f boost_1_69_0_b1_rc1.zip As always, the release managers would appreciate it if you download the candidate of your choice and give building it a try. Please report both success and failure, and anything else that is noteworthy. -- The Boost Release Managers

6 17

[release] Boost 1.69.0 Beta 1
by Marshall Clow 19 Nov '18

19 Nov '18

Boost release 1.69.0 beta 1 is now available at: <https://dl.bintray.com/boostorg/beta/1.69.0.beta1/source/> The SHA256 checksums are as follows: ee0ecd7d31f58474c1e0210089c9e66bd878d4d1e7436ac511e359aa4a9d3e86 ./boost_1_69_0_b1.7z 3e25c46f2171799caabbeb419ba7859fffb62208f3a1c80798713377ab07af0e ./boost_1_69_0_b1.tar.bz2 71f4b57175058af1b8c320971cf29226e5a652931a679f7e1c086655147ecafb ./boost_1_69_0_b1.tar.gz ec9ef7d2c9f0d41f560769e67bc7ff207cc999243a7dd6c3f6bcfbdbf0827a7b ./boost_1_69_0_b1.zip For details of what's in the release, see < https://www.boost.org/users/history/version_1_69_0.html>. Please download the beta, give it a try, and report any problems you encounter. Thanks, -- The Boost Release Team

1 0

`b2 toolset=clang-win` now works on Appveyor
by Peter Dimov 18 Nov '18

18 Nov '18

With the current develop branch (since Boost.Build hasn't been merged to master yet), b2 toolset=clang-win now works on Appveyor without additional configuration. You can see it in action at https://ci.appveyor.com/project/pdimov/assert/builds/20331077/job/0hux9a6ml…

4 16

[release] Boost 1.69.0 Beta 1 Release Candidate 2
by Marshall Clow 18 Nov '18

18 Nov '18

The release candidates for the second 1.69.0 beta release are now available at: <https://dl.bintray.com/boostorg/beta/1.69.0.beta1.rc2/source/> The release notes are not yet final. The SHA256 checksums are as follows: 77827b25121159a4e65cfbdf19713e2d589fce267fd6f08615a453d24753c9d3 ./boost_1_69_0_b1_rc2.7z ea05c6e01c856369afdab1f6c075e06fb0f965ab1c247f753ed5c951a9db4e71 ./boost_1_69_0_b1_rc2.tar.bz2 b393a73cf084be716c40ef346cfacb1c95e7b14637e8385eeeb50774dd0b99ed ./boost_1_69_0_b1_rc2.tar.gz 74c0c0a19a700fee2b4f434bb7df50840642e3c35924e85864b278bd519af062 ./boost_1_69_0_b1_rc2.zip As always, the release managers would appreciate it if you download the candidate of your choice and give building it a try. Please report both success and failure, and anything else that is noteworthy. -- The Boost Release Managers

9 29

Re: [boost] [bjam] [build] Documentation for 1.69
by Rene Rivera 17 Nov '18

17 Nov '18

On Fri, Nov 16, 2018 at 1:54 PM Edward Diener <eldiener(a)tropicsoft.com> wrote: > On 11/16/2018 2:40 PM, Rene Rivera wrote: > > On Fri, Nov 16, 2018 at 1:27 PM Edward Diener via Boost < > boost(a)lists.boost.org> wrote: > >> >> It is not really a website/webpage issue but a distribution issue. The >> distribution has an index.html, which gives the doc for the >> distribution, and the link in the doc for the Tool Boost.Build never >> actually exists. >> > > This index.html? <https://github.com/boostorg/boost/blob/master/index.html> > Or some other one? > > In our distribution the top-level index.html brings up the doc. In the doc > there is a link to tools/build/index.html but this html file never exists > in a Boost distribution. Check out any of the past distributions, such as > Boost 1.68, and you will see this. > This <https://github.com/boostorg/boost/pull/218> should fix it. But We'll have to wait until the master branch is open again before it makes it to the release. -- -- Rene Rivera -- Grafik - Don't Assume Anything -- Robot Dreams - http://robot-dreams.net

1 0