Fri, 10 Oct 2014 15:51:58 +0200
8059758: Footprint regressions with JDK-8038423
Summary: Changes in JDK-8038423 always initialize (zero out) virtual memory used for auxiliary data structures. This causes a footprint regression for G1 in startup benchmarks. This is because they do not touch that memory at all, so the operating system does not actually commit these pages. The fix is to, if the initialization value of the data structures matches the default value of just committed memory (=0), do not do anything.
Reviewed-by: jwilhelm, brutisso
1 /*
2 * Copyright (c) 2001, 2012, 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 *
23 */
25 #ifndef SHARE_VM_GC_IMPLEMENTATION_G1_DIRTYCARDQUEUE_HPP
26 #define SHARE_VM_GC_IMPLEMENTATION_G1_DIRTYCARDQUEUE_HPP
28 #include "gc_implementation/g1/ptrQueue.hpp"
29 #include "memory/allocation.hpp"
31 class FreeIdSet;
33 // A closure class for processing card table entries. Note that we don't
34 // require these closure objects to be stack-allocated.
35 class CardTableEntryClosure: public CHeapObj<mtGC> {
36 public:
37 // Process the card whose card table entry is "card_ptr". If returns
38 // "false", terminate the iteration early.
39 virtual bool do_card_ptr(jbyte* card_ptr, uint worker_i = 0) = 0;
40 };
42 // A ptrQueue whose elements are "oops", pointers to object heads.
43 class DirtyCardQueue: public PtrQueue {
44 public:
45 DirtyCardQueue(PtrQueueSet* qset_, bool perm = false) :
46 // Dirty card queues are always active, so we create them with their
47 // active field set to true.
48 PtrQueue(qset_, perm, true /* active */) { }
50 // Apply the closure to all elements, and reset the index to make the
51 // buffer empty. If a closure application returns "false", return
52 // "false" immediately, halting the iteration. If "consume" is true,
53 // deletes processed entries from logs.
54 bool apply_closure(CardTableEntryClosure* cl,
55 bool consume = true,
56 uint worker_i = 0);
58 // Apply the closure to all elements of "buf", down to "index"
59 // (inclusive.) If returns "false", then a closure application returned
60 // "false", and we return immediately. If "consume" is true, entries are
61 // set to NULL as they are processed, so they will not be processed again
62 // later.
63 static bool apply_closure_to_buffer(CardTableEntryClosure* cl,
64 void** buf, size_t index, size_t sz,
65 bool consume = true,
66 uint worker_i = 0);
67 void **get_buf() { return _buf;}
68 void set_buf(void **buf) {_buf = buf;}
69 size_t get_index() { return _index;}
70 void reinitialize() { _buf = 0; _sz = 0; _index = 0;}
71 };
75 class DirtyCardQueueSet: public PtrQueueSet {
76 // The closure used in mut_process_buffer().
77 CardTableEntryClosure* _mut_process_closure;
79 DirtyCardQueue _shared_dirty_card_queue;
81 // Override.
82 bool mut_process_buffer(void** buf);
84 // Protected by the _cbl_mon.
85 FreeIdSet* _free_ids;
87 // The number of completed buffers processed by mutator and rs thread,
88 // respectively.
89 jint _processed_buffers_mut;
90 jint _processed_buffers_rs_thread;
92 // Current buffer node used for parallel iteration.
93 BufferNode* volatile _cur_par_buffer_node;
94 public:
95 DirtyCardQueueSet(bool notify_when_complete = true);
97 void initialize(CardTableEntryClosure* cl, Monitor* cbl_mon, Mutex* fl_lock,
98 int process_completed_threshold,
99 int max_completed_queue,
100 Mutex* lock, PtrQueueSet* fl_owner = NULL);
102 // The number of parallel ids that can be claimed to allow collector or
103 // mutator threads to do card-processing work.
104 static uint num_par_ids();
106 static void handle_zero_index_for_thread(JavaThread* t);
108 // Apply the given closure to all entries in all currently-active buffers.
109 // This should only be applied at a safepoint. (Currently must not be called
110 // in parallel; this should change in the future.) If "consume" is true,
111 // processed entries are discarded.
112 void iterate_closure_all_threads(CardTableEntryClosure* cl,
113 bool consume = true,
114 uint worker_i = 0);
116 // If there exists some completed buffer, pop it, then apply the
117 // specified closure to all its elements, nulling out those elements
118 // processed. If all elements are processed, returns "true". If no
119 // completed buffers exist, returns false. If a completed buffer exists,
120 // but is only partially completed before a "yield" happens, the
121 // partially completed buffer (with its processed elements set to NULL)
122 // is returned to the completed buffer set, and this call returns false.
123 bool apply_closure_to_completed_buffer(CardTableEntryClosure* cl,
124 uint worker_i = 0,
125 int stop_at = 0,
126 bool during_pause = false);
128 // Helper routine for the above.
129 bool apply_closure_to_completed_buffer_helper(CardTableEntryClosure* cl,
130 uint worker_i,
131 BufferNode* nd);
133 BufferNode* get_completed_buffer(int stop_at);
135 // Applies the current closure to all completed buffers,
136 // non-consumptively.
137 void apply_closure_to_all_completed_buffers(CardTableEntryClosure* cl);
139 void reset_for_par_iteration() { _cur_par_buffer_node = _completed_buffers_head; }
140 // Applies the current closure to all completed buffers, non-consumptively.
141 // Parallel version.
142 void par_apply_closure_to_all_completed_buffers(CardTableEntryClosure* cl);
144 DirtyCardQueue* shared_dirty_card_queue() {
145 return &_shared_dirty_card_queue;
146 }
148 // Deallocate any completed log buffers
149 void clear();
151 // If a full collection is happening, reset partial logs, and ignore
152 // completed ones: the full collection will make them all irrelevant.
153 void abandon_logs();
155 // If any threads have partial logs, add them to the global list of logs.
156 void concatenate_logs();
157 void clear_n_completed_buffers() { _n_completed_buffers = 0;}
159 jint processed_buffers_mut() {
160 return _processed_buffers_mut;
161 }
162 jint processed_buffers_rs_thread() {
163 return _processed_buffers_rs_thread;
164 }
166 };
168 #endif // SHARE_VM_GC_IMPLEMENTATION_G1_DIRTYCARDQUEUE_HPP