- Boost - lists.boost.org

Re: [boost] Asio multithreaded server
by Christopher Kohlhoff 17 Nov '06

17 Nov '06

berserker_r <berserker_r(a)hotmail.com> wrote: > I'm using 0.3.7 with boost 1.33.1. Try this change to win_iocp_io_service.hpp in addition to the previous patch: @@ -125,10 +125,13 @@ #endif LPOVERLAPPED overlapped = 0; ::SetLastError(0); - ::GetQueuedCompletionStatus(iocp_.handle, &bytes_transferred, - &completion_key, &overlapped, INFINITE); + BOOL ok = ::GetQueuedCompletionStatus(iocp_.handle, + &bytes_transferred, &completion_key, &overlapped, 1000); DWORD last_error = ::GetLastError(); + if (!ok && overlapped == 0 && last_error == WAIT_TIMEOUT) + continue; + if (overlapped) { // We may have been passed a last_error value in the completion_key. Note that I haven't tested that it even compiles. Cheers, Chris

1 0

Re: [boost] Asio multithreaded http server
by berserker_r 17 Nov '06

17 Nov '06

Pedro Lamarão wrote: > You can rework your read handler to do all I/O necessary, and to submit > the obtained data to a work queue somewhere else. > Another thread would then dispatch work items from this work queue to > worker threads. > After the work is finished, the item would be moved to an exit queue, > with a response for the peer, or something. I tried to process the read handler operation in an another thread but any other operation (for example accepting new connections in the server) is still locked until the session's work is done... Can you snip a sample based on http://asio.cvs.sourceforge.net/asio/asio/src/tests/performance/server.cpp?… I'm missing something...I have also tried the patch that Chris has suggested but with no success... Thanks

1 0

[Boost-bugs] [ boost-Bugs-1598153 ] top-level configure is broken
by SourceForge.net 17 Nov '06

17 Nov '06

Bugs item #1598153, was opened at 2006-11-16 20:53 Message generated for change (Tracker Item Submitted) made by Item Submitter You can respond by visiting: https://sourceforge.net/tracker/?func=detail&atid=107586&aid=1598153&group_… Please note that this message will contain a full copy of the comment thread, including the initial issue submission, for this request, not just the latest update. Category: build Group: release 1.34.0 Status: Open Resolution: None Priority: 5 Private: No Submitted By: eponym (eponym) Assigned to: Nobody/Anonymous (nobody) Summary: top-level configure is broken Initial Comment: The top-level configure script in the RC1.34.0 release is broken. This script starts out as: #!/bin/sh which implies that it is a Bourne-shell script. But now almost all of tests in the file have been converted to look like the following: 220 if test "x$LIBDIR" == x; then 221 LIBDIR="$EPREFIX/lib" 222 fi where (in 1.33.1) they used to look like this: 217 if test "x$LIBDIR" = "x" ; then 218 LIBDIR="$EPREFIX/lib" 219 fi The problem is that "==" is not a valid Bourne-shell test-command operator, so the entire build breaks immediately on any platform which uses a true Bourne shell as sh. The fix is to either convert all of these operators to "=", or to stop claiming the script is a Bourne shell script and use "#!/bin/bash" instead. But the latter approach is not recommended because there are many older machines without bash in that location. ---------------------------------------------------------------------- You can respond by visiting: https://sourceforge.net/tracker/?func=detail&atid=107586&aid=1598153&group_… ------------------------------------------------------------------------- Take Surveys. Earn Cash. Influence the Future of IT Join SourceForge.net's Techsay panel and you'll get the chance to share your opinions on IT & business topics through brief surveys - and earn cash http://www.techsay.com/default.php?page=join.php&p=sourceforge&CID=DEVDEV _______________________________________________ Boost-bugs mailing list Boost-bugs(a)lists.sourceforge.net https://lists.sourceforge.net/lists/listinfo/boost-bugs

1 0

[Boost-bugs] [ boost-Bugs-1598141 ] top-level configure is broken
by SourceForge.net 17 Nov '06

17 Nov '06

Bugs item #1598141, was opened at 2006-11-16 19:46 Message generated for change (Tracker Item Submitted) made by Item Submitter You can respond by visiting: https://sourceforge.net/tracker/?func=detail&atid=107586&aid=1598141&group_… Please note that this message will contain a full copy of the comment thread, including the initial issue submission, for this request, not just the latest update. Category: build Group: release 1.34.0 Status: Open Resolution: None Priority: 5 Private: No Submitted By: eponym (eponym) Assigned to: Nobody/Anonymous (nobody) Summary: top-level configure is broken Initial Comment: The top-level configure script in the RC1.34.0 release is broken. This script starts out as: #!/bin/sh which implies that it is a Bourne-shell script. But now almost all of tests in the file have been converted to look like the following: 220 if test "x$LIBDIR" == x; then 221 LIBDIR="$EPREFIX/lib" 222 fi where (in 1.33.1) they used to look like this: 217 if test "x$LIBDIR" = "x" ; then 218 LIBDIR="$EPREFIX/lib" 219 fi The problem is that "==" is not a valid Bourne-shell test-command operator, so the entire build breaks immediately on any platform which uses a true Bourne shell as sh. The fix is to either convert all of these operators to "=", or to stop claiming the script is a Bourne shell script and use "#!/bin/bash" instead. But the latter approach is not recommended because there are many older machines without bash in that location. ---------------------------------------------------------------------- You can respond by visiting: https://sourceforge.net/tracker/?func=detail&atid=107586&aid=1598141&group_… ------------------------------------------------------------------------- Take Surveys. Earn Cash. Influence the Future of IT Join SourceForge.net's Techsay panel and you'll get the chance to share your opinions on IT & business topics through brief surveys - and earn cash http://www.techsay.com/default.php?page=join.php&p=sourceforge&CID=DEVDEV _______________________________________________ Boost-bugs mailing list Boost-bugs(a)lists.sourceforge.net https://lists.sourceforge.net/lists/listinfo/boost-bugs

1 0

I think using spinlocks to simulate an atomic shared_ptr is deadlock-prone, or inefficient.
by Talbot, George 17 Nov '06

17 Nov '06

I've been playing around with the atomic_shared example class that I posted, and I'm not entirely happy with a spinlock-based solution to a shared_ptr type class. To implement operator= for a class like this has two issues: 1) operator= for an atomic shared_ptr can only be "best effort". If another thread wins out, so be it. I'm going to, for the purposes of this discussion, assume that this is OK, and that if you don't like it, you'll use compare_and_set/swap to do a better job. 2) Without any sort of 2-pointer-wide atomic assignment in hardware, operator= really looks like this: lock the source pointer make a local copy of it release the source pointer lock the destination set the value of the destination from the copy unlock the destination This won't deadlock, but has to make an extra copy of the pointer locally. To avoid the copy, we would have to lock both the source and destination before the assignment of the underlying shared_ptr, which, in the code I sent I did, but is deadlock-prone. See the implementation of swap for even more inefficiency. However, what is the "right" way to do this? I read the stuff from Chris Thommason and I have to admit that I'm not too sure how I'd wrap shared_ptr with it to make this work. Can I have a bit of brainstorming assistance? P.S. Appended is a version of atomic_shared using spinlocks that I don't think deadlocks, but I could be wrong. Can I get a bit of help looking at it from more experienced eyes? P.S. Peter Dimov: Is it OK that I put your name on this as one of the authors? You had told me in previous posts to the list how the operations should likely work with a spinlock, so it seemed appropriate. -- George T. Talbot <gtalbot(a)locuspharma.com> /** \file atomic_shared.h * * \author George T. Talbot * \author Peter Dimov * * \brief This file defines a template class that can wrap * boost::shared_ptr and provide thread-safe atomic * read/write operations. * * (C) Copyright George Talbot, Peter Dimov 2006. * * Distributed under the Boost Software License, Version 1.0. (See * accompanying file LICENSE_1_0.txt or copy at * http://www.boost.org/LICENSE_1_0.txt) */ #ifndef ATOMIC_SHARED_H #define ATOMIC_SHARED_H #include <boost/shared_ptr.hpp> #include <pthread.h> #include <stdexcept> #include <cerrno> #include <cassert> #ifdef ATOMIC_ABORT_ON_ERROR #define ATOMIC_SHARED_ABORT ::abort(); #else #define ATOMIC_SHARED_ABORT #endif /** A wrapper for shared_ptr that implements atomic assignments and compare_and_swap. */ template<class T> class atomic_shared { typedef boost::shared_ptr<T> base_ptr; /** Lock a spinlock protecting an atomic pointer. * * @param l Spinlock to lock. * @param should_throw If true, thrown an exception if lock fails. */ static void lock(pthread_spinlock_t& l, bool should_throw = true) { int rv = ::pthread_spin_lock(&l); if (rv) { errno = rv; ATOMIC_SHARED_ABORT if (should_throw) { throw std::logic_error("can't lock spinlock"); } } } /** Unlock a spinlock protecting an atomic pointer. */ static void unlock(pthread_spinlock_t& l) { int rv = ::pthread_spin_unlock(&l); if (rv) { ATOMIC_SHARED_ABORT errno = rv; throw std::logic_error("can't lock spinlock"); } } /** Initialize a spinlock protecting an atomic pointer. */ static void init(pthread_spinlock_t& l) { int rv = ::pthread_spin_init(&l, PTHREAD_PROCESS_PRIVATE); if (rv) { ATOMIC_SHARED_ABORT errno = rv; throw std::logic_error("can't initialize spinlock"); } } public: typedef typename base_ptr::element_type element_type; ///< Type of element to which pointer points. typedef typename base_ptr::value_type value_type; ///< Same as element_type. typedef typename base_ptr::pointer pointer; ///< Pointer to refcounted object. typedef typename base_ptr::reference reference; ///< Reference to refcounted object. /** Initialize an empty spinlock. */ atomic_shared() { init(spinlock); } /** Create a managed pointer from a bare one. */ template<class Y> explicit atomic_shared(Y* p) : ptr(p) { init(spinlock); } /** Create a managed pointer from a bare one, and a custom deleter. */ template<class Y, class D> atomic_shared(Y * p, D d) : ptr(p, d) { init(spinlock); } atomic_shared(const base_ptr& p) : ptr(p) { init(spinlock); } atomic_shared(const atomic_shared<T>& p) { init(spinlock); lock(p.spinlock); ptr = p.ptr; unlock(p.spinlock); } atomic_shared<T>& operator=(atomic_shared<T> p) // local copy to avoid deadlock. { if (&p != this) { lock(spinlock); ptr = p.ptr unlock(spinlock); } return *this; } template<class Y> atomic_shared(const atomic_shared<Y>& p) { init(spinlock); lock(p.spinlock); ptr = p.ptr; unlock(p.spinlock); } template<class Y> atomic_shared<T>& operator=(atomic_shared<Y> p) // local copy to avoid deadlock. { lock(spinlock); ptr = p.ptr unlock(spinlock); return *this; } ~atomic_shared() { // Lock the spinlock to hold off all other copiers. lock(spinlock, false); // Destroy the spinlock--this should cause all other copiers to // either assert or throw. int rv = ::pthread_spin_destroy(&spinlock); // For debugging, drop us into the debugger if we can't destroy the // spinlock. if (rv) { ATOMIC_SHARED_ABORT } } /** Reset the pointer to an empty pointer. */ void reset() { lock(spinlock); ptr.reset(); unlock(spinlock); } /** Reset the pointer and replace it with a new bare pointer. */ template<class Y> void reset(Y* p) { lock(spinlock); ptr.reset(p); unlock(spinlock); } /** Reset the pointer and replace it with a new bare pointer with custom deleter. */ template<class Y, class D> void reset(Y* p, D d) { lock(spinlock); ptr.reset(p, d); unlock(spinlock); } reference operator*() const { return ptr.operator*(); } T* operator->() const { return ptr.operator->(); } T* get() const { return ptr.get(); } operator bool() const { return ptr; } bool operator!() const { return !ptr; } bool unique() const { return ptr.unique(); } long use_count() const { return ptr.use_count(); } /** Atomically swap the pointer with another pointer. */ void swap(atomic_shared<T>& other) { atomic_shared<T> temp(*this); atomic_shared<T> temp2(other); lock(spinlock); ptr = temp2.ptr; unlock(spinlock); lock(other.spinlock); other = temp.ptr; unlock(other.spinlock); } /** Attempt to set the value of the pointer with another pointer, but only if the * pointer is the same as a previously sampled value of the pointer. * * @return true if the swap was successful. */ bool compare_and_set(const atomic_shared<T>& cmp, atomic_shared<T> xchg) // Note that xchg is a local copy. { int rv = ::pthread_spin_trylock(&spinlock); switch (rv) { case EBUSY: if ((void*)&xchg < (void*)this) unlock(xchg.spinlock); return false; case 0: break; default: ATOMIC_SHARED_ABORT errno = rv; throw std::logic_error("can't pthread_spin_trylock"); } bool r = ptr == cmp.ptr; if (r) ptr.swap(xchg.ptr); unlock(spinlock); return r; } private: template<class Y> friend class atomic_shared; base_ptr ptr; mutable pthread_spinlock_t spinlock; }; // atomic_shared #endif

3 2

atomic_ops library
by Neal Becker 17 Nov '06

17 Nov '06

Perhaps of some interest: http://www.hpl.hp.com/research/linux/atomic_ops/

3 5

[proposal] Atomically Thread-Safe Static Initialization For Boost...
by Chris Thomasson 16 Nov '06

16 Nov '06

Here is the C++ pseudo-code: namespace atomic { template<typename T> class var; template<typename T> class once; namespace mb { enum naked_e { naked }; enum fence_e { fence }; enum release_e { release }; enum depends_e { depends }; enum acquire_depends_e { acquire_depends }; } namespace externlib_api { class hashed_mutex; template<typename T> extern T load(T volatile*, mb::naked_e) const throw(); template<typename T> extern T load(T volatile*, mb::depends_e) const throw(); template<typename T> extern void store(T volatile*, T const&, mb::release_e) throw(); template<typename T> extern void store(T volatile*, T const&, mb::naked_e) throw(); template<typename T> extern bool cas(T volatile*, T const&, T const&, mb::acquire_depends_e) throw(); template<typename T> extern bool cas(T volatile*, T const&, T const&, mb::fence_e) throw(); } template<typename T> class var { mutable T volatile m_state; public: var() throw() {} var(T const &state) throw() : m_state(state) {} public: inline T load(mb::depends_e) const throw() { return externlib_api::load(&m_state, mb::depends); } inline T load(mb::naked_e) const throw() { return externlib_api::load(&m_state, mb::naked); } public: inline void store(T const &xchg, mb::fence_e) throw() { externlib_api::store(&m_state, xchg, mb::fence); } inline void store(T const &xchg, mb::naked_e) throw() { externlib_api::store(&m_state, xchg, mb::naked); } public: inline bool cas(T const &cmp, T const &xchg, mb::fence_e) throw() { return externlib_api::cas(&m_state, cmp, xchg, mb::fence); } inline bool cas(T const &cmp, T const &xchg, mb::acquire_depends_e) throw() { return externlib_api::cas(&m_state, cmp, xchg, mb::acquire_depends); } }; template<typename T> class once { var<T*> m_state; var<intword_t> m_count; public: once() throw() : m_state(0), m_count(1) {} ~once() throw() { if (try_dec()) { try { delete local; } catch(...) { assert(false); throw; } } } private: bool try_dec() throw() { intword_t local; do { local = m_count.load(mb::naked); if (! local || local < 1) { return false; } // use mb::fence to cover *both acquire and release // wrt the result of the decrement } while(! m_count.cas(local, local - 1, mb::fence)); return (local == 1); } bool try_inc() throw() { intword_t local; do { local = m_count.load(mb::naked); if (! local || local < 1) { return false; } } while(! m_count.cas(local, local + 1, mb::acquire_depends)); return true; } public: // atomic load / thread-saftey: strong T* load() const { T *local = m_state.load(mb::depends); if (! local) { externlib_api::hashed_mutex::guard_t const &lock(this); if (! try_inc()) { return 0; } local = m_state.load(mb::naked); if (! local) { // call try_dec on exceptions... local = new T; m_state.store(local, mb::release); } } else if(! try_inc()) { return 0; } return local; } // dec the refcount void dec() { if (try_dec()) { delete local; } } }; } okay, here is sample usage now: static atomic::once<foo> g_foo; void some_threads(...) { for(;;) { // whatever... foo *myfoo = g_foo.load(); if (myfoo) { // use myfoo... // okay, we are finished with myfoo g_foo.dec(); } } } This should be a workable solution to the static initialization problem... What do you all think?

3 25

Re: [boost] Review Request: Boost Exception
by Matthew Herrmann 16 Nov '06

16 Nov '06

> > Message: 5 > Date: Tue, 14 Nov 2006 20:38:43 +0200 > From: "Peter Dimov" <pdimov(a)mmltd.net> > Subject: Re: [boost] Review Request: Boost Exception > To: <boost(a)lists.boost.org> > Message-ID: <00ee01c7081c$1f94f230$6607a8c0@pdimov2> > Content-Type: text/plain; format=flowed; charset="iso-8859-1"; > reply-type=original > > David Abrahams wrote: > >> > "Peter Dimov" <pdimov(a)mmltd.net> writes: >> > >> >>> >> David Abrahams wrote: >>> >>>> >>> "Peter Dimov" <pdimov(a)mmltd.net> writes: >>>> >>> >>>> >>>>> >>>> Moving the catch clause to a destructor doesn't seem an improvement >>>>> >>>> to me. >>>>> >>>> >>> >>>> >>> Using a catch clause to add information to a propagating exception >>>> >>> feels syntactically heavy to me, but of course others may disagree. >>>> >>> And it may also be that without language support, there's not >>>> >>> really a good way to avoid that weight. I'm just expressing an >>>> >>> aesthetic preference here. >>>> >>> >> >>> >> Won't you need to prepare all the extra information even if nothing >>> >> throws? >>> >> > >> > No, you could do it lazily. >> > > I'm afraid that I need to be shown an example in order to "get it". :-) > I think Mr Abrahams is referring to an idea similar to this: (please ignore the class name, it is a placeholder only) void read_file() { boost::exception_info e(..., filename, current_pos, is_connected); ... e.success(); return; } e.success() sets a flag to true, which prevents the generation of error information when the object is destroyed. To remove the e.success(), you'd need to detect whether the stack was being unwound due to an exception or due to a natural return. This is where language support (or compiler-dependent tricks) would be required. Nested exceptions complicate that picture. The other issue is how to handle return values cleanly. You could make success() a pass-through function so you could handle return values with a shorter syntax: int sum(int a, int b) { error_info e; ... return e.success(a+b); } template <typename T> T& error_info::success(T& value) { flag = true; return rhs; } (special care needed to avoid copying and to handle references/temporaries etc). Ultimately, this approach is cleaner when there are more exit points due to exceptions than from return statements. Otherwise, you could forget to call success() at one of the return sites and hit a performance issue as it generates the exception info. Regards, Matthew Herrmann

8 11

Re: [boost] [fusion] comparing iterators with is_same?
by dan marsden 16 Nov '06

16 Nov '06

Steven Watanabe wrote: > >In accumulate and fold I see > >is_same< > typename result_of::begin<Sequence const>::type > , typename result_of::end<Sequence const>::type>() > >shouldn't this be result_of::equal_to<...>()? > You're correct, that is a defect. Now fixed in CVS. Thanks for picking this up Cheers Dan Send instant messages to your online friends http://uk.messenger.yahoo.com

1 0

Re: [boost] Asio multithreaded http server
by Christopher Kohlhoff 16 Nov '06

16 Nov '06

berserker_r <berserker_r(a)hotmail.com> wrote: > Actually the server looks to be "locked" to accept new > connections until the current session has finished its work > even calling io_service::run from multiple threads. What OS are you using? Is the session's work CPU bound? Cheers, Chris

4 3