scheduling

There is a peculiarity that I encountered while using Java scheduled executors and was wondering if what I experienced is normal. I need to schedule tasks that execute at a predefined rate of 5 seconds. It is expected that these tasks will take longer than 5 seconds to execute from time to time, but when the time to run them goes below 5 seconds, the backed up list of tasks should run in quick succession to catch up. When running the tasks, it is important to know what the original scheduled execution time was (think scheduledExecutionTime() in java.util.TimerTask ). Finally, I need to track

I'm writing something on the linux scheduler and I need to know which process was running before my interrupt came in.. is the current structure available? If I do current->pid while in the interrupt handler, do I get the pid of the process I interrupted? You can, current->pid exists and is the process that was interrupted (may be the idle thread, or any). If you're writing inside the Linux scheduler, you should be very careful. current is changed by the scheduler as it chooses a new process to run, so its value depends on when exactly you read it. I wouldn't expect current to be valid outside

I need to manage a pool of threads having different priorities, so I wrote the following thread startup procedure: static int startup(thrd_t *thrd, thrd_sync_t *sync, int prio) { pthread_attr_t attr; int err; struct sched_param param = { .sched_priority = prio }; assert(pthread_attr_init(&attr) == 0); assert(pthread_attr_setschedpolicy(&attr, SCHED_FIFO) == 0); assert(pthread_attr_setschedparam(&attr, &param) == 0); err = pthread_create(&thrd->handler, &attr, thread_routine, (void *)thrd); pthread_attr_destroy(&attr); return err; } In principle the unprivileged user should not be allowed to