@@ -6,13 +6,20 @@
 #include <iomanip>
 #include <string>
 #include <cmath>
 #include <list>
 
 #include <boost/signals2.hpp>
+#include <boost/signals2/dummy_mutex.hpp>
+#include <boost/signals2/signal_type.hpp>
 #include <boost/timer.hpp>
+
+#ifdef _WIN32
+    #include "windows.h"
+#endif // _WIN32
+
 
 struct A
 {
     void operator()( int a )
         {
             b = ++a;
@@ -31,31 +38,38 @@
 template<typename T>
 void
 test_boost( int s, size_t N )
 {
     T a;
 
-    typedef boost::signals2::signal<void (int)> signal;
+    namespace bs2 = boost::signals2;
+    using namespace bs2::keywords;
+    typedef bs2::signal_type<void (int), mutex_type<bs2::dummy_mutex>>::type signal;
 
     signal si;
     for ( int i = 0; i < s; ++i )
         si.connect( a );
 
     for ( size_t i = 0;i < N; ++i )
     {
         int t = i %1000;
         si( t );
     }
 }
 
-int main( int argc,  char** argv )
+int main( int const argc,  char * * const argv )
 {
+#ifdef _WIN32
+    BOOST_VERIFY( ::SetPriorityClass ( ::GetCurrentProcess(), REALTIME_PRIORITY_CLASS       ) );
+    BOOST_VERIFY( ::SetThreadPriority( ::GetCurrentThread (), THREAD_PRIORITY_TIME_CRITICAL ) );
+#endif // _WIN32
+
     boost::timer ti;
 
-    int Nslots = 4; // std::atoi( argv[1] );
-    size_t Ncalls = 10000000; // std::atoi( argv[2] )+1;
+    int    const Nslots( ( argc < 2 ) ?          4 : std::atoi( argv[ 1 ] ) );
+    size_t const Ncalls( ( argc < 3 ) ? 1000000000 : std::atoi( argv[ 2 ] ) );
     const int ws = 6;
     const int w = 15;
 
     //
     // with dummy
     //
@@ -63,27 +77,28 @@
               << "call dummy::operator()\n";
     std::cout << std::setw( ws ) << "#Slots"
               << std::setw( w ) << "#Calls"
               << std::setw( w ) << "boost::signals"
               << std::endl;
 
-    double t = 0.0, n = 0.0;
-    for ( size_t s = 0;s < Nslots; ++s )
+    double       t( 0 );
+    unsigned int n( 0 );
+    for ( size_t s = 1;s < Nslots; ++s )
     {
         for ( size_t i = 100;i < Ncalls; i*=10 )
         {
             std::cout << std::setw( ws ) << s;
             std::cout << std::setw( w ) << i;
 
             ti.restart();
             test_boost<dummy>( s,  i );
             double b = ti.elapsed();
             std::cout << std::setw( w ) << b;
             std::cout << std::endl;
             t += b;
-            n += i;
+            n += s * i;
         }
     }
 
     //
     // with A
     //
@@ -91,24 +106,24 @@
               << "call A::operator()\n";
     std::cout << std::setw( ws ) << "#Slots"
               << std::setw( w ) << "#Calls"
               << std::setw( w ) << "boost::signals"
               << std::endl;
 
-    for ( size_t s = 0;s < Nslots; ++s )
+    for ( size_t s = 1;s < Nslots; ++s )
     {
         for ( size_t i = 100;i < Ncalls; i*=10 )
         {
             std::cout << std::setw( ws ) << s;
             std::cout << std::setw( w ) << i;
 
             ti.restart();
             test_boost<A>( s,  i );
             double b = ti.elapsed();
             std::cout << std::setw( w ) << b;
             std::cout << std::endl;
             t += b;
-            n += i;
+            n += s * i;
         }
     }
     std::cout << "average time per call: " << t/n << std::endl;
 }