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

[context] msvc /SAFESEH
by Jeff Flinn 12 Aug '15

12 Aug '15

I need to build my application with /SAFESEH which uses boost coroutine which uses context. I'm getting the following link errors: 1>libboost_context-vc100-mt-gd-1_53.lib(jump_i386_ms_pe_masm.obj) : error LNK2026: module unsafe for SAFESEH image. 1>libboost_context-vc100-mt-gd-1_53.lib(make_i386_ms_pe_masm.obj) : error LNK2026: module unsafe for SAFESEH image. I've built boost static libs with the same MSVC vesion and options (sans /SAFESEH as it's not a compile/lib option) Compiler/linker versions: Microsoft (R) 32-bit C/C++ Optimizing Compiler Version 16.00.40219.01 for 80x86 Microsoft (R) Incremental Linker Version 10.00.40219.01 Has anyone run into this and resolved the error? Any insight is appreciated. Thanks, Jeff

3 9

Is there any interest in a library for actor programming?
by Charousset, Dominik 28 May '14

28 May '14

Hi, is there any interest in a library for actor programming? The library we've developed is a C++11 open source library named "libcppa". It is currently released under LGPL2, but re-releasing the library under the boost license is not an issue. You'll find all important links and ressources either under http://libcppa.org or on the GitHub project page: https://github.com/Neverlord/libcppa, including a user manual as HTML or PDF. We've also submitted a paper to the C++Now conference. What is actor programming? For those of you who aren't yet familiar with the actor model: actors basically represent tasks or services that communicate via message passing. In libcppa, actors are very lightweight (you can spawn literally millions of them) and scheduled cooperatively using a thread pool (although actors are allowed to opt-out of the cooperative scheduling). Some of the main strengths of this programming paradigm are: (1) network transparency, (2) race conditions are avoided by design, (3) a strong failure model that enables developers to build reliable distributed systems, and (4) the actor model addresses both concurrency (multiple actors on one host) and distribution (any number of actors on any number of hosts). Here's the classical hello world example: ---------------------------------------------------------------------------------- #include <string> #include <iostream> #include "cppa/cppa.hpp" using namespace std; using namespace cppa; void mirror() { // wait for messages become ( // invoke this lambda expression if we receive a string on_arg_match >> [](const string& what) { // prints "Hello World!" via aout (thread-safe cout wrapper) aout << what << endl; // replies "!dlroW olleH" reply(string(what.rbegin(), what.rend())); // terminates this actor ('become' otherwise loops forever) self->quit(); } ); } void hello_world(const actor_ptr& buddy) { // send "Hello World!" to our buddy ... sync_send(buddy, "Hello World!").then( // ... and wait for a response on_arg_match >> [](const string& what) { // prints "!dlroW olleH" aout << what << endl; } ); } int main() { // create a new actor that calls 'mirror()' auto mirror_actor = spawn(mirror); // create another actor that calls 'hello_world(mirror_actor)' spawn(hello_world, mirror_actor); // wait until all other actors we have spawned are done await_all_others_done(); // run cleanup code before exiting main shutdown(); } ---------------------------------------------------------------------------------- A message is simply a tuple of values that is pattern matched at the receiver. For example, " on_arg_match >> [](const string& what) {...}" defines a message handler that is called whenever a tuple with one single string element arrives. "on_arg_match" simply defines a pattern that matches the signature of the given lambda. Please have a look at the examples folder on GitHub (https://github.com/Neverlord/libcppa/tree/master/examples) or at the user manual (http://neverlord.github.io/libcppa/manual/) if you want to see more examples. Best regards, Dominik Charousset

17 62

required toolsets
by Steven Watanabe 15 May '14

15 May '14

AMDG The list of required toolsets in explicit-failures-markup.xml is out-dated. Therefore, if no one objects, I propose setting it to the following: msvc-10.0, msvc-11.0, gcc-4.6, gcc-4.7, clang-darwin-11, clang-darwin-4.2.1, clang-linux-3.1, clang-linux-3.2, gcc-mingw-4.7, gcc-mingw-4.6 (two releases of each major compiler that appears in both the trunk and release regression tests) The sole effect of this is to determine which toolsets appear in the issues list: http://www.boost.org/development/tests/trunk/developer/issues.html In Christ, Steven Watanabe

10 32

[atomic] Support for specialized instructions
by Andrey Semashev 14 May '14

14 May '14

Hi, I've been contemplating the idea of adding support for some specialized atomic instructions to Boost.Atomic. Since I'm only familiar with x86 architecture, my current candidates are: * Increment/decrement with a check for zero result (lock inc/dec). The decrement is the most essential of the two because it would be useful for reference counters of various kinds. The increment is mostly beneficial in terms of code size, and it probably doesn't need the check for zero in most cases. * In-place logical operations (lock and/or/xor). These are useful in cases when the code needs to operate on flags or bit sets but doesn't need the result of the operation. Optional variants can be provided with a test for zero result. * Bit set/reset operations (lock bts/btr). The use cases are similar to the logical operations but the advantage is that the previous value of the altered bit can be returned. BTW, these operations are needed in Boost.Sync to implement mutexes on Windows. All these operations can be implemented through the standard atomic<> interface, and that's what would be done on platforms without support for the specialized instructions. For now the idea is to add special member functions to atomic<>, when used with arithmetic types. I was thinking about providing free functions as well, although I think that the complete set of the standard atomic functions would be required for that. Comments? Opinions?

4 6

[asio] Bug: Handlers execute on the wrong strand.
by Greg Barron 04 Apr '14

04 Apr '14

Hi All, I would like to refer you to this bug report: https://svn.boost.org/trac/boost/ticket/9203 I won't paste the full contents of the bug report into this message. The executive summary is that the allocation algorithm for the implementation of asio::strand can and does allocate the implementation of an existing strand to strands that are subsequently allocated. This can have the effect that handlers wrapped in strand (b) will actually be executed on strand (a). I consider this to be a bug but if there is something that I'm misunderstanding about the operation of strands it would be great if you could help me clear it up. If the consensus is that this is a bug, what are the chances for it to be included in the 1.56 release? It is probably too late to be included in the 1.55 release. I've implemented a work around which could only be described as a hack and would be embarrassed to show it to anybody. But it gets me over my hump :). Thanks! -- Greg

5 4

Post-git forking process
by Sohail Somani 29 Mar '14

29 Mar '14

Hey all, Often, I find bugs in Boost that I need to patch manually before the next release. What I used to do before was keep a copy of Boost in my source tree which made this easier: just patch it directly. This made it easy to modify, but annoying to post patches and honestly, they just got lost most of the time. With Git, it should become easier to contribute said patches as well as pull in whichever particular changes I need. However when I attempted such a fork recently, I was a bit lost. As I understood it, the process should have been: 1. Create a fork of https://github.com/boostorg/boost and use this fork in my project 2. Create a fork of the library/libraries I wanted to patch 3. Update the submodules in my boostorg/boost fork to point to my forked libraries 4. Post a pull request for the respective libraries. Once the changes have been accepted, point back to the official boostorg repo I failed terribly, no doubt due to PEBKAC. Is there a chance that someone could write a tutorial or a how-to guide for the recommended process of forking Boost with Git? The main thing I need is the ability to have a patched version of Boost that I can use while the patches are being reviewed/accepted/rejected. Thanks, Sohail

6 20

sqlpp11: SQL for C++
by Roland Bock 06 Feb '14

06 Feb '14

Hi, over the last four or five years I developed several SQL libraries for C++. With C++11 I was finally able to create an SQL library that meets my own expectations and requirements. It is being used in production, I recently put it on github, and I would really like to hear from you guys whether this is something that could be interesting for you personally or for boost? https://github.com/rbock/sqlpp11 https://github.com/rbock/sqlpp11/wiki sqlpp11 is a template library representing an embedded domain specific language (EDSL) that allows you to * define types representing tables and columns, * construct type safe queries checked at compile time for syntax errors, type errors, name errors and even some semantic errors, * interpret results by iterating over query-specific structs with appropriately named and typed members. This results in several benefits, e.g. * the library user operates comfortably on structs and functions, * the compiler reports many kinds of errors long before the code enters unit testing or production, * the library hides the gory details of string construction for queries and interpreting string based results returned by select calls. I.e. you don't need to use strings in query construction where you wouldn't use them in SQL and there is no need to use positional arguments or to parse strings when obtaining fields from a result row (the latter being true unless you do not know which columns to select at compile time). The library supports both static and dynamic queries. The former offers greater benefit in terms of type and consistency checking. The latter makes it easier to construct queries on the flight. Specific traits of databases (e.g. unsupported or non-standard features) are known at compile time as well. This way, the compiler can tell the developer at compile time if a query is not accepted by the database (e.g. if a feature is missing). And the library can form the query in the correct manner, for instance if the engine uses concat instead of operator|| to concatenate strings. Two Examples: ============= Static Select: -------------- // selecting zero or more results, iterating over the results for (const auto& row : db.run( select(foo.name, foo.hasFun) .from(foo) .where(foo.id > 17 and foo.name.like("%bar%")))) { if (row.name.is_null()) std::cerr << "name will convert to empty string" << std::endl; std::string name = row.name; // text fields are implicitly convertible to string bool hasFun = hasFun; // bool fields are implicitly convertible to bool } Dynamic Select: ---------------- auto s = dynamic_select(db, tab.foo).dynamic_columns().from(tab); if (userWantsBar) s.add_column(tab.bar); for(const auto& row : run(s)) { std::cerr << "row.foo: " << row.foo; if (userWantsBar) std::cerr << "row.bar" << row.at("bar"); std::cerr << std::endl; }; Please let me know your questions/thoughts/suggestions/rants. Contributions welcome, of course :-) Regards, Roland

22 88

C++03 and C++11 ABI compatibility for compiled libraries
by Andrey Semashev 24 Jan '14

24 Jan '14

Hi, I would like to raise the issue of binary compatibility of compiled Boost libraries between C++03 and C++11. I faced this problem with gcc on Linux, but other compilers and platforms may be affected as well. To summarize the problem: * Most, if not all Linux distributions build packages in C++03 mode. This is also the default in gcc. * Some Boost libraries conditionally use C++11 features in their binary interfaces (see [1] as an example). This makes C++03 and C++11 versions of the library binary incompatible. * Given that, users are unable to use C++11 in their code that uses Boost because of linker failures. I don't have the complete list of the offending C++11 features that break ABI, but it would seem that at least scoped enums and rvalue references are among them. Are there any more? I would like to hear opinions on the possible course of action to tackle this problem. Currently, I see 2 choices: 1. Avoid using C++11 features in binary interfaces. This may also mean avoiding STL types in binary interfaces, if they differ between C++03 and C++11 (I didn't verify that). This is my suggested hotfix solution for Boost.Filesystem [1] and the approach I took in Boost.Log. Obviously, this cripples code and error prone, but it keeps a single binary that can be used from any flavor of C++ on the user's side. 2. Compile different versions of Boost libraries, for each supported C++ version. The C++ version should be encoded into the library file names, so that different versions can coexist. This would require changes in Boost.Build and autolinking support code, but I think this would be a better long-term solution. Opinions? [1] https://svn.boost.org/trac/boost/ticket/6779

12 27

Re: [boost] Is there interest in a collection of call stack utilities?
by Aurelian Melinte 14 Jan '14

14 Jan '14

Hello, To follow up on the discussion https://groups.google.com/forum/#!topic/boost-developers-archive/PSwTBEEe0Ao I was not clear if there is interest for it or not. I went ahead and the first cut of the code is now at https://github.com/melintea/Boost-Call_stack Please feel free to take a look and comment. Regards, Aurelian

6 7

Removing support for old compilers
by Joaquin M Lopez Munoz 14 Jan '14

14 Jan '14

Hi Stephen As part of your initiative of removing support for old compilers, are you building somewhere a change log in the form of either a list of compiler deficiencies or compiler versions no longer supported? I understand this should be inserted in a prominent place on the Boost 1.56 release notes and can serve as a reference for lib maintainers reviewing your patches (tracking changesets is harder and commit messages are not always completely illuminating). Thank you, Joaquín M López Muñoz Telefónica Digital

16 51