1.1 --- a/src/share/vm/gc_implementation/parallelScavenge/psOldGen.hpp Wed Jun 22 14:26:49 2016 +0800 1.2 +++ b/src/share/vm/gc_implementation/parallelScavenge/psOldGen.hpp Fri Jun 24 17:12:13 2016 +0800 1.3 @@ -22,12 +22,6 @@ 1.4 * 1.5 */ 1.6 1.7 -/* 1.8 - * This file has been modified by Loongson Technology in 2015. These 1.9 - * modifications are Copyright (c) 2015 Loongson Technology, and are made 1.10 - * available on the same license terms set forth above. 1.11 - */ 1.12 - 1.13 #ifndef SHARE_VM_GC_IMPLEMENTATION_PARALLELSCAVENGE_PSOLDGEN_HPP 1.14 #define SHARE_VM_GC_IMPLEMENTATION_PARALLELSCAVENGE_PSOLDGEN_HPP 1.15 1.16 @@ -35,7 +29,6 @@ 1.17 #include "gc_implementation/parallelScavenge/psGenerationCounters.hpp" 1.18 #include "gc_implementation/parallelScavenge/psVirtualspace.hpp" 1.19 #include "gc_implementation/shared/mutableSpace.hpp" 1.20 -#include "gc_implementation/shared/mutableNUMASpace.hpp" 1.21 #include "gc_implementation/shared/spaceCounters.hpp" 1.22 #include "runtime/safepoint.hpp" 1.23 1.24 @@ -80,15 +73,9 @@ 1.25 // Support for MT garbage collection. CAS allocation is lower overhead than grabbing 1.26 // and releasing the heap lock, which is held during gc's anyway. This method is not 1.27 // safe for use at the same time as allocate_noexpand()! 1.28 - HeapWord* cas_allocate_noexpand(size_t word_size, int node) { 1.29 + HeapWord* cas_allocate_noexpand(size_t word_size) { 1.30 assert(SafepointSynchronize::is_at_safepoint(), "Must only be called at safepoint"); 1.31 - HeapWord* res; 1.32 - if(UseOldNUMA) { 1.33 - res = object_space()->cas_allocate_oldnuma(word_size, node); 1.34 - } 1.35 - else { 1.36 - res = object_space()->cas_allocate(word_size); 1.37 - } 1.38 + HeapWord* res = object_space()->cas_allocate(word_size); 1.39 if (res != NULL) { 1.40 _start_array.allocate_block(res); 1.41 } 1.42 @@ -96,13 +83,13 @@ 1.43 } 1.44 1.45 // Support for MT garbage collection. See above comment. 1.46 - HeapWord* cas_allocate(size_t word_size, int node) { 1.47 - HeapWord* res = cas_allocate_noexpand(word_size, node); 1.48 - return (res == NULL) ? expand_and_cas_allocate(word_size, node) : res; 1.49 + HeapWord* cas_allocate(size_t word_size) { 1.50 + HeapWord* res = cas_allocate_noexpand(word_size); 1.51 + return (res == NULL) ? expand_and_cas_allocate(word_size) : res; 1.52 } 1.53 1.54 HeapWord* expand_and_allocate(size_t word_size); 1.55 - HeapWord* expand_and_cas_allocate(size_t word_size, int node); 1.56 + HeapWord* expand_and_cas_allocate(size_t word_size); 1.57 void expand(size_t bytes); 1.58 bool expand_by(size_t bytes); 1.59 bool expand_to_reserved(); 1.60 @@ -160,22 +147,6 @@ 1.61 size_t capacity_in_bytes() const { return object_space()->capacity_in_bytes(); } 1.62 size_t used_in_bytes() const { return object_space()->used_in_bytes(); } 1.63 size_t free_in_bytes() const { return object_space()->free_in_bytes(); } 1.64 - size_t free_in_bytes_numa() const { 1.65 - size_t min_size, free_bytes; 1.66 - MutableNUMASpace* s = (MutableNUMASpace*) object_space(); 1.67 - int i = s->lgrp_spaces()->length(); 1.68 - int j; 1.69 - MutableNUMASpace::LGRPSpace *ls; 1.70 - MutableSpace* sp; 1.71 - for(j = 0; j < i; j++) { 1.72 - ls = s->lgrp_spaces()->at(j); 1.73 - sp = ls->space(); 1.74 - free_bytes = sp->free_in_bytes(); 1.75 - if(j == 0) min_size = free_bytes; 1.76 - if(free_bytes < min_size) min_size = free_bytes; 1.77 - } 1.78 - return min_size; 1.79 - } 1.80 1.81 size_t capacity_in_words() const { return object_space()->capacity_in_words(); } 1.82 size_t used_in_words() const { return object_space()->used_in_words(); }