mirror of
https://git.suyu.dev/suyu/suyu.git
synced 2024-11-25 22:57:22 +00:00
217 lines
5.8 KiB
C
217 lines
5.8 KiB
C
|
// Copyright 2014 Citra Emulator Project / PPSSPP Project
|
||
|
// Licensed under GPLv2
|
||
|
// Refer to the license.txt file included.
|
||
|
|
||
|
#pragma once
|
||
|
|
||
|
#include "common/common.h"
|
||
|
|
||
|
namespace Common {
|
||
|
|
||
|
template<class IdType>
|
||
|
struct ThreadQueueList {
|
||
|
// Number of queues (number of priority levels starting at 0.)
|
||
|
static const int NUM_QUEUES = 128;
|
||
|
|
||
|
// Initial number of threads a single queue can handle.
|
||
|
static const int INITIAL_CAPACITY = 32;
|
||
|
|
||
|
struct Queue {
|
||
|
// Next ever-been-used queue (worse priority.)
|
||
|
Queue *next;
|
||
|
// First valid item in data.
|
||
|
int first;
|
||
|
// One after last valid item in data.
|
||
|
int end;
|
||
|
// A too-large array with room on the front and end.
|
||
|
IdType *data;
|
||
|
// Size of data array.
|
||
|
int capacity;
|
||
|
};
|
||
|
|
||
|
ThreadQueueList() {
|
||
|
memset(queues, 0, sizeof(queues));
|
||
|
first = invalid();
|
||
|
}
|
||
|
|
||
|
~ThreadQueueList() {
|
||
|
for (int i = 0; i < NUM_QUEUES; ++i)
|
||
|
{
|
||
|
if (queues[i].data != NULL)
|
||
|
free(queues[i].data);
|
||
|
}
|
||
|
}
|
||
|
|
||
|
// Only for debugging, returns priority level.
|
||
|
int contains(const IdType uid) {
|
||
|
for (int i = 0; i < NUM_QUEUES; ++i)
|
||
|
{
|
||
|
if (queues[i].data == NULL)
|
||
|
continue;
|
||
|
|
||
|
Queue *cur = &queues[i];
|
||
|
for (int j = cur->first; j < cur->end; ++j)
|
||
|
{
|
||
|
if (cur->data[j] == uid)
|
||
|
return i;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
return -1;
|
||
|
}
|
||
|
|
||
|
inline IdType pop_first() {
|
||
|
Queue *cur = first;
|
||
|
while (cur != invalid())
|
||
|
{
|
||
|
if (cur->end - cur->first > 0)
|
||
|
return cur->data[cur->first++];
|
||
|
cur = cur->next;
|
||
|
}
|
||
|
|
||
|
//_dbg_assert_msg_(SCEKERNEL, false, "ThreadQueueList should not be empty.");
|
||
|
return 0;
|
||
|
}
|
||
|
|
||
|
inline IdType pop_first_better(u32 priority) {
|
||
|
Queue *cur = first;
|
||
|
Queue *stop = &queues[priority];
|
||
|
while (cur < stop)
|
||
|
{
|
||
|
if (cur->end - cur->first > 0)
|
||
|
return cur->data[cur->first++];
|
||
|
cur = cur->next;
|
||
|
}
|
||
|
|
||
|
return 0;
|
||
|
}
|
||
|
|
||
|
inline void push_front(u32 priority, const IdType threadID) {
|
||
|
Queue *cur = &queues[priority];
|
||
|
cur->data[--cur->first] = threadID;
|
||
|
if (cur->first == 0)
|
||
|
rebalance(priority);
|
||
|
}
|
||
|
|
||
|
inline void push_back(u32 priority, const IdType threadID) {
|
||
|
Queue *cur = &queues[priority];
|
||
|
cur->data[cur->end++] = threadID;
|
||
|
if (cur->end == cur->capacity)
|
||
|
rebalance(priority);
|
||
|
}
|
||
|
|
||
|
inline void remove(u32 priority, const IdType threadID) {
|
||
|
Queue *cur = &queues[priority];
|
||
|
//_dbg_assert_msg_(SCEKERNEL, cur->next != NULL, "ThreadQueueList::Queue should already be linked up.");
|
||
|
|
||
|
for (int i = cur->first; i < cur->end; ++i)
|
||
|
{
|
||
|
if (cur->data[i] == threadID)
|
||
|
{
|
||
|
int remaining = --cur->end - i;
|
||
|
if (remaining > 0)
|
||
|
memmove(&cur->data[i], &cur->data[i + 1], remaining * sizeof(IdType));
|
||
|
return;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
// Wasn't there.
|
||
|
}
|
||
|
|
||
|
inline void rotate(u32 priority) {
|
||
|
Queue *cur = &queues[priority];
|
||
|
//_dbg_assert_msg_(SCEKERNEL, cur->next != NULL, "ThreadQueueList::Queue should already be linked up.");
|
||
|
|
||
|
if (cur->end - cur->first > 1)
|
||
|
{
|
||
|
cur->data[cur->end++] = cur->data[cur->first++];
|
||
|
if (cur->end == cur->capacity)
|
||
|
rebalance(priority);
|
||
|
}
|
||
|
}
|
||
|
|
||
|
inline void clear() {
|
||
|
for (int i = 0; i < NUM_QUEUES; ++i)
|
||
|
{
|
||
|
if (queues[i].data != NULL)
|
||
|
free(queues[i].data);
|
||
|
}
|
||
|
memset(queues, 0, sizeof(queues));
|
||
|
first = invalid();
|
||
|
}
|
||
|
|
||
|
inline bool empty(u32 priority) const {
|
||
|
const Queue *cur = &queues[priority];
|
||
|
return cur->first == cur->end;
|
||
|
}
|
||
|
|
||
|
inline void prepare(u32 priority) {
|
||
|
Queue *cur = &queues[priority];
|
||
|
if (cur->next == NULL)
|
||
|
link(priority, INITIAL_CAPACITY);
|
||
|
}
|
||
|
|
||
|
private:
|
||
|
Queue *invalid() const {
|
||
|
return (Queue *) -1;
|
||
|
}
|
||
|
|
||
|
void link(u32 priority, int size) {
|
||
|
//_dbg_assert_msg_(SCEKERNEL, queues[priority].data == NULL, "ThreadQueueList::Queue should only be initialized once.");
|
||
|
|
||
|
if (size <= INITIAL_CAPACITY)
|
||
|
size = INITIAL_CAPACITY;
|
||
|
else
|
||
|
{
|
||
|
int goal = size;
|
||
|
size = INITIAL_CAPACITY;
|
||
|
while (size < goal)
|
||
|
size *= 2;
|
||
|
}
|
||
|
Queue *cur = &queues[priority];
|
||
|
cur->data = (IdType *) malloc(sizeof(IdType) * size);
|
||
|
cur->capacity = size;
|
||
|
cur->first = size / 2;
|
||
|
cur->end = size / 2;
|
||
|
|
||
|
for (int i = (int) priority - 1; i >= 0; --i)
|
||
|
{
|
||
|
if (queues[i].next != NULL)
|
||
|
{
|
||
|
cur->next = queues[i].next;
|
||
|
queues[i].next = cur;
|
||
|
return;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
cur->next = first;
|
||
|
first = cur;
|
||
|
}
|
||
|
|
||
|
void rebalance(u32 priority) {
|
||
|
Queue *cur = &queues[priority];
|
||
|
int size = cur->end - cur->first;
|
||
|
if (size >= cur->capacity - 2) {
|
||
|
IdType *new_data = (IdType *)realloc(cur->data, cur->capacity * 2 * sizeof(IdType));
|
||
|
if (new_data != NULL) {
|
||
|
cur->capacity *= 2;
|
||
|
cur->data = new_data;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
int newFirst = (cur->capacity - size) / 2;
|
||
|
if (newFirst != cur->first) {
|
||
|
memmove(&cur->data[newFirst], &cur->data[cur->first], size * sizeof(IdType));
|
||
|
cur->first = newFirst;
|
||
|
cur->end = newFirst + size;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
// The first queue that's ever been used.
|
||
|
Queue *first;
|
||
|
// The priority level queues of thread ids.
|
||
|
Queue queues[NUM_QUEUES];
|
||
|
};
|
||
|
|
||
|
} // namespace
|