- Boost - lists.boost.org

MSM Review period extended to Dec 13th
by David Abrahams 06 Dec '09

06 Dec '09

Hi All, We thought this might happen because of the Thanksgiving holiday, and it did: we are extending the review period for the Meta State Machine library until Dec 13th. However, please don't let that delay your review; we'd like to see them all as soon as possible. Msm was written by Christophe Henry, inspired in part by the example in the book "C++ Template Metaprogramming" (http://boostpro.com/mplbook) About the library: Msm (Meta State Machine) is a library allowing the user to easily define high-performance, straightforward and readable UML2 finite state machines, while respecting the principles of efficiency and declarativeness of the original example. To that end, Msm offers several Domain-Specific Embedded Languages that strive to closely emulate a standard UML diagram. Msm supports a broad range of UML features: - state entry/exit - transition actions/guards - composite states - history - orthogonal regions - terminate states - deferred events - explicit entry/fork - entry/exit pseudostates - anonymous transitions - transition conflicts And several non-standard features to make the developer's life easier (interrupt states, query about the current state(s)). Msm (in its current version, 2.0) can be found: * in the sandbox (http://svn.boost.org/svn/boost/sandbox/msm/) * or in the vault: (http://www.boostpro.com/vault/index.php?directory=Msm) Everybody on this list is invited to participate in this formal review. I hope to see your review of Msm, including your vote on acceptance, and I welcome your participation in the ensuing discussions on the Boost developers' mailing list. Please always include in your review a vote as to whether the library should be accepted into Boost. Additionally please consider giving feedback on the following general topics: - 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? -- David Abrahams BoostPro Computing http://boostpro.com

2 1

Regex allocator support
by Fred Sundvik 06 Dec '09

06 Dec '09

Hi, We recently had to use the regular expression library in conditions where there was no available physical memory, for reporting resource consumption when our console game runs out of memory. This wasn't possible however due to the fact that the basic_regex does some dynamic allocations and doesn't provide any allocator specialization, allthough match_results for example does. So we modified the boost code a little bit and added a new template paramter for the allocator, and made constructors that takes allocators as parameters. This was quite straightforward to do, the allocators just had to be passed forward to the all internal classes it uses. The shared_ptr's had to be changed to use the three parameter constructor, that takes a a deleter and allocator, to prevent them from allocating. The mem_block_cache system was a bit more complicated. Initially we disabled it completely, but that obviously wasn't the best solution. So we figured out, that we can use a custom allocator as default, instead of std::allocator. That custom allocator then had to be specialized for the mem_block_nodes, and the funcion calls to get_mem_block replaced by allocator calls. Our implementation isn't ideal, though as we used mem_block_node as the specialization, and to pass the correct size to the allocator, we allocate BOOST_REGEX_BLOCKSIZE / sizeof(mem_block_node) of them, this way it works for allocators that don't specialize for mem_block_node(but only if the size is dividable by sizeof(mem_block_node) ). Better would probably be to make a new type that is BOOST_REGEX_BLOCKSIZE big. We also found another problem with allocation, the match_result::format functions only takes string_type, that isn't specialized by any allocator as they input. This made it impossible to call them with strings using different allocators. So we added specializations of those functions for different allocators and traits. There are probably more functions like that, but since our code doesn't use them there was no need to change anything. So my question is, what are the chances that theese kinds of modificiations gets implemented in the actual library, and possibly in the next c++ standard library as well? I consider it a quite big design flaw to not have any control of the internal allocations, so for me this a quite big thing. Obviously we are doing well with the modifications we made here internally, but there are other applications too that would benefit, many embedded applications for example. Would our code changes be of any use? The changes are only the minimal needed to make it work in our case, and there's many compiler and option permutations not taken care of, so obviously a lot of work would still be needed. Also there's no additional unit tests made. Fred Sundvik Bugbear Entertainment Ltd.

5 7

Notice: Boost.Atomic (atomic operations library)
by Helge Bahmann 05 Dec '09

05 Dec '09

Hello, as promised I have started extracting an atomic operations library. Current state is available at: http://www.chaoticmind.net/~hcb/projcets/boost.atomic It implements boost::atomic<TYPE> which faithfully mimics std::atomic<TYPE> as specified in the C++0x draft standard. As allowed by the standard, operations transparently fall back to locking when the underlying architecture does not support the requested operation, so the library already contains a "fallback" implementation that works an all platforms (using mutex from boost::thread). It currently natively supports gcc/x86, gcc/powerpc and gcc/alpha (I can vouch for the correctness of the implementations on these targets). It contains some entirely untested support for building implementations from CAS operations on other systems (e.g. _InterlockedCompareExchange on win), so I would greatly appreciate any feedback if it works/doesn't on any particular platform. There is some preliminary documentation, but not in boostdoc format -- after unsuccessfully struggling with bjam/boostbook & friends for a few hours I simply gave up and reverted to trusty old doxygen :( Is there any step-by-step guide on how to create, build and document a new library? I could really use that as the boost build and documentation system is pretty alien to an autotools-accustomed guy like me. Best regards Helge

10 33

Re: [boost] [msm] Review
by Christophe Henry 05 Dec '09

05 Dec '09

Hi David, > It is sad that my comments are construed as criticism of MSM, since they merely point out the (I thought obvious...) >similarities with another library already in Boost. >After having tried MSM for a few days, most of it rocks, and I will provide a review later today. Oh I didn't take it as a criticism of MSM at all, merely of a valid issue which will have to be solved in Boost at some point because, as Boost grows, it is bound to happen again. I'll look at your review with great interest and thank you for taking the time to write it. To the core of your point, which is actually a valid concern. I agree that MSM and Statechart are solving the same problem. To explain what I (and probably Andreas) mean, let's look at the problem from a different angle. Let's suppose we'd build a Statechart 2.0. How would it look like? Would it go for the MSM way, putting as much as possible on the compiler, at the risk of breaking it, or the Statechart way, less metaprogramming and easier on compilers but slowlier and with a less descriptive interface (in my opinion)? Would it go for a transition table way or a state::react way? What kind of state storage would it take? And so on and so on. What is likely is that we'd probably not even manage to agree on the goals, much less on the design or the implementation. MSM comes from my frustration with not managing to make Satechart do what I needed. This shows that the philosophy of both authors is quite different and likely incompatible. Christophe

1 0

Fixed bug in filesystem library ?
by Luca Severini 05 Dec '09

05 Dec '09

Hello everyone, I'm a newbie to boost libraries but I have some good experience in software development on Mac OS. Today I use downloaded and used boost for the first time. I use a MacBook Pro with Snow Leopard 10.6.2. The IDE is Xcode 3.2.1 Writing some very basic code to learn how to use the filesystem library I got assertions (below) simply iterating recursilvely through a local directory to list its content. /Developer/Test/TestFolder Boost_Test(57690) malloc: *** error for object 0xe518: pointer being freed was not allocated *** set a breakpoint in malloc_error_break to debug Investigating in the code I've found the assertions were triggered by two uninitialized std::string variables with same name passed to the functions detail::dir_itr_first() and detail::dir_itr_increment(). Initializing both to the simple content ".", directly in the constructor, seems to have fixed the problem (no assertions anymore). Here are the two functions I've changed in the file operations.hpp. The code I added is in green. Nothing has been deleted. I was thinking to follow the instructions to submit the fix but, please excuse me, I've found easier to send an email to the list. Hopefully someone with better knowledge of boost than me will submit gthe fix if it's the case o will find a better solution. Best regards, Luac Severini template<class Path> system::error_code basic_directory_iterator<Path>::m_init(const Path & dir_path) { if ( dir_path.empty() ) { m_imp.reset(); return detail::not_found_error(); } typename Path::external_string_type name("."); // String initialized to avoid assertion file_status fs, symlink_fs; system::error_code ec( detail::dir_itr_first( m_imp->m_handle, #if defined(BOOST_POSIX_API) m_imp->m_buffer, #endif dir_path.external_directory_string(), name, fs, symlink_fs ) ); if ( ec ) { m_imp.reset(); return ec; } if ( m_imp->m_handle == 0 ) m_imp.reset(); // eof, so make end iterator else // not eof { m_imp->m_directory_entry.assign( dir_path / Path::traits_type::to_internal( name ), fs, symlink_fs ); if ( name[0] == dot<Path>::value // dot or dot-dot && (name.size() == 1 || (name[1] == dot<Path>::value && name.size() == 2)) ) { increment(); } } return boost::system::error_code(); } template<class Path> void basic_directory_iterator<Path>::increment() { BOOST_ASSERT( m_imp.get() && "attempt to increment end iterator" ); BOOST_ASSERT( m_imp->m_handle != 0 && "internal program error" ); typename Path::external_string_type name("."); // String initialized to avoid assertion file_status fs, symlink_fs; system::error_code ec; for (;;) { ec = detail::dir_itr_increment( m_imp->m_handle, #if defined(BOOST_POSIX_API) m_imp->m_buffer, #endif name, fs, symlink_fs ); if ( ec ) { boost::throw_exception( basic_filesystem_error<Path>( "boost::filesystem::basic_directory_iterator increment", m_imp->m_directory_entry.path().parent_path(), ec ) ); } if ( m_imp->m_handle == 0 ) { m_imp.reset(); return; } // eof, make end if ( !(name[0] == dot<Path>::value // !(dot or dot-dot) && (name.size() == 1 || (name[1] == dot<Path>::value && name.size() == 2))) ) { m_imp->m_directory_entry.replace_filename( Path::traits_type::to_internal( name ), fs, symlink_fs ); return; } } }

2 1

[iostreams] 1.41 gzip filter regression
by Alexander Arhipenko 05 Dec '09

05 Dec '09

Hi guys, In 1.41 we are experiencing regression in boost::iostreams::gzip_decompressor. Almost 50% percents of our test *.gz files failed to decompress. Following code snippet usually throws gzip error: std::ifstream f(n, std::ios_base::in | std::ios_base::binary); if(!f) { std::cerr<<"cant' open "<<n<<'\n'; } namespace io = boost::iostreams; io::filtering_istream in; in.push(io::gzip_decompressor() ); in.push(f); std::istreambuf_iterator<char> b(in); std::istreambuf_iterator<char> e; std::cout<<n<<'\n'; std::copy(b, e, std::ostream_iterator<char>(std::cout) ); Maybe that is caused by incorrect api usage. In this case, sorry for the noise in advance. I've attached minimal example that reproduces the issue. Build showfile executable and run ./showfile myfile.odt.bz2.gz > result. You should have 'error: gzip error' on stderr. Regards

4 8

svn mergeinfo broken at the root.
by Steven Watanabe 05 Dec '09

05 Dec '09

AMDG Beman, I'm not quire sure what you did, but svn:mergeinfo doesn't work for me anymore. https://svn.boost.org/trac/boost/changeset/57638 destroyed the svn:mergeinfo for all the revisions that I had already merged (I have been doing all merges at the root). In Christ, Steven Watanabe

1 0

symbolic links while building boost
by Zachary Turner 04 Dec '09

04 Dec '09

I use Windows primarily, and typically after building boost, there are two copies of each library. One with the version extension such as -1_41, and the other without. My understanding is that the one without the version number is supposed to be a symlink to the one with the version number on platforms such as linux, but that on Windows it is just a copy of the file due to poor support for symlinks in windows. My question is whether there has been any talk of changing this. Windows has supported first class symlinks since Vista, so it would seem possible to have Vista and beyond actually use this functionality and create real symlinks. Thoughts? Zach

3 3

Re: [boost] Meta State Machine library review / MSM, question
by Christophe Henry 04 Dec '09

04 Dec '09

Hi Barend, >All my states are structs. Why is the state an integer here? How can I >(humanly or with MSM) translate that state to one of the states defined? >It works, I get a message, but still don't know which transition was not >provided... Unfortunately, no_transition is one of the few cases, where because of implementation details, MSM already crossed the compile-time / run-time boundary and all it has is the state id. Annex A shows the order in which the (usually hidden) state index is calculated. It's simply the order of appearance in the transition table. First are source states checked, then target states. Regards, Christophe

1 0

Re: [boost] [msm] Review
by Christophe Henry 04 Dec '09

04 Dec '09

Hi all, Looks like there was a fair bit of discussion ;-) I'll try to give my take on the many discussed points. Jeffrey Bosboom wrote: >But I think this concern can be addressed if there is a documentation >page that compares the libraries that is included in (or linked from) >both libraries' documentation. This would make it much easier for a >user to choose one or the other without having to read the full >documentation for each. This sounds like a good idea to me. Not everybody followed the review. Andrew Venikov wrote: >I think an even better example would be map and hash_map. >They serve almost identical purpose but using totally different >techniques. The user of stl is expected to understand the differences >and chose the appropriate container. >Why not do the same with SC and MSM? Yes, we should really write a page explaining the trade-offs. David Bergman wrote: > I would even have welcomed some macros that introduce the state declarations for simplistic states, > from that transition table expression. There is something like this in eUML (on compilers with native typeof). Is this ok for you? typedef BOOST_TYPEOF(build_state( )) Paused; I can of course also add a macro for other compilers. David Bergman wrote: >Well, well, I seem to be the only one caring about this, and MSM sure is a fine library, >so I say 'welcome metamagical states!'. > NOTE: no, this was not a formal review ;-) I would welcome a formal review though. It'd help the review manager make a decision ;-) Jeffrey Bosboom wrote: >Decide whether MSM should be included or not on its own merits. If so, >then MSM makes Boost better; we shouldn't be so concerned with being >perfect that we lose the opportunity to be better. I agree. We should always decide on a library's merit and then see how to handle it. It'd be sad to lose an opprtunity to make boost more valuable on organisatory grounds. This doesn't apply only to MSM. David Bergman wrote: >You have a good point there. Although I would rather have seen the MSM guys collaborate with the Statechart guys >on making Statechart easier to use (especially the expression of the transition table) and/or more performant, though. >If that would have led to a combined Statechart 2.0 (analogous to Spirit 2.0) in a year, I would wait. Merging would be quite hard. While both libraries seem to have almost the same interface, scratching the surface will show many differences. The reason is that both libraries follow a pretty different philosophy and use different techniques. The best which might be achieveable would be a new front-end in MSM trying to match as much as possible SC's front-end. It would probably work for simple state machines. It might even work for composites. I'm not expert enough in Statechart to tell if more is possible. And the question is if someone would ever need this. You would still get the compiler limitations (and maybe add some more due to the added metaprogramming) and not all of SC's features. Why to use it then? However, if someone is willing to take this task on, I'd be ready to help. Ideally we would have to do the same in Statechart for one of MSM's front-ends. Sounds like a lot of work. Christophe

1 0