Priority queue in C for operating system - c

Question

I need to write a new function called enqueue_priority using my previous enqueue and dequeue functions I cant use sort premade sort I dont know how to implement the priority queue. This is for a simple linux operating system. I am just dragging this out because stack says that My question is mostly code and needs more words but I dont have anything else to say about it
this struct is in a different file
struct pcb {
uint32_t esp;
uint32_t pid;
struct pcb *next;
uint32_t priority;
};
typedef struct pcb pcb_t;
#endif
starts new file
struct pcbq {
pcb_t *head;
pcb_t *tail;
};
typedef struct pcbq pcbq_t;
pcbq_t RR_q;
pcb_t *Running;
void initq(pcbq_t *q) {
q->head = q->tail = 0;
}
bool comparePTR(pcb_t *a1, pcb_t *a2) {
return a1->priority < a2->priority;
}
void enqueue_priority (pcbq_t *q, pcb_t *item){
// item->next = 0;
// if (q->tail == 0) {
// q->tail = q->head = item;
// } else {
// q->tail->next = item;
// q->tail = item;
// }
}
void enqueue(pcbq_t *q, pcb_t *item) {
item->next = 0;
if (q->tail == 0) {
q->tail = q->head = item;
} else {
q->tail->next = item;
q->tail = item;
}
}
void default_handler();
pcb_t *dequeue(pcbq_t *q) {
if (q->head == 0) {
default_handler();
}
pcb_t *item = q->head;
q->head = q->head->next;
return item;
}
void init_rrq() {
Running = 0;
initq(&RR_q);
}
// returns 1 if no process is on the ready Q
int rr_schedule() {
if (Running == 0) {
default_handler();
}
if (RR_q.head == 0)
return 1; // running process is the only one in the system
enqueue(&RR_q, Running);
Running = dequeue(&RR_q);
return 0;
}
void rr_schedule_first() {
if (RR_q.head == 0)
default_handler();
Running = dequeue(&RR_q);
}
void rr_enqueue(pcb_t *pcb) {
enqueue(&RR_q, pcb);
}

Answer 1

Note: As others have mentioned, there are better ways to implement a priority queue. But ...
To implement a priority queue with a linked list, one way is to insert the new item in the correct sorted place when we add a new item.
We have to scan the list looking for the proper place.
Your code had elements of both a doubly linked list and singly linked list. But, it was mostly a singly linked list (e.g. your pcb didn't have a prev pointer).
The only time the tail was used, was to append to the back of the list (in enqueue).
But, to maintain the sort, we'd probably never want to use that, but, only enqueue_priority.
So, I've simplified the code. Also, the RR* stuff wasn't relevant to the queue insertion, so I've elided that as well.
I've coded this, but not tested it:
#include <stdio.h>
#include <stdint.h>
struct pcb {
uint32_t esp;
uint32_t pid;
uint32_t priority;
struct pcb *next;
};
typedef struct pcb pcb_t;
struct pcbq {
pcb_t *head;
};
typedef struct pcbq pcbq_t;
void
initq(pcbq_t *q)
{
q->head = NULL;
}
// enqueue_priority -- enqueue item in proper sorted order
void
enqueue_priority(pcbq_t *q, pcb_t *item)
{
pcb_t *bef = NULL;
pcb_t *cur = q->head;
item->next = NULL;
// find the lower priority (use rightmost of same/equal priority)
for (; cur != NULL; cur = cur->next) {
if (cur->priority > item->priority)
break;
bef = cur;
}
do {
// empty queue
if (q->head == NULL) {
q->head = item;
break;
}
// insert after lower
if (bef != NULL) {
item->next = bef->next;
bef->next = item;
}
// insert before head of non-empty queue
else {
item->next = q->head;
q->head = item;
}
} while (0);
}
// enqueue -- enqueue at back of queue
void
enqueue(pcbq_t *q, pcb_t *item)
{
pcb_t *cur = q->head;
pcb_t *bef = NULL;
item->next = NULL;
for (; cur != NULL; cur = cur->next)
bef = cur;
// append to end of queue
if (bef != NULL)
bef->next = item;
// empty list
else
q->head = item;
}
// dequeue -- dequeue from front of queue
pcb_t *
dequeue(pcbq_t *q)
{
pcb_t *item = q->head;
do {
if (item == NULL)
break;
q->head = item->next;
item->next = NULL;
} while (0);
return item;
}
UPDATE:
The above requires a list scan. However, if we used separate queues for each priority level, we could use a modified version of the above to enqueue and dequeue faster (we add back the tail pointer).
This is [AFAIK] how OSes actually do it. It requires that we look at each queue and check for a non-null head, but with few(er) priority levels (e.g. 10), this will be faster when we have (e.g.) thousands of processes.
So, here's the modified version:
#include <stdio.h>
#include <stdint.h>
struct pcb {
uint32_t esp;
uint32_t pid;
uint32_t priority;
struct pcb *next;
};
typedef struct pcb pcb_t;
struct pcbq {
pcb_t *head;
pcb_t *tail;
};
typedef struct pcbq pcbq_t;
#define MAXPRIORITY 10
pcbq_t allqueues[MAXPRIORITY];
void
initq(pcbq_t *q)
{
q->head = NULL;
}
// enqueue -- enqueue at back of queue
void
enqueue(pcbq_t *q, pcb_t *item)
{
item->next = NULL;
// empty list
if (q->tail == NULL) {
q->tail = item;
q->head = item;
}
// append to end of queue
else {
q->tail->next = item;
q->tail = item;
}
}
// enqueue_priority -- enqueue item in proper sorted order
void
enqueue_priority(pcbq_t *q, pcb_t *item)
{
q += item->priority;
enqueue(q,item);
}
// dequeue -- dequeue from front of queue
pcb_t *
dequeue(pcbq_t *q)
{
pcb_t *item = q->head;
do {
if (item == NULL)
break;
q->head = item->next;
if (item == q->tail)
q->tail = NULL;
} while (0);
return item;
}
// dequeue_priority -- dequeue from front of highest priority queue
pcb_t *
dequeue_priority(pcbq_t *q)
{
pcb_t *item = NULL;
for (int qidx = 0; qidx < MAXPRIORITY; ++qidx, ++q) {
if (q->head != NULL) {
item = dequeue(q);
break;
}
}
return item;
}