[pcsx_rearmed.git] / deps / lightrec / recompiler.c

/*
 * Copyright (C) 2019-2020 Paul Cercueil <paul@crapouillou.net>
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 */

#include "debug.h"
#include "interpreter.h"
#include "lightrec-private.h"
#include "memmanager.h"

#include <errno.h>
#include <stdatomic.h>
#include <stdbool.h>
#include <stdlib.h>
#include <pthread.h>

struct block_rec {
	struct block *block;
	struct block_rec *next;
};

struct recompiler {
	struct lightrec_state *state;
	pthread_t thd;
	pthread_cond_t cond;
	pthread_mutex_t mutex;
	bool stop;
	struct block *current_block;
	struct block_rec *list;
};

static void slist_remove(struct recompiler *rec, struct block_rec *elm)
{
	struct block_rec *prev;

	if (rec->list == elm) {
		rec->list = elm->next;
	} else {
		for (prev = rec->list; prev && prev->next != elm; )
			prev = prev->next;
		if (prev)
			prev->next = elm->next;
	}
}

static void lightrec_compile_list(struct recompiler *rec)
{
	struct block_rec *next;
	struct block *block;
	int ret;

	while (!!(next = rec->list)) {
		block = next->block;
		rec->current_block = block;

		pthread_mutex_unlock(&rec->mutex);

		ret = lightrec_compile_block(block);
		if (ret) {
			pr_err("Unable to compile block at PC 0x%x: %d\n",
			       block->pc, ret);
		}

		pthread_mutex_lock(&rec->mutex);

		slist_remove(rec, next);
		lightrec_free(rec->state, MEM_FOR_LIGHTREC,
			      sizeof(*next), next);
		pthread_cond_signal(&rec->cond);
	}

	rec->current_block = NULL;
}

static void * lightrec_recompiler_thd(void *d)
{
	struct recompiler *rec = d;

	pthread_mutex_lock(&rec->mutex);

	for (;;) {
		do {
			pthread_cond_wait(&rec->cond, &rec->mutex);

			if (rec->stop) {
				pthread_mutex_unlock(&rec->mutex);
				return NULL;
			}

		} while (!rec->list);

		lightrec_compile_list(rec);
	}
}

struct recompiler *lightrec_recompiler_init(struct lightrec_state *state)
{
	struct recompiler *rec;
	int ret;

	rec = lightrec_malloc(state, MEM_FOR_LIGHTREC, sizeof(*rec));
	if (!rec) {
		pr_err("Cannot create recompiler: Out of memory\n");
		return NULL;
	}

	rec->state = state;
	rec->stop = false;
	rec->current_block = NULL;
	rec->list = NULL;

	ret = pthread_cond_init(&rec->cond, NULL);
	if (ret) {
		pr_err("Cannot init cond variable: %d\n", ret);
		goto err_free_rec;
	}

	ret = pthread_mutex_init(&rec->mutex, NULL);
	if (ret) {
		pr_err("Cannot init mutex variable: %d\n", ret);
		goto err_cnd_destroy;
	}

	ret = pthread_create(&rec->thd, NULL, lightrec_recompiler_thd, rec);
	if (ret) {
		pr_err("Cannot create recompiler thread: %d\n", ret);
		goto err_mtx_destroy;
	}

	return rec;

err_mtx_destroy:
	pthread_mutex_destroy(&rec->mutex);
err_cnd_destroy:
	pthread_cond_destroy(&rec->cond);
err_free_rec:
	lightrec_free(state, MEM_FOR_LIGHTREC, sizeof(*rec), rec);
	return NULL;
}

void lightrec_free_recompiler(struct recompiler *rec)
{
	rec->stop = true;

	/* Stop the thread */
	pthread_mutex_lock(&rec->mutex);
	pthread_cond_signal(&rec->cond);
	pthread_mutex_unlock(&rec->mutex);
	pthread_join(rec->thd, NULL);

	pthread_mutex_destroy(&rec->mutex);
	pthread_cond_destroy(&rec->cond);
	lightrec_free(rec->state, MEM_FOR_LIGHTREC, sizeof(*rec), rec);
}

int lightrec_recompiler_add(struct recompiler *rec, struct block *block)
{
	struct block_rec *block_rec, *prev;

	pthread_mutex_lock(&rec->mutex);

	for (block_rec = rec->list, prev = NULL; block_rec;
	     prev = block_rec, block_rec = block_rec->next) {
		if (block_rec->block == block) {
			/* The block to compile is already in the queue - bump
			 * it to the top of the list */
			if (prev) {
				prev->next = block_rec->next;
				block_rec->next = rec->list;
				rec->list = block_rec;
			}

			pthread_mutex_unlock(&rec->mutex);
			return 0;
		}
	}

	/* By the time this function was called, the block has been recompiled
	 * and ins't in the wait list anymore. Just return here. */
	if (block->function) {
		pthread_mutex_unlock(&rec->mutex);
		return 0;
	}

	block_rec = lightrec_malloc(rec->state, MEM_FOR_LIGHTREC,
				    sizeof(*block_rec));
	if (!block_rec) {
		pthread_mutex_unlock(&rec->mutex);
		return -ENOMEM;
	}

	pr_debug("Adding block PC 0x%x to recompiler\n", block->pc);

	block_rec->block = block;
	block_rec->next = rec->list;
	rec->list = block_rec;

	/* Signal the thread */
	pthread_cond_signal(&rec->cond);
	pthread_mutex_unlock(&rec->mutex);

	return 0;
}

void lightrec_recompiler_remove(struct recompiler *rec, struct block *block)
{
	struct block_rec *block_rec;

	pthread_mutex_lock(&rec->mutex);

	for (block_rec = rec->list; block_rec; block_rec = block_rec->next) {
		if (block_rec->block == block) {
			if (block == rec->current_block) {
				/* Block is being recompiled - wait for
				 * completion */
				do {
					pthread_cond_wait(&rec->cond,
							  &rec->mutex);
				} while (block == rec->current_block);
			} else {
				/* Block is not yet being processed - remove it
				 * from the list */
				slist_remove(rec, block_rec);
				lightrec_free(rec->state, MEM_FOR_LIGHTREC,
					      sizeof(*block_rec), block_rec);
			}

			break;
		}
	}

	pthread_mutex_unlock(&rec->mutex);
}

void * lightrec_recompiler_run_first_pass(struct block *block, u32 *pc)
{
	bool freed;

	if (likely(block->function)) {
		if (block->flags & BLOCK_FULLY_TAGGED) {
			freed = atomic_flag_test_and_set(&block->op_list_freed);

			if (!freed) {
				pr_debug("Block PC 0x%08x is fully tagged"
					 " - free opcode list\n", block->pc);

				/* The block was already compiled but the opcode list
				 * didn't get freed yet - do it now */
				lightrec_free_opcode_list(block->state,
							  block->opcode_list);
				block->opcode_list = NULL;
			}
		}

		return block->function;
	}

	/* Mark the opcode list as freed, so that the threaded compiler won't
	 * free it while we're using it in the interpreter. */
	freed = atomic_flag_test_and_set(&block->op_list_freed);

	/* Block wasn't compiled yet - run the interpreter */
	*pc = lightrec_emulate_block(block, *pc);

	if (!freed)
		atomic_flag_clear(&block->op_list_freed);

	/* The block got compiled while the interpreter was running.
	 * We can free the opcode list now. */
	if (block->function && (block->flags & BLOCK_FULLY_TAGGED) &&
	    !atomic_flag_test_and_set(&block->op_list_freed)) {
		pr_debug("Block PC 0x%08x is fully tagged"
			 " - free opcode list\n", block->pc);

		lightrec_free_opcode_list(block->state, block->opcode_list);
		block->opcode_list = NULL;
	}

	return NULL;
}
Commit	Line	Data
d16005f8 PC	1	/*
	2	* Copyright (C) 2019-2020 Paul Cercueil <paul@crapouillou.net>
	3	*
	4	* This library is free software; you can redistribute it and/or
	5	* modify it under the terms of the GNU Lesser General Public
	6	* License as published by the Free Software Foundation; either
	7	* version 2.1 of the License, or (at your option) any later version.
	8	*
	9	* This library is distributed in the hope that it will be useful,
	10	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	11	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	12	* Lesser General Public License for more details.
	13	*/
	14
	15	#include "debug.h"
	16	#include "interpreter.h"
	17	#include "lightrec-private.h"
	18	#include "memmanager.h"
	19
	20	#include <errno.h>
	21	#include <stdatomic.h>
	22	#include <stdbool.h>
	23	#include <stdlib.h>
	24	#include <pthread.h>
	25
	26	struct block_rec {
	27	struct block *block;
	28	struct block_rec *next;
	29	};
	30
	31	struct recompiler {
	32	struct lightrec_state *state;
	33	pthread_t thd;
	34	pthread_cond_t cond;
	35	pthread_mutex_t mutex;
	36	bool stop;
	37	struct block *current_block;
	38	struct block_rec *list;
	39	};
	40
	41	static void slist_remove(struct recompiler rec, struct block_rec elm)
	42	{
	43	struct block_rec *prev;
	44
	45	if (rec->list == elm) {
	46	rec->list = elm->next;
	47	} else {
	48	for (prev = rec->list; prev && prev->next != elm; )
	49	prev = prev->next;
	50	if (prev)
	51	prev->next = elm->next;
	52	}
	53	}
	54
	55	static void lightrec_compile_list(struct recompiler *rec)
	56	{
	57	struct block_rec *next;
	58	struct block *block;
	59	int ret;
	60
	61	while (!!(next = rec->list)) {
	62	block = next->block;
	63	rec->current_block = block;
	64
65	pthread_mutex_unlock(&rec->mutex);
66
67	ret = lightrec_compile_block(block);
68	if (ret) {
69	pr_err("Unable to compile block at PC 0x%x: %d\n",
70	block->pc, ret);
71	}
72
73	pthread_mutex_lock(&rec->mutex);
74
75	slist_remove(rec, next);
76	lightrec_free(rec->state, MEM_FOR_LIGHTREC,
77	sizeof(*next), next);
78	pthread_cond_signal(&rec->cond);
79	}
80
81	rec->current_block = NULL;
82	}
83
84	static void * lightrec_recompiler_thd(void *d)
85	{
86	struct recompiler *rec = d;
87
88	pthread_mutex_lock(&rec->mutex);
89
90	for (;;) {
91	do {
92	pthread_cond_wait(&rec->cond, &rec->mutex);
93
94	if (rec->stop) {
95	pthread_mutex_unlock(&rec->mutex);
96	return NULL;
97	}
98
99	} while (!rec->list);
100
101	lightrec_compile_list(rec);
102	}
103	}
104
105	struct recompiler lightrec_recompiler_init(struct lightrec_state state)
106	{
107	struct recompiler *rec;
108	int ret;
109
110	rec = lightrec_malloc(state, MEM_FOR_LIGHTREC, sizeof(*rec));
111	if (!rec) {
112	pr_err("Cannot create recompiler: Out of memory\n");
113	return NULL;
114	}
115
116	rec->state = state;
117	rec->stop = false;
118	rec->current_block = NULL;
119	rec->list = NULL;
120
121	ret = pthread_cond_init(&rec->cond, NULL);
122	if (ret) {
123	pr_err("Cannot init cond variable: %d\n", ret);
124	goto err_free_rec;
125	}
126
127	ret = pthread_mutex_init(&rec->mutex, NULL);
128	if (ret) {
129	pr_err("Cannot init mutex variable: %d\n", ret);
130	goto err_cnd_destroy;
131	}
132
133	ret = pthread_create(&rec->thd, NULL, lightrec_recompiler_thd, rec);
134	if (ret) {
135	pr_err("Cannot create recompiler thread: %d\n", ret);
136	goto err_mtx_destroy;
137	}
138
139	return rec;
140
141	err_mtx_destroy:
142	pthread_mutex_destroy(&rec->mutex);
143	err_cnd_destroy:
144	pthread_cond_destroy(&rec->cond);
145	err_free_rec:
146	lightrec_free(state, MEM_FOR_LIGHTREC, sizeof(*rec), rec);
147	return NULL;
148	}
149
150	void lightrec_free_recompiler(struct recompiler *rec)
151	{
152	rec->stop = true;
153
154	/* Stop the thread */
155	pthread_mutex_lock(&rec->mutex);
156	pthread_cond_signal(&rec->cond);
157	pthread_mutex_unlock(&rec->mutex);
158	pthread_join(rec->thd, NULL);
159
160	pthread_mutex_destroy(&rec->mutex);
161	pthread_cond_destroy(&rec->cond);
162	lightrec_free(rec->state, MEM_FOR_LIGHTREC, sizeof(*rec), rec);
163	}
164
165	int lightrec_recompiler_add(struct recompiler rec, struct block block)
166	{
167	struct block_rec block_rec, prev;
168
169	pthread_mutex_lock(&rec->mutex);
170
171	for (block_rec = rec->list, prev = NULL; block_rec;
172	prev = block_rec, block_rec = block_rec->next) {
173	if (block_rec->block == block) {
174	/* The block to compile is already in the queue - bump
175	* it to the top of the list */
176	if (prev) {
177	prev->next = block_rec->next;
178	block_rec->next = rec->list;
179	rec->list = block_rec;
180	}
181
182	pthread_mutex_unlock(&rec->mutex);
183	return 0;
184	}
185	}
186
187	/* By the time this function was called, the block has been recompiled
188	* and ins't in the wait list anymore. Just return here. */
189	if (block->function) {
190	pthread_mutex_unlock(&rec->mutex);
191	return 0;
192	}
193
194	block_rec = lightrec_malloc(rec->state, MEM_FOR_LIGHTREC,
195	sizeof(*block_rec));
196	if (!block_rec) {
197	pthread_mutex_unlock(&rec->mutex);
198	return -ENOMEM;
199	}
200
201	pr_debug("Adding block PC 0x%x to recompiler\n", block->pc);
202
203	block_rec->block = block;
204	block_rec->next = rec->list;
205	rec->list = block_rec;
206
207	/* Signal the thread */
208	pthread_cond_signal(&rec->cond);
209	pthread_mutex_unlock(&rec->mutex);
210
211	return 0;
212	}
213
214	void lightrec_recompiler_remove(struct recompiler rec, struct block block)
215	{
216	struct block_rec *block_rec;
217
218	pthread_mutex_lock(&rec->mutex);
219
220	for (block_rec = rec->list; block_rec; block_rec = block_rec->next) {
221	if (block_rec->block == block) {
222	if (block == rec->current_block) {
223	/* Block is being recompiled - wait for
224	* completion */
225	do {
226	pthread_cond_wait(&rec->cond,
227	&rec->mutex);
228	} while (block == rec->current_block);
229	} else {
230	/* Block is not yet being processed - remove it
231	* from the list */
232	slist_remove(rec, block_rec);
233	lightrec_free(rec->state, MEM_FOR_LIGHTREC,
234	sizeof(*block_rec), block_rec);
235	}
236
237	break;
238	}
239	}
240
241	pthread_mutex_unlock(&rec->mutex);
242	}
243
244	void * lightrec_recompiler_run_first_pass(struct block block, u32 pc)
245	{
246	bool freed;
247
248	if (likely(block->function)) {
249	if (block->flags & BLOCK_FULLY_TAGGED) {
250	freed = atomic_flag_test_and_set(&block->op_list_freed);
251
252	if (!freed) {
253	pr_debug("Block PC 0x%08x is fully tagged"
254	" - free opcode list\n", block->pc);
255
256	/* The block was already compiled but the opcode list
257	* didn't get freed yet - do it now */
258	lightrec_free_opcode_list(block->state,
259	block->opcode_list);
260	block->opcode_list = NULL;
261	}
262	}
263
264	return block->function;
265	}
266
267	/* Mark the opcode list as freed, so that the threaded compiler won't
268	* free it while we're using it in the interpreter. */
269	freed = atomic_flag_test_and_set(&block->op_list_freed);
270
271	/* Block wasn't compiled yet - run the interpreter */
272	pc = lightrec_emulate_block(block, pc);
273
274	if (!freed)
275	atomic_flag_clear(&block->op_list_freed);
276
277	/* The block got compiled while the interpreter was running.
278	* We can free the opcode list now. */
279	if (block->function && (block->flags & BLOCK_FULLY_TAGGED) &&
280	!atomic_flag_test_and_set(&block->op_list_freed)) {
281	pr_debug("Block PC 0x%08x is fully tagged"
282	" - free opcode list\n", block->pc);
283
284	lightrec_free_opcode_list(block->state, block->opcode_list);
285	block->opcode_list = NULL;
286	}
287
288	return NULL;
289	}