< prev index next >

src/hotspot/share/gc/z/zStat.cpp

Print this page


   1 /*
   2  * Copyright (c) 2015, 2019, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.
   8  *
   9  * This code is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12  * version 2 for more details (a copy is included in the LICENSE file that
  13  * accompanied this code).
  14  *
  15  * You should have received a copy of the GNU General Public License version
  16  * 2 along with this work; if not, write to the Free Software Foundation,
  17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  */


  24 #include "precompiled.hpp"
  25 #include "gc/z/zCollectedHeap.hpp"
  26 #include "gc/z/zCPU.hpp"
  27 #include "gc/z/zGlobals.hpp"
  28 #include "gc/z/zHeap.inline.hpp"
  29 #include "gc/z/zLargePages.inline.hpp"
  30 #include "gc/z/zNMethodTable.hpp"
  31 #include "gc/z/zNUMA.hpp"
  32 #include "gc/z/zStat.hpp"
  33 #include "gc/z/zTracer.inline.hpp"
  34 #include "gc/z/zUtils.hpp"
  35 #include "memory/resourceArea.hpp"
  36 #include "runtime/atomic.hpp"
  37 #include "runtime/os.hpp"
  38 #include "runtime/timer.hpp"
  39 #include "utilities/align.hpp"
  40 #include "utilities/compilerWarnings.hpp"
  41 #include "utilities/debug.hpp"
  42 #include "utilities/ticks.hpp"
  43 
  44 #define ZSIZE_FMT               SIZE_FORMAT "M(%.0lf%%)"
  45 #define ZSIZE_ARGS(size)        ((size) / M), (percent_of(size, ZStatHeap::max_capacity()))
  46 
  47 #define ZTABLE_ARGS_NA          "%9s", "-"
  48 #define ZTABLE_ARGS(size)       SIZE_FORMAT_W(8) "M (%.0lf%%)", \
  49                                 ((size) / M), (percent_of(size, ZStatHeap::max_capacity()))
  50 
  51 //
  52 // Stat sampler/counter data
  53 //
  54 struct ZStatSamplerData {
  55   uint64_t _nsamples;
  56   uint64_t _sum;
  57   uint64_t _max;
  58 
  59   ZStatSamplerData() :
  60     _nsamples(0),
  61     _sum(0),
  62     _max(0) {}
  63 
  64   void add(const ZStatSamplerData& new_sample) {
  65     _nsamples += new_sample._nsamples;
  66     _sum += new_sample._nsamples;
  67     _max = MAX2(_max, new_sample._max);
  68   }
  69 };
  70 


 611 
 612 const char* ZStatPhase::name() const {
 613   return _sampler.name();
 614 }
 615 
 616 ZStatPhaseCycle::ZStatPhaseCycle(const char* name) :
 617     ZStatPhase("Collector", name) {}
 618 
 619 void ZStatPhaseCycle::register_start(const Ticks& start) const {
 620   timer()->register_gc_start(start);
 621 
 622   ZTracer::tracer()->report_gc_start(ZCollectedHeap::heap()->gc_cause(), start);
 623 
 624   ZCollectedHeap::heap()->print_heap_before_gc();
 625   ZCollectedHeap::heap()->trace_heap_before_gc(ZTracer::tracer());
 626 
 627   log_info(gc, start)("Garbage Collection (%s)",
 628                        GCCause::to_string(ZCollectedHeap::heap()->gc_cause()));
 629 }
 630 



 631 void ZStatPhaseCycle::register_end(const Ticks& start, const Ticks& end) const {
 632   timer()->register_gc_end(end);
 633 
 634   ZCollectedHeap::heap()->print_heap_after_gc();
 635   ZCollectedHeap::heap()->trace_heap_after_gc(ZTracer::tracer());
 636 
 637   ZTracer::tracer()->report_gc_end(end, timer()->time_partitions());
 638 
 639   const Tickspan duration = end - start;
 640   ZStatSample(_sampler, duration.value());
 641 
 642   ZStatLoad::print();
 643   ZStatMMU::print();
 644   ZStatMark::print();
 645   ZStatRelocation::print();
 646   ZStatNMethods::print();
 647   ZStatMetaspace::print();
 648   ZStatReferences::print();
 649   ZStatHeap::print();
 650 
 651   log_info(gc)("Garbage Collection (%s) " ZSIZE_FMT "->" ZSIZE_FMT,
 652                GCCause::to_string(ZCollectedHeap::heap()->gc_cause()),
 653                ZSIZE_ARGS(ZStatHeap::used_at_mark_start()),
 654                ZSIZE_ARGS(ZStatHeap::used_at_relocate_end()));
 655 }
 656 
 657 Tickspan ZStatPhasePause::_max;
 658 
 659 ZStatPhasePause::ZStatPhasePause(const char* name) :
 660     ZStatPhase("Phase", name) {}
 661 
 662 const Tickspan& ZStatPhasePause::max() {
 663   return _max;
 664 }
 665 
 666 void ZStatPhasePause::register_start(const Ticks& start) const {
 667   timer()->register_gc_pause_start(name(), start);
 668 
 669   LogTarget(Debug, gc, phases, start) log;
 670   log_start(log);
 671 }
 672 
 673 void ZStatPhasePause::register_end(const Ticks& start, const Ticks& end) const {
 674   timer()->register_gc_pause_end(end);


1199                     ref.discovered,
1200                     ref.enqueued);
1201 }
1202 
1203 void ZStatReferences::print() {
1204   print("Soft", _soft);
1205   print("Weak", _weak);
1206   print("Final", _final);
1207   print("Phantom", _phantom);
1208 }
1209 
1210 //
1211 // Stat heap
1212 //
1213 ZStatHeap::ZAtInitialize ZStatHeap::_at_initialize;
1214 ZStatHeap::ZAtMarkStart ZStatHeap::_at_mark_start;
1215 ZStatHeap::ZAtMarkEnd ZStatHeap::_at_mark_end;
1216 ZStatHeap::ZAtRelocateStart ZStatHeap::_at_relocate_start;
1217 ZStatHeap::ZAtRelocateEnd ZStatHeap::_at_relocate_end;
1218 




1219 size_t ZStatHeap::available(size_t used) {
1220   return _at_initialize.max_capacity - used;
1221 }
1222 
1223 size_t ZStatHeap::reserve(size_t used) {
1224   return MIN2(_at_initialize.max_reserve, available(used));
1225 }
1226 
1227 size_t ZStatHeap::free(size_t used) {
1228   return available(used) - reserve(used);
1229 }
1230 
1231 void ZStatHeap::set_at_initialize(size_t min_capacity,
1232                                   size_t max_capacity,
1233                                   size_t max_reserve) {
1234   _at_initialize.min_capacity = min_capacity;
1235   _at_initialize.max_capacity = max_capacity;
1236   _at_initialize.max_reserve = max_reserve;
1237 }
1238 
1239 void ZStatHeap::set_at_mark_start(size_t soft_max_capacity,
1240                                   size_t capacity,
1241                                   size_t used) {
1242   _at_mark_start.soft_max_capacity = soft_max_capacity;
1243   _at_mark_start.capacity = capacity;
1244   _at_mark_start.reserve = reserve(used);
1245   _at_mark_start.used = used;
1246   _at_mark_start.free = free(used);
1247 }
1248 
1249 void ZStatHeap::set_at_mark_end(size_t capacity,
1250                                 size_t allocated,
1251                                 size_t used) {
1252   _at_mark_end.capacity = capacity;
1253   _at_mark_end.reserve = reserve(used);
1254   _at_mark_end.allocated = allocated;
1255   _at_mark_end.used = used;
1256   _at_mark_end.free = free(used);
1257 }
1258 
1259 void ZStatHeap::set_at_select_relocation_set(size_t live,
1260                                              size_t garbage,
1261                                              size_t reclaimed) {
1262   _at_mark_end.live = live;


1295   _at_relocate_end.used_high = used_high;
1296   _at_relocate_end.used_low = used_low;
1297   _at_relocate_end.free = free(used);
1298   _at_relocate_end.free_high = free(used_low);
1299   _at_relocate_end.free_low = free(used_high);
1300 }
1301 
1302 size_t ZStatHeap::max_capacity() {
1303   return _at_initialize.max_capacity;
1304 }
1305 
1306 size_t ZStatHeap::used_at_mark_start() {
1307   return _at_mark_start.used;
1308 }
1309 
1310 size_t ZStatHeap::used_at_relocate_end() {
1311   return _at_relocate_end.used;
1312 }
1313 
1314 void ZStatHeap::print() {
1315   log_info(gc, heap)("Min Capacity: "
1316                      ZSIZE_FMT, ZSIZE_ARGS(_at_initialize.min_capacity));
1317   log_info(gc, heap)("Max Capacity: "
1318                      ZSIZE_FMT, ZSIZE_ARGS(_at_initialize.max_capacity));
1319   log_info(gc, heap)("Soft Max Capacity: "
1320                      ZSIZE_FMT, ZSIZE_ARGS(_at_mark_start.soft_max_capacity));
1321 
1322   ZStatTablePrinter table(10, 18);
1323   log_info(gc, heap)("%s", table()
1324                      .fill()
1325                      .center("Mark Start")
1326                      .center("Mark End")
1327                      .center("Relocate Start")
1328                      .center("Relocate End")
1329                      .center("High")
1330                      .center("Low")
1331                      .end());
1332   log_info(gc, heap)("%s", table()
1333                      .right("Capacity:")
1334                      .left(ZTABLE_ARGS(_at_mark_start.capacity))
1335                      .left(ZTABLE_ARGS(_at_mark_end.capacity))
1336                      .left(ZTABLE_ARGS(_at_relocate_start.capacity))
1337                      .left(ZTABLE_ARGS(_at_relocate_end.capacity))
1338                      .left(ZTABLE_ARGS(_at_relocate_end.capacity_high))
1339                      .left(ZTABLE_ARGS(_at_relocate_end.capacity_low))
1340                      .end());
1341   log_info(gc, heap)("%s", table()
1342                      .right("Reserve:")
1343                      .left(ZTABLE_ARGS(_at_mark_start.reserve))
1344                      .left(ZTABLE_ARGS(_at_mark_end.reserve))
1345                      .left(ZTABLE_ARGS(_at_relocate_start.reserve))
1346                      .left(ZTABLE_ARGS(_at_relocate_end.reserve))
1347                      .left(ZTABLE_ARGS(_at_relocate_end.reserve_high))
1348                      .left(ZTABLE_ARGS(_at_relocate_end.reserve_low))
1349                      .end());
1350   log_info(gc, heap)("%s", table()
1351                      .right("Free:")
1352                      .left(ZTABLE_ARGS(_at_mark_start.free))
1353                      .left(ZTABLE_ARGS(_at_mark_end.free))
1354                      .left(ZTABLE_ARGS(_at_relocate_start.free))
1355                      .left(ZTABLE_ARGS(_at_relocate_end.free))
1356                      .left(ZTABLE_ARGS(_at_relocate_end.free_high))
1357                      .left(ZTABLE_ARGS(_at_relocate_end.free_low))
1358                      .end());
1359   log_info(gc, heap)("%s", table()
1360                      .right("Used:")
1361                      .left(ZTABLE_ARGS(_at_mark_start.used))
1362                      .left(ZTABLE_ARGS(_at_mark_end.used))
1363                      .left(ZTABLE_ARGS(_at_relocate_start.used))
1364                      .left(ZTABLE_ARGS(_at_relocate_end.used))
1365                      .left(ZTABLE_ARGS(_at_relocate_end.used_high))
1366                      .left(ZTABLE_ARGS(_at_relocate_end.used_low))
1367                      .end());
1368   log_info(gc, heap)("%s", table()
1369                      .right("Live:")
1370                      .left(ZTABLE_ARGS_NA)
1371                      .left(ZTABLE_ARGS(_at_mark_end.live))
1372                      .left(ZTABLE_ARGS(_at_mark_end.live /* Same as at mark end */))
1373                      .left(ZTABLE_ARGS(_at_mark_end.live /* Same as at mark end */))
1374                      .left(ZTABLE_ARGS_NA)
1375                      .left(ZTABLE_ARGS_NA)
1376                      .end());
1377   log_info(gc, heap)("%s", table()
1378                      .right("Allocated:")
1379                      .left(ZTABLE_ARGS_NA)
1380                      .left(ZTABLE_ARGS(_at_mark_end.allocated))
1381                      .left(ZTABLE_ARGS(_at_relocate_start.allocated))
1382                      .left(ZTABLE_ARGS(_at_relocate_end.allocated))
1383                      .left(ZTABLE_ARGS_NA)
1384                      .left(ZTABLE_ARGS_NA)
1385                      .end());
1386   log_info(gc, heap)("%s", table()
1387                      .right("Garbage:")
1388                      .left(ZTABLE_ARGS_NA)
1389                      .left(ZTABLE_ARGS(_at_mark_end.garbage))
1390                      .left(ZTABLE_ARGS(_at_relocate_start.garbage))
1391                      .left(ZTABLE_ARGS(_at_relocate_end.garbage))
1392                      .left(ZTABLE_ARGS_NA)
1393                      .left(ZTABLE_ARGS_NA)
1394                      .end());
1395   log_info(gc, heap)("%s", table()
1396                      .right("Reclaimed:")
1397                      .left(ZTABLE_ARGS_NA)
1398                      .left(ZTABLE_ARGS_NA)
1399                      .left(ZTABLE_ARGS(_at_relocate_start.reclaimed))
1400                      .left(ZTABLE_ARGS(_at_relocate_end.reclaimed))
1401                      .left(ZTABLE_ARGS_NA)
1402                      .left(ZTABLE_ARGS_NA)
1403                      .end());
1404 }
   1 /*
   2  * Copyright (c) 2015, 2018, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.
   8  *
   9  * This code is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12  * version 2 for more details (a copy is included in the LICENSE file that
  13  * accompanied this code).
  14  *
  15  * You should have received a copy of the GNU General Public License version
  16  * 2 along with this work; if not, write to the Free Software Foundation,
  17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  */


  24 #include "precompiled.hpp"
  25 #include "gc/z/zCollectedHeap.hpp"
  26 #include "gc/z/zCPU.hpp"
  27 #include "gc/z/zGlobals.hpp"
  28 #include "gc/z/zHeap.inline.hpp"
  29 #include "gc/z/zLargePages.inline.hpp"
  30 #include "gc/z/zNMethodTable.hpp"
  31 #include "gc/z/zNUMA.hpp"
  32 #include "gc/z/zStat.hpp"
  33 #include "gc/z/zTracer.inline.hpp"
  34 #include "gc/z/zUtils.hpp"
  35 #include "memory/resourceArea.hpp"
  36 #include "runtime/atomic.hpp"
  37 #include "runtime/os.hpp"
  38 #include "runtime/timer.hpp"
  39 #include "utilities/align.hpp"
  40 #include "utilities/compilerWarnings.hpp"
  41 #include "utilities/debug.hpp"
  42 #include "utilities/ticks.hpp"
  43 







  44 //
  45 // Stat sampler/counter data
  46 //
  47 struct ZStatSamplerData {
  48   uint64_t _nsamples;
  49   uint64_t _sum;
  50   uint64_t _max;
  51 
  52   ZStatSamplerData() :
  53     _nsamples(0),
  54     _sum(0),
  55     _max(0) {}
  56 
  57   void add(const ZStatSamplerData& new_sample) {
  58     _nsamples += new_sample._nsamples;
  59     _sum += new_sample._nsamples;
  60     _max = MAX2(_max, new_sample._max);
  61   }
  62 };
  63 


 604 
 605 const char* ZStatPhase::name() const {
 606   return _sampler.name();
 607 }
 608 
 609 ZStatPhaseCycle::ZStatPhaseCycle(const char* name) :
 610     ZStatPhase("Collector", name) {}
 611 
 612 void ZStatPhaseCycle::register_start(const Ticks& start) const {
 613   timer()->register_gc_start(start);
 614 
 615   ZTracer::tracer()->report_gc_start(ZCollectedHeap::heap()->gc_cause(), start);
 616 
 617   ZCollectedHeap::heap()->print_heap_before_gc();
 618   ZCollectedHeap::heap()->trace_heap_before_gc(ZTracer::tracer());
 619 
 620   log_info(gc, start)("Garbage Collection (%s)",
 621                        GCCause::to_string(ZCollectedHeap::heap()->gc_cause()));
 622 }
 623 
 624 #define ZUSED_FMT                       SIZE_FORMAT "M(%.0lf%%)"
 625 #define ZUSED_ARGS(size, max_capacity)  ((size) / M), (percent_of(size, max_capacity))
 626 
 627 void ZStatPhaseCycle::register_end(const Ticks& start, const Ticks& end) const {
 628   timer()->register_gc_end(end);
 629 
 630   ZCollectedHeap::heap()->print_heap_after_gc();
 631   ZCollectedHeap::heap()->trace_heap_after_gc(ZTracer::tracer());
 632 
 633   ZTracer::tracer()->report_gc_end(end, timer()->time_partitions());
 634 
 635   const Tickspan duration = end - start;
 636   ZStatSample(_sampler, duration.value());
 637 
 638   ZStatLoad::print();
 639   ZStatMMU::print();
 640   ZStatMark::print();
 641   ZStatRelocation::print();
 642   ZStatNMethods::print();
 643   ZStatMetaspace::print();
 644   ZStatReferences::print();
 645   ZStatHeap::print();
 646 
 647   log_info(gc)("Garbage Collection (%s) " ZUSED_FMT "->" ZUSED_FMT,
 648                GCCause::to_string(ZCollectedHeap::heap()->gc_cause()),
 649                ZUSED_ARGS(ZStatHeap::used_at_mark_start(), ZStatHeap::max_capacity()),
 650                ZUSED_ARGS(ZStatHeap::used_at_relocate_end(), ZStatHeap::max_capacity()));
 651 }
 652 
 653 Tickspan ZStatPhasePause::_max;
 654 
 655 ZStatPhasePause::ZStatPhasePause(const char* name) :
 656     ZStatPhase("Phase", name) {}
 657 
 658 const Tickspan& ZStatPhasePause::max() {
 659   return _max;
 660 }
 661 
 662 void ZStatPhasePause::register_start(const Ticks& start) const {
 663   timer()->register_gc_pause_start(name(), start);
 664 
 665   LogTarget(Debug, gc, phases, start) log;
 666   log_start(log);
 667 }
 668 
 669 void ZStatPhasePause::register_end(const Ticks& start, const Ticks& end) const {
 670   timer()->register_gc_pause_end(end);


1195                     ref.discovered,
1196                     ref.enqueued);
1197 }
1198 
1199 void ZStatReferences::print() {
1200   print("Soft", _soft);
1201   print("Weak", _weak);
1202   print("Final", _final);
1203   print("Phantom", _phantom);
1204 }
1205 
1206 //
1207 // Stat heap
1208 //
1209 ZStatHeap::ZAtInitialize ZStatHeap::_at_initialize;
1210 ZStatHeap::ZAtMarkStart ZStatHeap::_at_mark_start;
1211 ZStatHeap::ZAtMarkEnd ZStatHeap::_at_mark_end;
1212 ZStatHeap::ZAtRelocateStart ZStatHeap::_at_relocate_start;
1213 ZStatHeap::ZAtRelocateEnd ZStatHeap::_at_relocate_end;
1214 
1215 #define ZSIZE_NA               "%9s", "-"
1216 #define ZSIZE_ARGS(size)       SIZE_FORMAT_W(8) "M (%.0lf%%)", \
1217                                ((size) / M), (percent_of(size, _at_initialize.max_capacity))
1218 
1219 size_t ZStatHeap::available(size_t used) {
1220   return _at_initialize.max_capacity - used;
1221 }
1222 
1223 size_t ZStatHeap::reserve(size_t used) {
1224   return MIN2(_at_initialize.max_reserve, available(used));
1225 }
1226 
1227 size_t ZStatHeap::free(size_t used) {
1228   return available(used) - reserve(used);
1229 }
1230 
1231 void ZStatHeap::set_at_initialize(size_t max_capacity,

1232                                   size_t max_reserve) {

1233   _at_initialize.max_capacity = max_capacity;
1234   _at_initialize.max_reserve = max_reserve;
1235 }
1236 
1237 void ZStatHeap::set_at_mark_start(size_t capacity,

1238                                   size_t used) {

1239   _at_mark_start.capacity = capacity;
1240   _at_mark_start.reserve = reserve(used);
1241   _at_mark_start.used = used;
1242   _at_mark_start.free = free(used);
1243 }
1244 
1245 void ZStatHeap::set_at_mark_end(size_t capacity,
1246                                 size_t allocated,
1247                                 size_t used) {
1248   _at_mark_end.capacity = capacity;
1249   _at_mark_end.reserve = reserve(used);
1250   _at_mark_end.allocated = allocated;
1251   _at_mark_end.used = used;
1252   _at_mark_end.free = free(used);
1253 }
1254 
1255 void ZStatHeap::set_at_select_relocation_set(size_t live,
1256                                              size_t garbage,
1257                                              size_t reclaimed) {
1258   _at_mark_end.live = live;


1291   _at_relocate_end.used_high = used_high;
1292   _at_relocate_end.used_low = used_low;
1293   _at_relocate_end.free = free(used);
1294   _at_relocate_end.free_high = free(used_low);
1295   _at_relocate_end.free_low = free(used_high);
1296 }
1297 
1298 size_t ZStatHeap::max_capacity() {
1299   return _at_initialize.max_capacity;
1300 }
1301 
1302 size_t ZStatHeap::used_at_mark_start() {
1303   return _at_mark_start.used;
1304 }
1305 
1306 size_t ZStatHeap::used_at_relocate_end() {
1307   return _at_relocate_end.used;
1308 }
1309 
1310 void ZStatHeap::print() {







1311   ZStatTablePrinter table(10, 18);
1312   log_info(gc, heap)("%s", table()
1313                      .fill()
1314                      .center("Mark Start")
1315                      .center("Mark End")
1316                      .center("Relocate Start")
1317                      .center("Relocate End")
1318                      .center("High")
1319                      .center("Low")
1320                      .end());
1321   log_info(gc, heap)("%s", table()
1322                      .right("Capacity:")
1323                      .left(ZSIZE_ARGS(_at_mark_start.capacity))
1324                      .left(ZSIZE_ARGS(_at_mark_end.capacity))
1325                      .left(ZSIZE_ARGS(_at_relocate_start.capacity))
1326                      .left(ZSIZE_ARGS(_at_relocate_end.capacity))
1327                      .left(ZSIZE_ARGS(_at_relocate_end.capacity_high))
1328                      .left(ZSIZE_ARGS(_at_relocate_end.capacity_low))
1329                      .end());
1330   log_info(gc, heap)("%s", table()
1331                      .right("Reserve:")
1332                      .left(ZSIZE_ARGS(_at_mark_start.reserve))
1333                      .left(ZSIZE_ARGS(_at_mark_end.reserve))
1334                      .left(ZSIZE_ARGS(_at_relocate_start.reserve))
1335                      .left(ZSIZE_ARGS(_at_relocate_end.reserve))
1336                      .left(ZSIZE_ARGS(_at_relocate_end.reserve_high))
1337                      .left(ZSIZE_ARGS(_at_relocate_end.reserve_low))
1338                      .end());
1339   log_info(gc, heap)("%s", table()
1340                      .right("Free:")
1341                      .left(ZSIZE_ARGS(_at_mark_start.free))
1342                      .left(ZSIZE_ARGS(_at_mark_end.free))
1343                      .left(ZSIZE_ARGS(_at_relocate_start.free))
1344                      .left(ZSIZE_ARGS(_at_relocate_end.free))
1345                      .left(ZSIZE_ARGS(_at_relocate_end.free_high))
1346                      .left(ZSIZE_ARGS(_at_relocate_end.free_low))
1347                      .end());
1348   log_info(gc, heap)("%s", table()
1349                      .right("Used:")
1350                      .left(ZSIZE_ARGS(_at_mark_start.used))
1351                      .left(ZSIZE_ARGS(_at_mark_end.used))
1352                      .left(ZSIZE_ARGS(_at_relocate_start.used))
1353                      .left(ZSIZE_ARGS(_at_relocate_end.used))
1354                      .left(ZSIZE_ARGS(_at_relocate_end.used_high))
1355                      .left(ZSIZE_ARGS(_at_relocate_end.used_low))
1356                      .end());
1357   log_info(gc, heap)("%s", table()
1358                      .right("Live:")
1359                      .left(ZSIZE_NA)
1360                      .left(ZSIZE_ARGS(_at_mark_end.live))
1361                      .left(ZSIZE_ARGS(_at_mark_end.live /* Same as at mark end */))
1362                      .left(ZSIZE_ARGS(_at_mark_end.live /* Same as at mark end */))
1363                      .left(ZSIZE_NA)
1364                      .left(ZSIZE_NA)
1365                      .end());
1366   log_info(gc, heap)("%s", table()
1367                      .right("Allocated:")
1368                      .left(ZSIZE_NA)
1369                      .left(ZSIZE_ARGS(_at_mark_end.allocated))
1370                      .left(ZSIZE_ARGS(_at_relocate_start.allocated))
1371                      .left(ZSIZE_ARGS(_at_relocate_end.allocated))
1372                      .left(ZSIZE_NA)
1373                      .left(ZSIZE_NA)
1374                      .end());
1375   log_info(gc, heap)("%s", table()
1376                      .right("Garbage:")
1377                      .left(ZSIZE_NA)
1378                      .left(ZSIZE_ARGS(_at_mark_end.garbage))
1379                      .left(ZSIZE_ARGS(_at_relocate_start.garbage))
1380                      .left(ZSIZE_ARGS(_at_relocate_end.garbage))
1381                      .left(ZSIZE_NA)
1382                      .left(ZSIZE_NA)
1383                      .end());
1384   log_info(gc, heap)("%s", table()
1385                      .right("Reclaimed:")
1386                      .left(ZSIZE_NA)
1387                      .left(ZSIZE_NA)
1388                      .left(ZSIZE_ARGS(_at_relocate_start.reclaimed))
1389                      .left(ZSIZE_ARGS(_at_relocate_end.reclaimed))
1390                      .left(ZSIZE_NA)
1391                      .left(ZSIZE_NA)
1392                      .end());
1393 }
< prev index next >