Attachment 295340 Details for Bug 164990 – fixed CodeBlockSet and InferredValue

[patch] fixed CodeBlockSet and InferredValue

blah.patch (text/plain), 19.93 KB, created by Filip Pizlo on 2016-11-22 12:58:11 PST

(hide)

Description:

Filename:

MIME Type:

Creator: Filip Pizlo

Created: 2016-11-22 12:58:11 PST

Size: 19.93 KB

patch

obsolete

>Index: PerformanceTests/JetStream/cdjs/benchmark.js
>===================================================================
>--- PerformanceTests/JetStream/cdjs/benchmark.js	(revision 208897)
>+++ PerformanceTests/JetStream/cdjs/benchmark.js	(working copy)
>@@ -29,6 +29,7 @@ function benchmarkImpl(configuration) {
>     var numFrames = configuration.numFrames;
>     var expectedCollisions = configuration.expectedCollisions;
>     var percentile = configuration.percentile;
>+    var exclude = configuration.exclude;
> 
>     var simulator = new Simulator(numAircraft);
>     var detector = new CollisionDetector();
>@@ -46,10 +47,13 @@ function benchmarkImpl(configuration) {
>             time: after - before,
>             numCollisions: collisions.length
>         };
>+        print("CDjs: " + result.time);
>         if (verbosity >= 2)
>             result.collisions = collisions;
>         results.push(result);
>     }
>+    
>+    results.splice(0, exclude);
> 
>     if (verbosity >= 1) {
>         for (var i = 0; i < results.length; ++i) {
>@@ -85,17 +89,30 @@ function benchmark() {
>         numAircraft: 1000,
>         numFrames: 200,
>         expectedCollisions: 14484,
>-        percentile: 95
>+        percentile: 95,
>+        exclude: 0
>     });
> }
> 
>-function largeBenchmark() {
>+function longBenchmark() {
>     return benchmarkImpl({
>         verbosity: 0,
>+        numAircraft: 1000,
>+        numFrames: 20000,
>+        expectedCollisions: 697299,
>+        percentile: 99.5,
>+        exclude: 0
>+    });
>+}
>+
>+function largeBenchmark() {
>+    return benchmarkImpl({
>+        verbosity: 1,
>         numAircraft: 20000,
>-        numFrames: 100,
>-        expectedCollisions: 5827,
>-        percentile: 95
>+        numFrames: 110,
>+        expectedCollisions: 7316,
>+        percentile: 97,
>+        exclude: 10
>     });
> }
> 
>Index: Source/JavaScriptCore/heap/CodeBlockSet.cpp
>===================================================================
>--- Source/JavaScriptCore/heap/CodeBlockSet.cpp	(revision 208897)
>+++ Source/JavaScriptCore/heap/CodeBlockSet.cpp	(working copy)
>@@ -61,10 +61,6 @@ void CodeBlockSet::clearMarksForFullColl
>     LockHolder locker(&m_lock);
>     for (CodeBlock* codeBlock : m_oldCodeBlocks)
>         codeBlock->clearVisitWeaklyHasBeenCalled();
>-
>-    // We promote after we clear marks on the old generation CodeBlocks because
>-    // none of the young generations CodeBlocks need to be cleared.
>-    promoteYoungCodeBlocks(locker);
> }
> 
> void CodeBlockSet::lastChanceToFinalize()
>@@ -80,17 +76,29 @@ void CodeBlockSet::lastChanceToFinalize(
> void CodeBlockSet::deleteUnmarkedAndUnreferenced(CollectionScope scope)
> {
>     LockHolder locker(&m_lock);
>-    HashSet<CodeBlock*>& set = scope == CollectionScope::Eden ? m_newCodeBlocks : m_oldCodeBlocks;
>     Vector<CodeBlock*> unmarked;
>-    for (CodeBlock* codeBlock : set) {
>-        if (Heap::isMarked(codeBlock))
>-            continue;
>-        unmarked.append(codeBlock);
>-    }
>-
>-    for (CodeBlock* codeBlock : unmarked) {
>-        codeBlock->classInfo()->methodTable.destroy(codeBlock);
>-        set.remove(codeBlock);
>+    
>+    auto consider = [&] (HashSet<CodeBlock*>& set) {
>+        for (CodeBlock* codeBlock : set) {
>+            if (Heap::isMarked(codeBlock))
>+                continue;;
>+            unmarked.append(codeBlock);
>+        }
>+        for (CodeBlock* codeBlock : unmarked) {
>+            codeBlock->classInfo()->methodTable.destroy(codeBlock);
>+            set.remove(codeBlock);
>+        }
>+        unmarked.resize(0);
>+    };
>+
>+    switch (scope) {
>+    case CollectionScope::Eden:
>+        consider(m_newCodeBlocks);
>+        break;
>+    case CollectionScope::Full:
>+        consider(m_oldCodeBlocks);
>+        consider(m_newCodeBlocks);
>+        break;
>     }
> 
>     // Any remaining young CodeBlocks are live and need to be promoted to the set of old CodeBlocks.
>Index: Source/JavaScriptCore/heap/Heap.cpp
>===================================================================
>--- Source/JavaScriptCore/heap/Heap.cpp	(revision 208897)
>+++ Source/JavaScriptCore/heap/Heap.cpp	(working copy)
>@@ -82,7 +82,8 @@ namespace {
> 
> double maxPauseMS(double thisPauseMS)
> {
>-    static double maxPauseMS = std::max(thisPauseMS, maxPauseMS);
>+    static double maxPauseMS;
>+    maxPauseMS = std::max(thisPauseMS, maxPauseMS);
>     return maxPauseMS;
> }
> 
>@@ -346,6 +347,15 @@ void Heap::lastChanceToFinalize()
>     RELEASE_ASSERT(!m_vm->entryScope);
>     RELEASE_ASSERT(m_mutatorState == MutatorState::Running);
>     
>+    if (m_collectContinuouslyThread) {
>+        {
>+            LockHolder locker(m_collectContinuouslyLock);
>+            m_shouldStopCollectingContinuously = true;
>+            m_collectContinuouslyCondition.notifyOne();
>+        }
>+        waitForThreadCompletion(m_collectContinuouslyThread);
>+    }
>+    
>     // Carefully bring the thread down. We need to use waitForCollector() until we know that there
>     // won't be any other collections.
>     bool stopped = false;
>@@ -624,6 +634,7 @@ void Heap::markToFixpoint(double gcStart
>         MonotonicTime topOfLoop = MonotonicTime::now();
>         {
>             TimingScope preConvergenceTimingScope(*this, "Heap::markToFixpoint conservative scan");
>+            m_objectSpace.prepareForConservativeScan();
>             ConservativeRoots conservativeRoots(*this);
>             SuperSamplerScope superSamplerScope(false);
>             gatherStackRoots(conservativeRoots);
>@@ -1204,7 +1215,7 @@ void Heap::collectInThread()
>     m_codeBlocks->writeBarrierCurrentlyExecuting(this);
>     m_codeBlocks->clearCurrentlyExecuting();
>         
>-    prepareForAllocation();
>+    m_objectSpace.prepareForAllocation();
>     updateAllocationLimits();
> 
>     didFinishCollection(gcStartTime);
>@@ -1356,6 +1367,8 @@ bool Heap::stopIfNecessarySlow(unsigned 
>         return true;
>     }
>     
>+    sanitizeStackForVM(m_vm);
>+
>     m_worldState.compareExchangeStrong(oldState, oldState | stoppedBit);
>     ParkingLot::unparkAll(&m_worldState);
>     ParkingLot::compareAndPark(&m_worldState, oldState | stoppedBit);
>@@ -1536,8 +1549,6 @@ void Heap::finalize()
>         sweepLargeAllocations();
>     }
>     
>-    if (Options::collectContinuously())
>-        collectAsync();
>     if (HasOwnPropertyCache* cache = vm()->hasOwnPropertyCache())
>         cache->clear();
> }
>@@ -1549,8 +1560,6 @@ Heap::Ticket Heap::requestCollection(Opt
>     ASSERT(vm()->currentThreadIsHoldingAPILock());
>     RELEASE_ASSERT(vm()->atomicStringTable() == wtfThreadData().atomicStringTable());
>     
>-    sanitizeStackForVM(m_vm);
>-
>     LockHolder locker(*m_threadLock);
>     m_requests.append(scope);
>     m_lastGrantedTicket++;
>@@ -1668,11 +1677,6 @@ void Heap::notifyIncrementalSweeper()
>     m_sweeper->startSweeping();
> }
> 
>-void Heap::prepareForAllocation()
>-{
>-    m_objectSpace.prepareForAllocation();
>-}
>-
> void Heap::updateAllocationLimits()
> {
>     static const bool verbose = false;
>@@ -2137,8 +2141,37 @@ void Heap::setRunLoop(CFRunLoopRef runLo
> void Heap::notifyIsSafeToCollect()
> {
>     m_isSafeToCollect = true;
>-    if (Options::collectContinuously())
>-        collectAsync();
>+    
>+    if (Options::collectContinuously()) {
>+        m_collectContinuouslyThread = createThread(
>+            "JSC DEBUG Continuous GC",
>+            [this] () {
>+                MonotonicTime initialTime = MonotonicTime::now();
>+                Seconds period = Seconds::fromMilliseconds(Options::collectContinuouslyPeriodMS());
>+                for (;;) {
>+                    {
>+                        LockHolder locker(m_collectContinuouslyLock);
>+                        Seconds elapsed = MonotonicTime::now() - initialTime;
>+                        Seconds elapsedInPeriod = elapsed % period;
>+                        MonotonicTime timeToWakeUp =
>+                            initialTime + elapsed - elapsedInPeriod + period;
>+                        while (!hasElapsed(timeToWakeUp) && !m_shouldStopCollectingContinuously) {
>+                            m_collectContinuouslyCondition.waitUntil(
>+                                m_collectContinuouslyLock, timeToWakeUp);
>+                        }
>+                    }
>+                    if (m_shouldStopCollectingContinuously)
>+                        return;
>+                    
>+                    LockHolder locker(*m_threadLock);
>+                    if (!m_requests.isEmpty())
>+                        continue;
>+                    m_requests.append(Nullopt);
>+                    m_lastGrantedTicket++;
>+                    m_threadCondition->notifyOne(locker);
>+                }
>+            });
>+    }
> }
> 
> } // namespace JSC
>Index: Source/JavaScriptCore/heap/Heap.h
>===================================================================
>--- Source/JavaScriptCore/heap/Heap.h	(revision 208897)
>+++ Source/JavaScriptCore/heap/Heap.h	(working copy)
>@@ -451,7 +451,6 @@ private:
>     void snapshotUnswept();
>     void deleteSourceProviderCaches();
>     void notifyIncrementalSweeper();
>-    void prepareForAllocation();
>     void harvestWeakReferences();
>     void finalizeUnconditionalFinalizers();
>     void clearUnmarkedExecutables();
>@@ -608,6 +607,11 @@ private:
>     RefPtr<AutomaticThreadCondition> m_threadCondition; // The mutator must not wait on this. It would cause a deadlock.
>     RefPtr<AutomaticThread> m_thread;
>     
>+    Lock m_collectContinuouslyLock;
>+    Condition m_collectContinuouslyCondition;
>+    bool m_shouldStopCollectingContinuously { false };
>+    ThreadIdentifier m_collectContinuouslyThread { 0 };
>+    
>     MonotonicTime m_lastGCStartTime;
>     MonotonicTime m_lastGCEndTime;
>     MonotonicTime m_currentGCStartTime;
>Index: Source/JavaScriptCore/heap/MarkedSpace.cpp
>===================================================================
>--- Source/JavaScriptCore/heap/MarkedSpace.cpp	(revision 208896)
>+++ Source/JavaScriptCore/heap/MarkedSpace.cpp	(working copy)
>@@ -393,16 +393,13 @@ void MarkedSpace::stopAllocating()
>         });
> }
> 
>-void MarkedSpace::prepareForMarking()
>+void MarkedSpace::prepareForConservativeScan()
> {
>-    if (m_heap->collectionScope() == CollectionScope::Eden)
>-        m_largeAllocationsOffsetForThisCollection = m_largeAllocationsNurseryOffset;
>-    else
>-        m_largeAllocationsOffsetForThisCollection = 0;
>     m_largeAllocationsForThisCollectionBegin = m_largeAllocations.begin() + m_largeAllocationsOffsetForThisCollection;
>     m_largeAllocationsForThisCollectionSize = m_largeAllocations.size() - m_largeAllocationsOffsetForThisCollection;
>     m_largeAllocationsForThisCollectionEnd = m_largeAllocations.end();
>     RELEASE_ASSERT(m_largeAllocationsForThisCollectionEnd == m_largeAllocationsForThisCollectionBegin + m_largeAllocationsForThisCollectionSize);
>+    
>     std::sort(
>         m_largeAllocationsForThisCollectionBegin, m_largeAllocationsForThisCollectionEnd,
>         [&] (LargeAllocation* a, LargeAllocation* b) {
>@@ -410,6 +407,14 @@ void MarkedSpace::prepareForMarking()
>         });
> }
> 
>+void MarkedSpace::prepareForMarking()
>+{
>+    if (m_heap->collectionScope() == CollectionScope::Eden)
>+        m_largeAllocationsOffsetForThisCollection = m_largeAllocationsNurseryOffset;
>+    else
>+        m_largeAllocationsOffsetForThisCollection = 0;
>+}
>+
> void MarkedSpace::resumeAllocating()
> {
>     forEachAllocator(
>Index: Source/JavaScriptCore/heap/MarkedSpace.h
>===================================================================
>--- Source/JavaScriptCore/heap/MarkedSpace.h	(revision 208896)
>+++ Source/JavaScriptCore/heap/MarkedSpace.h	(working copy)
>@@ -142,6 +142,8 @@ public:
>     void resumeAllocating(); // If we just stopped allocation but we didn't do a collection, we need to resume allocation.
>     
>     void prepareForMarking();
>+    
>+    void prepareForConservativeScan();
> 
>     typedef HashSet<MarkedBlock*>::iterator BlockIterator;
> 
>@@ -223,6 +225,7 @@ private:
>     bool m_isIterating;
>     bool m_isMarking { false };
>     MarkedBlockSet m_blocks;
>+    
>     Vector<LargeAllocation*> m_largeAllocations;
>     unsigned m_largeAllocationsNurseryOffset { 0 };
>     unsigned m_largeAllocationsOffsetForThisCollection { 0 };
>@@ -230,6 +233,7 @@ private:
>     LargeAllocation** m_largeAllocationsForThisCollectionBegin { nullptr };
>     LargeAllocation** m_largeAllocationsForThisCollectionEnd { nullptr };
>     unsigned m_largeAllocationsForThisCollectionSize { 0 };
>+    
>     SentinelLinkedList<WeakSet, BasicRawSentinelNode<WeakSet>> m_activeWeakSets;
>     SentinelLinkedList<WeakSet, BasicRawSentinelNode<WeakSet>> m_newActiveWeakSets;
>     
>Index: Source/JavaScriptCore/runtime/InferredValue.cpp
>===================================================================
>--- Source/JavaScriptCore/runtime/InferredValue.cpp	(revision 208896)
>+++ Source/JavaScriptCore/runtime/InferredValue.cpp	(working copy)
>@@ -119,10 +119,13 @@ InferredValue::ValueCleanup::~ValueClean
> 
> void InferredValue::ValueCleanup::finalizeUnconditionally()
> {
>-    ASSERT(m_owner->m_value);
>-    ASSERT(m_owner->m_value.get().isCell());
>+    JSValue value = m_owner->m_value.get();
>     
>-    if (Heap::isMarked(m_owner->m_value.get().asCell()))
>+    // Concurrent GC means that this could have changed since we installed the finalizer.
>+    if (!value || !value.isCell())
>+        return;
>+    
>+    if (Heap::isMarked(value.asCell()))
>         return;
>     
>     m_owner->invalidate(*m_owner->vm(), StringFireDetail("InferredValue clean-up during GC"));
>Index: Source/JavaScriptCore/runtime/Options.cpp
>===================================================================
>--- Source/JavaScriptCore/runtime/Options.cpp	(revision 208896)
>+++ Source/JavaScriptCore/runtime/Options.cpp	(working copy)
>@@ -328,6 +328,10 @@ static void recomputeDependentOptions()
>     Options::useFTLJIT() = false;
> #endif
>     
>+#if !CPU(X86_64)
>+    Options::useConcurrentGC() = false;
>+#endif
>+    
> #if OS(WINDOWS) && CPU(X86) 
>     // Disable JIT on Windows if SSE2 is not present 
>     if (!MacroAssemblerX86::supportsFloatingPoint())
>Index: Source/JavaScriptCore/runtime/Options.h
>===================================================================
>--- Source/JavaScriptCore/runtime/Options.h	(revision 208897)
>+++ Source/JavaScriptCore/runtime/Options.h	(working copy)
>@@ -184,8 +184,9 @@ typedef const char* optionString;
>     v(bool, verboseSanitizeStack, false, Normal, nullptr) \
>     v(bool, useGenerationalGC, true, Normal, nullptr) \
>     v(bool, useConcurrentBarriers, true, Normal, nullptr) \
>-    v(bool, useConcurrentGC, false, Normal, nullptr) \
>+    v(bool, useConcurrentGC, true, Normal, nullptr) \
>     v(bool, collectContinuously, false, Normal, nullptr) \
>+    v(double, collectContinuouslyPeriodMS, 1, Normal, nullptr) \
>     v(bool, forceFencedBarrier, false, Normal, nullptr) \
>     v(unsigned, largeHeapSize, 32 * 1024 * 1024, Normal, nullptr) \
>     v(unsigned, smallHeapSize, 1 * 1024 * 1024, Normal, nullptr) \
>Index: Source/JavaScriptCore/runtime/SparseArrayValueMap.cpp
>===================================================================
>--- Source/JavaScriptCore/runtime/SparseArrayValueMap.cpp	(revision 208896)
>+++ Source/JavaScriptCore/runtime/SparseArrayValueMap.cpp	(working copy)
>@@ -1,5 +1,5 @@
> /*
>- * Copyright (C) 2011-2012, 2016 Apple Inc. All rights reserved.
>+ * Copyright (C) 2011-2016 Apple Inc. All rights reserved.
>  *
>  * Redistribution and use in source and binary forms, with or without
>  * modification, are permitted provided that the following conditions
>@@ -74,11 +74,16 @@ Structure* SparseArrayValueMap::createSt
> 
> SparseArrayValueMap::AddResult SparseArrayValueMap::add(JSObject* array, unsigned i)
> {
>-    SparseArrayEntry entry;
>-    entry.setWithoutWriteBarrier(jsUndefined());
>-
>-    AddResult result = m_map.add(i, entry);
>-    size_t capacity = m_map.capacity();
>+    AddResult result;
>+    size_t capacity;
>+    {
>+        InternalLocker locker(this);
>+        SparseArrayEntry entry;
>+        entry.setWithoutWriteBarrier(jsUndefined());
>+        
>+        result = m_map.add(i, entry);
>+        capacity = m_map.capacity();
>+    }
>     if (capacity != m_reportedCapacity) {
>         // FIXME: Adopt reportExtraMemoryVisited, and switch to reportExtraMemoryAllocated.
>         // https://bugs.webkit.org/show_bug.cgi?id=142595
>@@ -88,6 +93,18 @@ SparseArrayValueMap::AddResult SparseArr
>     return result;
> }
> 
>+void SparseArrayValueMap::remove(iterator it)
>+{
>+    InternalLocker locker(this);
>+    m_map.remove(it);
>+}
>+
>+void SparseArrayValueMap::remove(unsigned i)
>+{
>+    InternalLocker locker(this);
>+    m_map.remove(i);
>+}
>+
> bool SparseArrayValueMap::putEntry(ExecState* exec, JSObject* array, unsigned i, JSValue value, bool shouldThrow)
> {
>     VM& vm = exec->vm();
>@@ -180,6 +197,7 @@ void SparseArrayValueMap::visitChildren(
>     Base::visitChildren(thisObject, visitor);
>     
>     SparseArrayValueMap* thisMap = jsCast<SparseArrayValueMap*>(thisObject);
>+    InternalLocker locker(thisMap);
>     iterator end = thisMap->m_map.end();
>     for (iterator it = thisMap->m_map.begin(); it != end; ++it)
>         visitor.append(&it->value);
>Index: Source/JavaScriptCore/runtime/SparseArrayValueMap.h
>===================================================================
>--- Source/JavaScriptCore/runtime/SparseArrayValueMap.h	(revision 208896)
>+++ Source/JavaScriptCore/runtime/SparseArrayValueMap.h	(working copy)
>@@ -1,5 +1,5 @@
> /*
>- * Copyright (C) 2011, 2012 Apple Inc. All rights reserved.
>+ * Copyright (C) 2011-2016 Apple Inc. All rights reserved.
>  *
>  * Redistribution and use in source and binary forms, with or without
>  * modification, are permitted provided that the following conditions
>@@ -49,7 +49,6 @@ struct SparseArrayEntry : public WriteBa
>     unsigned attributes;
> };
> 
>-// FIXME: This needs to have a lock in it.
> class SparseArrayValueMap final : public JSCell {
> public:
>     typedef JSCell Base;
>@@ -111,8 +110,8 @@ public:
>     AddResult add(JSObject*, unsigned);
>     iterator find(unsigned i) { return m_map.find(i); }
>     // This should ASSERT the remove is valid (check the result of the find).
>-    void remove(iterator it) { m_map.remove(it); }
>-    void remove(unsigned i) { m_map.remove(i); }
>+    void remove(iterator it);
>+    void remove(unsigned i);
> 
>     // These methods do not mutate the contents of the map.
>     iterator notFound() { return m_map.end(); }
>Index: Tools/Scripts/run-jsc-stress-tests
>===================================================================
>--- Tools/Scripts/run-jsc-stress-tests	(revision 208896)
>+++ Tools/Scripts/run-jsc-stress-tests	(working copy)
>@@ -424,6 +424,7 @@ BASE_OPTIONS = ["--useFTLJIT=false", "--
> EAGER_OPTIONS = ["--thresholdForJITAfterWarmUp=10", "--thresholdForJITSoon=10", "--thresholdForOptimizeAfterWarmUp=20", "--thresholdForOptimizeAfterLongWarmUp=20", "--thresholdForOptimizeSoon=20", "--thresholdForFTLOptimizeAfterWarmUp=20", "--thresholdForFTLOptimizeSoon=20", "--maximumEvalCacheableSourceLength=150000", "--useEagerCodeBlockJettisonTiming=true"]
> NO_CJIT_OPTIONS = ["--useConcurrentJIT=false", "--thresholdForJITAfterWarmUp=100", "--scribbleFreeCells=true"]
> FTL_OPTIONS = ["--useFTLJIT=true"]
>+COLLECT_CONTINUOUSLY_OPTIONS = ["--collectContinuously=true", "--useGenerationalGC=false"]
> 
> $runlist = []
> 
>@@ -859,15 +860,15 @@ def runDFGEagerNoCJITValidate(*optionalT
> end
> 
> def runFTLEager(*optionalTestSpecificOptions)
>-    run("ftl-eager", *(FTL_OPTIONS + EAGER_OPTIONS + optionalTestSpecificOptions))
>+    run("ftl-eager", *(FTL_OPTIONS + EAGER_OPTIONS + COLLECT_CONTINUOUSLY_OPTIONS + optionalTestSpecificOptions))
> end
> 
> def runFTLEagerNoCJITValidate(*optionalTestSpecificOptions)
>-    run("ftl-eager-no-cjit", "--validateGraph=true", *(FTL_OPTIONS + NO_CJIT_OPTIONS + EAGER_OPTIONS + optionalTestSpecificOptions))
>+    run("ftl-eager-no-cjit", "--validateGraph=true", *(FTL_OPTIONS + NO_CJIT_OPTIONS + EAGER_OPTIONS + COLLECT_CONTINUOUSLY_OPTIONS + optionalTestSpecificOptions))
> end
> 
> def runFTLEagerNoCJITOSRValidation(*optionalTestSpecificOptions)
>-    run("ftl-eager-no-cjit-osr-validation", "--validateFTLOSRExitLiveness=true", *(FTL_OPTIONS + NO_CJIT_OPTIONS + EAGER_OPTIONS + optionalTestSpecificOptions))
>+    run("ftl-eager-no-cjit-osr-validation", "--validateFTLOSRExitLiveness=true", *(FTL_OPTIONS + NO_CJIT_OPTIONS + EAGER_OPTIONS + COLLECT_CONTINUOUSLY_OPTIONS + optionalTestSpecificOptions))
> end
> 
> def runNoCJITNoASO(*optionalTestSpecificOptions)

Actions: View | Formatted Diff | Diff

Attachments on bug 164990: 295265 | 295337 | 295340 | 295342 | 295387 | 295452 | 295463 | 295477 | 295561 | 295579 | 295586 | 295604 | 295615 | 295667 | 295669 | 295688 | 295704 | 295706 | 295711 | 295746 | 295808 | 295812 | 295898 | 295987 | 296012 | 296039 | 296042 | 296045 | 296054 | 296059 | 296060 | 296072 | 296080 | 296094 | 296106 | 296110 | 296112 | 296114 | 296115 | 296116 | 296119 | 296125 | 296126 | 296127 | 296149 | 296206 | 296208 | 296209 | 296210 | 296294 | 296365 | 296376 | 296379 | 296467