1 /*

     2  * Copyright 1999-2007 Sun Microsystems, Inc.  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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,

    20  * CA 95054 USA or visit www.sun.com if you need additional information or

    21  * have any questions.

    22  *

    23  */

    24 

    25 // Thread-Local Edens support

    26 

    27 # include "incls/_precompiled.incl"

    28 # include "incls/_threadLocalAllocBuffer.cpp.incl"

    29 

    30 // static member initialization

    31 unsigned         ThreadLocalAllocBuffer::_target_refills = 0;

    32 GlobalTLABStats* ThreadLocalAllocBuffer::_global_stats   = NULL;

    33 

    34 void ThreadLocalAllocBuffer::clear_before_allocation() {

    35   _slow_refill_waste += (unsigned)remaining();

    36   make_parsable(true);   // also retire the TLAB

    37 }

    38 

    39 void ThreadLocalAllocBuffer::accumulate_statistics_before_gc() {

    40   global_stats()->initialize();

    41 

    42   for(JavaThread *thread = Threads::first(); thread; thread = thread->next()) {

    43     thread->tlab().accumulate_statistics();

    44     thread->tlab().initialize_statistics();

    45   }

    46 

    47   // Publish new stats if some allocation occurred.

    48   if (global_stats()->allocation() != 0) {

    49     global_stats()->publish();

    50     if (PrintTLAB) {

    51       global_stats()->print();

    52     }

    53   }

    54 }

    55 

    56 void ThreadLocalAllocBuffer::accumulate_statistics() {

    57   size_t capacity = Universe::heap()->tlab_capacity(myThread()) / HeapWordSize;

    58   size_t unused   = Universe::heap()->unsafe_max_tlab_alloc(myThread()) / HeapWordSize;

    59   size_t used     = capacity - unused;

    60 

    61   // Update allocation history if a reasonable amount of eden was allocated.

    62   bool update_allocation_history = used > 0.5 * capacity;

    63 

    64   _gc_waste += (unsigned)remaining();

    65 

    66   if (PrintTLAB && (_number_of_refills > 0 || Verbose)) {

    67     print_stats("gc");

    68   }

    69 

    70   if (_number_of_refills > 0) {

    71 

    72     if (update_allocation_history) {

    73       // Average the fraction of eden allocated in a tlab by this

    74       // thread for use in the next resize operation.

    75       // _gc_waste is not subtracted because it's included in

    76       // "used".

    77       size_t allocation = _number_of_refills * desired_size();

    78       double alloc_frac = allocation / (double) used;

    79       _allocation_fraction.sample(alloc_frac);

    80     }

    81     global_stats()->update_allocating_threads();

    82     global_stats()->update_number_of_refills(_number_of_refills);

    83     global_stats()->update_allocation(_number_of_refills * desired_size());

    84     global_stats()->update_gc_waste(_gc_waste);

    85     global_stats()->update_slow_refill_waste(_slow_refill_waste);

    86     global_stats()->update_fast_refill_waste(_fast_refill_waste);

    87 

    88   } else {

    89     assert(_number_of_refills == 0 && _fast_refill_waste == 0 &&

    90            _slow_refill_waste == 0 && _gc_waste          == 0,

    91            "tlab stats == 0");

    92   }

    93   global_stats()->update_slow_allocations(_slow_allocations);

    94 }

    95 

    96 // Fills the current tlab with a dummy filler array to create

    97 // an illusion of a contiguous Eden and optionally retires the tlab.

    98 // Waste accounting should be done in caller as appropriate; see,

    99 // for example, clear_before_allocation().

   100 void ThreadLocalAllocBuffer::make_parsable(bool retire) {

   101   if (end() != NULL) {

   102     invariants();

   103     MemRegion mr(top(), hard_end());

   104     SharedHeap::fill_region_with_object(mr);

   105 

   106     if (retire || ZeroTLAB) {  // "Reset" the TLAB

   107       set_start(NULL);

   108       set_top(NULL);

   109       set_pf_top(NULL);

   110       set_end(NULL);

   111     }

   112   }

   113   assert(!(retire || ZeroTLAB)  ||

   114          (start() == NULL && end() == NULL && top() == NULL),

   115          "TLAB must be reset");

   116 }

   117 

   118 void ThreadLocalAllocBuffer::resize_all_tlabs() {

   119   for(JavaThread *thread = Threads::first(); thread; thread = thread->next()) {

   120     thread->tlab().resize();

   121   }

   122 }

   123 

   124 void ThreadLocalAllocBuffer::resize() {

   125 

   126   if (ResizeTLAB) {

   127     // Compute the next tlab size using expected allocation amount

   128     size_t alloc = (size_t)(_allocation_fraction.average() *

   129                             (Universe::heap()->tlab_capacity(myThread()) / HeapWordSize));

   130     size_t new_size = alloc / _target_refills;

   131 

   132     new_size = MIN2(MAX2(new_size, min_size()), max_size());

   133 

   134     size_t aligned_new_size = align_object_size(new_size);

   135 

   136     if (PrintTLAB && Verbose) {

   137       gclog_or_tty->print("TLAB new size: thread: " INTPTR_FORMAT " [id: %2d]"

   138                           " refills %d  alloc: %8.6f desired_size: " SIZE_FORMAT " -> " SIZE_FORMAT "\n",

   139                           myThread(), myThread()->osthread()->thread_id(),

   140                           _target_refills, _allocation_fraction.average(), desired_size(), aligned_new_size);

   141     }

   142     set_desired_size(aligned_new_size);

   143 

   144     set_refill_waste_limit(initial_refill_waste_limit());

   145   }

   146 }

   147 

   148 void ThreadLocalAllocBuffer::initialize_statistics() {

   149     _number_of_refills = 0;

   150     _fast_refill_waste = 0;

   151     _slow_refill_waste = 0;

   152     _gc_waste          = 0;

   153     _slow_allocations  = 0;

   154 }

   155 

   156 void ThreadLocalAllocBuffer::fill(HeapWord* start,

   157                                   HeapWord* top,

   158                                   size_t    new_size) {

   159   _number_of_refills++;

   160   if (PrintTLAB && Verbose) {

   161     print_stats("fill");

   162   }

   163   assert(top <= start + new_size - alignment_reserve(), "size too small");

   164   initialize(start, top, start + new_size - alignment_reserve());

   165 

   166   // Reset amount of internal fragmentation

   167   set_refill_waste_limit(initial_refill_waste_limit());

   168 }

   169 

   170 void ThreadLocalAllocBuffer::initialize(HeapWord* start,

   171                                         HeapWord* top,

   172                                         HeapWord* end) {

   173   set_start(start);

   174   set_top(top);

   175   set_pf_top(top);

   176   set_end(end);

   177   invariants();

   178 }

   179 

   180 void ThreadLocalAllocBuffer::initialize() {

   181   initialize(NULL,                    // start

   182              NULL,                    // top

   183              NULL);                   // end

   184 

   185   set_desired_size(initial_desired_size());

   186 

   187   // Following check is needed because at startup the main (primordial)

   188   // thread is initialized before the heap is.  The initialization for

   189   // this thread is redone in startup_initialization below.

   190   if (Universe::heap() != NULL) {

   191     size_t capacity   = Universe::heap()->tlab_capacity(myThread()) / HeapWordSize;

   192     double alloc_frac = desired_size() * target_refills() / (double) capacity;

   193     _allocation_fraction.sample(alloc_frac);

   194   }

   195 

   196   set_refill_waste_limit(initial_refill_waste_limit());

   197 

   198   initialize_statistics();

   199 }

   200 

   201 void ThreadLocalAllocBuffer::startup_initialization() {

   202 

   203   // Assuming each thread's active tlab is, on average,

   204   // 1/2 full at a GC

   205   _target_refills = 100 / (2 * TLABWasteTargetPercent);

   206   _target_refills = MAX2(_target_refills, (unsigned)1U);

   207 

   208   _global_stats = new GlobalTLABStats();

   209 

   210   // During jvm startup, the main (primordial) thread is initialized

   211   // before the heap is initialized.  So reinitialize it now.

   212   guarantee(Thread::current()->is_Java_thread(), "tlab initialization thread not Java thread");

   213   Thread::current()->tlab().initialize();

   214 

   215   if (PrintTLAB && Verbose) {

   216     gclog_or_tty->print("TLAB min: " SIZE_FORMAT " initial: " SIZE_FORMAT " max: " SIZE_FORMAT "\n",

   217                         min_size(), Thread::current()->tlab().initial_desired_size(), max_size());

   218   }

   219 }

   220 

   221 size_t ThreadLocalAllocBuffer::initial_desired_size() {

   222   size_t init_sz;

   223 

   224   if (TLABSize > 0) {

   225     init_sz = MIN2(TLABSize / HeapWordSize, max_size());

   226   } else if (global_stats() == NULL) {

   227     // Startup issue - main thread initialized before heap initialized.

   228     init_sz = min_size();

   229   } else {

   230     // Initial size is a function of the average number of allocating threads.

   231     unsigned nof_threads = global_stats()->allocating_threads_avg();

   232 

   233     init_sz  = (Universe::heap()->tlab_capacity(myThread()) / HeapWordSize) /

   234                       (nof_threads * target_refills());

   235     init_sz = align_object_size(init_sz);

   236     init_sz = MIN2(MAX2(init_sz, min_size()), max_size());

   237   }

   238   return init_sz;

   239 }

   240 

   241 const size_t ThreadLocalAllocBuffer::max_size() {

   242 

   243   // TLABs can't be bigger than we can fill with a int[Integer.MAX_VALUE].

   244   // This restriction could be removed by enabling filling with multiple arrays.

   245   // If we compute that the reasonable way as

   246   //    header_size + ((sizeof(jint) * max_jint) / HeapWordSize)

   247   // we'll overflow on the multiply, so we do the divide first.

   248   // We actually lose a little by dividing first,

   249   // but that just makes the TLAB  somewhat smaller than the biggest array,

   250   // which is fine, since we'll be able to fill that.

   251 

   252   size_t unaligned_max_size = typeArrayOopDesc::header_size(T_INT) +

   253                               sizeof(jint) *

   254                               ((juint) max_jint / (size_t) HeapWordSize);

   255   return align_size_down(unaligned_max_size, MinObjAlignment);

   256 }

   257 

   258 void ThreadLocalAllocBuffer::print_stats(const char* tag) {

   259   Thread* thrd = myThread();

   260   size_t waste = _gc_waste + _slow_refill_waste + _fast_refill_waste;

   261   size_t alloc = _number_of_refills * _desired_size;

   262   double waste_percent = alloc == 0 ? 0.0 :

   263                       100.0 * waste / alloc;

   264   size_t tlab_used  = Universe::heap()->tlab_capacity(thrd) -

   265                       Universe::heap()->unsafe_max_tlab_alloc(thrd);

   266   gclog_or_tty->print("TLAB: %s thread: " INTPTR_FORMAT " [id: %2d]"

   267                       " desired_size: " SIZE_FORMAT "KB"

   268                       " slow allocs: %d  refill waste: " SIZE_FORMAT "B"

   269                       " alloc:%8.5f %8.0fKB refills: %d waste %4.1f%% gc: %dB"

   270                       " slow: %dB fast: %dB\n",

   271                       tag, thrd, thrd->osthread()->thread_id(),

   272                       _desired_size / (K / HeapWordSize),

   273                       _slow_allocations, _refill_waste_limit * HeapWordSize,

   274                       _allocation_fraction.average(),

   275                       _allocation_fraction.average() * tlab_used / K,

   276                       _number_of_refills, waste_percent,

   277                       _gc_waste * HeapWordSize,

   278                       _slow_refill_waste * HeapWordSize,

   279                       _fast_refill_waste * HeapWordSize);

   280 }

   281 

   282 void ThreadLocalAllocBuffer::verify() {

   283   HeapWord* p = start();

   284   HeapWord* t = top();

   285   HeapWord* prev_p = NULL;

   286   while (p < t) {

   287     oop(p)->verify();

   288     prev_p = p;

   289     p += oop(p)->size();

   290   }

   291   guarantee(p == top(), "end of last object must match end of space");

   292 }

   293 

   294 Thread* ThreadLocalAllocBuffer::myThread() {

   295   return (Thread*)(((char *)this) +

   296                    in_bytes(start_offset()) -

   297                    in_bytes(Thread::tlab_start_offset()));

   298 }

   299 

   300 

   301 GlobalTLABStats::GlobalTLABStats() :

   302   _allocating_threads_avg(TLABAllocationWeight) {

   303 

   304   initialize();

   305 

   306   _allocating_threads_avg.sample(1); // One allocating thread at startup

   307 

   308   if (UsePerfData) {

   309 

   310     EXCEPTION_MARK;

   311     ResourceMark rm;

   312 

   313     char* cname = PerfDataManager::counter_name("tlab", "allocThreads");

   314     _perf_allocating_threads =

   315       PerfDataManager::create_variable(SUN_GC, cname, PerfData::U_None, CHECK);

   316 

   317     cname = PerfDataManager::counter_name("tlab", "fills");

   318     _perf_total_refills =

   319       PerfDataManager::create_variable(SUN_GC, cname, PerfData::U_None, CHECK);

   320 

   321     cname = PerfDataManager::counter_name("tlab", "maxFills");

   322     _perf_max_refills =

   323       PerfDataManager::create_variable(SUN_GC, cname, PerfData::U_None, CHECK);

   324 

   325     cname = PerfDataManager::counter_name("tlab", "alloc");

   326     _perf_allocation =

   327       PerfDataManager::create_variable(SUN_GC, cname, PerfData::U_Bytes, CHECK);

   328 

   329     cname = PerfDataManager::counter_name("tlab", "gcWaste");

   330     _perf_gc_waste =

   331       PerfDataManager::create_variable(SUN_GC, cname, PerfData::U_Bytes, CHECK);

   332 

   333     cname = PerfDataManager::counter_name("tlab", "maxGcWaste");

   334     _perf_max_gc_waste =

   335       PerfDataManager::create_variable(SUN_GC, cname, PerfData::U_Bytes, CHECK);

   336 

   337     cname = PerfDataManager::counter_name("tlab", "slowWaste");

   338     _perf_slow_refill_waste =

   339       PerfDataManager::create_variable(SUN_GC, cname, PerfData::U_Bytes, CHECK);

   340 

   341     cname = PerfDataManager::counter_name("tlab", "maxSlowWaste");

   342     _perf_max_slow_refill_waste =

   343       PerfDataManager::create_variable(SUN_GC, cname, PerfData::U_Bytes, CHECK);

   344 

   345     cname = PerfDataManager::counter_name("tlab", "fastWaste");

   346     _perf_fast_refill_waste =

   347       PerfDataManager::create_variable(SUN_GC, cname, PerfData::U_Bytes, CHECK);

   348 

   349     cname = PerfDataManager::counter_name("tlab", "maxFastWaste");

   350     _perf_max_fast_refill_waste =

   351       PerfDataManager::create_variable(SUN_GC, cname, PerfData::U_Bytes, CHECK);

   352 

   353     cname = PerfDataManager::counter_name("tlab", "slowAlloc");

   354     _perf_slow_allocations =

   355       PerfDataManager::create_variable(SUN_GC, cname, PerfData::U_None, CHECK);

   356 

   357     cname = PerfDataManager::counter_name("tlab", "maxSlowAlloc");

   358     _perf_max_slow_allocations =

   359       PerfDataManager::create_variable(SUN_GC, cname, PerfData::U_None, CHECK);

   360   }

   361 }

   362 

   363 void GlobalTLABStats::initialize() {

   364   // Clear counters summarizing info from all threads

   365   _allocating_threads      = 0;

   366   _total_refills           = 0;

   367   _max_refills             = 0;

   368   _total_allocation        = 0;

   369   _total_gc_waste          = 0;

   370   _max_gc_waste            = 0;

   371   _total_slow_refill_waste = 0;

   372   _max_slow_refill_waste   = 0;

   373   _total_fast_refill_waste = 0;

   374   _max_fast_refill_waste   = 0;

   375   _total_slow_allocations  = 0;

   376   _max_slow_allocations    = 0;

   377 }

   378 

   379 void GlobalTLABStats::publish() {

   380   _allocating_threads_avg.sample(_allocating_threads);

   381   if (UsePerfData) {

   382     _perf_allocating_threads   ->set_value(_allocating_threads);

   383     _perf_total_refills        ->set_value(_total_refills);

   384     _perf_max_refills          ->set_value(_max_refills);

   385     _perf_allocation           ->set_value(_total_allocation);

   386     _perf_gc_waste             ->set_value(_total_gc_waste);

   387     _perf_max_gc_waste         ->set_value(_max_gc_waste);

   388     _perf_slow_refill_waste    ->set_value(_total_slow_refill_waste);

   389     _perf_max_slow_refill_waste->set_value(_max_slow_refill_waste);

   390     _perf_fast_refill_waste    ->set_value(_total_fast_refill_waste);

   391     _perf_max_fast_refill_waste->set_value(_max_fast_refill_waste);

   392     _perf_slow_allocations     ->set_value(_total_slow_allocations);

   393     _perf_max_slow_allocations ->set_value(_max_slow_allocations);

   394   }

   395 }

   396 

   397 void GlobalTLABStats::print() {

   398   size_t waste = _total_gc_waste + _total_slow_refill_waste + _total_fast_refill_waste;

   399   double waste_percent = _total_allocation == 0 ? 0.0 :

   400                          100.0 * waste / _total_allocation;

   401   gclog_or_tty->print("TLAB totals: thrds: %d  refills: %d max: %d"

   402                       " slow allocs: %d max %d waste: %4.1f%%"

   403                       " gc: " SIZE_FORMAT "B max: " SIZE_FORMAT "B"

   404                       " slow: " SIZE_FORMAT "B max: " SIZE_FORMAT "B"

   405                       " fast: " SIZE_FORMAT "B max: " SIZE_FORMAT "B\n",

   406                       _allocating_threads,

   407                       _total_refills, _max_refills,

   408                       _total_slow_allocations, _max_slow_allocations,

   409                       waste_percent,

   410                       _total_gc_waste * HeapWordSize,

   411                       _max_gc_waste * HeapWordSize,

   412                       _total_slow_refill_waste * HeapWordSize,

   413                       _max_slow_refill_waste * HeapWordSize,

   414                       _total_fast_refill_waste * HeapWordSize,

   415                       _max_fast_refill_waste * HeapWordSize);

   416 }