GC allocation trigger should be tuned to system RAM
[WebKit-https.git] / Source / JavaScriptCore / runtime / JSGlobalData.h
1 /*
2  * Copyright (C) 2008, 2009 Apple Inc. All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions
6  * are met:
7  *
8  * 1.  Redistributions of source code must retain the above copyright
9  *     notice, this list of conditions and the following disclaimer. 
10  * 2.  Redistributions in binary form must reproduce the above copyright
11  *     notice, this list of conditions and the following disclaimer in the
12  *     documentation and/or other materials provided with the distribution. 
13  * 3.  Neither the name of Apple Computer, Inc. ("Apple") nor the names of
14  *     its contributors may be used to endorse or promote products derived
15  *     from this software without specific prior written permission. 
16  *
17  * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
18  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
19  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
20  * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
21  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
22  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
23  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
24  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27  */
28
29 #ifndef JSGlobalData_h
30 #define JSGlobalData_h
31
32 #include "CachedTranscendentalFunction.h"
33 #include "DateInstanceCache.h"
34 #include "ExecutableAllocator.h"
35 #include "Heap.h"
36 #include "Intrinsic.h"
37 #include "JITStubs.h"
38 #include "JSValue.h"
39 #include "LLIntData.h"
40 #include "NumericStrings.h"
41 #include "SmallStrings.h"
42 #include "Strong.h"
43 #include "Terminator.h"
44 #include "TimeoutChecker.h"
45 #include "WeakRandom.h"
46 #include <wtf/BumpPointerAllocator.h>
47 #include <wtf/Forward.h>
48 #include <wtf/HashMap.h>
49 #include <wtf/RefCounted.h>
50 #include <wtf/SimpleStats.h>
51 #include <wtf/ThreadSpecific.h>
52 #include <wtf/WTFThreadData.h>
53 #if ENABLE(REGEXP_TRACING)
54 #include <wtf/ListHashSet.h>
55 #endif
56
57 struct OpaqueJSClass;
58 struct OpaqueJSClassContextData;
59
60 namespace JSC {
61
62     class CodeBlock;
63     class CommonIdentifiers;
64     class HandleStack;
65     class IdentifierTable;
66     class Interpreter;
67     class JSGlobalObject;
68     class JSObject;
69     class Keywords;
70     class LLIntOffsetsExtractor;
71     class NativeExecutable;
72     class ParserArena;
73     class RegExpCache;
74     class Stringifier;
75     class Structure;
76     class UString;
77 #if ENABLE(REGEXP_TRACING)
78     class RegExp;
79 #endif
80
81     struct HashTable;
82     struct Instruction;
83
84     struct DSTOffsetCache {
85         DSTOffsetCache()
86         {
87             reset();
88         }
89         
90         void reset()
91         {
92             offset = 0.0;
93             start = 0.0;
94             end = -1.0;
95             increment = 0.0;
96         }
97
98         double offset;
99         double start;
100         double end;
101         double increment;
102     };
103
104     enum ThreadStackType {
105         ThreadStackTypeLarge,
106         ThreadStackTypeSmall
107     };
108
109     struct TypedArrayDescriptor {
110         TypedArrayDescriptor()
111             : m_classInfo(0)
112             , m_storageOffset(0)
113             , m_lengthOffset(0)
114         {
115         }
116         TypedArrayDescriptor(const ClassInfo* classInfo, size_t storageOffset, size_t lengthOffset)
117             : m_classInfo(classInfo)
118             , m_storageOffset(storageOffset)
119             , m_lengthOffset(lengthOffset)
120         {
121         }
122         const ClassInfo* m_classInfo;
123         size_t m_storageOffset;
124         size_t m_lengthOffset;
125     };
126
127 #if ENABLE(DFG_JIT)
128     class ConservativeRoots;
129
130     struct ScratchBuffer {
131         ScratchBuffer()
132             : m_activeLength(0)
133         {
134         }
135
136         static ScratchBuffer* create(size_t size)
137         {
138             ScratchBuffer* result = new (fastMalloc(ScratchBuffer::allocationSize(size))) ScratchBuffer;
139
140             return result;
141         }
142
143         static size_t allocationSize(size_t bufferSize) { return sizeof(size_t) + bufferSize; }
144         void setActiveLength(size_t activeLength) { m_activeLength = activeLength; }
145         size_t activeLength() const { return m_activeLength; };
146         size_t* activeLengthPtr() { return &m_activeLength; };
147         void* dataBuffer() { return m_buffer; }
148
149         size_t m_activeLength;
150         void* m_buffer[0];
151     };
152 #endif
153
154     class JSGlobalData : public RefCounted<JSGlobalData> {
155     public:
156         // WebCore has a one-to-one mapping of threads to JSGlobalDatas;
157         // either create() or createLeaked() should only be called once
158         // on a thread, this is the 'default' JSGlobalData (it uses the
159         // thread's default string uniquing table from wtfThreadData).
160         // API contexts created using the new context group aware interface
161         // create APIContextGroup objects which require less locking of JSC
162         // than the old singleton APIShared JSGlobalData created for use by
163         // the original API.
164         enum GlobalDataType { Default, APIContextGroup, APIShared };
165         
166         struct ClientData {
167             JS_EXPORT_PRIVATE virtual ~ClientData() = 0;
168         };
169
170         bool isSharedInstance() { return globalDataType == APIShared; }
171         bool usingAPI() { return globalDataType != Default; }
172         static bool sharedInstanceExists();
173         JS_EXPORT_PRIVATE static JSGlobalData& sharedInstance();
174
175         JS_EXPORT_PRIVATE static PassRefPtr<JSGlobalData> create(ThreadStackType, HeapType = SmallHeap);
176         JS_EXPORT_PRIVATE static PassRefPtr<JSGlobalData> createLeaked(ThreadStackType, HeapType = SmallHeap);
177         static PassRefPtr<JSGlobalData> createContextGroup(ThreadStackType, HeapType = SmallHeap);
178         JS_EXPORT_PRIVATE ~JSGlobalData();
179
180         void makeUsableFromMultipleThreads() { heap.machineThreads().makeUsableFromMultipleThreads(); }
181
182         Heap heap; // The heap is our first data member to ensure that it's destructed after all the objects that reference it.
183
184         GlobalDataType globalDataType;
185         ClientData* clientData;
186         CallFrame* topCallFrame;
187
188         const HashTable* arrayConstructorTable;
189         const HashTable* arrayPrototypeTable;
190         const HashTable* booleanPrototypeTable;
191         const HashTable* dateTable;
192         const HashTable* dateConstructorTable;
193         const HashTable* errorPrototypeTable;
194         const HashTable* globalObjectTable;
195         const HashTable* jsonTable;
196         const HashTable* mathTable;
197         const HashTable* numberConstructorTable;
198         const HashTable* numberPrototypeTable;
199         const HashTable* objectConstructorTable;
200         const HashTable* objectPrototypeTable;
201         const HashTable* privateNamePrototypeTable;
202         const HashTable* regExpTable;
203         const HashTable* regExpConstructorTable;
204         const HashTable* regExpPrototypeTable;
205         const HashTable* stringTable;
206         const HashTable* stringConstructorTable;
207         
208         Strong<Structure> structureStructure;
209         Strong<Structure> debuggerActivationStructure;
210         Strong<Structure> activationStructure;
211         Strong<Structure> interruptedExecutionErrorStructure;
212         Strong<Structure> terminatedExecutionErrorStructure;
213         Strong<Structure> staticScopeStructure;
214         Strong<Structure> strictEvalActivationStructure;
215         Strong<Structure> stringStructure;
216         Strong<Structure> notAnObjectStructure;
217         Strong<Structure> propertyNameIteratorStructure;
218         Strong<Structure> getterSetterStructure;
219         Strong<Structure> apiWrapperStructure;
220         Strong<Structure> scopeChainNodeStructure;
221         Strong<Structure> executableStructure;
222         Strong<Structure> nativeExecutableStructure;
223         Strong<Structure> evalExecutableStructure;
224         Strong<Structure> programExecutableStructure;
225         Strong<Structure> functionExecutableStructure;
226         Strong<Structure> regExpStructure;
227         Strong<Structure> structureChainStructure;
228
229         IdentifierTable* identifierTable;
230         CommonIdentifiers* propertyNames;
231         const MarkedArgumentBuffer* emptyList; // Lists are supposed to be allocated on the stack to have their elements properly marked, which is not the case here - but this list has nothing to mark.
232         SmallStrings smallStrings;
233         NumericStrings numericStrings;
234         DateInstanceCache dateInstanceCache;
235         WTF::SimpleStats machineCodeBytesPerBytecodeWordForBaselineJIT;
236         Vector<CodeBlock*> codeBlocksBeingCompiled;
237         void startedCompiling(CodeBlock* codeBlock)
238         {
239             codeBlocksBeingCompiled.append(codeBlock);
240         }
241
242         void finishedCompiling(CodeBlock* codeBlock)
243         {
244             ASSERT_UNUSED(codeBlock, codeBlock == codeBlocksBeingCompiled.last());
245             codeBlocksBeingCompiled.removeLast();
246         }
247
248         void setInDefineOwnProperty(bool inDefineOwnProperty)
249         {
250             m_inDefineOwnProperty = inDefineOwnProperty;
251         }
252
253         bool isInDefineOwnProperty()
254         {
255             return m_inDefineOwnProperty;
256         }
257
258 #if ENABLE(ASSEMBLER)
259         ExecutableAllocator executableAllocator;
260 #endif
261
262 #if !ENABLE(JIT)
263         bool canUseJIT() { return false; } // interpreter only
264 #elif !ENABLE(CLASSIC_INTERPRETER) && !ENABLE(LLINT)
265         bool canUseJIT() { return true; } // jit only
266 #else
267         bool canUseJIT() { return m_canUseAssembler; }
268 #endif
269
270 #if !ENABLE(YARR_JIT)
271         bool canUseRegExpJIT() { return false; } // interpreter only
272 #elif !ENABLE(CLASSIC_INTERPRETER) && !ENABLE(LLINT)
273         bool canUseRegExpJIT() { return true; } // jit only
274 #else
275         bool canUseRegExpJIT() { return m_canUseAssembler; }
276 #endif
277
278         OwnPtr<ParserArena> parserArena;
279         OwnPtr<Keywords> keywords;
280         Interpreter* interpreter;
281 #if ENABLE(JIT)
282         OwnPtr<JITThunks> jitStubs;
283         MacroAssemblerCodeRef getCTIStub(ThunkGenerator generator)
284         {
285             return jitStubs->ctiStub(this, generator);
286         }
287         NativeExecutable* getHostFunction(NativeFunction, Intrinsic);
288 #endif
289         NativeExecutable* getHostFunction(NativeFunction, NativeFunction constructor);
290
291         TimeoutChecker timeoutChecker;
292         Terminator terminator;
293
294         JSValue exception;
295
296         const ClassInfo* const jsArrayClassInfo;
297         const ClassInfo* const jsFinalObjectClassInfo;
298
299         LLInt::Data llintData;
300
301         ReturnAddressPtr exceptionLocation;
302         JSValue hostCallReturnValue;
303         CallFrame* callFrameForThrow;
304         void* targetMachinePCForThrow;
305         Instruction* targetInterpreterPCForThrow;
306 #if ENABLE(DFG_JIT)
307         uint32_t osrExitIndex;
308         void* osrExitJumpDestination;
309         Vector<ScratchBuffer*> scratchBuffers;
310         size_t sizeOfLastScratchBuffer;
311         
312         ScratchBuffer* scratchBufferForSize(size_t size)
313         {
314             if (!size)
315                 return 0;
316             
317             if (size > sizeOfLastScratchBuffer) {
318                 // Protect against a N^2 memory usage pathology by ensuring
319                 // that at worst, we get a geometric series, meaning that the
320                 // total memory usage is somewhere around
321                 // max(scratch buffer size) * 4.
322                 sizeOfLastScratchBuffer = size * 2;
323
324                 scratchBuffers.append(ScratchBuffer::create(sizeOfLastScratchBuffer));
325             }
326
327             ScratchBuffer* result = scratchBuffers.last();
328             result->setActiveLength(0);
329             return result;
330         }
331
332         void gatherConservativeRoots(ConservativeRoots&);
333 #endif
334
335         HashMap<OpaqueJSClass*, OwnPtr<OpaqueJSClassContextData> > opaqueJSClassData;
336
337         JSGlobalObject* dynamicGlobalObject;
338
339         HashSet<JSObject*> stringRecursionCheckVisitedObjects;
340
341         double cachedUTCOffset;
342         DSTOffsetCache dstOffsetCache;
343         
344         UString cachedDateString;
345         double cachedDateStringValue;
346
347         int maxReentryDepth;
348
349         RegExpCache* m_regExpCache;
350         BumpPointerAllocator m_regExpAllocator;
351
352 #if ENABLE(REGEXP_TRACING)
353         typedef ListHashSet<RefPtr<RegExp> > RTTraceList;
354         RTTraceList* m_rtTraceList;
355 #endif
356
357 #ifndef NDEBUG
358         ThreadIdentifier exclusiveThread;
359 #endif
360
361         CachedTranscendentalFunction<sin> cachedSin;
362
363         JS_EXPORT_PRIVATE void resetDateCache();
364
365         JS_EXPORT_PRIVATE void startSampling();
366         JS_EXPORT_PRIVATE void stopSampling();
367         JS_EXPORT_PRIVATE void dumpSampleData(ExecState* exec);
368         RegExpCache* regExpCache() { return m_regExpCache; }
369 #if ENABLE(REGEXP_TRACING)
370         void addRegExpToTrace(PassRefPtr<RegExp> regExp);
371 #endif
372         JS_EXPORT_PRIVATE void dumpRegExpTrace();
373
374         bool isCollectorBusy() { return heap.isBusy(); }
375         JS_EXPORT_PRIVATE void releaseExecutableMemory();
376
377 #if ENABLE(GC_VALIDATION)
378         bool isInitializingObject() const; 
379         void setInitializingObjectClass(const ClassInfo*);
380 #endif
381
382 #if CPU(X86) && ENABLE(JIT)
383         unsigned m_timeoutCount;
384 #endif
385
386 #define registerTypedArrayFunction(type, capitalizedType) \
387         void registerTypedArrayDescriptor(const capitalizedType##Array*, const TypedArrayDescriptor& descriptor) \
388         { \
389             ASSERT(!m_##type##ArrayDescriptor.m_classInfo || m_##type##ArrayDescriptor.m_classInfo == descriptor.m_classInfo); \
390             m_##type##ArrayDescriptor = descriptor; \
391         } \
392         const TypedArrayDescriptor& type##ArrayDescriptor() const { ASSERT(m_##type##ArrayDescriptor.m_classInfo); return m_##type##ArrayDescriptor; }
393
394         registerTypedArrayFunction(int8, Int8);
395         registerTypedArrayFunction(int16, Int16);
396         registerTypedArrayFunction(int32, Int32);
397         registerTypedArrayFunction(uint8, Uint8);
398         registerTypedArrayFunction(uint8Clamped, Uint8Clamped);
399         registerTypedArrayFunction(uint16, Uint16);
400         registerTypedArrayFunction(uint32, Uint32);
401         registerTypedArrayFunction(float32, Float32);
402         registerTypedArrayFunction(float64, Float64);
403 #undef registerTypedArrayFunction
404
405     private:
406         friend class LLIntOffsetsExtractor;
407         
408         JSGlobalData(GlobalDataType, ThreadStackType, HeapType);
409         static JSGlobalData*& sharedInstanceInternal();
410         void createNativeThunk();
411 #if ENABLE(ASSEMBLER) && (ENABLE(CLASSIC_INTERPRETER) || ENABLE(LLINT))
412         bool m_canUseAssembler;
413 #endif
414 #if ENABLE(GC_VALIDATION)
415         const ClassInfo* m_initializingObjectClass;
416 #endif
417         bool m_inDefineOwnProperty;
418
419         TypedArrayDescriptor m_int8ArrayDescriptor;
420         TypedArrayDescriptor m_int16ArrayDescriptor;
421         TypedArrayDescriptor m_int32ArrayDescriptor;
422         TypedArrayDescriptor m_uint8ArrayDescriptor;
423         TypedArrayDescriptor m_uint8ClampedArrayDescriptor;
424         TypedArrayDescriptor m_uint16ArrayDescriptor;
425         TypedArrayDescriptor m_uint32ArrayDescriptor;
426         TypedArrayDescriptor m_float32ArrayDescriptor;
427         TypedArrayDescriptor m_float64ArrayDescriptor;
428     };
429
430 #if ENABLE(GC_VALIDATION)
431     inline bool JSGlobalData::isInitializingObject() const
432     {
433         return !!m_initializingObjectClass;
434     }
435
436     inline void JSGlobalData::setInitializingObjectClass(const ClassInfo* initializingObjectClass)
437     {
438         m_initializingObjectClass = initializingObjectClass;
439     }
440 #endif
441
442 } // namespace JSC
443
444 #endif // JSGlobalData_h