Programming

Hello,

I am writing a threaded program using the pthread library in linux. I have a master thread that needs to control worker threads, in particular, it has to be able to ensure that none of the worker threads will be running for a specified amount of time, even if the worker threads are active. This means that I cannot use the regular pthread_cond synchronization functions, because the other threads might be executing.

I basically need to replicate the 'suspend' method to control active worker threads. Is there any way to achieve this with pthreads? Or can you suggest other (preferably portable) libraries that give me this functionality?

Thank you very much!

P.S.
Why didn't they just add a suspend method to pthreads? I can see why the a cancel method might be unsafe, but not suspend...

So, you want to start and stop threads at will from the outside?

What 'suspend' method do you want to emulate? I know of none.

Yes, that's exactly what I want to do. But just a few minutes ago, I found a webite from INRIA's linuxthread package, which pretty much answers my questions - it's not possible. One alternate "solution" the worker thread poll a global variable (a "request") and based on the value, the worker thread suspends itself on a condition variable.

pauillac.inria.fr/~xleroy/linuxthreads/faq.html?#E.4

Solaris threads has a suspend method, and i believe kernel threads have a suspend method too. But this man page confuses me: unix.com/man-page/all/3t/pthread_resume_np/

It lists a pthread_suspend method....

Any idea why?

---------- Post updated at 10:14 PM ---------- Previous update was at 10:07 PM ----------

Since (apparently) it cannot be done with pthreads, i thought i might try to accomplish this with the clone() system call. However, I keep getting segmentation fault. I have no idea why... (I know the printf isn't thread safe, but it's a quick and dirty way to see if the process is active or not. Even if i'm just doing arithmetic operations, I still get a segmentation fault)

What I'm trying to do is to have the main process "activate" the worker for 1 second every 2 seconds. Is this doable?

Code:

#define _GNU_SOURCE

#include <malloc.h> 
#include <signal.h> 
#include <sched.h> 
#include <stdio.h> 
#include <fcntl.h> 
#include <stdlib.h>


int worker() {
    while(1) 
    {
      printf("hello \t");
    }
 
    return 0;
    
}

int main(int argc, char *argv[]) {
    void **child_stack;
    int child_pid;
    
    child_stack = (void **) malloc(16328);
    
    child_pid = clone(worker, child_stack, CLONE_VM|CLONE_FILES, NULL);

    while(1) 
    {
      sleep(1);
      kill(child_pid, SIGSTOP);
      sleep(2);
      kill(child_pid, SIGCONT);
    }
    
    return 0;
}

Using clone() will make your code linux-specific.

The proper way to do this would be to reorganize your code so that threads don't waste time idle, rather than killing and unkilling them from the outside all the time.

Or use standard IPC mechanisms that cause execution to block, like blocking on a read of a message queue or blocking on sempahore using semwait().

Thank you all for your suggestions. I should clarify that I'm developing something for a real time embedded system. I need to implement a TDMA server, so I'm going to have N thread executing periodically, with arbitrary execution times. It could happen that a thread finishes its execution before its timeslot, and I need to insure that the CPU will remain idle in that time to save energy.

My first idea was to simply suspend all the threads whose turn it wasn't, and to activate the one correct thread. Which is why I was looking for a way to implement a 'suspend' method.

jim mcnamara, I'm not sure I understand your suggestion. How could I preempt a running task and block it? The running task does not know when it should wait for synchronization.

Thank you again,

If the thread doesn't know when it should wait for synchronization, that's a serious design flaw. You're trying to write something more akin to an operating system, capable of imposing order from the outside.

Threads are asynchronous, anyway. Your main thread can't possibly know when a worker thread has completed anything unless the worker thread tells it so. If you try and force synchronization from the outside by guessing, you're going to catch it too soon occasionally -- and if main is given reliable information from the thread, why can't the thread use this information itself?

If these jobs are periodic with long stretches of inactivity, why not create new threads on demand instead of keeping old ones around forever? Let them quit when they're done. Threads that don't exist use no CPU.