1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
|
/*
* Copyright (c) 2011 by Hewlett-Packard Company. All rights reserved.
*
* THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED
* OR IMPLIED. ANY USE IS AT YOUR OWN RISK.
*
* Permission is hereby granted to use or copy this program
* for any purpose, provided the above notices are retained on all copies.
* Permission to modify the code and to distribute modified code is granted,
* provided the above notices are retained, and a notice that the code was
* modified is included with the above copyright notice.
*
*/
#include "private/gc_priv.h"
#ifdef ENABLE_DISCLAIM
#include "gc_disclaim.h"
#ifdef THREAD_LOCAL_ALLOC
# include "private/thread_local_alloc.h"
#else
STATIC ptr_t * GC_finalized_objfreelist = NULL;
#endif /* !THREAD_LOCAL_ALLOC */
STATIC int GC_finalized_kind = 0;
STATIC int GC_CALLBACK GC_finalized_disclaim(void *obj,
void *cd GC_ATTR_UNUSED)
{
struct GC_finalizer_closure *fc = *(void **)obj;
if (((word)fc & 1) != 0) {
/* [1] The disclaim function may be passed fragments from the */
/* free-list, on which it should not run finalization. */
/* To recognize this case, we use the fact that the first word */
/* on such fragments are always even (a link to the next */
/* fragment, or NULL). If it is desirable to have a finalizer */
/* which does not use the first word for storing finalization */
/* info, GC_reclaim_with_finalization must be extended to clear */
/* fragments so that the assumption holds for the selected word. */
fc = (void *)((word)fc & ~(word)1);
(*fc->proc)((void **)obj + 1, fc->cd);
}
return 0;
}
static GC_bool done_init = FALSE;
GC_API void GC_CALL GC_init_finalized_malloc(void)
{
DCL_LOCK_STATE;
GC_init(); /* In case it's not already done. */
LOCK();
if (done_init) {
UNLOCK();
return;
}
done_init = TRUE;
GC_finalized_objfreelist = (ptr_t *)GC_new_free_list_inner();
GC_finalized_kind = GC_new_kind_inner((void **)GC_finalized_objfreelist,
GC_DS_LENGTH, TRUE, TRUE);
GC_register_disclaim_proc(GC_finalized_kind, GC_finalized_disclaim,
NULL, TRUE);
UNLOCK();
}
#ifdef THREAD_LOCAL_ALLOC
STATIC void * GC_core_finalized_malloc(size_t lb,
const struct GC_finalizer_closure *fclos)
#else
GC_API void * GC_CALL GC_finalized_malloc(size_t lb,
const struct GC_finalizer_closure *fclos)
#endif
{
ptr_t op;
ptr_t *opp;
word lg;
DCL_LOCK_STATE;
lb += sizeof(void *);
GC_ASSERT(done_init);
if (EXPECT(SMALL_OBJ(lb), TRUE)) {
lg = GC_size_map[lb];
opp = &GC_finalized_objfreelist[lg];
LOCK();
if (EXPECT((op = *opp) == 0, FALSE)) {
UNLOCK();
op = GC_generic_malloc((word)lb, GC_finalized_kind);
} else {
*opp = obj_link(op);
obj_link(op) = 0;
GC_bytes_allocd += GRANULES_TO_BYTES(lg);
UNLOCK();
}
} else {
op = GC_generic_malloc((word)lb, GC_finalized_kind);
}
*(void **)op = (ptr_t)fclos + 1; /* See [1] */
return GC_clear_stack(op + sizeof(void *));
}
#ifdef THREAD_LOCAL_ALLOC
GC_API void * GC_CALL GC_finalized_malloc(size_t client_lb,
const struct GC_finalizer_closure *fclos)
{
size_t lb = client_lb + sizeof(void *);
size_t lg = ROUNDED_UP_GRANULES(lb);
GC_tlfs tsd;
void *result;
void **tiny_fl, **my_fl, *my_entry;
void *next;
if (EXPECT(lg >= GC_TINY_FREELISTS, FALSE))
return GC_core_finalized_malloc(client_lb, fclos);
tsd = GC_getspecific(GC_thread_key);
tiny_fl = tsd->finalized_freelists;
my_fl = tiny_fl + lg;
my_entry = *my_fl;
while (EXPECT((word)my_entry
<= DIRECT_GRANULES + GC_TINY_FREELISTS + 1, FALSE)) {
if ((word)my_entry - 1 < DIRECT_GRANULES) {
*my_fl = (ptr_t)my_entry + lg + 1;
return GC_core_finalized_malloc(client_lb, fclos);
} else {
GC_generic_malloc_many(GC_RAW_BYTES_FROM_INDEX(lg),
GC_finalized_kind, my_fl);
my_entry = *my_fl;
if (my_entry == 0) {
GC_oom_func oom_fn;
LOCK();
oom_fn = GC_oom_fn;
UNLOCK();
return((*oom_fn)(lb));
}
}
}
next = obj_link(my_entry);
result = (void *)my_entry;
*my_fl = next;
*(void **)result = (ptr_t)fclos + 1;
PREFETCH_FOR_WRITE(next);
return (void **)result + 1;
}
#endif /* THREAD_LOCAL_ALLOC */
#endif /* ENABLE_DISCLAIM */
|
