Add plugable memory manager interface.

Author: ademakov

ChangeLog

@@ -1,3 +1,16 @@
+2012-10-16  Aleksey Demakov  <[email protected]>
+
+	* include/jit/jit-memory.h: add file that defines pluggable memory
+	manager interface.
+	* jit-internal.h, jit/jit-memory.c: add a number of _jit_memory_*
+	pluggable memory wrapper functions. Replace with these wrappers
+	all _jit_cache_* calls.
+	* jit/jit-cache.c (jit_default_memory_manager): add function that
+	gets memory mamnager plugin interface.
+	* jit/jit-cache.h: remove file.
+	* include/jit/jit-context.h:
+	* jit/jit-context.c (jit_context_set_memory_manager): add function.
+
 2012-10-12  Aleksey Demakov  <[email protected]>
 
 	* include/jit/jit-util.h, jit/jit-alloc.c (jit_malloc_exec)

include/jit/Makefile.am

@@ -19,6 +19,7 @@ dist_libjitinclude_HEADERS = \
 	jit-init.h \
 	jit-insn.h \
 	jit-intrinsic.h \
+	jit-memory.h \
 	jit-meta.h \
 	jit-objmodel.h \
 	jit-objmodel-private.h \

include/jit/jit-context.h

@@ -22,18 +22,26 @@
 #define	_JIT_CONTEXT_H
 
 #include <jit/jit-common.h>
+#include <jit/jit-memory.h>
 
 #ifdef	__cplusplus
 extern	"C" {
 #endif
 
 jit_context_t jit_context_create(void) JIT_NOTHROW;
 void jit_context_destroy(jit_context_t context) JIT_NOTHROW;
+
 void jit_context_build_start(jit_context_t context) JIT_NOTHROW;
 void jit_context_build_end(jit_context_t context) JIT_NOTHROW;
+
 void jit_context_set_on_demand_driver(
 	jit_context_t context,
 	jit_on_demand_driver_func driver) JIT_NOTHROW;
+
+void jit_context_set_memory_manager(
+	jit_context_t context,
+	jit_memory_manager_t manager) JIT_NOTHROW;
+
 int jit_context_set_meta
 	(jit_context_t context, int type, void *data,
 	 jit_meta_free_func free_data) JIT_NOTHROW;

include/jit/jit-memory.h

@@ -0,0 +1,79 @@
+/*
+ * jit-memory.h - Memory management.
+ *
+ * Copyright (C) 2012  Southern Storm Software, Pty Ltd.
+ *
+ * The libjit 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.
+ *
+ * The libjit 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.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with the libjit library.  If not, see
+ * <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef _JIT_MEMORY_H
+#define	_JIT_MEMORY_H
+
+#include <jit/jit-defs.h>
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+/*
+ * Result values for "_jit_cache_start_function" and "_jit_cache_end_function".
+ */
+#define	JIT_MEMORY_OK		0	/* Function is OK */
+#define	JIT_MEMORY_RESTART	1	/* Restart is required */
+#define	JIT_MEMORY_TOO_BIG	2	/* Function is too big for the cache */
+#define JIT_MEMORY_ERROR	3	/* Other error */
+
+
+/* TODO: the proper place for this is jit-def.h and it's going to depend on the platform. */
+typedef unsigned int jit_size_t;
+
+typedef void *jit_memory_context_t;
+
+typedef struct jit_memory_manager const* jit_memory_manager_t;
+
+struct jit_memory_manager
+{
+	jit_memory_context_t (*create)(jit_context_t context);
+	void (*destroy)(jit_memory_context_t memctx);
+
+	jit_function_t (*find_function)(jit_memory_context_t memctx, void *pc);
+
+	jit_function_t (*alloc_function)(jit_memory_context_t memctx);
+	void (*free_function)(jit_memory_context_t memctx, jit_function_t func);
+
+	int (*start_function)(jit_memory_context_t memctx, jit_function_t func);
+	int (*end_function)(jit_memory_context_t memctx, int result);
+	int (*extend_limit)(jit_memory_context_t memctx, int count);
+
+	void * (*get_limit)(jit_memory_context_t memctx);
+	void * (*get_break)(jit_memory_context_t memctx);
+	void (*set_break)(jit_memory_context_t memctx, void *brk);
+
+	void * (*alloc_trampoline)(jit_memory_context_t memctx);
+	void (*free_trampoline)(jit_memory_context_t memctx, void *ptr);
+
+	void * (*alloc_closure)(jit_memory_context_t memctx);
+	void (*free_closure)(jit_memory_context_t memctx, void *ptr);
+
+	void * (*alloc_data)(jit_memory_context_t memctx, jit_size_t size, jit_size_t align);
+};
+
+jit_memory_manager_t jit_default_memory_manager(void) JIT_NOTHROW;
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif	/* _JIT_MEMORY_H */

jit/Makefile.am

@@ -17,7 +17,6 @@ libjit_la_SOURCES = \
 	jit-bitset.h \
 	jit-bitset.c \
 	jit-block.c \
-	jit-cache.h \
 	jit-cache.c \
 	jit-compile.c \
 	jit-config.h \
@@ -45,6 +44,7 @@ libjit_la_SOURCES = \
 	jit-interp-opcode.c \
 	jit-intrinsic.c \
 	jit-live.c \
+	jit-memory.c \
 	jit-meta.c \
 	jit-opcode-apply.c \
 	jit-objmodel.c \

jit/jit-apply.c

@@ -23,7 +23,6 @@
 #include "jit-internal.h"
 #include "jit-apply-rules.h"
 #include "jit-apply-func.h"
-#include "jit-cache.h"
 #if HAVE_STDLIB_H
 	#include <stdlib.h>
 #endif
@@ -872,7 +871,6 @@ void *
 jit_closure_create(jit_context_t context, jit_type_t signature, jit_closure_func func, void *user_data)
 {
 #ifdef jit_closure_size
-	jit_cache_t cache;
 	jit_closure_t closure;
 
 	/* Validate the parameters */
@@ -881,21 +879,19 @@ jit_closure_create(jit_context_t context, jit_type_t signature, jit_closure_func
 		return 0;
 	}
 
-	/* Acquire the cache lock while we do this */
-	jit_mutex_lock(&context->cache_lock);
-
-	/* Allocate space for the closure within the context's function cache */
-	cache = _jit_context_get_cache(context);
-	if(!cache)
+	/* Acquire the memory context */
+	_jit_memory_lock(context);
+	if(!_jit_memory_ensure(context))
 	{
-		jit_mutex_unlock(&context->cache_lock);
+		_jit_memory_unlock(context);
 		return 0;
 	}
 
-	closure = (jit_closure_t)_jit_cache_alloc_closure(cache);
+	/* Allocate memory space for the closure */
+	closure = (jit_closure_t) _jit_memory_alloc_closure(context);
 	if(!closure)
 	{
-		jit_mutex_unlock(&context->cache_lock);
+		_jit_memory_unlock(context);
 		return 0;
 	}
 
@@ -905,12 +901,12 @@ jit_closure_create(jit_context_t context, jit_type_t signature, jit_closure_func
 	closure->func = func;
 	closure->user_data = user_data;
 
+	/* Release the memory context, as we are finished with it */
+	_jit_memory_unlock(context);
+
 	/* Perform a cache flush on the closure's code */
 	_jit_flush_exec(closure->buf, sizeof(closure->buf));
 
-	/* Unlock the cache, as we are finished with it */
-	jit_mutex_unlock(&context->cache_lock);
-
 	/* Return the completed closure to the caller */
 	return closure;
 

jit/jit-cache.c

@@ -25,7 +25,6 @@ See the bottom of this file for documentation on the cache system.
 */
 
 #include "jit-internal.h"
-#include "jit-cache.h"
 #include "jit-apply-func.h"
 
 #include <stddef.h> /* for offsetof */
@@ -76,7 +75,7 @@ struct jit_cache_page
 /*
  * Structure of the method cache.
  */
-#define	JIT_CACHE_DEBUG_SIZE		64
+typedef struct jit_cache *jit_cache_t;
 struct jit_cache
 {
 	struct jit_cache_page	*pages;		/* List of pages currently in the cache */
@@ -117,6 +116,8 @@ struct jit_cache
 #define	SetBlack(node)	\
 	((node)->left = (jit_cache_method_t)(((jit_nuint)(node)->left) & ~((jit_nuint)1)))
 
+void _jit_cache_destroy(jit_cache_t cache);
+
 /*
  * Allocate a cache page and add it to the cache.
  */
@@ -517,13 +518,13 @@ _jit_cache_start_function(jit_cache_t cache, jit_function_t func)
 	/* Bail out if there is a started function already */
 	if(cache->method)
 	{
-		return JIT_CACHE_ERROR;
+		return JIT_MEMORY_ERROR;
 	}
 
 	/* Bail out if the cache is already full */
 	if(!cache->free_start)
 	{
-		return JIT_CACHE_TOO_BIG;
+		return JIT_MEMORY_TOO_BIG;
 	}
 
 	/* Save the cache position */
@@ -540,7 +541,7 @@ _jit_cache_start_function(jit_cache_t cache, jit_function_t func)
 	cache->method->left = 0;
 	cache->method->right = 0;
 
-	return JIT_CACHE_OK;
+	return JIT_MEMORY_OK;
 }
 
 int
@@ -549,17 +550,17 @@ _jit_cache_end_function(jit_cache_t cache, int result)
 	/* Bail out if there is no started function */
 	if(!cache->method)
 	{
-		return JIT_CACHE_ERROR;
+		return JIT_MEMORY_ERROR;
 	}
 
 	/* Determine if we ran out of space while writing the function */
-	if(result != JIT_CACHE_OK || cache->free_start >= cache->free_end)
+	if(result != JIT_MEMORY_OK || cache->free_start >= cache->free_end)
 	{
 		/* Restore the saved cache position */
 		cache->free_start = cache->prev_start;
 		cache->free_end = cache->prev_end;
 		cache->method = 0;
-		return JIT_CACHE_RESTART;
+		return JIT_MEMORY_RESTART;
 	}
 
 	/* Update the method region block and then add it to the lookup tree */
@@ -568,7 +569,7 @@ _jit_cache_end_function(jit_cache_t cache, int result)
 	cache->method = 0;
 
 	/* The method is ready to go */
-	return JIT_CACHE_OK;
+	return JIT_MEMORY_OK;
 }
 
 void *
@@ -797,6 +798,30 @@ _jit_cache_get_function(jit_cache_t cache, void *pc)
 	return 0;
 }
 
+jit_memory_manager_t
+jit_default_memory_manager(void)
+{
+	static const struct jit_memory_manager mm = {
+		&_jit_cache_create,
+		&_jit_cache_destroy,
+		&_jit_cache_get_function,
+		&_jit_cache_alloc_function,
+		&_jit_cache_free_function,
+		&_jit_cache_start_function,
+		&_jit_cache_end_function,
+		&_jit_cache_extend,
+		&_jit_cache_get_code_limit,
+		&_jit_cache_get_code_break,
+		&_jit_cache_set_code_break,
+		&_jit_cache_alloc_trampoline,
+		&_jit_cache_free_trampoline,
+		&_jit_cache_alloc_closure,
+		&_jit_cache_free_closure,
+		&_jit_cache_alloc_data
+	};
+	return &mm;
+}
+
 /*
 
 Using the cache