void start_d()
{
while (1)
{
append_result();
MsgEnv *env;
switch (append_i)
{
case 5:
break;
case 7:
env = receive_message();
release_msg_env(env);
utest_assert(0, "D should not run for a second time");
break;
default:
trace_uint(ALWAYS,"append_i ", append_i);
utest_assert(0, "d process append_i not recongized");
break;
}
release_processor();
}
}
void proc6(void) {
// OUTPUT PROCESS - gathers data from all the other processes and outputs to //uart0
while (1) {
int counter = 0;
int total = 5;
int i = 0;
int asciioffset = 48;
//uart0_put_string("G021_test: START\n\r");
//uart0_put_string("G021_test: total ");//uart0_put_char(total+asciioffset);//uart0_put_string(" tests\n\r");
for (i = 1; i < total+1; i++) {
//uart0_put_string("G021_test: test ");
//uart0_put_char(i+asciioffset);
if (is_process_blocked(i))
{
//uart0_put_string(" BLOCKED");
}
else
{
if (results[i] == 0) {
//uart0_put_string(" FAIL");
} else {
//uart0_put_string(" OK");
counter++;
}
}
//uart0_put_string("\n\r");
}
//uart0_put_string("G021_test: ");//uart0_put_char(counter+asciioffset);//uart0_put_string("/");//uart0_put_char(total+asciioffset);//uart0_put_string(" tests OK\n\r");
//uart0_put_string("G021_test: ");//uart0_put_char((total-counter)+asciioffset);//uart0_put_string("/");//uart0_put_char(total+asciioffset);//uart0_put_string(" tests FAIL\n\r");
//uart0_put_string("G021_test: END\n\r");
release_processor();
}
}
/**
* @brief: a process that prints five uppercase letters
* and then yields the cpu.
*/
void proc1(void)
{
int i = 0;
int ret_val = 10;
while (1) {
if ( i != 0 && i%5 == 0 ) {
print_debug("\n\r");
ret_val = release_processor();
print_debug("Process 1 completed!\r\n");
if (ret_val == -1) {
print_debug("G021_test: test 1 FAIL\r\n");
test_results[0] = 0;
} else {
print_debug("G021_test: test 1 OK\r\n");
}
}
print_char_debug('A' + i%26);
i++;
}
}
void *s_request_memory_block()
{
void *allocMem;
mmu_blockdesc_t *b;
if (!mmu_can_alloc_mem()) {
current_process->state = BLOCKED;
release_processor();
}
if (table.block->next) {
allocMem = table.block->start;
b = table.block;
table.block = b->next;
b->next = NULL;
} else {
allocMem = table.block->start;
table.block->start += MMU_BLOCK_SIZE;
if (table.block->start >= table.block->end) {
table.block = NULL;
}
}
set_bit(table.bitVector, getBitFromAddress(allocMem), 1);
return allocMem;
}
/**
* @brief: a process that prints 5x6 uppercase letters
* and then yields the cpu.
*/
void proc1(void)
{
int i = 0;
int ret_val = 10;
int x = 0;
while ( 1) {
if ( i != 0 && i%5 == 0 ) {
uart1_put_string("\n\r");
if ( i%30 == 0 ) {
ret_val = release_processor();
#ifdef DEBUG_0
printf("proc1: ret_val=%d\n", ret_val);
#endif /* DEBUG_0 */
}
for ( x = 0; x < 500000; x++); // some artifical delay
}
uart1_put_char('A' + i%26);
i++;
}
}
void test_proc_p1_a_6(void) {
while (1) {
uart1_put_string("proc6: \n\r");
release_processor();
}
}
void proc6(void)
{
while ( 1 ) {
release_processor();
}
}
void procC()
{
//create local message queue to store msg envs in FIFO order
MsgEnvQ *msgQueue = (MsgEnvQ*)MsgEnvQ_create();
//initialize msg env pointers to keep track of messages
ps("Proc C started!");
MsgEnv *msg_env;
while(1)
{
//while (MsgEnvQ_size(CURRENT_PROCESS->rcv_msg_queue) > 0 || MsgEnvQ_size(msgQueue) == 0)
while(MsgEnvQ_size(msgQueue) == 0)
{
msg_env = (MsgEnv*)receive_message();
MsgEnvQ_enqueue(msgQueue, msg_env);
}
msg_env = (MsgEnv*)MsgEnvQ_dequeue(msgQueue);
if(msg_env->msg_type == COUNT_REPORT)
{
if( (atoi(msg_env->data)) % 20 == 0)
//if( (msg_env->time_delay) % 20 == 0)
{
// BBJ. Don't use memcpy etc anymore, I think this is causing memory problems in OS since it crashes like 5-6 minutes in!!
//char tempData[20] = "\nProcess C\0";
//memcpy(msg_env->data,tempData,strlen(tempData)+1);
sprintf(msg_env->data, "\nProcess C\n");
send_console_chars(msg_env);
//wait for output confirmation with 'DISPLAY_ACK' msg type
while(1)
{
msg_env = (MsgEnv*)receive_message();
if (msg_env->msg_type == DISPLAY_ACK)
{
if(request_delay(3, WAKEUP10, msg_env)!= SUCCESS)
{
ps("requesting delay for Process C went wrong");
}
while(1){
msg_env = receive_message();
if(msg_env->msg_type==WAKEUP10)
{
break;
}else if(msg_env->msg_type == COUNT_REPORT){
MsgEnvQ_enqueue(msgQueue, msg_env);
}else{
release_message_env(msg_env);
}
}
break;
}else if(msg_env->msg_type == COUNT_REPORT){
//enqueue the msg env onto local msg queue if it originated from proc_A
MsgEnvQ_enqueue(msgQueue, msg_env);
}
// random message. ignore
else
release_message_env(msg_env);
}
}
}
//deallocate message envelopes and release processor
release_message_env(msg_env);
if (MsgEnvQ_size(msgQueue) == 0) {
ps("Process C is releasing processor!");
release_processor();
}
}
}
void process_C()
{
msg_env_queue_t* messageQueue = msg_env_queue_create();
MsgEnv * timeout_msg = request_msg_env();
while(1)
{
// setup variables that will be used by the process
MsgEnv *deq_msg;
// check if the process message queue is empty or not
// if the queue is empty, then recieve a message env
// and enqueue it!
if(msg_env_queue_is_empty(messageQueue))
{
MsgEnv *received_msg = receive_message();
msg_env_queue_enqueue(messageQueue, received_msg);
}
// dequeue a message env from the message queue
deq_msg = msg_env_queue_dequeue(messageQueue);
// check if the dequeued message type is a COUNT_REPORT
if(deq_msg->msg_type == COUNT_REPORT)
{
//check if the message in the env is divisible by 20
//if it is divisible, then continue into the if statement
//otherwise release all envelopes and and yeild processor
if (*((int *)(deq_msg->msg)) % 20 == 0)
{
//copys the 'Process C' string into the dequeued msg env
rtx_strcpy(deq_msg->msg, "\r\nProcess C\r\n", 1024);
//send the message env to the console for printing
send_console_chars(deq_msg, 0);
request_delay(1000, WAKEUP_10, timeout_msg);
// "Go passive for 10 seconds" in the outline
while(1)
{
//recieve a message env
deq_msg = receive_message();
//if the recieved env is a type 'WAKEUP_10' then
//exit the while loop
//otherwise, enqueue the recieved message env back into the
//message env queue
if(deq_msg->msg_type == WAKEUP_10)
{
break;
}
else
{
msg_env_queue_enqueue(messageQueue, deq_msg);
}
}
}
else
{
release_msg_env(deq_msg);
}
}
else
{
trace(ERROR, "WTEDF");
release_msg_env(deq_msg);
}
//release all the envelopes and yeild the processor
release_processor();
}
}
// *** PROCESS C *** PID 5
void ProcessC(){
// init the local queue
struct envQ* localQ = (struct envQ *) malloc (sizeof (struct envQ));
if (localQ==NULL)
{
printf("localQ in Proc C not created properly");
return;
} // can we use the queue on the proc pcb instead?
PCB* pC_pcb = convert_PID(5);
msg_env* envC = request_msg_env();
// infinite loop of normal activity
while (1)
{
printf("A\n");
int NUM =envC->msg_text[0];
// if theres nothing the localQ, receive a message and enqueue it
if (localQ->head == NULL)
{
envC = receive_message();
int H = env_ENQ(envC,localQ);
if (H ==0)
printf("Cannot enqueue on localQ");
}
// if there is something on the localQ, dequeue it
else {
envC = env_DEQ(localQ);
}
// if the message type is count report, and the value in msg_text is evenly divisible by 20, display "Process C"
if (envC->msg_type == 2 && NUM % 20 == 0){
// send the display message
strcpy(envC->msg_text, "Process C\n\0");
int W = send_console_chars(envC); // Returns confirmation of sending
if (W==1)
{
// if it is the ack message request a delay of 10s, with wakeup code "wakeup10"
int R = request_delay(10000, WAKEUP, envC); // request_delay returns an int
if (R==0)
printf("Error with request_delay");
// wait for wakeup message
envC = receive_message();
// if its not the wakeup message put it on the local Q
while (envC->msg_type != WAKEUP)
{
envC = receive_message();
int XX = env_ENQ(envC,localQ);
if (XX==0)
printf("Error with putting message on local Q in Proc C");
}
}
else
printf("Error sending 'Process C' to screen in Proc C");
}
// deallocate envelopes
int dun = release_msg_env(envC);
if (dun==0)
printf("ERROR IN DEALLOCATING ENVELOPE AT END OF Proc C");
// release processor
release_processor();
}// end of infinite loop
}
void stress_a() {
#ifdef _STRESS_DEBUG
rtx_dbug_outs("Registering Stress Test A...\r\n");
#endif
struct MessageEnvelope * msg_rx;
struct num_message * num_msg;
struct MessageEnvelope * reg_cmd = (MessageEnvelope *)request_memory_block();
reg_cmd->type = TYPE_REGISTER_CMD;
str_copy((BYTE *) "%Z", (BYTE *)reg_cmd->msg);
send_message(KCD_PID, reg_cmd);
UINT32 num;
while(1) {
#ifdef _STRESS_DEBUG
rtx_dbug_outs("Enter: Stress Test A - Loop 1\r\n");
#endif
msg_rx = (MessageEnvelope *)receive_message(NULL);
#ifdef _STRESS_DEBUG
rtx_dbug_outs("Stress Test A received a message in Loop 1\r\n");
#endif
if(msg_rx->msg[0] == '%' && msg_rx->msg[1] == 'Z') {
#ifdef _STRESS_DEBUG
rtx_dbug_outs("Stress Test A received valid message - breaking out of loop\r\n");
#endif
release_memory_block((void *)msg_rx);
break;
}
release_memory_block((void *)msg_rx);
}
num = 0;
while(1) {
#ifdef _STRESS_DEBUG
rtx_dbug_outs("Enter: Stress Test A - Loop 2\r\n");
#endif
num_msg = (num_message *)request_memory_block();
#ifdef _STRESS_DEBUG
rtx_dbug_outs_int("Just got memory block for message num ", num);
#endif
num_msg->type = TYPE_COUNT_REPORT;
num_msg->msg = num;
send_message(STRESS_B_PID, num_msg);
#ifdef _STRESS_DEBUG
rtx_dbug_outs("Stress Test A sent message to Stress Test B\r\n");
#endif
num = num + 1;
release_processor();
#ifdef _STRESS_DEBUG
rtx_dbug_outs("Stress Test A back from release processor\r\n");
#endif
}
}
void stress_c() {
#ifdef _STRESS_DEBUG
rtx_dbug_outs("Initializing: Stress Test C\r\n");
#endif
msgq_head = NULL;
msgq_tail = NULL;
struct num_message * msg_rx;
struct num_message * msg_wake;
struct MessageEnvelope * proc_c;
struct num_message * hibernate;
while(1) {
#ifdef _STRESS_DEBUG
rtx_dbug_outs("Enter: Stress Test C\r\n");
#endif
if(msgq_head == NULL) {
// receive message
msg_rx = (num_message *)receive_message(NULL);
#ifdef _STRESS_DEBUG
rtx_dbug_outs("Stress Test C received a message\r\n");
#endif
} else {
// dequeue first message from local message queue
msg_rx = msgq_head->env;
msgq_head = msgq_head->next;
if(msgq_head == NULL) {
msgq_tail = NULL;
}
#ifdef _STRESS_DEBUG
rtx_dbug_outs("Stress Test C dequeued a message\r\n");
#endif
}
UINT32 type = msg_rx->type;
UINT32 msg_data = msg_rx->msg;
release_memory_block((void *)msg_rx);
if(type == TYPE_COUNT_REPORT) {
#ifdef _STRESS_DEBUG
rtx_dbug_outs_int("Stress Test C got message ", msg_rx->msg);
#endif
if(msg_data%20 == 0) {
proc_c = (MessageEnvelope *)request_memory_block();
str_copy((BYTE *) "Process C\r\n", (BYTE *)proc_c->msg);
send_message(CRT_PID, proc_c);
#ifdef _STRESS_DEBUG
rtx_dbug_outs("Stress Test C sent a message to CRT\r\n");
#endif
// hibernate for 10 seconds
hibernate = (num_message *)request_memory_block();
hibernate->type = TYPE_WAKEUP10;
delayed_send(STRESS_C_PID, hibernate, 10000);
while(1) {
msg_wake = (num_message *)receive_message(NULL);
if(msg_wake->type == TYPE_WAKEUP10) {
break;
} else {
// enqueue the message into local queue
enqueue_local_msg(msg_wake);
}
}
}
}
release_memory_block((void *)hibernate);
release_processor();
}
}
void null_process() {
while (1) {
release_processor();
//LOG("Running null process");
}
}
VOID null_process(){
while( 1 ){
release_processor();
}
}
void null process() {
while(1) {
release_processor();
}
}
void null_proc(void) {
uart1_put_string("Running null process\n\r");
while(1) {
release_processor();
}
}
void process_C()
{
msg_env_queue_t* messageQueue = msg_env_queue_create();
while(1)
{
// setup variables that will be used by the process
MsgEnv *deq_msg;
MsgEnv *rec_msg = NULL;
MsgEnv *rec_msg_2 = NULL;
// check if the process message queue is empty or not
// if the queue is empty, then recieve a message env
// and enqueue it!
if(msg_env_queue_is_empty(messageQueue))
{
MsgEnv *received_msg = receive_message();
msg_env_queue_enqueue(messageQueue, received_msg);
}
// dequeue a message env from the message queue
deq_msg = msg_env_queue_dequeue(messageQueue);
// check if the dequeued message type is a COUNT_REPORT
if(deq_msg->msg_type == COUNT_REPORT)
{
//check if the message in the env is divisible by 20
//if it is divisible, then continue into the if statement
//otherwise release all envelopes and and yeild processor
if (*((int *)(deq_msg->msg)) % 20 == 0)
{
//copys the 'Process C' string into the dequeued msg env
strcpy(deq_msg->msg, "\nProcess C\n");
//send the message env to the console for printing
send_console_chars(deq_msg);
//loop forever (until 'breaked')
while(1)
{
//recieve a message
rec_msg = receive_message();
//check if the recieved message is a type "DISPLAY_ACK"
//if not then check if it is a type "COUNT_REPORT"
//and if that fails then we got a error and the RTX should report it!
if(rec_msg->msg_type == DISPLAY_ACK)
{
//check for an error case
if(request_delay(100, WAKEUP_10, rec_msg) != CODE_SUCCESS)
{
}
break;
}
else if (rec_msg->msg_type == COUNT_REPORT)
{
//enqueue the released env back into the message queue
msg_env_queue_enqueue(messageQueue, rec_msg);
}
else
{
assert(0);
}
}
// "Go passive for 10 seconds" in the outline
while(1)
{
//recieve a message env
rec_msg_2 = receive_message();
//if the recieved env is a type 'WAKEUP_10' then
//exit the while loop
//otherwise, enqueue the recieved message env back into the
//message env queue
if(rec_msg_2->msg_type == WAKEUP_10)
{
break;
}
else
{
msg_env_queue_enqueue(messageQueue, rec_msg_2);
}
}
}
}
//release all the envelopes and yeild the processor
release_msg_env(rec_msg);
release_msg_env(rec_msg_2);
release_msg_env(deq_msg);
release_processor();
}
}
void CCI()
{
//printf("You're in the CCI\n");
int HH=0;
int MM=0;
int SS=0;
int pri=0;
int id=0;
int U = 0;
int dun = 0;
msg_env* env = request_msg_env();
msg_env* first = request_msg_env();
while(1)
{
// send the welcome message
/*
if (first == NULL){
terminate(1);
}
strcpy(first->msg_text, "Enter input for the CCI [s, ps, c [##:##:##], cd, ct, b, n [new_prio] [pid], e... , t]:\0");
int F = 0;
F = send_console_chars(first);
if (F == 0){
terminate(1);
}
*/
U = get_console_chars(env); //keyboard input
//sleep(5);
// only do this if there was input
if (U==1)
{
env = receive_message();
while (env->msg_type != CONSOLE_INPUT)
{
env = receive_message(); //***STOPS HERE TO WAIT FOR INPUT
}
char* input_txt = env->msg_text;
// send envelope to Process A
if (strcmp(input_txt,"s")==0)
{
// printf("input was s\n");
//if the text in the field is "s"
env = request_msg_env(); //request an envelope
int Z =0;
Z = send_message(3,env); // send message to Process A
}
// display process status of all processes
else if (strcmp(input_txt,"ps")==0)
{
// printf("input was ps\n");
env = request_msg_env(); //request an envelope
int J=request_process_status(env);
if (J==0)
printf("Error with getting Process Status\n");
}
// allows time to be displayed on console and halts if getting ct
else if (strcmp(input_txt,"cd")==0)
{
// printf("input was cd\n");
wallClockOut = 1;
}
else if (strcmp(input_txt,"ct")==0)
{
// printf("input was ct\n");
wallClockOut = 0;
}
// set clock to any valid 24hr time
else if (strncmp(input_txt,"c", 1)==0)
{
// printf("input was c\n");
int HH = atoi(input_txt+2);
int MM = atoi(input_txt+5);
int SS = atoi(input_txt+8);
int R = clock_set(wallclock, HH, MM, SS);
if (R==0)
printf("Error with setting clock in CCI\n");
}
// b displays past instances of send and receive messages
else if (strcmp(input_txt,"b")==0)
{
// printf("input was b\n");
env = request_msg_env(); //request an envelope
int U=get_trace_buffers(env);
if (U==0)
printf("Error performing call on Trace Buffers\n");
}
// terminates RTX
else if (strcmp(input_txt,"t")==0)
{
terminate(0);
}
// changes priority
else if (strncmp(input_txt,"n",1)==0)
{
// printf("input was n\n");
int new_pri = atoi(input_txt+2);
int ID = atoi(input_txt+4);
int R = change_priority(new_pri, ID);
if (R==0)
printf("Error with changing priority in CCI\n");
}
// echo the input back
else if (strncmp(input_txt,"e", 1)==0)
{
// printf("input was e\n");
env = request_msg_env(); //request an envelope
input_txt[0] = ' ';
strcat(input_txt, "\n\n");
strcpy(env->msg_text, "echo is: ");
strcpy(env->msg_text, input_txt);
int R = send_console_chars(env);
if (R==0)
printf("Error with echoing to screen\n");
}
else
{
env = request_msg_env(); //request an envelope
char* temp = (char*) malloc(sizeof(SIZE));
sprintf(temp, "'%s' is not valid CCI input. Please try again.\n\n", input_txt);
strcpy(env->msg_text, temp);
int R = send_console_chars(env);
if (R==0)
printf("Error with printing invalid input message\n");
// printf("'%s' is not valid CCI input. Please try again.\n\n", input_txt);
}
dun = release_msg_env(env);
if (dun == 0)
{
env = request_msg_env(); //request an envelope
strcpy(env->msg_text, "ERROR IN DEALLOCATING ENVELOPE AT END OF CCI\n");
int R = send_console_chars(env);
if (R==0)
printf("Error with printing error message\n");
}
//else
// printf("CCI finished, I think\n");
}
env = request_msg_env();
// if there was no input
release_processor();
}
}
void procC()
{
//create local message queue to store msg envs in FIFO order
MsgEnvQ *msgQueue = (MsgEnvQ*)MsgEnvQ_create();
//initialize msg env pointers to keep track of messages
MsgEnv *msg_env;
MsgEnv *msg_env2;
//loop forever
while(1)
{
//if the local msg queue is empty, then receive a message, enqueue it to avoid null pointers for deallocation
if(msgQueue->head == NULL)
{
msg_env = (MsgEnv*)receive_message();
MsgEnvQ_enqueue(msgQueue, msg_env);
}
//dequeue the first msg on the local msg queue
msg_env = (MsgEnv*)MsgEnvQ_dequeue(msgQueue);
//check if the dequeued msg type is 'COUNT_REPORT'
if(msg_env->msg_type == COUNT_REPORT)
{
//the msg originated from proc_A, check if the data is divisible by 20
//********check the line below plz*********
if( (*(int*)msg_env->data) % 20 == 0)
{
//get a message envelope, set the data to 'Process C'
//send it to display on the screen
msg_env2 = (MsgEnv*)request_msg_env();
char tempData[20] = "Process C";
memcpy(msg_env2->data,tempData,strlen(tempData));
//msg_env2->data = '\nProcess C\n';
send_console_chars(msg_env2);
//wait for output confirmation with 'DISPLAY_ACK' msg type
while(1)
{
//receive message, possibly from send_console_chars or proc_B
msg_env2 = (MsgEnv*)receive_message();
//check for msg type 'env2LAY_ACK' or 'COUNT_REPORT'
if (msg_env2->msg_type == DISPLAY_ACK)
{
//go passive for 10seconds, use the msg env we got back from send_console_chars
int stat = request_delay(10000, WAKEUP10, msg_env2);
//if the delay request fails
//*****what do i do here?***** print error
if(stat != SUCCESS)
{
printf("\nWHAT?!?! something went wrong with the delay request...\n");
}
//resume after getting a 10seconds delay request
while(1)
{
//reuse the msg_env2 pointer to get returned msg env from delay request
msg_env2 = (MsgEnv*)receive_message();
//check if its msg_type is 'WAKEUP_10' or 'COUNT_REPORT'
if(msg_env2->msg_type == WAKEUP10)
{
//get out of "waiting for delay finish' loop
break;
}else if(msg_env2->msg_type == COUNT_REPORT){
//enqueue the msg env onto local msg queue if it originated from proc_A
MsgEnvQ_enqueue(msgQueue, msg_env2);
}else{
//shouldn't get here, useless msg env to proc_c
}
}
//get out of 'waiting for output confirmation' loop
break;
}else if(msg_env2->msg_type == COUNT_REPORT){
//enqueue the msg env onto local msg queue if it originated from proc_A
MsgEnvQ_enqueue(msgQueue, msg_env2);
}else{
//shouldn't get here, useless msg env to proc_c
}
}
}
}
//deallocate message envelopes and release processor
release_message_env(msg_env);
release_message_env(msg_env2);
release_processor();
}
}
//Prints test results,
//Test 1 sender (message can be accurately sent/recieved)
void proc1(void) {
int failures = 0;
int passes = 0;
int destination = 2;
int i;
int all_tests_done = 0;
int pid = 1;
int char_offset = 48;
msgbuf *msg;
crt_send_string("G007_test: START\n\r");
//create a message to send to process 2
msg = request_memory_block();
msg->mtype = DEFAULT;
msg->mtext[0] = MSG_TEXT_1;
//send the message to process 2
send_message(destination, msg);
//mark tests 1 and 2 failed (process 2 will mark the tests passed later if sucessful)
test_status[0] = TEST_FAILURE;
test_status[1] = TEST_FAILURE;
// wait for all the processes to finish
set_process_priority(pid, LOWEST);
while (!all_tests_done) {
all_tests_done = 1;
for (i = 0; i < NUM_TESTS; i++) {
if (test_status[i] == TEST_PENDING) {
all_tests_done = 0;
release_processor();
}
}
}
// check statuses of all test processes
for (i = 0; i < NUM_TESTS; i++) {
crt_send_string("G007_test: test ");
crt_send_char(i + 1 + 48);
if (test_status[i] == TEST_SUCCESS) {
crt_send_string(" OK\n\r");
passes++;
} else {
crt_send_string(" FAIL\n\r");
failures++;
}
}
crt_send_string("G007_test: ");
crt_send_char(passes + char_offset);
crt_send_string("/");
crt_send_char(NUM_TESTS + char_offset);
crt_send_string(" tests OK\n\r");
crt_send_string("G007_test: ");
crt_send_char(failures + char_offset);
crt_send_string("/");
crt_send_char(NUM_TESTS + char_offset);
crt_send_string(" tests FAIL\n\r");
crt_send_string("G007_test: END\n\r");
#ifdef _DEBUG_HOTKEYS
// Force this process to be BLOCKED_ON_MEMORY
while (request_memory_block()) {
//YOLO
}
#endif // _DEBUG_HOTKEYS
while (1) {
release_processor();
}
}