<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN"
"http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head><meta http-equiv="content-type" content="text/html; charset=utf-8" /><style type="text/css"><!--
#msg dl { border: 1px #006 solid; background: #369; padding: 6px; color: #fff; }
#msg dt { float: left; width: 6em; font-weight: bold; }
#msg dt:after { content:':';}
#msg dl, #msg dt, #msg ul, #msg li, #header, #footer { font-family: verdana,arial,helvetica,sans-serif; font-size: 10pt; }
#msg dl a { font-weight: bold}
#msg dl a:link { color:#fc3; }
#msg dl a:active { color:#ff0; }
#msg dl a:visited { color:#cc6; }
h3 { font-family: verdana,arial,helvetica,sans-serif; font-size: 10pt; font-weight: bold; }
#msg pre { overflow: auto; background: #ffc; border: 1px #fc0 solid; padding: 6px; }
#msg ul, pre { overflow: auto; }
#header, #footer { color: #fff; background: #636; border: 1px #300 solid; padding: 6px; }
#patch { width: 100%; }
#patch h4 {font-family: verdana,arial,helvetica,sans-serif;font-size:10pt;padding:8px;background:#369;color:#fff;margin:0;}
#patch .propset h4, #patch .binary h4 {margin:0;}
#patch pre {padding:0;line-height:1.2em;margin:0;}
#patch .diff {width:100%;background:#eee;padding: 0 0 10px 0;overflow:auto;}
#patch .propset .diff, #patch .binary .diff {padding:10px 0;}
#patch span {display:block;padding:0 10px;}
#patch .modfile, #patch .addfile, #patch .delfile, #patch .propset, #patch .binary, #patch .copfile {border:1px solid #ccc;margin:10px 0;}
#patch ins {background:#dfd;text-decoration:none;display:block;padding:0 10px;}
#patch del {background:#fdd;text-decoration:none;display:block;padding:0 10px;}
#patch .lines, .info {color:#888;background:#fff;}
--></style>
<title>[20722] branches/js-collector-tweaks/JavaScriptCore</title>
</head>
<body>
<div id="msg">
<dl>
<dt>Revision</dt> <dd><a href="http://trac.webkit.org/projects/webkit/changeset/20722">20722</a></dd>
<dt>Author</dt> <dd>mjs</dd>
<dt>Date</dt> <dd>2007-04-05 09:35:43 -0700 (Thu, 05 Apr 2007)</dd>
</dl>
<h3>Log Message</h3>
<pre> Not reviewed, experimental change.
- remove the concept of oversize objects, now that there aren't any (for now
only enforced with an assert).
This change is a .66% speedup on JS iBench for 32-bit platforms, probably much more
for 64-bit since it finally gives a reasonable cell size, but I did not test that.
* kjs/collector.cpp:
(KJS::): Use different cell size for 32-bit and 64-bit, now that there is no
oversize allocation.
(KJS::Collector::allocate): Remove oversize allocator.
(KJS::Collector::markStackObjectsConservatively): Don't check oversize objects.
(KJS::Collector::markMainThreadOnlyObjects): Ditto.
(KJS::Collector::collect): Ditto.</pre>
<h3>Modified Paths</h3>
<ul>
<li><a href="#branchesjscollectortweaksJavaScriptCoreChangeLog">branches/js-collector-tweaks/JavaScriptCore/ChangeLog</a></li>
<li><a href="#branchesjscollectortweaksJavaScriptCorekjscollectorcpp">branches/js-collector-tweaks/JavaScriptCore/kjs/collector.cpp</a></li>
</ul>
</div>
<div id="patch">
<h3>Diff</h3>
<a id="branchesjscollectortweaksJavaScriptCoreChangeLog"></a>
<div class="modfile"><h4>Modified: branches/js-collector-tweaks/JavaScriptCore/ChangeLog (20721 => 20722)</h4>
<pre class="diff"><span>
<span class="info">--- branches/js-collector-tweaks/JavaScriptCore/ChangeLog 2007-04-05 15:24:50 UTC (rev 20721)
+++ branches/js-collector-tweaks/JavaScriptCore/ChangeLog 2007-04-05 16:35:43 UTC (rev 20722)
</span><span class="lines">@@ -1,3 +1,21 @@
</span><ins>+2007-04-05 Maciej Stachowiak <mjs@apple.com>
+
+ Not reviewed, experimental change.
+
+ - remove the concept of oversize objects, now that there aren't any (for now
+ only enforced with an assert).
+
+ This change is a .66% speedup on JS iBench for 32-bit platforms, probably much more
+ for 64-bit since it finally gives a reasonable cell size, but I did not test that.
+
+ * kjs/collector.cpp:
+ (KJS::): Use different cell size for 32-bit and 64-bit, now that there is no
+ oversize allocation.
+ (KJS::Collector::allocate): Remove oversize allocator.
+ (KJS::Collector::markStackObjectsConservatively): Don't check oversize objects.
+ (KJS::Collector::markMainThreadOnlyObjects): Ditto.
+ (KJS::Collector::collect): Ditto.
+
</ins><span class="cx"> 2007-04-03 Kevin McCullough <kmccullough@apple.com>
</span><span class="cx">
</span><span class="cx"> Reviewed by Adam.
</span></span></pre></div>
<a id="branchesjscollectortweaksJavaScriptCorekjscollectorcpp"></a>
<div class="modfile"><h4>Modified: branches/js-collector-tweaks/JavaScriptCore/kjs/collector.cpp (20721 => 20722)</h4>
<pre class="diff"><span>
<span class="info">--- branches/js-collector-tweaks/JavaScriptCore/kjs/collector.cpp 2007-04-05 15:24:50 UTC (rev 20721)
+++ branches/js-collector-tweaks/JavaScriptCore/kjs/collector.cpp 2007-04-05 16:35:43 UTC (rev 20722)
</span><span class="lines">@@ -58,8 +58,14 @@
</span><span class="cx">
</span><span class="cx"> namespace KJS {
</span><span class="cx">
</span><ins>+
+
</ins><span class="cx"> // tunable parameters
</span><del>-const size_t MINIMUM_CELL_SIZE = 48;
</del><ins>+
+template<bool is32Bit, bool is64Bit> struct CellSize;
+template<> struct CellSize<true, false> { static const size_t m_value = 48; }; // 32-bit
+template<> struct CellSize<false, true> { static const size_t m_value = 80; }; // 64-bit
+
</ins><span class="cx"> const size_t BLOCK_SIZE = (8 * 4096);
</span><span class="cx"> const size_t SPARE_EMPTY_BLOCKS = 2;
</span><span class="cx"> const size_t MIN_ARRAY_SIZE = 14;
</span><span class="lines">@@ -68,12 +74,12 @@
</span><span class="cx"> const size_t ALLOCATIONS_PER_COLLECTION = 1000;
</span><span class="cx">
</span><span class="cx"> // derived constants
</span><del>-const size_t CELL_ARRAY_LENGTH = (MINIMUM_CELL_SIZE / sizeof(double)) + (MINIMUM_CELL_SIZE % sizeof(double) != 0 ? sizeof(double) : 0);
</del><ins>+const size_t MINIMUM_CELL_SIZE = CellSize<sizeof(void*) == sizeof(uint32_t), sizeof(void*) == sizeof(uint64_t)>::m_value;
+const size_t CELL_ARRAY_LENGTH = (MINIMUM_CELL_SIZE / sizeof(double)) + (MINIMUM_CELL_SIZE % sizeof(double) != 0 ? 1 : 0);
</ins><span class="cx"> const size_t CELL_SIZE = CELL_ARRAY_LENGTH * sizeof(double);
</span><del>-const size_t CELLS_PER_BLOCK = ((BLOCK_SIZE * 8 - sizeof(uint32_t) * 8 - sizeof(void *) * 8) / (CELL_SIZE * 8));
</del><ins>+const size_t CELLS_PER_BLOCK = ((BLOCK_SIZE * 8 - sizeof(uint32_t) * 8 - sizeof(void*) * 8) / (CELL_SIZE * 8));
</ins><span class="cx">
</span><span class="cx">
</span><del>-
</del><span class="cx"> struct CollectorCell {
</span><span class="cx"> union {
</span><span class="cx"> double memory[CELL_ARRAY_LENGTH];
</span><span class="lines">@@ -97,15 +103,11 @@
</span><span class="cx"> size_t usedBlocks;
</span><span class="cx"> size_t firstBlockWithPossibleSpace;
</span><span class="cx">
</span><del>- CollectorCell **oversizeCells;
- size_t numOversizeCells;
- size_t usedOversizeCells;
-
</del><span class="cx"> size_t numLiveObjects;
</span><span class="cx"> size_t numLiveObjectsAtLastCollect;
</span><span class="cx"> };
</span><span class="cx">
</span><del>-static CollectorHeap heap = {NULL, 0, 0, 0, NULL, 0, 0, 0, 0};
</del><ins>+static CollectorHeap heap = {NULL, 0, 0, 0, 0, 0};
</ins><span class="cx">
</span><span class="cx"> size_t Collector::mainThreadOnlyObjectCount = 0;
</span><span class="cx"> bool Collector::memoryFull = false;
</span><span class="lines">@@ -136,6 +138,7 @@
</span><span class="cx"> {
</span><span class="cx"> ASSERT(JSLock::lockCount() > 0);
</span><span class="cx"> ASSERT(JSLock::currentThreadIsHoldingLock());
</span><ins>+ ASSERT(s <= CELL_SIZE);
</ins><span class="cx">
</span><span class="cx"> // collect if needed
</span><span class="cx"> size_t numLiveObjects = heap.numLiveObjects;
</span><span class="lines">@@ -151,25 +154,6 @@
</span><span class="cx"> GCLock lock;
</span><span class="cx"> #endif
</span><span class="cx">
</span><del>- if (s > CELL_SIZE) {
- // oversize allocator
- size_t usedOversizeCells = heap.usedOversizeCells;
- size_t numOversizeCells = heap.numOversizeCells;
-
- if (usedOversizeCells == numOversizeCells) {
- numOversizeCells = max(MIN_ARRAY_SIZE, numOversizeCells * GROWTH_FACTOR);
- heap.numOversizeCells = numOversizeCells;
- heap.oversizeCells = static_cast<CollectorCell **>(fastRealloc(heap.oversizeCells, numOversizeCells * sizeof(CollectorCell *)));
- }
-
- void *newCell = fastMalloc(s);
- heap.oversizeCells[usedOversizeCells] = static_cast<CollectorCell *>(newCell);
- heap.usedOversizeCells = usedOversizeCells + 1;
- heap.numLiveObjects = numLiveObjects + 1;
-
- return newCell;
- }
-
</del><span class="cx"> // slab allocator
</span><span class="cx">
</span><span class="cx"> size_t usedBlocks = heap.usedBlocks;
</span><span class="lines">@@ -384,8 +368,6 @@
</span><span class="cx">
</span><span class="cx"> size_t usedBlocks = heap.usedBlocks;
</span><span class="cx"> CollectorBlock **blocks = heap.blocks;
</span><del>- size_t usedOversizeCells = heap.usedOversizeCells;
- CollectorCell **oversizeCells = heap.oversizeCells;
</del><span class="cx">
</span><span class="cx"> const size_t lastCellOffset = sizeof(CollectorCell) * (CELLS_PER_BLOCK - 1);
</span><span class="cx">
</span><span class="lines">@@ -394,20 +376,15 @@
</span><span class="cx"> if (IS_CELL_ALIGNED(x) && x) {
</span><span class="cx"> for (size_t block = 0; block < usedBlocks; block++) {
</span><span class="cx"> size_t offset = x - reinterpret_cast<char *>(blocks[block]);
</span><del>- if (offset <= lastCellOffset && offset % sizeof(CollectorCell) == 0)
- goto gotGoodPointer;
</del><ins>+ if (offset <= lastCellOffset && offset % sizeof(CollectorCell) == 0) {
+ if (((CollectorCell *)x)->u.freeCell.zeroIfFree != 0) {
+ JSCell *imp = reinterpret_cast<JSCell *>(x);
+ if (!imp->marked())
+ imp->mark();
+ }
+ break;
+ }
</ins><span class="cx"> }
</span><del>- for (size_t i = 0; i != usedOversizeCells; i++)
- if (x == reinterpret_cast<char *>(oversizeCells[i]))
- goto gotGoodPointer;
- continue;
-
-gotGoodPointer:
- if (((CollectorCell *)x)->u.freeCell.zeroIfFree != 0) {
- JSCell *imp = reinterpret_cast<JSCell *>(x);
- if (!imp->marked())
- imp->mark();
- }
</del><span class="cx"> }
</span><span class="cx"> }
</span><span class="cx"> }
</span><span class="lines">@@ -694,18 +671,6 @@
</span><span class="cx"> }
</span><span class="cx"> }
</span><span class="cx"> }
</span><del>-
- for (size_t cell = 0; cell < heap.usedOversizeCells; cell++) {
- ASSERT(count < mainThreadOnlyObjectCount);
-
- JSCell* imp = reinterpret_cast<JSCell*>(heap.oversizeCells[cell]);
- if (imp->m_collectOnMainThreadOnly) {
- if (!imp->marked())
- imp->mark();
- if (++count == mainThreadOnlyObjectCount)
- return;
- }
- }
</del><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> bool Collector::collect()
</span><span class="lines">@@ -841,37 +806,6 @@
</span><span class="cx"> if (heap.numLiveObjects != numLiveObjects)
</span><span class="cx"> heap.firstBlockWithPossibleSpace = 0;
</span><span class="cx">
</span><del>- size_t cell = 0;
- while (cell < heap.usedOversizeCells) {
- JSCell *imp = (JSCell *)heap.oversizeCells[cell];
-
- if (imp->m_marked) {
- imp->m_marked = false;
- cell++;
- } else {
- ASSERT(currentThreadIsMainThread || !imp->m_collectOnMainThreadOnly);
- if (imp->m_collectOnMainThreadOnly)
- --mainThreadOnlyObjectCount;
- imp->~JSCell();
-#if DEBUG_COLLECTOR
- heap.oversizeCells[cell]->u.freeCell.zeroIfFree = 0;
-#else
- fastFree(imp);
-#endif
-
- // swap with the last oversize cell so we compact as we go
- heap.oversizeCells[cell] = heap.oversizeCells[heap.usedOversizeCells - 1];
-
- heap.usedOversizeCells--;
- numLiveObjects--;
-
- if (heap.numOversizeCells > MIN_ARRAY_SIZE && heap.usedOversizeCells < heap.numOversizeCells / LOW_WATER_FACTOR) {
- heap.numOversizeCells = heap.numOversizeCells / GROWTH_FACTOR;
- heap.oversizeCells = (CollectorCell **)fastRealloc(heap.oversizeCells, heap.numOversizeCells * sizeof(CollectorCell *));
- }
- }
- }
-
</del><span class="cx"> bool deleted = heap.numLiveObjects != numLiveObjects;
</span><span class="cx">
</span><span class="cx"> heap.numLiveObjects = numLiveObjects;
</span></span></pre>
</div>
</div>
</body>
</html>