Searched defs:word_size (Results 1 - 22 of 22) sorted by relevance

/openjdk7/hotspot/agent/src/share/classes/sun/jvm/hotspot/memory/
H A DLinearAllocBlock.java51 public long word_size() { method in class:LinearAllocBlock
/openjdk7/hotspot/src/share/vm/gc_implementation/g1/
H A Dg1AllocRegion.inline.hpp31 size_t word_size,
36 return alloc_region->allocate_no_bot_updates(word_size);
38 return alloc_region->allocate(word_size);
43 size_t word_size,
49 return alloc_region->par_allocate_no_bot_updates(word_size);
51 return alloc_region->par_allocate(word_size);
55 inline HeapWord* G1AllocRegion::attempt_allocation(size_t word_size, argument
62 HeapWord* result = par_allocate(alloc_region, word_size, bot_updates);
64 trace("alloc", word_size, result);
67 trace("alloc failed", word_size);
30 allocate(HeapRegion* alloc_region, size_t word_size, bool bot_updates) argument
42 par_allocate(HeapRegion* alloc_region, size_t word_size, bool bot_updates) argument
71 attempt_allocation_locked(size_t word_size, bool bot_updates) argument
91 attempt_allocation_force(size_t word_size, bool bot_updates) argument
[all...]
H A Dvm_operations_g1.cpp39 size_t word_size)
40 : VM_G1OperationWithAllocRequest(gc_count_before, word_size,
42 guarantee(word_size > 0, "an allocation should always be requested");
61 size_t word_size,
65 : VM_G1OperationWithAllocRequest(gc_count_before, word_size, gc_cause),
73 guarantee(word_size == 0 || gc_cause == GCCause::_g1_inc_collection_pause,
37 VM_G1CollectForAllocation( unsigned int gc_count_before, size_t word_size) argument
59 VM_G1IncCollectionPause( unsigned int gc_count_before, size_t word_size, bool should_initiate_conc_mark, double target_pause_time_ms, GCCause::Cause gc_cause) argument
H A Dg1AllocRegion.cpp113 HeapWord* G1AllocRegion::new_alloc_region_and_allocate(size_t word_size, argument
119 HeapRegion* new_alloc_region = allocate_new_region(word_size, force);
124 HeapWord* result = allocate(new_alloc_region, word_size, _bot_updates);
186 void G1AllocRegion::trace(const char* str, size_t word_size, HeapWord* result) { argument
190 if ((word_size == 0 && result == NULL) || (G1_ALLOC_REGION_TRACING > 1)) {
208 word_size, result);
209 } else if (word_size != 0) {
210 jio_snprintf(rest_buffer, buffer_length, SIZE_FORMAT, word_size);
H A Dg1CollectedHeap.inline.hpp62 G1CollectedHeap::attempt_allocation(size_t word_size, argument
65 assert(!isHumongous(word_size), "attempt_allocation() should not "
68 HeapWord* result = _mutator_alloc_region.attempt_allocation(word_size,
71 result = attempt_allocation_slow(word_size, gc_count_before_ret);
75 dirty_young_block(result, word_size);
81 word_size) {
82 assert(!isHumongous(word_size),
85 HeapWord* result = _survivor_gc_alloc_region.attempt_allocation(word_size,
89 result = _survivor_gc_alloc_region.attempt_allocation_locked(word_size,
93 dirty_young_block(result, word_size);
80 survivor_attempt_allocation(size_t word_size) argument
98 old_attempt_allocation(size_t word_size) argument
117 dirty_young_block(HeapWord* start, size_t word_size) argument
[all...]
H A Dvm_operations_g1.hpp46 size_t word_size,
49 _word_size(word_size), _result(NULL), _pause_succeeded(false) { }
70 size_t word_size);
86 size_t word_size,
45 VM_G1OperationWithAllocRequest(unsigned int gc_count_before, size_t word_size, GCCause::Cause gc_cause) argument
H A DconcurrentMark.inline.hpp175 size_t word_size,
180 MemRegion mr(addr, word_size);
213 size_t word_size,
218 MemRegion mr(addr, word_size);
405 inline void ConcurrentMark::grayRoot(oop obj, size_t word_size, argument
419 // We cannot assert that word_size == obj->size() given that obj
422 // assert that word_size is under an upper bound which is its
424 assert(word_size * HeapWordSize <= hr->capacity(),
426 word_size * HeapWordSize, hr->capacity(),
431 par_mark_and_count(obj, word_size, h
174 par_mark_and_count(oop obj, size_t word_size, HeapRegion* hr, uint worker_id) argument
212 par_mark_and_count(oop obj, size_t word_size, uint worker_id) argument
[all...]
H A DheapRegion.hpp199 virtual HeapWord* allocate(size_t word_size);
200 HeapWord* par_allocate(size_t word_size);
213 void update_bot_for_object(HeapWord* start, size_t word_size) { argument
214 _offsets.alloc_block(start, word_size);
380 inline HeapWord* par_allocate_no_bot_updates(size_t word_size) { argument
382 return ContiguousSpace::par_allocate(word_size);
384 inline HeapWord* allocate_no_bot_updates(size_t word_size) { argument
386 return ContiguousSpace::allocate(word_size);
H A Dg1CollectedHeap.cpp568 HeapRegion* G1CollectedHeap::new_region(size_t word_size, bool do_expand) { argument
569 assert(!isHumongous(word_size) || word_size <= HeapRegion::GrainWords,
605 word_size * HeapWordSize);
606 if (expand(word_size * HeapWordSize)) {
623 size_t word_size) {
624 assert(isHumongous(word_size), "word_size should be humongous");
625 assert(num_regions * HeapRegion::GrainWords >= word_size, "pre-condition");
632 HeapRegion* hr = new_region(word_size, fals
622 humongous_obj_allocate_find_first(uint num_regions, size_t word_size) argument
667 humongous_obj_allocate_initialize_regions(uint first, uint num_regions, size_t word_size) argument
802 humongous_obj_allocate(size_t word_size) argument
856 allocate_new_tlab(size_t word_size) argument
865 mem_allocate(size_t word_size, bool* gc_overhead_limit_was_exceeded) argument
916 attempt_allocation_slow(size_t word_size, unsigned int *gc_count_before_ret) argument
1025 attempt_allocation_humongous(size_t word_size, unsigned int * gc_count_before_ret) argument
1135 attempt_allocation_at_safepoint(size_t word_size, bool expect_null_mutator_alloc_region) argument
1279 do_collection(bool explicit_gc, bool clear_all_soft_refs, size_t word_size) argument
1570 resize_if_necessary_after_full_collection(size_t word_size) argument
1659 satisfy_failed_allocation(size_t word_size, bool* succeeded) argument
1733 expand_and_allocate(size_t word_size) argument
2444 size_t word_size = HeapRegion::GrainWords - 1024; local
3634 do_collection_pause(size_t word_size, unsigned int gc_count_before, bool* succeeded) argument
4450 par_allocate_during_gc(GCAllocPurpose purpose, size_t word_size) argument
6358 new_mutator_alloc_region(size_t word_size, bool force) argument
6390 allocate_new_region(size_t word_size, bool force) argument
6418 new_gc_alloc_region(size_t word_size, uint count, GCAllocPurpose ap) argument
6461 allocate_new_region(size_t word_size, bool force) argument
6473 allocate_new_region(size_t word_size, bool force) argument
[all...]
/openjdk7/hotspot/src/share/vm/memory/
H A Dgeneration.inline.hpp46 HeapWord* OneContigSpaceCardGeneration::allocate(size_t word_size, argument
49 return the_space()->allocate(word_size);
52 HeapWord* OneContigSpaceCardGeneration::par_allocate(size_t word_size, argument
55 return the_space()->par_allocate(word_size);
H A DmemRegion.hpp47 MemRegion(HeapWord* start, size_t word_size) : argument
48 _start(start), _word_size(word_size) {};
69 void set_word_size(size_t word_size) { argument
70 _word_size = word_size;
86 size_t word_size() const { return _word_size; } function in class:VALUE_OBJ_CLASS_SPEC
88 bool is_empty() const { return word_size() == 0; }
H A DdefNewGeneration.hpp261 virtual bool should_allocate(size_t word_size, bool is_tlab) { argument
266 const bool non_zero = word_size > 0;
267 const bool overflows = word_size >= overflow_limit;
269 const bool not_too_big = word_size < _pretenure_size_threshold_words;
279 HeapWord* allocate(size_t word_size, bool is_tlab);
280 HeapWord* allocate_from_space(size_t word_size);
282 HeapWord* par_allocate(size_t word_size, bool is_tlab);
H A Dgeneration.hpp255 virtual bool should_allocate(size_t word_size, bool is_tlab) { argument
259 result = (word_size > 0) && (word_size < overflow_limit);
266 virtual HeapWord* allocate(size_t word_size, bool is_tlab) = 0;
269 virtual HeapWord* par_allocate(size_t word_size, bool is_tlab) = 0;
275 size_t word_size) {
365 size_t word_size,
367 return (full || should_allocate(word_size, is_tlab));
383 // allocation of the given "word_size".
386 size_t word_size,
274 allocation_limit_reached(Space* space, HeapWord* top, size_t word_size) argument
364 should_collect(bool full, size_t word_size, bool is_tlab) argument
[all...]
H A DdefNewGeneration.cpp998 HeapWord* DefNewGeneration::allocate(size_t word_size, argument
1005 HeapWord* result = eden()->par_allocate(word_size);
1014 next_gen()->allocation_limit_reached(eden(), eden()->top(), word_size);
1028 result = eden()->par_allocate(word_size);
1036 result = allocate_from_space(word_size);
1041 HeapWord* DefNewGeneration::par_allocate(size_t word_size, argument
1043 return eden()->par_allocate(word_size);
H A Dgeneration.cpp494 OneContigSpaceCardGeneration::expand_and_allocate(size_t word_size, argument
501 size_t byte_size = word_size * HeapWordSize;
507 result = _the_space->par_allocate(word_size);
519 expand(word_size*HeapWordSize, _min_heap_delta_bytes);
520 return _the_space->allocate(word_size);
/openjdk7/hotspot/src/share/vm/gc_implementation/parallelScavenge/
H A DpsOldGen.hpp63 HeapWord* allocate_noexpand(size_t word_size) { argument
66 HeapWord* res = object_space()->allocate(word_size);
76 HeapWord* cas_allocate_noexpand(size_t word_size) { argument
78 HeapWord* res = object_space()->cas_allocate(word_size);
86 HeapWord* cas_allocate(size_t word_size) { argument
87 HeapWord* res = cas_allocate_noexpand(word_size);
88 return (res == NULL) ? expand_and_cas_allocate(word_size) : res;
91 HeapWord* expand_and_allocate(size_t word_size);
92 HeapWord* expand_and_cas_allocate(size_t word_size);
166 HeapWord* allocate(size_t word_size);
[all...]
H A DpsYoungGen.hpp160 HeapWord* allocate(size_t word_size) { argument
161 HeapWord* result = eden_space()->cas_allocate(word_size);
H A DpsOldGen.cpp185 HeapWord* PSOldGen::allocate(size_t word_size) { argument
187 HeapWord* res = allocate_noexpand(word_size);
190 res = expand_and_allocate(word_size);
196 heap->size_policy()->tenured_allocation(word_size);
202 HeapWord* PSOldGen::expand_and_allocate(size_t word_size) { argument
203 expand(word_size*HeapWordSize);
207 return allocate_noexpand(word_size);
210 HeapWord* PSOldGen::expand_and_cas_allocate(size_t word_size) { argument
211 expand(word_size*HeapWordSize);
215 return cas_allocate_noexpand(word_size);
[all...]
/openjdk7/hotspot/src/share/vm/libadt/
H A Dvectset.hpp110 uint word_size() const { return size; } function in class:VectorSet
/openjdk7/hotspot/src/share/vm/gc_implementation/concurrentMarkSweep/
H A DcompactibleFreeListSpace.hpp49 void set(HeapWord* ptr, size_t word_size, size_t refill_size, argument
52 _word_size = word_size;
H A DconcurrentMarkSweepGeneration.cpp618 assert( _cmsGen->reserved().word_size() > 0
619 && _permGen->reserved().word_size() > 0,
1202 size_t word_size)
1219 if (word_size < pointer_delta(_icms_stop_limit, top)) {
3314 ConcurrentMarkSweepGeneration::expand_and_allocate(size_t word_size,
3320 expand(word_size*HeapWordSize, MinHeapDeltaBytes,
3325 return have_lock_and_allocate(word_size, tlab);
4779 _modUnionTable.heapWordDiffToOffsetDiff(dirtyRegion.word_size());
4874 dirtyRegion.word_size()/CardTableModRefBS::card_size_in_words;
6516 _bmWordSize = mr.word_size();
1201 allocation_limit_reached(Space* space, HeapWord* top, size_t word_size) argument
[all...]
/openjdk7/hotspot/src/share/vm/oops/
H A DmethodDataOop.cpp603 int word_size = align_size_up(byte_size, BytesPerWord) / BytesPerWord; local
604 return align_object_size(word_size);

Completed in 129 milliseconds