Re: thread interruption points

From:

scott@slp53.sl.home (Scott Lurndal)

Newsgroups:

comp.lang.c++

Date:

Fri, 20 Feb 2015 14:41:15 GMT

Message-ID:

<fIHFw.78172$1t1.68284@fx09.iad>

Robert Wessel <robertwessel2@yahoo.com> writes:

On Thu, 19 Feb 2015 18:54:59 -0600, Christopher Pisz
<nospam@notanaddress.com> wrote:

First, I just wanted to take a second and say that interruption points
on threads are wonderful...so far

I am using boost, because my employer is still requiring I support XP,
and this msvc2010, which doesn't seem to have C++11 threads, but as I
understand it they are almost identical.

If I interrupt a worker thread from my main thread, it throws a
thread_interrupted exception from any "interruption points". For my
purposes, they will be sleeps.

So, my worker thread must wrap all of its work in a try catch and can
for example's sake, log that it was interrupted, and exit in the catch.

This makes for a great way to shut everything down.

What I am worried about is, there are sleeps all over the place in the
worker thread, in many many classes. Am I going to have to go through
each class (I didn't write) and make sure they do something sane in
their destructors as the exception makes its way up the call stack? or
alternatively insert a lot of catch statements and try to handle things
there before rethrowing?

Pretty much yes.

But as far as I'm concerned, that's the wrong way to deal with things
like shutdown. Interruptions are too low level to be useful. Just
because you're in a wait doesn't mean you're in a convenient place to
shut the thread down. Sending a message of some sort to a thread to
shut down, which the thread checks for at reasonable points, makes
much more sense. An event semaphore is often useful. On those waits
where you want to allow shutdown, you can wait for the shutdown
semaphore in addition to the other items. And where it's appropriate,
you can poll it with a timed wait (with a zero timeout).

Something like this, perhaps (d_exit is marked volatile):

/**
* Execute I/O Control Blocks queued to this DLP instance.
*
* This is the main loop of the per-DLP instance thread.
*
* Loop until the d_exit flag is set to true.
* Set d_exited flag when the thread terminates to notify
* terminator that the thread terminated successfully.
*/
void
c_dlp::run(void)
{
    int diag;
    c_dlist pending;
    char tname[64];

    c_processor::set_this(d_processor);
    c_system::set_this(mp->get_system());
    c_memory::set_this(mp->get_system()->get_mem());

    snprintf(tname, sizeof(tname), "%04lu %s DLP",
             d_channel, get_hardware_name());
    set_threadname(tname);

    pending.init();

    lock_thread();
    while (!d_exit) {
        while (pending.is_empty()) {
            c_dlist_iterator di(&d_iocbs);
            while (di.next()) {
                c_iocb *iocb = (c_iocb *)di.curr();

                iocb->remove();
                pending.insert(iocb);
            }
            if (!pending.is_empty()) break;
            diag = pthread_cond_wait(&d_wait, &t_threadlock);
            if (diag != 0) {
                d_logger->log("%04lu/00 Unexpected cond-wait result: %s\n",
                              d_channel, strerror(diag));
            }
            if (d_exit) break;
        }

        if (d_exit) break;

        unlock_thread();
        c_dlist_iterator worklist(&pending);
        while (worklist.next()) {
            c_iocb * iocb = (c_iocb *)worklist.curr();
            iocb->remove();

            switch (iocb->get_op()) {
            case IOD_CANCEL:
                cancel(iocb);
                break;
            case IOD_READ:
                read(iocb);
                break;
            case IOD_WRITE:
                write(iocb);
                break;
            case IOD_TEST:
                if (iocb->get_op_var1() == IOD_TEST_IDENTIFY) {
                    set_rd(iocb, IOT_COMPLETE|IOT_EXT_RD_PRESENT,
                                 0x0000, d_testid << 8);
                } else {
                    test(iocb);
                }
                break;
            case IOD_ECHO:
                echo(iocb);
                break;
            }
        }
        lock_thread();
        pending.init();
    }
    d_exited = true;

    unlock_thread();
}

/**
* Destructor for a Data Link Processor. Tell the device thread
* to exit and wait for it to terminate.
*/
c_dlp::~c_dlp(void)
{

    lock_thread();

    d_exit = true;
    pthread_cond_signal(&d_wait);

    unlock_thread();

    if (!in_context()) {
        (void) join();
    }
}

/**
* Queue an IOCB to a DLP. Used by the SPIO instruction to deliver
* an IOCB to a DLP.
*
* Called from a processor thread.
*
* @param iocb The IOCB to deliver.
*/
void
c_dlp::queue(c_iocb *iocb)
{
    if (mp->get_system()->is_iotrace(iocb->get_channel())) {
        iocb->dump(d_logger, "Queue ", false);
    }

    lock_thread();
    d_iocbs.insert(iocb);
    pthread_cond_signal(&d_wait);
    unlock_thread();
    if (mp->get_host_cores() == 1) {
        sched_yield(); // Let the DLP thread run
    }
}