[Bug libc/30558] SIGEV_THREAD is badly implemented

["adhemerval.zanella at linaro dot org" <sourceware-bugzilla@sourceware.org>]

https://sourceware.org/bugzilla/show_bug.cgi?id=30558

--- Comment #7 from Adhemerval Zanella <adhemerval.zanella at linaro dot org> ---
(In reply to Stas Sergeev from comment #6)
> If I could make a wishes here,
> I'd say please implement SIGEV_THREAD
> on top of timerfd API.
> That way you avoid messing around
> signals, and can get a consistent
> timer_getoverrun().

I don't think this a promising approach for POSIX timers, besides adding an
extra file descriptor under the hoods (with might interfere with
RLIMIT_NOFILE), the timerfd inherits over fork which would require keeping
track of the user file descriptor, and adding an atfork handler to close them.
We would also need to synthesize a sigval argument, which most likely would
require even extra state that kernel already provides us for free.

I created an RFC implementation to avoid the thread creation per timer trigger
[1]: timer_create now creates a thread per SIGEV_THREAD invocation, and each
thread will issue the timer callback without creating and destroying a new
thread per invocation.

The glibc allows the created thread to be cancellable or call pthread_exit, and
it is not fully specified how the POSIX timer should act in this case.  On the
current implementation, the next timer invocation will create a new thread, so
only timer_delete will unregister the kernel timer.  My RFC changes the
semantic that once the callback issues pthread_exit or the thread is cancelled,
no more timers are triggered. I think I will need to implement something like
musl that setjmp/longjmp to avoid the abort the cancellation process, although
I am not sure if is the correct or expected semantic.

Performance-wise it seems that it does use fewer CPU cycles:

--
#include <time.h>
#include <signal.h>
#include <assert.h>
#include <unistd.h>

static void
tf (union sigval arg)
{
}

int main (int argc, char *argv[])
{
  const struct itimerspec itval = {
    { 0, 150000000 },
    { 0, 150000000 },
  };

  struct sigevent sigev = {
    .sigev_notify = SIGEV_THREAD,
    .sigev_notify_function = tf,
    .sigev_notify_attributes = NULL,
    .sigev_value.sival_ptr = NULL,
  };

  enum { count = 128 };
  timer_t timers[count];

  for (int i = 0; i < count; i++)
    {
      assert (timer_create (CLOCK_REALTIME, &sigev, &timers[i]) == 0);
      assert (timer_settime (timers[i], 0, &itval, NULL) == 0);
    }

  sleep (5);

  for (int i = 0; i < count; i++)
    assert (timer_delete (timers[i]) == 0);

  sleep (2);

  return 0;
}
--

Master:

$ perf stat ./timer-bench

 Performance counter stats for './timer-bench':

            121,50 msec task-clock                #    0,017 CPUs utilized
               187      context-switches          #    1,539 K/sec
                 0      cpu-migrations            #    0,000 /sec
               187      page-faults               #    1,539 K/sec
       302.445.622      cycles                    #    2,489 GHz               
      (72,86%)
         3.089.604      stalled-cycles-frontend   #    1,02% frontend cycles
idle     (81,64%)
        47.543.776      stalled-cycles-backend    #   15,72% backend cycles
idle      (83,82%)
       287.475.386      instructions              #    0,95  insn per cycle
                                                  #    0,17  stalled cycles per
insn  (83,43%)
        48.578.487      branches                  #  399,835 M/sec             
      (72,20%)
           459.578      branch-misses             #    0,95% of all branches   
      (67,88%)

       7,001998495 seconds time elapsed

       0,013313000 seconds user
       0,150883000 seconds sys

VS my RFC branch:

x86_64-linux-gnu$ perf stat ./elf/ld.so --library-path . ../timer-bench

 Performance counter stats for './elf/ld.so --library-path . ../timer-bench':

             68,61 msec task-clock                #    0,010 CPUs utilized
             4.662      context-switches          #   67,949 K/sec
               161      cpu-migrations            #    2,347 K/sec
               326      page-faults               #    4,751 K/sec
       127.514.086      cycles                    #    1,859 GHz
         3.714.619      stalled-cycles-frontend   #    2,91% frontend cycles
idle
        10.407.556      stalled-cycles-backend    #    8,16% backend cycles
idle
        65.273.326      instructions              #    0,51  insn per cycle
                                                  #    0,16  stalled cycles per
insn
        13.918.731      branches                  #  202,866 M/sec             
      (0,46%)
     <not counted>      branch-misses                                          
      (0,00%)

       7,006109877 seconds time elapsed

       0,000000000 seconds user
       0,079625000 seconds sys

Although the extra threads might generate more context-switches/page-faults
since each one will eventually call sigwaitinfo. I have not analyzed latency,
although I would expect to also show better results.


[1]
https://sourceware.org/git/?p=glibc.git;a=shortlog;h=refs/heads/azanella/bz30558-posix_timer

-- 
You are receiving this mail because:
You are on the CC list for the bug.