source: trunk/source/lisp-kernel/gc.h @ 15823

Last change on this file since 15823 was 15823, checked in by gb, 7 years ago

Still not working; may not be for another few days.
Will create a branch for this and revert trunk.

  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 7.8 KB
Line 
1/*
2   Copyright (C) 2009 Clozure Associates
3   Copyright (C) 1994-2001 Digitool, Inc
4   This file is part of Clozure CL. 
5
6   Clozure CL is licensed under the terms of the Lisp Lesser GNU Public
7   License , known as the LLGPL and distributed with Clozure CL as the
8   file "LICENSE".  The LLGPL consists of a preamble and the LGPL,
9   which is distributed with Clozure CL as the file "LGPL".  Where these
10   conflict, the preamble takes precedence. 
11
12   Clozure CL is referenced in the preamble as the "LIBRARY."
13
14   The LLGPL is also available online at
15   http://opensource.franz.com/preamble.html
16*/
17
18#ifndef __GC_H__
19#define __GC_H__ 1
20
21#include "lisp.h"
22#include "bits.h"
23#include "lisp-exceptions.h"
24#include "memprotect.h"
25
26
27
28#ifdef PPC
29#define is_node_fulltag(f)  ((1<<(f))&((1<<fulltag_cons)|(1<<fulltag_misc)))
30#ifdef PPC64
31#define PPC64_CODE_VECTOR_PREFIX (('C'<< 24) | ('O' << 16) | ('D' << 8) | 'E')
32#else
33/*
34  A code-vector's header can't look like a valid instruction or UUO:
35  the low 8 bits must be subtag_code_vector, and the top 6 bits
36  must be 0.  That means that the maximum length of a code vector
37  is 18 bits worth of elements (~1MB.)
38*/
39
40#define code_header_mask ((0x3f<<26) | subtag_code_vector)
41#endif
42#endif
43
44#ifdef X86
45#ifdef X8664
46#define is_node_fulltag(f)  ((1<<(f))&((1<<fulltag_cons)    | \
47                                       (1<<fulltag_tra_0)   | \
48                                       (1<<fulltag_tra_1)   | \
49                                       (1<<fulltag_misc)    | \
50                                       (1<<fulltag_symbol)  | \
51                                       (1<<fulltag_function)))
52#else
53#define is_node_fulltag(f)  ((1<<(f))&((1<<fulltag_cons) | \
54                                       (1<<fulltag_misc) | \
55                                       (1<<fulltag_tra)))
56#endif
57#endif
58
59#ifdef ARM
60#define is_node_fulltag(f)  ((1<<(f))&((1<<fulltag_cons)|(1<<fulltag_misc)))
61#endif
62
63extern void zero_memory_range(BytePtr,BytePtr);
64extern LispObj GCarealow, GCareadynamiclow;
65extern natural GCndnodes_in_area, GCndynamic_dnodes_in_area;
66extern bitvector GCmarkbits, GCdynamic_markbits,managed_static_refbits,global_refidx,dynamic_refidx,managed_static_refidx;
67LispObj *global_reloctab, *GCrelocptr;
68LispObj GCfirstunmarked;
69
70extern natural lisp_heap_gc_threshold;
71extern natural lisp_heap_notify_threshold;
72void mark_root(LispObj);
73void mark_pc_root(LispObj);
74void mark_locative_root(LispObj);
75void rmark(LispObj);
76LispObj *skip_over_ivector(LispObj, LispObj);
77void mark_simple_area_range(LispObj *,LispObj *);
78LispObj calculate_relocation();
79LispObj locative_forwarding_address(LispObj);
80LispObj node_forwarding_address(LispObj);
81void forward_range(LispObj *, LispObj *);
82void forward_tcr_xframes(TCR *);
83void note_memoized_references(ExceptionInformation *,LogicalAddress, LogicalAddress, BytePtr *, BytePtr *);
84void gc(TCR *, signed_natural);
85int change_hons_area_size(TCR *, signed_natural);
86void delete_protected_area(protected_area_ptr);
87Boolean egc_control(Boolean, BytePtr);
88Boolean free_segments_zero_filled_by_OS;
89
90/* an type representing 1/4 of a natural word */
91#if WORD_SIZE == 64
92typedef unsigned short qnode;
93#else
94typedef unsigned char qnode;
95#endif
96
97
98#ifdef fulltag_symbol
99#define is_symbol_fulltag(x) (fulltag_of(x) == fulltag_symbol)
100#else
101#define is_symbol_fulltag(x) (fulltag_of(x) == fulltag_misc)
102#endif
103
104#define area_dnode(w,low) ((natural)(((ptr_to_lispobj(w)) - ptr_to_lispobj(low))>>dnode_shift))
105#define gc_area_dnode(w)  area_dnode(w,GCarealow)
106#define gc_dynamic_area_dnode(w) area_dnode(w,GCareadynamiclow)
107
108#if defined(PPC64) || defined(X8632)
109#define forward_marker subtag_forward_marker
110#else
111#ifdef ARM
112#define forward_marker (0xe7fffff0|uuo_format_unary)
113#else
114#define forward_marker fulltag_nil
115#endif
116#endif
117
118#ifdef PPC64
119#define VOID_ALLOCPTR ((LispObj)(0x8000000000000000-dnode_size))
120#else
121#define VOID_ALLOCPTR ((LispObj)(-dnode_size))
122#endif
123
124#ifndef WINDOWS
125#include <sys/resource.h>
126typedef struct rusage paging_info;
127#else
128typedef natural paging_info;
129#endif
130
131#undef __argv
132#include <stdio.h>
133
134void sample_paging_info(paging_info *);
135void report_paging_info_delta(FILE*, paging_info *, paging_info *);
136
137
138#define GC_TRAP_FUNCTION_IMMEDIATE_GC (-1)
139#define GC_TRAP_FUNCTION_GC 0
140#define GC_TRAP_FUNCTION_PURIFY 1
141#define GC_TRAP_FUNCTION_IMPURIFY 2
142#define GC_TRAP_FUNCTION_FLASH_FREEZE 4
143#define GC_TRAP_FUNCTION_SAVE_APPLICATION 8
144
145#define GC_TRAP_FUNCTION_GET_LISP_HEAP_THRESHOLD 16
146#define GC_TRAP_FUNCTION_SET_LISP_HEAP_THRESHOLD 17
147#define GC_TRAP_FUNCTION_USE_LISP_HEAP_THRESHOLD 18
148#define GC_TRAP_FUNCTION_ENSURE_STATIC_CONSES 19
149#define GC_TRAP_FUNCTION_GET_GC_NOTIFICATION_THRESHOLD 20
150#define GC_TRAP_FUNCTION_SET_GC_NOTIFICATION_THRESHOLD 21
151#define GC_TRAP_FUNCTION_ALLOCATION_CONTROL 22
152#define GC_TRAP_FUNCTION_EGC_CONTROL 32
153#define GC_TRAP_FUNCTION_CONFIGURE_EGC 64
154#define GC_TRAP_FUNCTION_FREEZE 129
155#define GC_TRAP_FUNCTION_THAW 130
156
157Boolean GCDebug, GCverbose, just_purified_p;
158bitvector GCmarkbits, GCdynamic_markbits;
159LispObj GCarealow, GCareadynamiclow;
160natural GCndnodes_in_area, GCndynamic_dnodes_in_area;
161LispObj GCweakvll,GCdwsweakvll;
162LispObj GCephemeral_low;
163natural GCn_ephemeral_dnodes;
164natural GCstack_limit;
165
166#if WORD_SIZE == 64
167unsigned short *_one_bits;
168#else
169const unsigned char _one_bits[256];
170#endif
171
172#define one_bits(x) _one_bits[x]
173
174natural static_dnodes_for_area(area *a);
175void reapweakv(LispObj weakv);
176void reaphashv(LispObj hashv);
177Boolean mark_weak_hash_vector(hash_table_vector_header *hashp, natural elements);
178Boolean mark_weak_alist(LispObj weak_alist, int weak_type);
179void mark_tcr_tlb(TCR *);
180void mark_tcr_xframes(TCR *);
181void freeGCptrs(void);
182void reap_gcable_ptrs(void);
183unsigned short logcount16(unsigned short);
184void gc_init(void);
185LispObj node_forwarding_address(LispObj);
186Boolean update_noderef(LispObj *);
187void update_locref(LispObj *);
188void forward_gcable_ptrs(void);
189void forward_memoized_area(area *, natural, bitvector, bitvector);
190
191void forward_tcr_tlb(TCR *);
192void reclaim_static_dnodes(void);
193Boolean youngest_non_null_area_p(area *);
194void gc(TCR *, signed_natural);
195
196/* backend-interface */
197
198typedef void (*weak_mark_fun) (LispObj);
199weak_mark_fun mark_weak_htabv, dws_mark_weak_htabv;
200
201typedef void (*weak_process_fun)(void);
202
203weak_process_fun markhtabvs;
204
205
206#define hash_table_vector_header_count (sizeof(hash_table_vector_header)/sizeof(LispObj))
207
208void mark_root(LispObj);
209void rmark(LispObj);
210#ifdef X8632
211void mark_xp(ExceptionInformation *, natural);
212#else
213void mark_xp(ExceptionInformation *);
214#endif
215LispObj dnode_forwarding_address(natural, int);
216LispObj locative_forwarding_address(LispObj);
217void check_refmap_consistency(LispObj *, LispObj *, bitvector, bitvector);
218void check_all_areas(TCR *);
219void mark_tstack_area(area *);
220void mark_vstack_area(area *);
221void mark_cstack_area(area *);
222void mark_simple_area_range(LispObj *, LispObj *);
223void mark_memoized_area(area *, natural, bitvector);
224LispObj calculate_relocation(void);
225void forward_range(LispObj *, LispObj *);
226void forward_tstack_area(area *);
227void forward_vstack_area(area *);
228void forward_cstack_area(area *);
229LispObj compact_dynamic_heap(void);
230signed_natural purify(TCR *, signed_natural);
231signed_natural impurify(TCR *, signed_natural);
232signed_natural gc_like_from_xp(ExceptionInformation *, signed_natural(*fun)(TCR *, signed_natural), signed_natural);
233Boolean mark_ephemeral_root(LispObj);
234
235
236typedef enum {
237  xmacptr_flag_none = 0,        /* Maybe already disposed by Lisp */
238  xmacptr_flag_recursive_lock,  /* recursive-lock */
239  xmacptr_flag_ptr,             /* malloc/free */
240  xmacptr_flag_rwlock,          /* read/write lock */
241  xmacptr_flag_semaphore,        /* semaphore */
242  xmacptr_flag_user_first = 8,  /* first user-defined dispose fn */
243  xmacptr_flag_user_last = 16   /* exclusive upper bound */
244} xmacptr_flag;
245
246
247typedef void (*xmacptr_dispose_fn)(void *);
248
249extern xmacptr_dispose_fn xmacptr_dispose_functions[];
250
251extern bitvector global_mark_ref_bits, dynamic_mark_ref_bits, relocatable_mark_ref_bits;
252
253extern Boolean
254did_gc_notification_since_last_full_gc;
255
256
257
258#endif                          /* __GC_H__ */
Note: See TracBrowser for help on using the repository browser.