blob: c54a02e9ba6c8a97628958fce37688a1f5bec48d (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
|
#include "ipc/engine_message.h"
#include <stdio.h>
#include <assert.h>
atomic_flag handler_busy;
void engine_message_handler_init(engine_message_handler_t *handle) {
engine_message_t *message = calloc(sizeof(*message), 1);
engine_message_init(message);
handle->oldest_valid = message;
handle->newest_valid = message;
handle->count = 1;
handle->pushed_count = 0;
handle->popped_count = 0;
}
void engine_message_handler_deinit(engine_message_handler_t *handle) {
engine_message_t *next, *message = handle->oldest_valid;
int count = handle->count;
while (count-- > 0) {
next = message->next;
engine_message_deinit(message);
message = next;
}
}
void engine_message_handler_acquire(engine_message_handler_t *handle) {
while (atomic_flag_test_and_set(&handler_busy));
}
void engine_message_handler_release(engine_message_handler_t *handle) {
atomic_flag_clear(&handler_busy);
}
bool engine_message_handler_can_pop(engine_message_handler_t *handle) {
assert(handle != NULL);
engine_message_handler_acquire(handle);
if (handle->count == 0) {
engine_message_handler_release(handle);
return false;
}
if (handle->oldest_valid == NULL) {
printf("%d\n", handle->count);
}
bool output = engine_message_is_ready(handle->oldest_valid);
engine_message_handler_release(handle);
return output;
}
engine_message_t *engine_message_handler_pop(
engine_message_handler_t *handle
) {
assert(handle != NULL);
engine_message_handler_acquire(handle);
engine_message_t *output = handle->oldest_valid;
handle->oldest_valid = handle->oldest_valid->next;
handle->count--;
handle->popped_count++;
engine_message_handler_release(handle);
return output;
}
engine_message_t *engine_message_handler_push(
engine_message_handler_t *handle
) {
assert(handle != NULL);
engine_message_t *output = calloc(sizeof(*output), 1);
engine_message_init(output);
engine_message_handler_acquire(handle);
if (handle->count > 0) {
handle->newest_valid->next = output;
}
handle->newest_valid = output;
if (handle->count == 0) {
handle->oldest_valid = output;
}
handle->count++;
handle->pushed_count++;
engine_message_handler_release(handle);
return output;
}
void engine_messages_init(engine_messages_t *messages) {
assert(messages != NULL);
// idc, i don't want to exceed 10 threads anyway
messages->data = calloc(sizeof(*messages->data), 10);
for (int i = 0; i < 10; i++) {
messages->data[i] = malloc(sizeof(*messages->data[i]));
engine_message_handler_init(messages->data[i]);
}
messages->count = 0;
messages->capacity = 10;
}
void engine_messages_refresh(engine_messages_t *messages) {
assert(messages != NULL);
for (int i = 0; i < 10; i++) {
messages->data[i] = malloc(sizeof(*messages->data[i]));
engine_message_handler_init(messages->data[i]);
}
messages->count = 0;
messages->capacity = 10;
}
void engine_message_mark_ready(engine_message_t *message) {
atomic_store(&message->ready, 1);
}
bool engine_message_is_ready(engine_message_t *message) {
return atomic_load(&message->ready) == 1;
}
void engine_messages_deinit(engine_messages_t *messages) {
assert(messages != NULL);
for (int i = 0; i < 10; i++) {
engine_message_handler_deinit(messages->data[i]);
free(messages->data[i]);
}
free(messages->data);
}
void engine_message_init(engine_message_t *message) {
assert(message != NULL);
message->ready = 0;
ipc_moves_init(&message->pv);
}
void engine_message_deinit(engine_message_t *message) {
assert(message != NULL);
ipc_moves_deinit(&message->pv);
free(message);
}
|
