1.1 --- a/src/share/vm/memory/freeList.hpp Thu Mar 29 19:46:24 2012 -0700
1.2 +++ b/src/share/vm/memory/freeList.hpp Wed Apr 25 09:55:55 2012 -0700
1.3 @@ -119,7 +119,7 @@
1.4 // If this method is not used (just set the head instead),
1.5 // this check can be avoided.
1.6 if (v != NULL) {
1.7 - v->linkPrev(NULL);
1.8 + v->link_prev(NULL);
1.9 }
1.10 }
1.11
1.12 @@ -138,7 +138,7 @@
1.13 assert_proper_lock_protection();
1.14 set_tail(v);
1.15 if (v != NULL) {
1.16 - v->clearNext();
1.17 + v->clear_next();
1.18 }
1.19 }
1.20
1.21 @@ -185,12 +185,12 @@
1.22 inter_sweep_estimate,
1.23 intra_sweep_estimate);
1.24 }
1.25 - ssize_t coalDesired() const {
1.26 - return _allocation_stats.coalDesired();
1.27 + ssize_t coal_desired() const {
1.28 + return _allocation_stats.coal_desired();
1.29 }
1.30 - void set_coalDesired(ssize_t v) {
1.31 + void set_coal_desired(ssize_t v) {
1.32 assert_proper_lock_protection();
1.33 - _allocation_stats.set_coalDesired(v);
1.34 + _allocation_stats.set_coal_desired(v);
1.35 }
1.36
1.37 ssize_t surplus() const {
1.38 @@ -209,106 +209,106 @@
1.39 _allocation_stats.decrement_surplus();
1.40 }
1.41
1.42 - ssize_t bfrSurp() const {
1.43 - return _allocation_stats.bfrSurp();
1.44 + ssize_t bfr_surp() const {
1.45 + return _allocation_stats.bfr_surp();
1.46 }
1.47 - void set_bfrSurp(ssize_t v) {
1.48 + void set_bfr_surp(ssize_t v) {
1.49 assert_proper_lock_protection();
1.50 - _allocation_stats.set_bfrSurp(v);
1.51 + _allocation_stats.set_bfr_surp(v);
1.52 }
1.53 - ssize_t prevSweep() const {
1.54 - return _allocation_stats.prevSweep();
1.55 + ssize_t prev_sweep() const {
1.56 + return _allocation_stats.prev_sweep();
1.57 }
1.58 - void set_prevSweep(ssize_t v) {
1.59 + void set_prev_sweep(ssize_t v) {
1.60 assert_proper_lock_protection();
1.61 - _allocation_stats.set_prevSweep(v);
1.62 + _allocation_stats.set_prev_sweep(v);
1.63 }
1.64 - ssize_t beforeSweep() const {
1.65 - return _allocation_stats.beforeSweep();
1.66 + ssize_t before_sweep() const {
1.67 + return _allocation_stats.before_sweep();
1.68 }
1.69 - void set_beforeSweep(ssize_t v) {
1.70 + void set_before_sweep(ssize_t v) {
1.71 assert_proper_lock_protection();
1.72 - _allocation_stats.set_beforeSweep(v);
1.73 + _allocation_stats.set_before_sweep(v);
1.74 }
1.75
1.76 - ssize_t coalBirths() const {
1.77 - return _allocation_stats.coalBirths();
1.78 + ssize_t coal_births() const {
1.79 + return _allocation_stats.coal_births();
1.80 }
1.81 - void set_coalBirths(ssize_t v) {
1.82 + void set_coal_births(ssize_t v) {
1.83 assert_proper_lock_protection();
1.84 - _allocation_stats.set_coalBirths(v);
1.85 + _allocation_stats.set_coal_births(v);
1.86 }
1.87 - void increment_coalBirths() {
1.88 + void increment_coal_births() {
1.89 assert_proper_lock_protection();
1.90 - _allocation_stats.increment_coalBirths();
1.91 + _allocation_stats.increment_coal_births();
1.92 }
1.93
1.94 - ssize_t coalDeaths() const {
1.95 - return _allocation_stats.coalDeaths();
1.96 + ssize_t coal_deaths() const {
1.97 + return _allocation_stats.coal_deaths();
1.98 }
1.99 - void set_coalDeaths(ssize_t v) {
1.100 + void set_coal_deaths(ssize_t v) {
1.101 assert_proper_lock_protection();
1.102 - _allocation_stats.set_coalDeaths(v);
1.103 + _allocation_stats.set_coal_deaths(v);
1.104 }
1.105 - void increment_coalDeaths() {
1.106 + void increment_coal_deaths() {
1.107 assert_proper_lock_protection();
1.108 - _allocation_stats.increment_coalDeaths();
1.109 + _allocation_stats.increment_coal_deaths();
1.110 }
1.111
1.112 - ssize_t splitBirths() const {
1.113 - return _allocation_stats.splitBirths();
1.114 + ssize_t split_births() const {
1.115 + return _allocation_stats.split_births();
1.116 }
1.117 - void set_splitBirths(ssize_t v) {
1.118 + void set_split_births(ssize_t v) {
1.119 assert_proper_lock_protection();
1.120 - _allocation_stats.set_splitBirths(v);
1.121 + _allocation_stats.set_split_births(v);
1.122 }
1.123 - void increment_splitBirths() {
1.124 + void increment_split_births() {
1.125 assert_proper_lock_protection();
1.126 - _allocation_stats.increment_splitBirths();
1.127 + _allocation_stats.increment_split_births();
1.128 }
1.129
1.130 - ssize_t splitDeaths() const {
1.131 - return _allocation_stats.splitDeaths();
1.132 + ssize_t split_deaths() const {
1.133 + return _allocation_stats.split_deaths();
1.134 }
1.135 - void set_splitDeaths(ssize_t v) {
1.136 + void set_split_deaths(ssize_t v) {
1.137 assert_proper_lock_protection();
1.138 - _allocation_stats.set_splitDeaths(v);
1.139 + _allocation_stats.set_split_deaths(v);
1.140 }
1.141 - void increment_splitDeaths() {
1.142 + void increment_split_deaths() {
1.143 assert_proper_lock_protection();
1.144 - _allocation_stats.increment_splitDeaths();
1.145 + _allocation_stats.increment_split_deaths();
1.146 }
1.147
1.148 NOT_PRODUCT(
1.149 - // For debugging. The "_returnedBytes" in all the lists are summed
1.150 + // For debugging. The "_returned_bytes" in all the lists are summed
1.151 // and compared with the total number of bytes swept during a
1.152 // collection.
1.153 - size_t returnedBytes() const { return _allocation_stats.returnedBytes(); }
1.154 - void set_returnedBytes(size_t v) { _allocation_stats.set_returnedBytes(v); }
1.155 - void increment_returnedBytes_by(size_t v) {
1.156 - _allocation_stats.set_returnedBytes(_allocation_stats.returnedBytes() + v);
1.157 + size_t returned_bytes() const { return _allocation_stats.returned_bytes(); }
1.158 + void set_returned_bytes(size_t v) { _allocation_stats.set_returned_bytes(v); }
1.159 + void increment_returned_bytes_by(size_t v) {
1.160 + _allocation_stats.set_returned_bytes(_allocation_stats.returned_bytes() + v);
1.161 }
1.162 )
1.163
1.164 // Unlink head of list and return it. Returns NULL if
1.165 // the list is empty.
1.166 - Chunk* getChunkAtHead();
1.167 + Chunk* get_chunk_at_head();
1.168
1.169 // Remove the first "n" or "count", whichever is smaller, chunks from the
1.170 // list, setting "fl", which is required to be empty, to point to them.
1.171 void getFirstNChunksFromList(size_t n, FreeList<Chunk>* fl);
1.172
1.173 // Unlink this chunk from it's free list
1.174 - void removeChunk(Chunk* fc);
1.175 + void remove_chunk(Chunk* fc);
1.176
1.177 // Add this chunk to this free list.
1.178 - void returnChunkAtHead(Chunk* fc);
1.179 - void returnChunkAtTail(Chunk* fc);
1.180 + void return_chunk_at_head(Chunk* fc);
1.181 + void return_chunk_at_tail(Chunk* fc);
1.182
1.183 // Similar to returnChunk* but also records some diagnostic
1.184 // information.
1.185 - void returnChunkAtHead(Chunk* fc, bool record_return);
1.186 - void returnChunkAtTail(Chunk* fc, bool record_return);
1.187 + void return_chunk_at_head(Chunk* fc, bool record_return);
1.188 + void return_chunk_at_tail(Chunk* fc, bool record_return);
1.189
1.190 // Prepend "fl" (whose size is required to be the same as that of "this")
1.191 // to the front of "this" list.
1.192 @@ -316,7 +316,7 @@
1.193
1.194 // Verify that the chunk is in the list.
1.195 // found. Return NULL if "fc" is not found.
1.196 - bool verifyChunkInFreeLists(Chunk* fc) const;
1.197 + bool verify_chunk_in_free_list(Chunk* fc) const;
1.198
1.199 // Stats verification
1.200 void verify_stats() const PRODUCT_RETURN;
