factor/vm/master.hpp

#ifndef __FACTOR_MASTER_H__
#define __FACTOR_MASTER_H__

#define _THREAD_SAFE
#define _REENTRANT

#ifndef WINCE
#include <errno.h>
#endif

#ifdef FACTOR_DEBUG
#include <assert.h>
#endif

/* C headers */
#include <fcntl.h>
#include <limits.h>
#include <math.h>
#include <setjmp.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>

/* C++ headers */
#include <algorithm>
#include <map>
#include <set>
#include <vector>
#include <iostream>

/* Detect target CPU type */
#if defined(__arm__)
	#define FACTOR_ARM
#elif defined(__amd64__) || defined(__x86_64__)
	#define FACTOR_AMD64
	#define FACTOR_64
#elif defined(i386) || defined(__i386) || defined(__i386__) || defined(WIN32) || defined(_MSC_VER)
	#define FACTOR_X86
#elif defined(__POWERPC__) || defined(__ppc__) || defined(_ARCH_PPC)
	#define FACTOR_PPC
#else
	#error "Unsupported architecture"
#endif

#if defined(_MSC_VER)
	#define WINDOWS
	#define WINNT
#elif defined(WIN32)
	#define WINDOWS
#endif

#ifndef _MSC_VER
	#include <stdbool.h>
#endif

/* Forward-declare this since it comes up in function prototypes */
namespace factor
{
	struct factor_vm;
}

/* Factor headers */
#include "layouts.hpp"
#include "platform.hpp"
#include "primitives.hpp"
#include "segments.hpp"
#include "contexts.hpp"
#include "run.hpp"
#include "objects.hpp"
#include "profiler.hpp"
#include "errors.hpp"
#include "bignumint.hpp"
#include "bignum.hpp"
#include "booleans.hpp"
#include "instruction_operands.hpp"
#include "code_blocks.hpp"
#include "bump_allocator.hpp"
#include "bitwise_hacks.hpp"
#include "mark_bits.hpp"
#include "free_list.hpp"
#include "free_list_allocator.hpp"
#include "write_barrier.hpp"
#include "object_start_map.hpp"
#include "nursery_space.hpp"
#include "aging_space.hpp"
#include "tenured_space.hpp"
#include "data_heap.hpp"
#include "code_heap.hpp"
#include "gc.hpp"
#include "debug.hpp"
#include "strings.hpp"
#include "tuples.hpp"
#include "words.hpp"
#include "float_bits.hpp"
#include "io.hpp"
#include "image.hpp"
#include "alien.hpp"
#include "callbacks.hpp"
#include "dispatch.hpp"
#include "entry_points.hpp"
#include "vm.hpp"
#include "allot.hpp"
#include "tagged.hpp"
#include "data_roots.hpp"
#include "code_roots.hpp"
#include "generic_arrays.hpp"
#include "slot_visitor.hpp"
#include "collector.hpp"
#include "copying_collector.hpp"
#include "nursery_collector.hpp"
#include "aging_collector.hpp"
#include "to_tenured_collector.hpp"
#include "code_block_visitor.hpp"
#include "compaction.hpp"
#include "full_collector.hpp"
#include "callstack.hpp"
#include "arrays.hpp"
#include "math.hpp"
#include "byte_arrays.hpp"
#include "jit.hpp"
#include "quotations.hpp"
#include "inline_cache.hpp"
#include "factor.hpp"
#include "utilities.hpp"

#endif /* __FACTOR_MASTER_H__ */
Porting VM to C++ 2009-05-02 05:04:19 -04:00			`#ifndef __FACTOR_MASTER_H__`
			`#define __FACTOR_MASTER_H__`

added threadsafe defines. Dunno if they do much 2009-08-28 15:23:01 -04:00			`#define _THREAD_SAFE`
			`#define _REENTRANT`

Porting VM to C++ 2009-05-02 05:04:19 -04:00			`#ifndef WINCE`
			`#include <errno.h>`
			`#endif`

			`#ifdef FACTOR_DEBUG`
			`#include <assert.h>`
			`#endif`

Store forwarding table off to the side instead of in the code block; saves one cell per code block 2009-05-05 12:07:20 -04:00			`/* C headers */`
Porting VM to C++ 2009-05-02 05:04:19 -04:00			`#include <fcntl.h>`
			`#include <limits.h>`
			`#include <math.h>`
			`#include <setjmp.h>`
			`#include <stdio.h>`
			`#include <stdlib.h>`
			`#include <string.h>`
			`#include <time.h>`

Store forwarding table off to the side instead of in the code block; saves one cell per code block 2009-05-05 12:07:20 -04:00			`/* C++ headers */`
vm: number of generations is not configurable anymore, split up begin_gc() and end_gc() into collect_{nursery,aging,aging_again,tenured}() 2009-10-06 03:39:12 -04:00			`#include <algorithm>`
vm: new mark_bits data structure replaces hashtable when compacting code heap 2009-10-19 03:21:11 -04:00			`#include <map>`
Big VM cleanup - Move forward declarations of 'struct factor_vm' to one place - Rename template parameters from T and TYPE to descriptive names. New convention: CamelCase for template parameters - Change some higher-order functions taking function pointers into templates, and define classes overriding operator(). There's a bit of new boilerplate here but its more consistent than the old mish-mash approaches - Put GC state into a gc_state struct - Use exceptions instead of longjmp for non-local control transfer in GC - In code GC, instead of interleaving code block tracing with copying, add code blocks which need to be revisited to an std::set stored in the gc_state 2009-10-03 09:47:05 -04:00			`#include <set>`
vm: number of generations is not configurable anymore, split up begin_gc() and end_gc() into collect_{nursery,aging,aging_again,tenured}() 2009-10-06 03:39:12 -04:00			`#include <vector>`
vm: use iostreams instead of printf for debug messages, clean up a few things 2009-10-21 21:12:57 -04:00			`#include <iostream>`
VM: use an std::vector instead of a fixed-size buffer for GC roots 2009-09-08 15:21:09 -04:00
vm: fix compilation on 64-bit platforms 2010-01-13 08:18:49 -05:00			`/* Detect target CPU type */`
			`#if defined(__arm__)`
			`#define FACTOR_ARM`
			`#elif defined(__amd64__) \|\| defined(__x86_64__)`
			`#define FACTOR_AMD64`
			`#define FACTOR_64`
vm: Tweak Factor VM to compile with Microsoft Visual Studio on Windows, in addition to Mingw. Add an Nmakefile which can be used for this purpose. Rename Makefile to GNUmakefile. 2010-01-16 09:43:22 -05:00			`#elif defined(i386) \|\| defined(__i386) \|\| defined(__i386__) \|\| defined(WIN32) \|\| defined(_MSC_VER)`
vm: fix compilation on 64-bit platforms 2010-01-13 08:18:49 -05:00			`#define FACTOR_X86`
			`#elif defined(__POWERPC__) \|\| defined(__ppc__) \|\| defined(_ARCH_PPC)`
			`#define FACTOR_PPC`
			`#else`
			`#error "Unsupported architecture"`
			`#endif`

vm: Tweak Factor VM to compile with Microsoft Visual Studio on Windows, in addition to Mingw. Add an Nmakefile which can be used for this purpose. Rename Makefile to GNUmakefile. 2010-01-16 09:43:22 -05:00			`#if defined(_MSC_VER)`
vm: fix compilation on 64-bit platforms 2010-01-13 08:18:49 -05:00			`#define WINDOWS`
vm: Tweak Factor VM to compile with Microsoft Visual Studio on Windows, in addition to Mingw. Add an Nmakefile which can be used for this purpose. Rename Makefile to GNUmakefile. 2010-01-16 09:43:22 -05:00			`#define WINNT`
			`#elif defined(WIN32)`
			`#define WINDOWS`
			`#endif`

			`#ifndef _MSC_VER`
			`#include <stdbool.h>`
vm: fix compilation on 64-bit platforms 2010-01-13 08:18:49 -05:00			`#endif`

Big VM cleanup - Move forward declarations of 'struct factor_vm' to one place - Rename template parameters from T and TYPE to descriptive names. New convention: CamelCase for template parameters - Change some higher-order functions taking function pointers into templates, and define classes overriding operator(). There's a bit of new boilerplate here but its more consistent than the old mish-mash approaches - Put GC state into a gc_state struct - Use exceptions instead of longjmp for non-local control transfer in GC - In code GC, instead of interleaving code block tracing with copying, add code blocks which need to be revisited to an std::set stored in the gc_state 2009-10-03 09:47:05 -04:00			`/* Forward-declare this since it comes up in function prototypes */`
			`namespace factor`
			`{`
			`struct factor_vm;`
			`}`

Store forwarding table off to the side instead of in the code block; saves one cell per code block 2009-05-05 12:07:20 -04:00			`/* Factor headers */`
Porting VM to C++ 2009-05-02 05:04:19 -04:00			`#include "layouts.hpp"`
added VM relocation type 2009-08-18 15:40:26 -04:00			`#include "platform.hpp"`
vm ptr passed to primitives on X86.32 (other cpus still use singleton vm ptr) 2009-08-18 15:49:22 -04:00			`#include "primitives.hpp"`
VM: use better abstractions for tagged pointers, eliminate get()/set() stuff, clean up array, string, and byte-array element access 2009-05-04 02:00:30 -04:00			`#include "segments.hpp"`
			`#include "contexts.hpp"`
Porting VM to C++ 2009-05-02 05:04:19 -04:00			`#include "run.hpp"`
vm: rewrite 'become' primitive so that it uses a slot visitor instead of GC 2009-11-05 20:03:51 -05:00			`#include "objects.hpp"`
Porting VM to C++ 2009-05-02 05:04:19 -04:00			`#include "profiler.hpp"`
			`#include "errors.hpp"`
			`#include "bignumint.hpp"`
			`#include "bignum.hpp"`
Big cleanup of literal table and relocation-related code - new way to iterate over instruction_operands cleans up relocation code - move some methods out of the VM class to clean up code - if debugging is on, die earlier if attempting to allocate inside GC - callback heap entries are now code_blocks - replace block_granularity with data_alignment 2009-12-02 01:48:41 -05:00			`#include "booleans.hpp"`
vm: mark sweep now traces code block references; rename embedded_pointer to instruction_operand 2009-11-23 19:51:08 -05:00			`#include "instruction_operands.hpp"`
vm: eliminating literal table work in progress 2009-11-07 17:16:09 -05:00			`#include "code_blocks.hpp"`
vm: split off free_list_allocator from heap class, rename zone to bump_allocator 2009-10-20 16:15:05 -04:00			`#include "bump_allocator.hpp"`
vm: faster sweep algorithm 2009-11-01 21:15:42 -05:00			`#include "bitwise_hacks.hpp"`
vm: split off free_list_allocator from heap class, rename zone to bump_allocator 2009-10-20 16:15:05 -04:00			`#include "mark_bits.hpp"`
vm: remove crummy old GC stats, split off free list code, clean up various other things 2009-10-26 23:08:35 -04:00			`#include "free_list.hpp"`
vm: split off free_list_allocator from heap class, rename zone to bump_allocator 2009-10-20 16:15:05 -04:00			`#include "free_list_allocator.hpp"`
The great type renaming 2009-05-04 05:50:24 -04:00			`#include "write_barrier.hpp"`
vm: split off free_list_allocator from heap class, rename zone to bump_allocator 2009-10-20 16:15:05 -04:00			`#include "object_start_map.hpp"`
vm: mark sweep gc for tenured space work in progress 2009-10-20 23:20:49 -04:00			`#include "nursery_space.hpp"`
vm: working on new object-oriented garbage collector 2009-10-07 16:48:09 -04:00			`#include "aging_space.hpp"`
			`#include "tenured_space.hpp"`
vm: make a new old_space type to encapsulate a few things, split up generations array somewhat 2009-10-07 15:05:09 -04:00			`#include "data_heap.hpp"`
vm: clean up gc events, remove -verbosegc switch, fix compaction bug 2009-10-27 22:31:28 -04:00			`#include "code_heap.hpp"`
vm: rename data_gc.cpp to gc.cpp 2009-10-08 03:11:29 -04:00			`#include "gc.hpp"`
Porting VM to C++ 2009-05-02 05:04:19 -04:00			`#include "debug.hpp"`
			`#include "strings.hpp"`
			`#include "tuples.hpp"`
			`#include "words.hpp"`
			`#include "float_bits.hpp"`
			`#include "io.hpp"`
			`#include "image.hpp"`
			`#include "alien.hpp"`
vm: code heap compaction at runtime using compact-gc primitive 2009-10-16 12:39:22 -04:00			`#include "callbacks.hpp"`
tools.time: overhaul 2009-11-05 02:07:59 -05:00			`#include "dispatch.hpp"`
vm: move c_to_factor, lazy_jit_compile_impl, throw_impl, set_callstack assembly routines into non-optimizing compiler for x86-64 2010-01-05 21:47:36 -05:00			`#include "entry_points.hpp"`
reordered master to untangle dependency chain a bit 2009-08-17 16:37:12 -04:00			`#include "vm.hpp"`
vm: various minor optimizations speeding up gc0 and dispatch1 benchmarks, as well as bootstrap - make allot_object() inline, move slow case to allot_large_object() - reduce number of conditional branches in megamorphic cache miss handler - make unbox_array_size() inline, move slow case to unbox_array_size_slow() - new memset_cell() function uses memset_pattern4/8() on Mac OS X 2009-10-31 03:30:48 -04:00			`#include "allot.hpp"`
moved tagged template code back into tagged.hpp header 2009-08-17 16:37:15 -04:00			`#include "tagged.hpp"`
vm: rename gc_root to data_root, add code_root to fix a problem where code blocks would move underneath the PIC compiler if PIC compiler allocated enough 2009-11-02 19:10:34 -05:00			`#include "data_roots.hpp"`
			`#include "code_roots.hpp"`
vm: minor GC traces embedded pointers 2009-11-22 14:37:39 -05:00			`#include "generic_arrays.hpp"`
vm: factor out code that visits object slots and code heap blocks into slot_visitor and code_block_visitor 2009-10-24 04:54:53 -04:00			`#include "slot_visitor.hpp"`
vm: working on new object-oriented garbage collector 2009-10-07 16:48:09 -04:00			`#include "collector.hpp"`
			`#include "copying_collector.hpp"`
			`#include "nursery_collector.hpp"`
			`#include "aging_collector.hpp"`
			`#include "to_tenured_collector.hpp"`
vm: factor out code that visits object slots and code heap blocks into slot_visitor and code_block_visitor 2009-10-24 04:54:53 -04:00			`#include "code_block_visitor.hpp"`
vm: data heap compaction work in progress 2009-10-24 05:18:33 -04:00			`#include "compaction.hpp"`
vm: working on new object-oriented garbage collector 2009-10-07 16:48:09 -04:00			`#include "full_collector.hpp"`
inlineimpl.hpp is toast 2009-09-29 14:53:10 -04:00			`#include "callstack.hpp"`
			`#include "arrays.hpp"`
			`#include "math.hpp"`
			`#include "byte_arrays.hpp"`
Porting VM to C++ 2009-05-02 05:04:19 -04:00			`#include "jit.hpp"`
Cleaning up VM code 2009-05-02 10:19:09 -04:00			`#include "quotations.hpp"`
Porting VM to C++ 2009-05-02 05:04:19 -04:00			`#include "inline_cache.hpp"`
			`#include "factor.hpp"`
			`#include "utilities.hpp"`

			`#endif /* __FACTOR_MASTER_H__ */`