Geek Answers Handbook

Running a queue without blocking results in an energized cycle

I have blocked queues written in C as a linked list that contains requests from several threads sent and processed in one thread. After hours of stress, I end up with the last request, the next pointer points to itself, which creates an endless loop and blocks the flow of processing.

The application runs (and does not work) on Linux and Windows. I am debugging Windows where my COMPARE_EXCHANGE_PTRmaps to InterlockedCompareExchangePointer .

This is the code that pushes the request to the head of the list and is called from several threads:

void push_request(struct request * volatile * root, struct request * request)
{
    assert(request);

    do {
        request->next = *root;
    } while(COMPARE_EXCHANGE_PTR(root, request, request->next) != request->next);
}

This is the code that receives the request from the end of the list and is called by only one thread that processes them:

struct request * pop_request(struct request * volatile * root)
{
    struct request * volatile * p;
    struct request * request;

    do {
        p = root;
        while(*p && (*p)->next) p = &(*p)->next; // <- loops here
        request = *p;
    } while(COMPARE_EXCHANGE_PTR(p, NULL, request) != request);

     assert(request->next == NULL);

     return request;
}

, , , push_request. , , .

, , :

// device->requests is defined as struct request * volatile requests;
struct request * request = malloc(sizeof(struct request));
if(request) {
    // fill out request fields
    push_request(&device->requests, request);
    sem_post(device->request_sem);
}

, , , , :

if(sem_wait_timeout(device->request_sem, timeout) == sem_success) {
    struct request * request = pop_request(&device->requests);
    // handle request
    free(request);
}

, , , , , . ( , , .)

, pop_request . , . , 10, 1 3 .

, , , . , . ( ),

+5
1

, .

, req1. , :

device->requests == req1;
req1->next == NULL;

req2 . req2. while , :

device->requests == req1;
req1->next == NULL;
req2->next == req1;

COMPARE_EXCHANGE_PTR, :

device->requests == req2;
req1->next == NULL;
req2->next == req1;

... COMPARE_EXCHANGE_PTR() req1. , while , , .

, popping off req1 - , :

device->requests == req2;
req2->next == NULL;

. request->next - req2->next, NULL. req1 NULL, , while , :

device->requests == req2;
req2->next == req2;

, while , .

:

void push_request(struct request * volatile * root, struct request * request)
{
    struct request *oldroot;

    assert(request);

    do {
        request->next = oldroot = *root;
    } while(COMPARE_EXCHANGE_PTR(root, request, oldroot) != oldroot);
}
+8

More articles:


All Articles