- Boost-users - lists.boost.org

Fwd: Formal Review of Proposed Boost.Histogram Library
by Mateusz Loskot 19 Sep '18

19 Sep '18

FYI, We are reviewing Histogram library proposed to proposed . If you are interested in applications for mathematics, statistics, graphics, image analysis, and such, or in the Histogram library itself, please consider reviewing the Histogram library by the end of September 26th. Further details included below. You can post your review to the Boost development list to boost (at)lists.boost.org or directly to me to. Thank you! Mateusz Review Manager for the proposed Boost.Histogram ---------- Forwarded message --------- From: Mateusz Loskot <mateusz(a)loskot.net> Date: Mon, 17 Sep 2018 at 11:06 Subject: Formal Review of Proposed Boost.Histogram Library Starts TODAY To: <boost(a)lists.boost.org> Dear Boost Community, The formal review of Hans Dembinski's Histogram library starts TODAY, the September 17th, and lasts until September 26th, unless an extension occurs. =========== What is it? =========== Histogram is a header-only C++11 library, provides multi-dimensional histogram template class for counting, statistics and data exploration. The histogram class interface has been carefully designed to make the library * offer simple and convenient default behaviour * easy to learn and safe to use * convenient to use for one- as well as multi-dimensional analysis * compatible with STL algorithms * dependant only on C++11 standard library and optionally on Boost The author followed the "Don't pay for what you don't use" principle. The histogram class is customisable through policy classes, but the default policies were carefully crafted so that most users do not need to customize anything. The default policies guarantee the histogram to be safe to use as a black box, memory efficient, and very fast, where safety is related to overflow prevention and large values capping. This guarantees is one of unique features of the library in comparison to other implementations. The histogram class comes in two variants, which share a common interface: * static variant is optimised at compile-time to provide maximum performance, at the cost of reduced runtime flexibility and potentially larger executables; * dynamic variant is a bit slower, but configurable at run-time. Both variants of the histogram class provide optional serialization support implemented with Boost.Serialization. The library itself is header-only and the tests as well as examples can be built using both, Boost.Build and CMake. There are no dependencies required other than C++11 compiler. Optional dependencies include the GNU Scientific Library (GSL) and the ROOT framework from CERN which are needed the corresponding speed test programs used for performance comparison. A note on history: The library was first announced to the Boost community in May, 2016 [1] and the author received extensive feedback. Then, after a year of work posted second request for comments in April, 2017 [2]. =================== Getting the library =================== Checkout the `master` branch from the library git repository: https://github.com/HDembinski/histogram/ NOTE: The author follows the library submission process [3]: the master branch remains frozen for the period of the formal review, modifications in response to feedback should go to `develop` branch and big items may be worked and discussed via opening an issue on GitHub. Documentation: http://hdembinski.github.io/histogram/doc/html/ Website: http://hdembinski.github.io/histogram/ ================ Writing a review ================ Please, follow the official Boost formal review procedure [4]. If you feel this is an interesting library, then please submit your review to the Boost developer list (preferably), or the review manager to mateusz (at) loskot (dot) net. Here are some questions you might want to answer in your review: - 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 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. If needed, refer to the Boost Library Requirements and Guidelines [5]. Please, give constructive criticism! [1] https://lists.boost.org/Archives/boost/2016/05/229389.php [2] https://lists.boost.org/Archives/boost/2017/04/234410.php [3] https://www.boost.org/development/submissions.html#Review [4] https://www.boost.org/community/reviews.html [5] https://www.boost.org/development/requirements.html Mateusz Review Manager for the proposed Boost.Histogram -- Mateusz Loskot, http://mateusz.loskot.net

1 0

[asio] is the io_context queue FIFO?
by Frédéric 19 Sep '18

19 Sep '18

Is there a guarantee that the events posted using boost::asio::post() are called in the order of submission or can they be called in any order? Note that I have multiple threads running io_context.run(). Thanks, F

3 5

[asio] How to prevent high load CPU by io_context::run ?
by Dmitrij V 18 Sep '18

18 Sep '18

Hi. After run io and after connection an one client, I have 25% CPU loading by server. What I doing wrong ? How can I minimize it ? PS: Client connected to TCP server without limits by time, - persistent connections... -- the best regards

1 0

[asio] are defer/dispatch/post identical?
by Frédéric 18 Sep '18

18 Sep '18

Hi, Is there a difference between defer, dispatch and post free functions? They look very similar, there files look the same apart from the fact that they call defer, dispatch and post of the executor. The doc in executor seems to be the same. Thanks, F

2 2

Cannot cast from std::string to seastar::sstring.
by José Guilherme Vanz 17 Sep '18

17 Sep '18

Hi guys, I'm investigating a [bug](https://github.com/scylladb/scylla/issues/2905) in the Seastar/lexical_cast and I got stuck. Let me introduce what's going on and the further investigation that I did. The Seastar framework uses the boost program options to parse the command line arguments. But when the user try to pass a command line argument of seastar::sstring (Seastar string type) with a white space, the lib tells us that is invalid value. Turns out the boost program options call lexical_cast to cast from std::string to seastar::sstring. This cast is failing. The lexical_cast uses a stream to extract the value from the source, but the operator>> stops in the white space. Making the second validation in the same [line](https://github.com/boostorg/lexical_cast/blob/boost-1.66.0/include/bo… false. Note, there is a [call](https://github.com/boostorg/lexical_cast/blob/boost-1.66.0/include/bo… to unsetf to ensure that the white space will be skipped: stream.unsetf(std::ios::skipws);. What's am I trying to do is figure out where the problems live? Is there a bug in boost or is a sstring implemantion problem? Am I missing something? Thanks!

3 2

Re: [Boost-users] Looking for a mechanism (boost::asio
by Bjorn Reese 15 Sep '18

15 Sep '18

On 09/14/18 23:21, Tim Burgess via Boost-users wrote: > I need my main code to pause until I receive a response from the > hardware. I don’t want to use a timer, as this would be potentially Sounds like you need a promise/future.

1 0

Re: [Boost-users] Looking for a mechanism (boost::asio
by tim＠raisedbar.net 15 Sep '18

15 Sep '18

OK, I’ve just read the preamble for the ASIO library (Chapter 32) and it seems that this library, whilst extremely useful, does exactly the opposite of what I’m trying to achieve, as it allows main code execution to continue whilst waiting for a response from an external device. I need my main code to pause until I receive a response from the hardware. I don’t want to use a timer, as this would be potentially unreliable - I can never know how long a pause would be required and there would be the danger of having the code hanging around wasting time if the timer value is too generous. Best wishes. Tim Burgess From: Boost-users <boost-users-bounces(a)lists.boost.org> On Behalf Of Tim Burgess via Boost-users Sent: 14 September 2018 20:49 To: boost-users(a)lists.boost.org Cc: tim(a)raisedbar.net Subject: Re: [Boost-users] Looking for a mechanism Thanks – I’ll go and do some reading. Just to add more information: the hardware is a MIDI device, with the sent messages being groups of 6 individual short MIDI messages, so a total of 18 7-bit bytes per transmitted query. The response messages are groups of 4 MIDI short messages. There is something like 200 parameters to be queried – the MIDI connection is either via traditional DIN cables with a transfer rate of 31kbps, or over USB. Over the USB connection the manufacturer estimates that I should be able to get a full set of responses back in around 100ms. I’m using the rtMIDI library to do the heavy lifting in terms of handling the MIDI I/O devices and handling themessage formatting. Best wishes. Tim Burgess From: Boost-users <boost-users-bounces(a)lists.boost.org <mailto:boost-users-bounces@lists.boost.org> > On Behalf Of Keith Bennett via Boost-users Sent: 14 September 2018 18:54 To: boost-users(a)lists.boost.org <mailto:boost-users@lists.boost.org> Cc: Keith Bennett <kanezor(a)gmail.com <mailto:kanezor@gmail.com> > Subject: Re: [Boost-users] Looking for a mechanism Without more information it'd be hard to say. Are you familiar with Boost ASIO? It's a common method of handling asynchronous communication, though how much it can be used in your situation may depend on the particular hardware interface. The typical situation for a single-threaded process is to set up an executor context, maybe set up signal handlers, then make an asynchronous call using ASIO's objects. When making the asynchronous calls, you provide a callback function object. Your callback function object may then make another request during its processing. ASIO handles the under-the-hood abstraction (and generally simplifies it for most situations). But it's up to you to ensure that your call sequence is safe: for example ASIO will not prevent you from making multiple simultaneous writes to the same file descriptor despite it being unsafe in many situations. My understanding is that your callback is placed onto a function queue rather than called directly (contrast to POSIX signals where the OS interrupts whatever function is running right now). That can hurt your response performance if you're doing long-running tasks so it's worth considering. On Fri, Sep 14, 2018 at 12:03 PM Tim Burgess via Boost-users <boost-users(a)lists.boost.org <mailto:boost-users@lists.boost.org> > wrote: Hi, I’m trying to find a method of solving the problem detailed below using Boost (or an alternative: 1 – I have to send a series of messages to a hardware device to query its internal parameter values at application load-time. This I can do; 2 – I have a callback that receives responses from the hardware, though I get some replies go missing due to saturation; 3 * The hardware manufacturer tells me that I should send 1 query then wait for the response before sending the next query. I could use Sleep, but this depends on a specific wait time and I’m not sure if it suspends all processing, including my callback, so this doesn’t look satisfactory. What I’m looking for is a “wait until response” kind of thing, but I haven’t found such a thing so far, though I have found several wait routines for handling multiple threads. I’d appreciate any guidance as to what to look for, as my searches are obviously not asking the right questions. Best wishes. Tim Burgess Raised Bar Ltd. E: tim(a)raisedbar.net <mailto:tim@raisedbar.net> M: +44 (0)7989 486976 _______________________________________________ Boost-users mailing list Boost-users(a)lists.boost.org <mailto:Boost-users@lists.boost.org> https://lists.boost.org/mailman/listinfo.cgi/boost-users -- Keith Bennett

3 2

Looking for a mechanism
by tim＠raisedbar.net 14 Sep '18

14 Sep '18

Hi, I'm trying to find a method of solving the problem detailed below using Boost (or an alternative: 1 - I have to send a series of messages to a hardware device to query its internal parameter values at application load-time. This I can do; 2 - I have a callback that receives responses from the hardware, though I get some replies go missing due to saturation; 3 * The hardware manufacturer tells me that I should send 1 query then wait for the response before sending the next query. I could use Sleep, but this depends on a specific wait time and I'm not sure if it suspends all processing, including my callback, so this doesn't look satisfactory. What I'm looking for is a "wait until response" kind of thing, but I haven't found such a thing so far, though I have found several wait routines for handling multiple threads. I'd appreciate any guidance as to what to look for, as my searches are obviously not asking the right questions. Best wishes. Tim Burgess Raised Bar Ltd. E: <mailto:tim@raisedbar.net> tim(a)raisedbar.net M: +44 (0)7989 486976

2 2

[Beast] Downloading multiple urls in parallel
by Sean Farrow 13 Sep '18

13 Sep '18

Hi, Are there functions within beast to allow me to start downloading multiple url's in parallel and then handle each returned result with a different continuation function? Any help appreciated. Kind regards Sean.

2 3

[ASIO] Reestablish TCP connection after EOF
by csizmadiatamas 12 Sep '18

12 Sep '18

I would like to make a c++ TCP client using boost::asio based on this article: https://www.gamedev.net/blogs/entry/2249317-a-guide-to-getting-started-with… I have an existing server which behaviour is similar to a router configuration. You can connect to it and as soon as you have a command promt you can send a command to the server. It executes it and sends back the result and a command promt. Then you can send the next command... There is no problem with this part. My code is able to establish the connection, send and recive data until my client gets EOF. It means the server broke the connection. I would like my client to be able to reestablish the connection and this part is not working. Very much would appreciate your help. *Here is my header:* #pragma once #include <boost/asio.hpp> #include <boost/thread.hpp> #include <boost/asio/io_context_strand.hpp> class Hive; class Connection; class Connection : public boost::enable_shared_from_this< Connection > { friend class Hive; private: static const int m_reconnect_interval = 15000; boost::shared_ptr< Hive > m_hive; boost::asio::ip::tcp::socket m_socket; boost::asio::io_service::strand m_io_strand; boost::asio::deadline_timer m_keepalive_timer; boost::asio::deadline_timer m_reconnect_timer; boost::posix_time::ptime m_last_time; std::vector< uint8_t > m_recv_buffer; std::list< int32_t > m_pending_recvs; std::list< std::vector< uint8_t > > m_pending_sends; int32_t m_receive_buffer_size; int32_t m_keepalive_timer_interval; protected: Connection( boost::shared_ptr< Hive > hive ); virtual ~Connection(); private: Connection( const Connection & rhs ); Connection & operator =( const Connection & rhs ); void StartSend(); void StartRecv( int32_t total_bytes ); void StartKeepAliveTimer(); void StartReconnectTimer(); void StartError(const boost::system::error_code &error, std::string caller); void DispatchSend( std::vector< uint8_t > buffer ); void DispatchRecv( int32_t total_bytes ); void DispatchTimer( const boost::system::error_code & error ); void ReconnectTimer( const boost::system::error_code & error ); void HandleConnect( const boost::system::error_code & error ); void HandleSend( const boost::system::error_code & error, std::list< std::vector< uint8_t > >::iterator itr ); void HandleRecv( const boost::system::error_code & error, int32_t actual_bytes ); void HandleKeepAliveTimer(const boost::system::error_code &error); void HandleReconnectTimer( const boost::system::error_code & error ); void Reconnect(); private: // Called when the connection has successfully connected to the local host. virtual void OnAccept( const std::string & host, uint16_t port ) = 0; // Called when the connection has successfully connected to the remote host. virtual void OnConnect( const std::string & host, uint16_t port ) = 0; // Called when data has been sent by the connection. virtual void OnSend( const std::vector< uint8_t > & buffer ) = 0; // Called when data has been received by the connection. virtual void OnRecv( std::vector< uint8_t > & buffer ) = 0; // Called on each timer event. virtual void OnTimer( const boost::posix_time::time_duration & delta ) = 0; // Called when an error is encountered. virtual void OnError(const std::string error) = 0; public: // Starts an a/synchronous connect. void Connect(const std::string &host, const std::string &port); // Posts data to be sent to the connection. void Send(std::string message); // Posts a recv for the connection to process. If total_bytes is 0, then // as many bytes as possible up to GetReceiveBufferSize() will be // waited for. If Recv is not 0, then the connection will wait for exactly // total_bytes before invoking OnRecv. void Recv( int32_t total_bytes = 0 ); // Posts an asynchronous disconnect event for the object to process. void Disconnect(); }; class Hive : public boost::enable_shared_from_this< Hive > { private: boost::asio::io_service m_io_service; boost::shared_ptr< boost::asio::io_service::work > m_work_ptr; private: Hive( const Hive & rhs ); Hive & operator =( const Hive & rhs ); public: Hive(); virtual ~Hive(); // Returns the io_service of this object. boost::asio::io_service & GetService(); // Polls the networking subsystem once from the current thread and returns. void Poll(); // Runs the networking system on the current thread. This function blocks // until the networking system is stopped, so do not call on a single // threaded application with no other means of being able to call Stop // unless you code in such logic. void Run(); // Stops the networking system. All work is finished and no more // networking interactions will be possible afterwards until Reset is called. void Stop(); // Restarts the networking system after Stop as been called. A new work // object is created ad the shutdown flag is cleared. void Reset(); }; *and here is my cpp:* #include "network.h" #include <boost/interprocess/detail/atomic.hpp> #include <boost/interprocess/detail/config_begin.hpp> #include <boost/interprocess/detail/workaround.hpp> #include <boost/cstdint.hpp> #include <iostream> Hive::Hive() : m_work_ptr( new boost::asio::io_service::work( m_io_service ) ) { } Hive::~Hive() { } boost::asio::io_service & Hive::GetService() { return m_io_service; } void Hive::Poll() { m_io_service.poll(); } void Hive::Run() { m_io_service.run(); } void Hive::Stop() { m_work_ptr.reset(); m_io_service.run(); m_io_service.stop(); } void Hive::Reset() { m_io_service.reset(); m_work_ptr.reset( new boost::asio::io_service::work( m_io_service ) ); } Connection::Connection( boost::shared_ptr< Hive > hive ) : m_hive( hive ), m_socket( hive->GetService() ), m_io_strand( hive->GetService() ), m_keepalive_timer( hive->GetService() ), m_reconnect_timer(hive->GetService()), m_receive_buffer_size( 4096 ), m_keepalive_timer_interval( 2000 ) { } Connection::~Connection() { } void Connection::StartSend() { if( !m_pending_sends.empty() ) boost::asio::async_write( m_socket, boost::asio::buffer( m_pending_sends.front() ), boost::asio::bind_executor(m_io_strand, boost::bind( &Connection::HandleSend, shared_from_this(), boost::asio::placeholders::error, m_pending_sends.begin() ) ) ); } void Connection::StartRecv( int32_t total_bytes ) { if( total_bytes > 0 ) { m_recv_buffer.resize( total_bytes ); boost::asio::async_read( m_socket, boost::asio::buffer( m_recv_buffer ), boost::asio::bind_executor(m_io_strand, boost::bind( &Connection::HandleRecv, shared_from_this(), _1, _2 ) ) ); } else { m_recv_buffer.resize( m_receive_buffer_size ); m_socket.async_read_some( boost::asio::buffer( m_recv_buffer ), boost::asio::bind_executor(m_io_strand, boost::bind( &Connection::HandleRecv, shared_from_this(), _1, _2 ) ) ); } } void Connection::StartKeepAliveTimer() { std::cout << "[" << __FUNCTION__ << "] " << std::endl; m_last_time = boost::posix_time::microsec_clock::local_time(); m_keepalive_timer.expires_from_now( boost::posix_time::milliseconds( m_keepalive_timer_interval ) ); m_keepalive_timer.async_wait( boost::asio::bind_executor(m_io_strand, boost::bind( &Connection::DispatchTimer, shared_from_this(), _1 ) ) ); } void Connection::StartReconnectTimer() { std::cout << "[" << __FUNCTION__ << "] " << std::endl; m_last_time = boost::posix_time::microsec_clock::local_time(); m_reconnect_timer.expires_from_now( boost::posix_time::milliseconds( m_reconnect_interval ) ); m_reconnect_timer.async_wait( boost::asio::bind_executor(m_io_strand, boost::bind( &Connection::ReconnectTimer, shared_from_this(), _1 ) ) ); } void Connection::StartError(const boost::system::error_code &error, std::string caller) { OnError(caller + " " + error.message() + "(" + error.category().name() + ":" + std::to_string(error.value()) + ")"); boost::system::error_code ec; m_socket.shutdown(boost::asio::ip::tcp::socket::shutdown_both, ec); m_socket.close(ec); m_keepalive_timer.cancel(ec); if (error == boost::asio::error::misc_errors::eof || error == boost::system::errc::timed_out) StartReconnectTimer(); } void Connection::HandleConnect( const boost::system::error_code & error ) { if( error ) StartError(error, __FUNCTION__); else { if( m_socket.is_open() ) { OnConnect( m_socket.remote_endpoint().address().to_string(), m_socket.remote_endpoint().port() ); m_reconnect_timer.cancel(); StartKeepAliveTimer(); } else StartError(error, __FUNCTION__); } } void Connection::HandleSend( const boost::system::error_code & error, std::list< std::vector< uint8_t > >::iterator itr ) { if( error ) StartError(error, __FUNCTION__); else { OnSend( *itr ); m_pending_sends.erase( itr ); StartSend(); } } void Connection::HandleRecv( const boost::system::error_code & error, int32_t actual_bytes ) { if( error ) StartError(error, __FUNCTION__); else { m_recv_buffer.resize( actual_bytes ); OnRecv( m_recv_buffer ); m_pending_recvs.pop_front(); if( !m_pending_recvs.empty() ) StartRecv( m_pending_recvs.front() ); } } void Connection::HandleKeepAliveTimer(const boost::system::error_code &error) { if( error ) StartError(error, __FUNCTION__); else { OnTimer( boost::posix_time::microsec_clock::local_time() - m_last_time ); StartKeepAliveTimer(); } } void Connection::HandleReconnectTimer( const boost::system::error_code & error ) { std::cout << "[" << __FUNCTION__ << "] Calling reconnect... " << std::endl; Reconnect(); } void Connection::DispatchSend( std::vector< uint8_t > buffer ) { bool should_start_send = m_pending_sends.empty(); m_pending_sends.push_back( buffer ); if( should_start_send ) StartSend(); } void Connection::DispatchRecv( int32_t total_bytes ) { bool should_start_receive = m_pending_recvs.empty(); m_pending_recvs.push_back( total_bytes ); if( should_start_receive ) StartRecv( total_bytes ); } void Connection::DispatchTimer( const boost::system::error_code & error ) { boost::asio::post(m_io_strand, boost::bind(&Connection::HandleKeepAliveTimer, shared_from_this(), error ) ); } void Connection::ReconnectTimer( const boost::system::error_code & error ) { boost::asio::post(m_io_strand, boost::bind( &Connection::HandleReconnectTimer, shared_from_this(), error ) ); } void Connection::Connect(const std::string &host, const std::string &port) { std::cout << "[" << __FUNCTION__ << "] connecting to "<< host << ":" << port << std::endl; boost::system::error_code ec; boost::asio::ip::tcp::resolver resolver( m_hive->GetService() ); boost::asio::ip::tcp::resolver::query query( host, port ); boost::asio::ip::tcp::resolver::iterator iterator = resolver.resolve( query ); m_socket.async_connect( *iterator, boost::asio::bind_executor(m_io_strand, boost::bind( &Connection::HandleConnect, shared_from_this(), _1 ) ) ); } void Connection::Reconnect() { m_hive->Reset(); Connect("10.40.60.72", "23"); } void Connection::Disconnect() { boost::asio::post(m_io_strand, boost::bind(&Connection::HandleKeepAliveTimer, shared_from_this(), boost::asio::error::connection_reset ) ); } void Connection::Recv( int32_t total_bytes ) { boost::asio::post(m_io_strand, boost::bind( &Connection::DispatchRecv, shared_from_this(), total_bytes ) ); } void Connection::Send(std::string message) { std::vector< uint8_t > request; std::copy( message.begin(), message.end(), std::back_inserter( request ) ); boost::asio::post(m_io_strand, boost::bind( &Connection::DispatchSend, shared_from_this(), request ) ); } -- Sent from: http://boost.2283326.n4.nabble.com/Boost-Users-f2553780.html

1 0