I don't understand why a handmade linked list/ring was used here, with manual reference count. Don't we have std::list and std::shared_ptr for this kind of job? Can some one explain to me the rationale behind that?

I change the linked list to std::list, and the reference counting logic to std::shared_ptr, it passed the test cases. Because of the std::list overhead, now per emission size is 24 bytes compare to 8 bytes, I suppose when more slots are connected, the difference will be smaller. On my Mac, the peak memory used by the master implementation and my version are almost the same, 892928 vs 901120.

But surprisingly, the latency of my version is much smaller, on my 2013 Mac pro, with 3.5 GHz 6-Core Intel Xeon E5, the master implementation took 22.417022ns per emission. My version only took 4.695005ns.

> time -l ./test.master
Signal/Basic Tests: OK
Signal/CollectorVector: OK
Signal/CollectorUntil0: OK
Signal/CollectorWhile0: OK
Signal/Benchmark: Simple::Signal: OK
  Benchmark: Simple::Signal: 22.417022ns per emission (size=8): OK
Signal/Benchmark: callback loop: OK
  Benchmark: callback loop: 0.014000ns per round: OK
        0.02 real         0.02 user         0.00 sys
    892928  maximum resident set size
         0  average shared memory size
         0  average unshared data size
         0  average unshared stack size
       221  page reclaims
         9  page faults
         0  swaps
         0  block input operations
         0  block output operations
         0  messages sent
         0  messages received
         0  signals received
         1  voluntary context switches
         8  involuntary context switches

> time -l ./test.list
Signal/Basic Tests: OK
Signal/CollectorVector: OK
Signal/CollectorUntil0: OK
Signal/CollectorWhile0: OK
Signal/Benchmark: Simple::Signal: OK
  Benchmark: Simple::Signal: 4.695005ns per emission (size=24): OK
Signal/Benchmark: callback loop: OK
  Benchmark: callback loop: 0.001000ns per round: OK
        0.01 real         0.00 user         0.00 sys
    901120  maximum resident set size
         0  average shared memory size
         0  average unshared data size
         0  average unshared stack size
       221  page reclaims
        11  page faults
         0  swaps
         0  block input operations
         0  block output operations
         0  messages sent
         0  messages received
         0  signals received
         1  voluntary context switches
         5  involuntary context switches

The member method SignalLink::deactivate is currently unused and can be safely removed.

Moreover, it has a subtle issue: the comparison cbf == function wouldn't work in any case. That's because the two variables are of type CbFunction, that is std::function<R (Args...)> and the operator== for them is defined to check only with nullptr. In other terms, a std::function can be compared with nullptr, but it cannot be compared with another std::function, as from the standard.

Fortunately, everything compiles fine because it is part of a template class and, being that function not used, it is not considered by the compiler. You can easily test it by invoking the function somewhere: you won't get an error at runtime, while you will get an error at compile time saying that you cannot compare two functions.

for SimpleSignal.h

• make invoke const as well since emit calls it
• remove commented out includes
• add missing header

for test.cpp

• add
• minimal changes to support microsoft compiler

compile with -fsanitize=address to note small leak when using size(); fixed by adding a decref() call at the end of the while loop when calculating size

As suggested within the file test.cpp, one should use the following line to compile it:

g++ -Wall -O2 -std=gnu++11 -pthread test.cpp && ./a.out

Anyway, on some systems it results in the following annoying error:

test.cpp: In function ‘void bench_simple_signal()’: test.cpp:179:33: warning: format ‘%u’ expects argument of type ‘unsigned int’, but argument 3 has type ‘long unsigned int’ [-Wformat=]

An explicit cast will suppress that warning.