source: release/1.9/source/lisp-kernel/gc.h @ 16083

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

Ensure that darwin_sigreturn() is prototyped on platforms where it's
used.

Remove some remaining Mach-isms (notably the paging info stuff used
by GC-VERBOSE; just use getrusage()).

Make sure that the right headers are included in threads.h, to support
the remaining Mach-ism (use of Mach semaphores. Apple still doesn't
implement POSIX semaphores, though the functions have been prototyped
for several years now.)

This builds without warnings or errors on 10.8.1 with Xcode 4.4's
toolchain. It -may- address the problems described in ticket:1019.

  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 7.7 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;
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);
190void forward_tcr_tlb(TCR *);
191void reclaim_static_dnodes(void);
192Boolean youngest_non_null_area_p(area *);
193void gc(TCR *, signed_natural);
194
195/* backend-interface */
196
197typedef void (*weak_mark_fun) (LispObj);
198weak_mark_fun mark_weak_htabv, dws_mark_weak_htabv;
199
200typedef void (*weak_process_fun)(void);
201
202weak_process_fun markhtabvs;
203
204
205#define hash_table_vector_header_count (sizeof(hash_table_vector_header)/sizeof(LispObj))
206
207void mark_root(LispObj);
208void rmark(LispObj);
209#ifdef X8632
210void mark_xp(ExceptionInformation *, natural);
211#else
212void mark_xp(ExceptionInformation *);
213#endif
214LispObj dnode_forwarding_address(natural, int);
215LispObj locative_forwarding_address(LispObj);
216void check_refmap_consistency(LispObj *, LispObj *, bitvector);
217void check_all_areas(TCR *);
218void mark_tstack_area(area *);
219void mark_vstack_area(area *);
220void mark_cstack_area(area *);
221void mark_simple_area_range(LispObj *, LispObj *);
222void mark_memoized_area(area *, natural);
223LispObj calculate_relocation(void);
224void forward_range(LispObj *, LispObj *);
225void forward_tstack_area(area *);
226void forward_vstack_area(area *);
227void forward_cstack_area(area *);
228LispObj compact_dynamic_heap(void);
229signed_natural purify(TCR *, signed_natural);
230signed_natural impurify(TCR *, signed_natural);
231signed_natural gc_like_from_xp(ExceptionInformation *, signed_natural(*fun)(TCR *, signed_natural), signed_natural);
232Boolean mark_ephemeral_root(LispObj);
233
234
235typedef enum {
236  xmacptr_flag_none = 0,        /* Maybe already disposed by Lisp */
237  xmacptr_flag_recursive_lock,  /* recursive-lock */
238  xmacptr_flag_ptr,             /* malloc/free */
239  xmacptr_flag_rwlock,          /* read/write lock */
240  xmacptr_flag_semaphore,        /* semaphore */
241  xmacptr_flag_user_first = 8,  /* first user-defined dispose fn */
242  xmacptr_flag_user_last = 16   /* exclusive upper bound */
243} xmacptr_flag;
244
245
246typedef void (*xmacptr_dispose_fn)(void *);
247
248extern xmacptr_dispose_fn xmacptr_dispose_functions[];
249
250extern bitvector global_mark_ref_bits, dynamic_mark_ref_bits, relocatable_mark_ref_bits;
251
252extern Boolean
253did_gc_notification_since_last_full_gc;
254
255#endif                          /* __GC_H__ */
Note: See TracBrowser for help on using the repository browser.