The Tor Browser / file comparison

comparison: js/src/jsapi-tests/testGCFinalizeCallback.cpp

js/src/jsapi-tests/testGCFinalizeCallback.cpp

changeset 0
6474c204b198
equal deleted inserted replaced
-1:000000000000 0:008f9da7c621
1 /* This Source Code Form is subject to the terms of the Mozilla Public
2 * License, v. 2.0. If a copy of the MPL was not distributed with this
3 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
4
5 #include "jsapi-tests/tests.h"
6
7 static const unsigned BufferSize = 20;
8 static unsigned FinalizeCalls = 0;
9 static JSFinalizeStatus StatusBuffer[BufferSize];
10 static bool IsCompartmentGCBuffer[BufferSize];
11
12 BEGIN_TEST(testGCFinalizeCallback)
13 {
14 JS_SetGCParameter(rt, JSGC_MODE, JSGC_MODE_INCREMENTAL);
15 JS_SetFinalizeCallback(rt, FinalizeCallback);
16
17 /* Full GC, non-incremental. */
18 FinalizeCalls = 0;
19 JS_GC(rt);
20 CHECK(rt->gcIsFull);
21 CHECK(checkSingleGroup());
22 CHECK(checkFinalizeStatus());
23 CHECK(checkFinalizeIsCompartmentGC(false));
24
25 /* Full GC, incremental. */
26 FinalizeCalls = 0;
27 JS::PrepareForFullGC(rt);
28 JS::IncrementalGC(rt, JS::gcreason::API, 1000000);
29 CHECK(rt->gcIncrementalState == js::gc::NO_INCREMENTAL);
30 CHECK(rt->gcIsFull);
31 CHECK(checkMultipleGroups());
32 CHECK(checkFinalizeStatus());
33 CHECK(checkFinalizeIsCompartmentGC(false));
34
35 JS::RootedObject global1(cx, createGlobal());
36 JS::RootedObject global2(cx, createGlobal());
37 JS::RootedObject global3(cx, createGlobal());
38 CHECK(global1);
39 CHECK(global2);
40 CHECK(global3);
41
42 /* Compartment GC, non-incremental, single compartment. */
43 FinalizeCalls = 0;
44 JS::PrepareZoneForGC(global1->zone());
45 JS::GCForReason(rt, JS::gcreason::API);
46 CHECK(!rt->gcIsFull);
47 CHECK(checkSingleGroup());
48 CHECK(checkFinalizeStatus());
49 CHECK(checkFinalizeIsCompartmentGC(true));
50
51 /* Compartment GC, non-incremental, multiple compartments. */
52 FinalizeCalls = 0;
53 JS::PrepareZoneForGC(global1->zone());
54 JS::PrepareZoneForGC(global2->zone());
55 JS::PrepareZoneForGC(global3->zone());
56 JS::GCForReason(rt, JS::gcreason::API);
57 CHECK(!rt->gcIsFull);
58 CHECK(checkSingleGroup());
59 CHECK(checkFinalizeStatus());
60 CHECK(checkFinalizeIsCompartmentGC(true));
61
62 /* Compartment GC, incremental, single compartment. */
63 FinalizeCalls = 0;
64 JS::PrepareZoneForGC(global1->zone());
65 JS::IncrementalGC(rt, JS::gcreason::API, 1000000);
66 CHECK(rt->gcIncrementalState == js::gc::NO_INCREMENTAL);
67 CHECK(!rt->gcIsFull);
68 CHECK(checkSingleGroup());
69 CHECK(checkFinalizeStatus());
70 CHECK(checkFinalizeIsCompartmentGC(true));
71
72 /* Compartment GC, incremental, multiple compartments. */
73 FinalizeCalls = 0;
74 JS::PrepareZoneForGC(global1->zone());
75 JS::PrepareZoneForGC(global2->zone());
76 JS::PrepareZoneForGC(global3->zone());
77 JS::IncrementalGC(rt, JS::gcreason::API, 1000000);
78 CHECK(rt->gcIncrementalState == js::gc::NO_INCREMENTAL);
79 CHECK(!rt->gcIsFull);
80 CHECK(checkMultipleGroups());
81 CHECK(checkFinalizeStatus());
82 CHECK(checkFinalizeIsCompartmentGC(true));
83
84 #ifdef JS_GC_ZEAL
85
86 /* Full GC with reset due to new compartment, becoming compartment GC. */
87
88 FinalizeCalls = 0;
89 JS_SetGCZeal(cx, 9, 1000000);
90 JS::PrepareForFullGC(rt);
91 js::GCDebugSlice(rt, true, 1);
92 CHECK(rt->gcIncrementalState == js::gc::MARK);
93 CHECK(rt->gcIsFull);
94
95 JS::RootedObject global4(cx, createGlobal());
96 js::GCDebugSlice(rt, true, 1);
97 CHECK(rt->gcIncrementalState == js::gc::NO_INCREMENTAL);
98 CHECK(!rt->gcIsFull);
99 CHECK(checkMultipleGroups());
100 CHECK(checkFinalizeStatus());
101
102 for (unsigned i = 0; i < FinalizeCalls - 1; ++i)
103 CHECK(!IsCompartmentGCBuffer[i]);
104 CHECK(IsCompartmentGCBuffer[FinalizeCalls - 1]);
105
106 JS_SetGCZeal(cx, 0, 0);
107
108 #endif
109
110 /*
111 * Make some use of the globals here to ensure the compiler doesn't optimize
112 * them away in release builds, causing the compartments to be collected and
113 * the test to fail.
114 */
115 CHECK(JS_IsGlobalObject(global1));
116 CHECK(JS_IsGlobalObject(global2));
117 CHECK(JS_IsGlobalObject(global3));
118
119 JS_SetFinalizeCallback(rt, nullptr);
120 return true;
121 }
122
123 bool checkSingleGroup()
124 {
125 CHECK(FinalizeCalls < BufferSize);
126 CHECK(FinalizeCalls == 3);
127 return true;
128 }
129
130 bool checkMultipleGroups()
131 {
132 CHECK(FinalizeCalls < BufferSize);
133 CHECK(FinalizeCalls % 2 == 1);
134 CHECK((FinalizeCalls - 1) / 2 > 1);
135 return true;
136 }
137
138 bool checkFinalizeStatus()
139 {
140 /*
141 * The finalize callback should be called twice for each compartment group
142 * finalized, with status JSFINALIZE_GROUP_START and JSFINALIZE_GROUP_END,
143 * and then once more with JSFINALIZE_COLLECTION_END.
144 */
145
146 for (unsigned i = 0; i < FinalizeCalls - 1; i += 2) {
147 CHECK(StatusBuffer[i] == JSFINALIZE_GROUP_START);
148 CHECK(StatusBuffer[i + 1] == JSFINALIZE_GROUP_END);
149 }
150
151 CHECK(StatusBuffer[FinalizeCalls - 1] == JSFINALIZE_COLLECTION_END);
152
153 return true;
154 }
155
156 bool checkFinalizeIsCompartmentGC(bool isCompartmentGC)
157 {
158 for (unsigned i = 0; i < FinalizeCalls; ++i)
159 CHECK(IsCompartmentGCBuffer[i] == isCompartmentGC);
160
161 return true;
162 }
163
164 static void
165 FinalizeCallback(JSFreeOp *fop, JSFinalizeStatus status, bool isCompartmentGC)
166 {
167 if (FinalizeCalls < BufferSize) {
168 StatusBuffer[FinalizeCalls] = status;
169 IsCompartmentGCBuffer[FinalizeCalls] = isCompartmentGC;
170 }
171 ++FinalizeCalls;
172 }
173 END_TEST(testGCFinalizeCallback)

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial