You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@harmony.apache.org by xl...@apache.org on 2007/05/24 10:17:26 UTC
svn commit: r541224 [1/2] - in /harmony/enhanced/drlvm/trunk/vm/gc_gen/src:
common/ finalizer_weakref/ gen/ mark_compact/ mark_sweep/ utils/
Author: xli
Date: Thu May 24 01:17:25 2007
New Revision: 541224
URL: http://svn.apache.org/viewvc?view=rev&rev=541224
Log:
HARMONY-3825 : [drlvm][gc_gen]Patch for heap size extension
Modified:
harmony/enhanced/drlvm/trunk/vm/gc_gen/src/common/gc_common.cpp
harmony/enhanced/drlvm/trunk/vm/gc_gen/src/common/gc_common.h
harmony/enhanced/drlvm/trunk/vm/gc_gen/src/common/gc_for_vm.cpp
harmony/enhanced/drlvm/trunk/vm/gc_gen/src/common/gc_space.h
harmony/enhanced/drlvm/trunk/vm/gc_gen/src/common/hashcode.h
harmony/enhanced/drlvm/trunk/vm/gc_gen/src/common/space_tuner.cpp
harmony/enhanced/drlvm/trunk/vm/gc_gen/src/common/space_tuner.h
harmony/enhanced/drlvm/trunk/vm/gc_gen/src/finalizer_weakref/finalizer_weakref.cpp
harmony/enhanced/drlvm/trunk/vm/gc_gen/src/gen/gen.cpp
harmony/enhanced/drlvm/trunk/vm/gc_gen/src/gen/gen.h
harmony/enhanced/drlvm/trunk/vm/gc_gen/src/gen/gen_adapt.cpp
harmony/enhanced/drlvm/trunk/vm/gc_gen/src/mark_compact/fallback_mark_scan.cpp
harmony/enhanced/drlvm/trunk/vm/gc_gen/src/mark_compact/los_extention_mark_scan.cpp
harmony/enhanced/drlvm/trunk/vm/gc_gen/src/mark_compact/mspace.cpp
harmony/enhanced/drlvm/trunk/vm/gc_gen/src/mark_compact/mspace.h
harmony/enhanced/drlvm/trunk/vm/gc_gen/src/mark_compact/mspace_collect_compact.cpp
harmony/enhanced/drlvm/trunk/vm/gc_gen/src/mark_compact/mspace_collect_compact.h
harmony/enhanced/drlvm/trunk/vm/gc_gen/src/mark_compact/mspace_move_compact.cpp
harmony/enhanced/drlvm/trunk/vm/gc_gen/src/mark_compact/mspace_slide_compact.cpp
harmony/enhanced/drlvm/trunk/vm/gc_gen/src/mark_sweep/lspace.cpp
harmony/enhanced/drlvm/trunk/vm/gc_gen/src/mark_sweep/lspace_alloc_collect.cpp
harmony/enhanced/drlvm/trunk/vm/gc_gen/src/utils/seq_list.h
Modified: harmony/enhanced/drlvm/trunk/vm/gc_gen/src/common/gc_common.cpp
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/gc_gen/src/common/gc_common.cpp?view=diff&rev=541224&r1=541223&r2=541224
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/gc_gen/src/common/gc_common.cpp (original)
+++ harmony/enhanced/drlvm/trunk/vm/gc_gen/src/common/gc_common.cpp Thu May 24 01:17:25 2007
@@ -132,23 +132,34 @@
if (is_property_set("gc.mx", VM_PROPERTIES) == 1) {
max_heap_size = get_size_property("gc.mx");
- if (max_heap_size < min_heap_size)
+ if (max_heap_size < min_heap_size){
max_heap_size = min_heap_size;
- if (0 == max_heap_size)
+ printf("Max heap size: too small, reset to %d MB!\n", max_heap_size/MB);
+ }
+ if (0 == max_heap_size){
max_heap_size = HEAP_SIZE_DEFAULT;
+ printf("Max heap size: zero, reset to %d MB! \n", max_heap_size/MB);
+ }
min_heap_size = max_heap_size / 10;
- if (min_heap_size < min_heap_size_bytes) min_heap_size = min_heap_size_bytes;
+ if (min_heap_size < min_heap_size_bytes){
+ min_heap_size = min_heap_size_bytes;
+// printf("Min heap size: too small, reset to %d MB! \n", min_heap_size/MB);
+ }
}
if (is_property_set("gc.ms", VM_PROPERTIES) == 1) {
min_heap_size = get_size_property("gc.ms");
- if (min_heap_size < min_heap_size_bytes)
+ if (min_heap_size < min_heap_size_bytes){
min_heap_size = min_heap_size_bytes;
+ printf("Min heap size: too small, reset to %d MB! \n", min_heap_size/MB);
+ }
}
- if (min_heap_size > max_heap_size)
+ if (min_heap_size > max_heap_size){
max_heap_size = min_heap_size;
+ printf("Max heap size: too small, reset to %d MB\n", max_heap_size / MB);
+ }
min_heap_size_bytes = min_heap_size;
max_heap_size_bytes = max_heap_size;
@@ -251,6 +262,11 @@
gc_gen_assign_free_area_to_mutators((GC_Gen*)gc);
}
+void gc_adjust_heap_size(GC* gc, int64 pause_time)
+{
+ gc_gen_adjust_heap_size((GC_Gen*)gc, pause_time);
+}
+
void gc_copy_interior_pointer_table_to_rootset();
void gc_reclaim_heap(GC* gc, unsigned int gc_cause)
@@ -263,18 +279,10 @@
gc->cause = gc_cause;
gc_decide_collection_kind((GC_Gen*)gc, gc_cause);
-
- //For_LOS_extend!
-#ifdef GC_FIXED_SIZE_TUNER
- gc_space_tune_before_gc_fixed_size(gc, gc_cause);
-#else
- gc_space_tune_prepare(gc, gc_cause);
- gc_space_tune_before_gc(gc, gc_cause);
-#endif
+ gc_compute_space_tune_size_before_marking(gc, gc_cause);
#ifdef MARK_BIT_FLIPPING
- if(gc_match_kind(gc, MINOR_COLLECTION))
- mark_bit_flip();
+ if(gc_match_kind(gc, MINOR_COLLECTION)) mark_bit_flip();
#endif
gc_metadata_verify(gc, TRUE);
@@ -291,21 +299,22 @@
/* this has to be done after all mutators are suspended */
gc_reset_mutator_context(gc);
- if(!IGNORE_FINREF )
- gc_set_obj_with_fin(gc);
+ if(!IGNORE_FINREF ) gc_set_obj_with_fin(gc);
gc_gen_reclaim_heap((GC_Gen*)gc);
gc_reset_interior_pointer_table();
-
+
gc_metadata_verify(gc, FALSE);
int64 pause_time = time_now() - start_time;
gc->time_collections += pause_time;
+
+ gc_adjust_heap_size(gc, pause_time);
+
gc_gen_adapt((GC_Gen*)gc, pause_time);
- if(gc_is_gen_mode())
- gc_prepare_mutator_remset(gc);
+ if(gc_is_gen_mode()) gc_prepare_mutator_remset(gc);
if(!IGNORE_FINREF ){
gc_put_finref_to_vm(gc);
@@ -317,16 +326,12 @@
#endif
}
- //For_LOS_extend!
gc_space_tuner_reset(gc);
-
+
gc_assign_free_area_to_mutators(gc);
-
+
vm_resume_threads_after();
return;
}
-
-
-
Modified: harmony/enhanced/drlvm/trunk/vm/gc_gen/src/common/gc_common.h
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/gc_gen/src/common/gc_common.h?view=diff&rev=541224&r1=541223&r2=541224
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/gc_gen/src/common/gc_common.h (original)
+++ harmony/enhanced/drlvm/trunk/vm/gc_gen/src/common/gc_common.h Thu May 24 01:17:25 2007
@@ -388,7 +388,6 @@
Vector_Block* root_set;
Vector_Block* uncompressed_root_set;
- //For_LOS_extend
Space_Tuner* tuner;
}GC;
@@ -443,6 +442,9 @@
extern void* los_boundary;
+/*This flag indicate whether lspace is using a sliding compaction
+ *Fixme: check if the performance is a problem with this global flag.
+ */
extern Boolean* p_global_lspace_move_obj;
inline Boolean obj_is_moved(Partial_Reveal_Object* p_obj)
{ return ((p_obj >= los_boundary) || (*p_global_lspace_move_obj)); }
Modified: harmony/enhanced/drlvm/trunk/vm/gc_gen/src/common/gc_for_vm.cpp
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/gc_gen/src/common/gc_for_vm.cpp?view=diff&rev=541224&r1=541223&r2=541224
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/gc_gen/src/common/gc_for_vm.cpp (original)
+++ harmony/enhanced/drlvm/trunk/vm/gc_gen/src/common/gc_for_vm.cpp Thu May 24 01:17:25 2007
@@ -237,6 +237,7 @@
if(!p_obj) return 0;
assert(address_belongs_to_gc_heap(p_obj, p_global_gc));
Obj_Info_Type info = get_obj_info_raw(p_obj);
+ unsigned int new_info = 0;
int hash;
switch(info & HASHCODE_MASK){
@@ -250,7 +251,13 @@
hash = hashcode_lookup(p_obj,info);
break;
case HASHCODE_UNSET:
- set_obj_info(p_obj, info | HASHCODE_SET_BIT);
+ new_info = (unsigned int)(info | HASHCODE_SET_BIT);
+ while (true) {
+ unsigned int temp = atomic_cas32(&p_obj->obj_info, new_info, info);
+ if (temp == info) break;
+ info = get_obj_info_raw(p_obj);
+ new_info = (unsigned int)(info | HASHCODE_SET_BIT);
+ }
hash = hashcode_gen((void*)p_obj);
break;
default:
Modified: harmony/enhanced/drlvm/trunk/vm/gc_gen/src/common/gc_space.h
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/gc_gen/src/common/gc_space.h?view=diff&rev=541224&r1=541223&r2=541224
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/gc_gen/src/common/gc_space.h (original)
+++ harmony/enhanced/drlvm/trunk/vm/gc_gen/src/common/gc_space.h Thu May 24 01:17:25 2007
@@ -161,7 +161,8 @@
void* new_end = (void*)((POINTER_SIZE_INT)commit_base + commit_size);
space->committed_heap_size = (POINTER_SIZE_INT)new_end - (POINTER_SIZE_INT)space->heap_start;
-
+ /*Fixme: For_Heap_Adjust, but need fix if static mapping.*/
+ space->heap_end = new_end;
/* init the grown blocks */
Block_Header* block = (Block_Header*)commit_base;
Block_Header* last_block = (Block_Header*)((Block*)block -1);
Modified: harmony/enhanced/drlvm/trunk/vm/gc_gen/src/common/hashcode.h
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/gc_gen/src/common/hashcode.h?view=diff&rev=541224&r1=541223&r2=541224
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/gc_gen/src/common/hashcode.h (original)
+++ harmony/enhanced/drlvm/trunk/vm/gc_gen/src/common/hashcode.h Thu May 24 01:17:25 2007
@@ -53,6 +53,7 @@
typedef struct Hashcode_Buf{
Seq_List* list;
POINTER_SIZE_INT* checkpoint;
+ SpinLock lock;
}Hashcode_Buf;
extern GC_Metadata gc_metadata;
@@ -117,6 +118,7 @@
inline int hashcode_buf_lookup(Partial_Reveal_Object* p_obj,Hashcode_Buf* hashcode_buf)
{
POINTER_SIZE_INT obj_addr = (POINTER_SIZE_INT)p_obj;
+ lock(hashcode_buf->lock);
Seq_List* list = hashcode_buf->list;
seq_list_iterate_init(list);
while(seq_list_has_next(list)){
@@ -132,11 +134,13 @@
iter = vector_block_iterator_advance(curr_block, iter);
POINTER_SIZE_INT hashcode = (POINTER_SIZE_INT)*iter;
iter = vector_block_iterator_advance(curr_block, iter);
+ unlock(hashcode_buf->lock);
return *(int*)&hashcode;
}
}
}
assert(0);
+ unlock(hashcode_buf->lock);
return 0;
}
@@ -345,374 +349,6 @@
inline void precompute_hashcode_extend_size(Partial_Reveal_Object* p_obj, void* dest_addr,
unsigned int * obj_size_precompute)
-{
- if(hashcode_is_set(p_obj) && !hashcode_is_attached(p_obj)){
- if((POINTER_SIZE_INT)dest_addr != (POINTER_SIZE_INT)p_obj)
- *obj_size_precompute += GC_OBJECT_ALIGNMENT;
- }
-}
-
-inline int obj_lookup_hashcode_in_buf(Partial_Reveal_Object *p_obj);
-inline int hashcode_lookup(Partial_Reveal_Object* p_obj,Obj_Info_Type obj_info)
-{
- int hash;
- if(hashcode_is_attached(p_obj)){
- int offset = vm_object_size(p_obj);
- unsigned char* pos = (unsigned char *)p_obj;
- hash = *(int*) (pos + offset);
- }else if(hashcode_is_buffered(p_obj)){
- hash = obj_lookup_hashcode_in_buf(p_obj);
- }
- return hash;
-}
-#endif //_HASHCODE_H_
-#ifndef _HASHCODE_H_
-#define _HASHCODE_H_
-
-#include "gc_common.h"
-#include "../utils/vector_block.h"
-#include "../utils/seq_list.h"
-
-#define HASHCODE_MASK 0x1C
-
-#define HASHCODE_SET_BIT 0x04
-#define HASHCODE_ATTACHED_BIT 0x08
-#define HASHCODE_BUFFERED_BIT 0x10
-
-#define HASHCODE_EXTENDED_VT_BIT 0x02
-
-enum Hashcode_Kind{
- HASHCODE_UNSET = 0x0,
- HASHCODE_SET_UNALLOCATED = HASHCODE_SET_BIT,
- HASHCODE_SET_ATTACHED = HASHCODE_SET_BIT | HASHCODE_ATTACHED_BIT,
- HASHCODE_SET_BUFFERED = HASHCODE_SET_BIT | HASHCODE_BUFFERED_BIT
-};
-
-inline Boolean obj_is_sethash_in_vt(Partial_Reveal_Object* p_obj){
- return (Boolean)((POINTER_SIZE_INT)obj_get_vt_raw(p_obj) & HASHCODE_EXTENDED_VT_BIT);
-}
-
-inline void obj_sethash_in_vt(Partial_Reveal_Object* p_obj){
- VT vt = obj_get_vt_raw(p_obj);
- obj_set_vt(p_obj,(VT)((POINTER_SIZE_INT)vt | HASHCODE_EXTENDED_VT_BIT));
-}
-
-inline Boolean hashcode_is_set(Partial_Reveal_Object* p_obj)
-{
- Obj_Info_Type obj_info = get_obj_info_raw(p_obj);
- return obj_info & HASHCODE_SET_BIT;
-}
-
-inline Boolean hashcode_is_attached(Partial_Reveal_Object* p_obj)
-{
- Obj_Info_Type obj_info = get_obj_info_raw(p_obj);
- return obj_info & HASHCODE_ATTACHED_BIT;
-}
-
-inline Boolean hashcode_is_buffered(Partial_Reveal_Object* p_obj)
-{
- Obj_Info_Type obj_info = get_obj_info_raw(p_obj);
- return obj_info & HASHCODE_BUFFERED_BIT;
-}
-
-inline int hashcode_gen(void* addr)
-{ return (int)(POINTER_SIZE_INT)addr; }
-
-typedef struct Hashcode_Buf{
- Seq_List* list;
- POINTER_SIZE_INT* checkpoint;
-}Hashcode_Buf;
-
-extern GC_Metadata gc_metadata;
-Vector_Block* free_set_pool_get_entry(GC_Metadata *metadata);
-void free_set_pool_put_entry(Vector_Block* block, GC_Metadata *metadata);
-
-inline void hashcode_buf_set_checkpoint(Hashcode_Buf* hashcode_buf)
-{ hashcode_buf->checkpoint = vector_block_get_last_entry((Vector_Block*)hashcode_buf->list->end); }
-
-inline Hashcode_Buf* hashcode_buf_create()
-{
- Hashcode_Buf* hashcode_buf = (Hashcode_Buf*) STD_MALLOC(sizeof(Hashcode_Buf));
- memset(hashcode_buf, 0, sizeof(Hashcode_Buf));
- hashcode_buf->list = seq_list_create();
- return hashcode_buf;
-}
-
-inline void hashcode_buf_remove(Hashcode_Buf* hashcode_buf, Vector_Block* block)
-{
- Seq_List* list = hashcode_buf->list;
- seq_list_remove(list, (List_Node*) block);
- vector_block_clear(block);
- free_set_pool_put_entry(block, &gc_metadata);
-}
-
-inline void hashcode_buf_clear(Hashcode_Buf* hashcode_buf)
-{
- //push vector block back to free list
- Seq_List* list = hashcode_buf->list;
- seq_list_iterate_init(list);
-
- while(seq_list_has_next(list)){
- Vector_Block* curr_block = (Vector_Block*)seq_list_iterate_next(list);;
- vector_block_clear(curr_block);
- free_set_pool_put_entry(curr_block, &gc_metadata);
- }
- seq_list_clear(list);
- return;
-}
-
-inline void hashcode_buf_destory(Hashcode_Buf* hashcode_buf)
-{
- Seq_List* list = hashcode_buf->list;
- hashcode_buf_clear(hashcode_buf);
- seq_list_destruct(list);
- STD_FREE((void*)hashcode_buf);
-}
-
-inline void hashcode_buf_init(Hashcode_Buf* hashcode_buf)
-{
- Seq_List* list = hashcode_buf->list;
-#ifdef _DEBUG
- seq_list_iterate_init(list);
- assert(!seq_list_has_next(list));
-#endif
- Vector_Block* free_block = free_set_pool_get_entry(&gc_metadata);
- seq_list_add(list, (List_Node*)free_block);
- hashcode_buf_set_checkpoint(hashcode_buf);
- return;
-}
-
-inline int hashcode_buf_lookup(Partial_Reveal_Object* p_obj,Hashcode_Buf* hashcode_buf)
-{
- POINTER_SIZE_INT obj_addr = (POINTER_SIZE_INT)p_obj;
- Seq_List* list = hashcode_buf->list;
- seq_list_iterate_init(list);
- while(seq_list_has_next(list)){
- Vector_Block* curr_block = (Vector_Block*)seq_list_iterate_next(list);
- POINTER_SIZE_INT *iter = vector_block_iterator_init(curr_block);
-
- while(!vector_block_iterator_end(curr_block, iter)){
- POINTER_SIZE_INT addr = (POINTER_SIZE_INT)*iter;
- if(obj_addr != addr){
- iter = vector_block_iterator_advance(curr_block, iter);
- iter = vector_block_iterator_advance(curr_block, iter);
- }else{
- iter = vector_block_iterator_advance(curr_block, iter);
- POINTER_SIZE_INT hashcode = (POINTER_SIZE_INT)*iter;
- iter = vector_block_iterator_advance(curr_block, iter);
- return *(int*)&hashcode;
- }
- }
- }
- assert(0);
- return 0;
-}
-
-inline void hashcode_buf_add(Partial_Reveal_Object* p_obj, int32 hashcode, Hashcode_Buf* hashcode_buf)
-{
- Seq_List* list = hashcode_buf->list;
- Vector_Block* tail_block = (Vector_Block*)seq_list_end_node(list);
- vector_block_add_entry(tail_block, (POINTER_SIZE_INT) p_obj);
- POINTER_SIZE_INT hashcode_var = 0;
- *(int*) &hashcode_var = hashcode;
- vector_block_add_entry(tail_block, hashcode_var);
-
- if(!vector_block_is_full(tail_block)) return;
-
- tail_block = free_set_pool_get_entry(&gc_metadata);
- seq_list_add(list, (List_Node*)tail_block);
- return;
-}
-
-inline void hashcode_buf_refresh_all(Hashcode_Buf* hashcode_buf, POINTER_SIZE_INT dist)
-{
- Seq_List* list = hashcode_buf->list;
- seq_list_iterate_init(list);
- while(seq_list_has_next(list)){
- Vector_Block* curr_block = (Vector_Block*)seq_list_iterate_next(list);;
- POINTER_SIZE_INT *iter = vector_block_iterator_init(curr_block);
- while(!vector_block_iterator_end(curr_block, iter)){
- POINTER_SIZE_INT addr = (POINTER_SIZE_INT)*iter;
- *iter = addr - dist;
- iter =vector_block_iterator_advance(curr_block, iter);
- iter =vector_block_iterator_advance(curr_block, iter);
- }
- }
- return;
-}
-
-inline void hashcode_buf_rollback_new_entry(Hashcode_Buf* hashcode_buf)
-{
- Vector_Block* first_block = VECTOR_BLOCK_HEADER(hashcode_buf->checkpoint);
- POINTER_SIZE_INT* iter = hashcode_buf->checkpoint;
- while(!vector_block_iterator_end(first_block, iter)){
- Partial_Reveal_Object* p_obj = (Partial_Reveal_Object*)*iter;
- Obj_Info_Type oi = get_obj_info_raw(p_obj);
- set_obj_info(p_obj, oi & ~HASHCODE_BUFFERED_BIT);
- iter =vector_block_iterator_advance(first_block, iter);
- iter =vector_block_iterator_advance(first_block, iter);
- }
- first_block->tail = hashcode_buf->checkpoint;
-
- Seq_List* list = hashcode_buf->list;
- seq_list_iterate_init_after_node(list, (List_Node*)first_block);
- while(seq_list_has_next(list)){
- Vector_Block* curr_block = (Vector_Block*)seq_list_iterate_next(list);;
- iter = vector_block_iterator_init(curr_block);
- while(!vector_block_iterator_end(curr_block, iter)){
- Partial_Reveal_Object* p_obj = (Partial_Reveal_Object*)*iter;
- Obj_Info_Type oi = get_obj_info_raw(p_obj);
- set_obj_info(p_obj, oi & ~HASHCODE_BUFFERED_BIT);
- iter =vector_block_iterator_advance(curr_block, iter);
- iter =vector_block_iterator_advance(curr_block, iter);
- }
- hashcode_buf_remove(hashcode_buf, curr_block);
- }
- return;
-}
-
-inline void hashcode_buf_transfer_new_entry(Hashcode_Buf* old_buf, Hashcode_Buf* new_buf)
-{
- hashcode_buf_set_checkpoint(new_buf);
-
- Vector_Block* first_block = VECTOR_BLOCK_HEADER(old_buf->checkpoint);
- POINTER_SIZE_INT* iter = old_buf->checkpoint;
- while(!vector_block_iterator_end(first_block, iter)){
- Partial_Reveal_Object* p_obj = (Partial_Reveal_Object*)*iter;
-
- iter =vector_block_iterator_advance(first_block, iter);
- POINTER_SIZE_INT hashcode = (POINTER_SIZE_INT)*iter;
- iter =vector_block_iterator_advance(first_block, iter);
- hashcode_buf_add(p_obj, *(int*) &hashcode, new_buf);
- }
- first_block->tail = old_buf->checkpoint;
-
- Seq_List* list = old_buf->list;
- seq_list_iterate_init_after_node(list, (List_Node*)first_block);
- while(seq_list_has_next(list)){
- Vector_Block* curr_block = (Vector_Block*)seq_list_iterate_next(list);;
- iter = vector_block_iterator_init(curr_block);
- while(!vector_block_iterator_end(curr_block, iter)){
- Partial_Reveal_Object* p_obj = (Partial_Reveal_Object*)*iter;
- iter =vector_block_iterator_advance(curr_block, iter);
- POINTER_SIZE_INT hashcode = (POINTER_SIZE_INT)*iter;
- iter =vector_block_iterator_advance(curr_block, iter);
-
- hashcode_buf_add(p_obj, *(int*) &hashcode, new_buf);
- }
- hashcode_buf_remove(old_buf, curr_block);
- }
- return;
-}
-
-inline void hashcode_buf_refresh_new_entry(Hashcode_Buf* hashcode_buf, POINTER_SIZE_INT dist)
-{
- Vector_Block* first_block = VECTOR_BLOCK_HEADER(hashcode_buf->checkpoint);
- POINTER_SIZE_INT* iter = hashcode_buf->checkpoint;
- while(!vector_block_iterator_end(first_block, iter)){
- POINTER_SIZE_INT addr = (POINTER_SIZE_INT)*iter;
- *iter = addr - dist;
-
- iter =vector_block_iterator_advance(first_block, iter);
- iter =vector_block_iterator_advance(first_block, iter);
- }
-
- Seq_List* list = hashcode_buf->list;
- seq_list_iterate_init_after_node(list, (List_Node*)first_block);
- while(seq_list_has_next(list)){
- Vector_Block* curr_block = (Vector_Block*)seq_list_iterate_next(list);;
- iter = vector_block_iterator_init(curr_block);
- while(!vector_block_iterator_end(curr_block, iter)){
- POINTER_SIZE_INT addr = (POINTER_SIZE_INT)*iter;
- *iter = addr - dist;
-
- iter =vector_block_iterator_advance(curr_block, iter);
- iter =vector_block_iterator_advance(curr_block, iter);
- }
- }
- hashcode_buf_set_checkpoint(hashcode_buf);
- return;
-}
-
-void collector_hashcodeset_add_entry(Collector* collector, Partial_Reveal_Object** p_ref);
-
-inline Obj_Info_Type slide_compact_process_hashcode(Partial_Reveal_Object* p_obj, void* dest_addr,
- unsigned int* p_obj_size, Collector* collector,
- Hashcode_Buf* old_buf, Hashcode_Buf* new_buf)
-{
- Obj_Info_Type obj_info = get_obj_info(p_obj);
- POINTER_SIZE_INT hashcode;
-
- switch(obj_info & HASHCODE_MASK){
- case HASHCODE_SET_UNALLOCATED:
- if((POINTER_SIZE_INT)dest_addr != (POINTER_SIZE_INT)p_obj){
- *p_obj_size += GC_OBJECT_ALIGNMENT;
- obj_info = obj_info | HASHCODE_ATTACHED_BIT;
- *(int*) &hashcode = hashcode_gen(p_obj);
- POINTER_SIZE_INT obj_end_pos = (POINTER_SIZE_INT)dest_addr + vm_object_size(p_obj);
- collector_hashcodeset_add_entry(collector, (Partial_Reveal_Object**)obj_end_pos);
- collector_hashcodeset_add_entry(collector, (Partial_Reveal_Object**)hashcode);
- }
- break;
-
- case HASHCODE_SET_ATTACHED:
- obj_sethash_in_vt(p_obj);
- break;
-
- case HASHCODE_SET_BUFFERED:
- *(int*) &hashcode = hashcode_buf_lookup(p_obj, old_buf);
- if((POINTER_SIZE_INT)dest_addr != (POINTER_SIZE_INT)p_obj){
- *p_obj_size += GC_OBJECT_ALIGNMENT;
- obj_info = obj_info & ~HASHCODE_BUFFERED_BIT;
- obj_info = obj_info | HASHCODE_ATTACHED_BIT;
- POINTER_SIZE_INT obj_end_pos = (POINTER_SIZE_INT)dest_addr + vm_object_size(p_obj);
- collector_hashcodeset_add_entry(collector, (Partial_Reveal_Object**)obj_end_pos);
- collector_hashcodeset_add_entry(collector, (Partial_Reveal_Object**)hashcode);
- }else{
- hashcode_buf_add((Partial_Reveal_Object*)dest_addr, *(int*) &hashcode, new_buf);
- }
- break;
-
- case HASHCODE_UNSET:
- break;
-
- default:
- assert(0);
-
- }
- return obj_info;
-}
-
-inline void move_compact_process_hashcode(Partial_Reveal_Object* p_obj,
- Hashcode_Buf* old_buf, Hashcode_Buf* new_buf)
-{
- if(hashcode_is_set(p_obj) && !hashcode_is_attached(p_obj)){
- int hashcode;
- if(hashcode_is_buffered(p_obj)){
- /*already buffered objects;*/
- hashcode = hashcode_buf_lookup(p_obj, old_buf);
- hashcode_buf_add(p_obj, hashcode, new_buf);
- }else{
- /*objects need buffering.*/
- hashcode = hashcode_gen(p_obj);
- hashcode_buf_add(p_obj, hashcode, new_buf);
- Obj_Info_Type oi = get_obj_info_raw(p_obj);
- set_obj_info(p_obj, oi | HASHCODE_BUFFERED_BIT);
- }
- }
-}
-
-inline Obj_Info_Type trace_forward_process_hashcode(Partial_Reveal_Object* p_obj,
- Obj_Info_Type oi, unsigned int p_obj_size)
-{
- oi |= HASHCODE_ATTACHED_BIT;
- *(int *)(((char*)p_obj) + p_obj_size - GC_OBJECT_ALIGNMENT) = hashcode_gen(p_obj);
- assert(vm_object_size(p_obj) != 0);
- return oi;
-}
-
-inline void precompute_hashcode_extend_size(Partial_Reveal_Object* p_obj,
- void* dest_addr, unsigned int * obj_size_precompute)
{
if(hashcode_is_set(p_obj) && !hashcode_is_attached(p_obj)){
if((POINTER_SIZE_INT)dest_addr != (POINTER_SIZE_INT)p_obj)
Modified: harmony/enhanced/drlvm/trunk/vm/gc_gen/src/common/space_tuner.cpp
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/gc_gen/src/common/space_tuner.cpp?view=diff&rev=541224&r1=541223&r2=541224
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/gc_gen/src/common/space_tuner.cpp (original)
+++ harmony/enhanced/drlvm/trunk/vm/gc_gen/src/common/space_tuner.cpp Thu May 24 01:17:25 2007
@@ -27,38 +27,36 @@
Space* gc_get_mos(GC_Gen* gc);
Space* gc_get_nos(GC_Gen* gc);
Space* gc_get_los(GC_Gen* gc);
-POINTER_SIZE_INT mspace_get_expected_threshold(Mspace* mspace);
+float mspace_get_expected_threshold_ratio(Mspace* mspace);
POINTER_SIZE_INT lspace_get_failure_size(Lspace* lspace);
-/*Prepare the paramenters which are to be used to compute new los size.*/
-void gc_space_tune_prepare(GC* gc, unsigned int cause)
+void gc_decide_space_tune(GC* gc, unsigned int cause)
{
- if(gc_match_kind(gc, MINOR_COLLECTION))
- return;
-
Blocked_Space* mspace = (Blocked_Space*)gc_get_mos((GC_Gen*)gc);
Blocked_Space* fspace = (Blocked_Space*)gc_get_nos((GC_Gen*)gc);
Space* lspace = (Space*)gc_get_los((GC_Gen*)gc);
Space_Tuner* tuner = gc->tuner;
-
+ //debug_adjust
assert(fspace->free_block_idx >= fspace->first_block_idx);
unsigned int nos_alloc_size = (fspace->free_block_idx - fspace->first_block_idx) * GC_BLOCK_SIZE_BYTES;
fspace->alloced_size = nos_alloc_size;
/*Fixme: LOS_Adaptive: There should be a condition here, that fspace->collection_num != 0*/
mspace->alloced_size += (unsigned int)((float)nos_alloc_size * fspace->survive_ratio);
- /*For_statistic alloc speed: Speed could be represented by sum of alloced size.*/
- tuner->speed_los += lspace->alloced_size;
+ /*For_statistic alloc speed: Speed could be represented by sum of alloced size.
+ *The right of this time los/mos alloc speed is the biggest.
+ */
+ tuner->speed_los = lspace->alloced_size;
tuner->speed_los = (tuner->speed_los + tuner->old_speed_los) >> 1;
- tuner->speed_mos += mspace->alloced_size;
+ tuner->speed_mos = mspace->alloced_size;
tuner->speed_mos = (tuner->speed_mos + tuner->old_speed_mos) >> 1;
/*For_statistic wasted memory*/
POINTER_SIZE_INT curr_used_los = lspace->surviving_size + lspace->alloced_size;
- assert(curr_used_los <= lspace->committed_heap_size);
POINTER_SIZE_INT curr_wast_los = lspace->committed_heap_size - curr_used_los;
tuner->wast_los += curr_wast_los;
POINTER_SIZE_INT curr_used_mos = mspace->surviving_size + mspace->alloced_size;
- POINTER_SIZE_INT expected_mos = mspace_get_expected_threshold((Mspace*)mspace);
+ float expected_mos_ratio = mspace_get_expected_threshold_ratio((Mspace*)mspace);
+ POINTER_SIZE_INT expected_mos = (POINTER_SIZE_INT)((mspace->committed_heap_size + fspace->committed_heap_size) * expected_mos_ratio);
POINTER_SIZE_INT curr_wast_mos = 0;
if(expected_mos > curr_used_mos)
curr_wast_mos = expected_mos - curr_used_mos;
@@ -68,270 +66,263 @@
/*For_statistic ds in heuristic*/
tuner->current_ds = (unsigned int)((float)fspace->committed_heap_size * fspace->survive_ratio);
/*Fixme: Threshold should be computed by heuristic. tslow, total recycled heap size shold be statistic.*/
- tuner->threshold = tuner->current_ds;
- if(tuner->threshold > 8 * MB) tuner->threshold = 8 * MB;
+ tuner->threshold_waste = tuner->current_ds;
+ if(tuner->threshold_waste > 8 * MB) tuner->threshold_waste = 8 * MB;
tuner->min_tuning_size = tuner->current_ds;
if(tuner->min_tuning_size > 4 * MB) tuner->min_tuning_size = 4 * MB;
- return;
-}
-/*Check the tuning size, if too small, cancle the tuning.*/
-void check_space_tuner(GC* gc)
-{
- POINTER_SIZE_INT los_fail_sz_uped = 0;
-
- Space_Tuner* tuner = gc->tuner;
- if((!tuner->need_tune) && (!tuner->force_tune)){
- assert(tuner->kind == TRANS_NOTHING);
- assert(tuner->tuning_size == 0);
- return;
- }
- Space* lspace = (Space*)gc_get_los((GC_Gen*)gc);
- if((!tuner->force_tune) && (tuner->tuning_size < tuner->min_tuning_size)){
- tuner->tuning_size = 0;
- goto check_size;
- }
- if((tuner->need_tune) && (!tuner->force_tune)) goto check_size;
- /*tuner->force_tune must be true here!*/
- los_fail_sz_uped = lspace_get_failure_size((Lspace*)lspace);
- assert(!(los_fail_sz_uped % KB));
+ if(tuner->speed_los == 0) tuner->speed_los = 16;
+ if(tuner->speed_mos == 0) tuner->speed_mos = 16;
+
+ /*Needn't tune if dw does not reach threshold.*/
+ if(tuner->current_dw > tuner->threshold_waste) tuner->need_tune = 1;
+ /*If LOS is full, we should tune at lease "tuner->least_tuning_size" size*/
+ if(gc->cause == GC_CAUSE_LOS_IS_FULL) tuner->force_tune = 1;
- if(tuner->kind == TRANS_FROM_LOS_TO_MOS){
- tuner->kind = TRANS_FROM_MOS_TO_LOS;
- tuner->tuning_size = 0;
- lspace->move_object = 0;
- }
- if(tuner->tuning_size < los_fail_sz_uped){
- tuner->tuning_size = los_fail_sz_uped;
- }
-
-check_size:
- tuner->tuning_size = round_down_to_size(tuner->tuning_size, GC_BLOCK_SIZE_BYTES);
- if(tuner->tuning_size == 0){
- tuner->kind = TRANS_NOTHING;
- lspace->move_object = 0;
- }
-
return;
}
-
extern POINTER_SIZE_INT min_los_size_bytes;
extern POINTER_SIZE_INT min_none_los_size_bytes;
-/*Give the tuning kind, and tuning size hint*/
-void gc_space_tune_before_gc(GC* gc, unsigned int cause)
+
+void gc_compute_space_tune_size_before_marking(GC* gc, unsigned int cause)
{
- if(gc_match_kind(gc, MINOR_COLLECTION)) return;
+ if(gc_match_kind(gc, MINOR_COLLECTION)) return;
+
+ gc_decide_space_tune(gc, cause);
+
Space_Tuner* tuner = gc->tuner;
if((tuner->speed_los == 0) && ( tuner->speed_mos == 0)) return;
- if(tuner->speed_los == 0) tuner->speed_los = 16;
- if(tuner->speed_mos == 0) tuner->speed_mos = 16;
-
- /*Needn't tune if dw does not reach threshold.*/
- if(tuner->current_dw > tuner->threshold) tuner->need_tune = 1;
- /*If LOS is full, we should tune at lease "tuner->least_tuning_size" size*/
- if(gc->cause == GC_CAUSE_LOS_IS_FULL) tuner->force_tune = 1;
if((!tuner->need_tune) && (!tuner->force_tune)) return;
-
+
Blocked_Space* mspace = (Blocked_Space*)gc_get_mos((GC_Gen*)gc);
Blocked_Space* fspace = (Blocked_Space*)gc_get_nos((GC_Gen*)gc);
Space* lspace = (Space*)gc_get_los((GC_Gen*)gc);
- POINTER_SIZE_INT los_expect_survive_sz = (POINTER_SIZE_INT)((float)(lspace->surviving_size + lspace->alloced_size) * lspace->survive_ratio);
- POINTER_SIZE_INT los_expect_free_sz = ((lspace->committed_heap_size > los_expect_survive_sz) ?
- (lspace->committed_heap_size - los_expect_survive_sz) : 0);
+ POINTER_SIZE_INT los_expect_surviving_sz = (POINTER_SIZE_INT)((float)(lspace->surviving_size + lspace->alloced_size) * lspace->survive_ratio);
+ POINTER_SIZE_INT los_expect_free_sz = ((lspace->committed_heap_size > los_expect_surviving_sz) ?
+ (lspace->committed_heap_size - los_expect_surviving_sz) : 0);
POINTER_SIZE_INT mos_expect_survive_sz = (POINTER_SIZE_INT)((float)(mspace->surviving_size + mspace->alloced_size) * mspace->survive_ratio);
- POINTER_SIZE_INT mos_expect_threshold = mspace_get_expected_threshold((Mspace*)mspace);
+ float mos_expect_threshold_ratio = mspace_get_expected_threshold_ratio((Mspace*)mspace);
+ POINTER_SIZE_INT mos_expect_threshold = (POINTER_SIZE_INT)((mspace->committed_heap_size + fspace->committed_heap_size) * mos_expect_threshold_ratio);
POINTER_SIZE_INT mos_expect_free_sz = ((mos_expect_threshold > mos_expect_survive_sz)?
(mos_expect_threshold - mos_expect_survive_sz) : 0);
- POINTER_SIZE_INT total_free = los_expect_free_sz + mos_expect_free_sz;
- assert(total_free <= gc->committed_heap_size);
+ POINTER_SIZE_INT total_expect_free_sz = los_expect_free_sz + mos_expect_free_sz;
+
float new_los_ratio = (float)tuner->speed_los / (float)(tuner->speed_los + tuner->speed_mos);
- POINTER_SIZE_INT new_free_los_sz = (POINTER_SIZE_INT)((float)total_free * new_los_ratio);
- assert(new_free_los_sz <= gc->committed_heap_size);
- POINTER_SIZE_INT max_tuning_size = 0;
+ POINTER_SIZE_INT new_free_los_sz = (POINTER_SIZE_INT)((float)total_expect_free_sz * new_los_ratio);
+
/*LOS_Extend:*/
if((new_free_los_sz > los_expect_free_sz) )
{
- if ( (!tuner->force_tune) && (new_free_los_sz - los_expect_free_sz < tuner->min_tuning_size) ){
- tuner->kind = TRANS_NOTHING;
- tuner->tuning_size = 0;
- return;
- }
tuner->kind = TRANS_FROM_MOS_TO_LOS;
- tuner->tuning_size = round_down_to_size(new_free_los_sz - los_expect_free_sz, GC_BLOCK_SIZE_BYTES);
- POINTER_SIZE_INT non_los_sz = mspace->committed_heap_size + fspace->committed_heap_size;
- if(non_los_sz > min_none_los_size_bytes)
- max_tuning_size = non_los_sz - min_none_los_size_bytes;
- if(tuner->tuning_size > max_tuning_size) tuner->tuning_size = max_tuning_size;
+ tuner->tuning_size = new_free_los_sz - los_expect_free_sz;
}
/*LOS_Shrink:*/
- if((new_free_los_sz < los_expect_free_sz))
+ else if(new_free_los_sz < los_expect_free_sz)
{
- if ( (!tuner->force_tune) && (los_expect_free_sz - new_free_los_sz < tuner->min_tuning_size) ){
- tuner->kind = TRANS_NOTHING;
- tuner->tuning_size = 0;
- return;
- }
tuner->kind = TRANS_FROM_LOS_TO_MOS;
+ tuner->tuning_size = los_expect_free_sz - new_free_los_sz;
lspace->move_object = 1;
- assert(lspace->committed_heap_size >= min_los_size_bytes);
- max_tuning_size = lspace->committed_heap_size - min_los_size_bytes;
- POINTER_SIZE_INT tuning_size = los_expect_free_sz - new_free_los_sz;
- if(tuning_size > max_tuning_size) tuning_size = max_tuning_size;
- tuner->tuning_size = round_down_to_size(tuning_size, GC_BLOCK_SIZE_BYTES);
}
- if( (tuner->tuning_size == 0) && (!tuner->force_tune) ){
+ /*Nothing*/
+ else
+ {
+ tuner->tuning_size = 0;
+ }
+
+ /*If not force tune, and the tuning size is too small, tuner will not take effect.*/
+ if( (!tuner->force_tune) && (tuner->tuning_size < tuner->min_tuning_size) ){
tuner->kind = TRANS_NOTHING;
+ tuner->tuning_size = 0;
lspace->move_object = 0;
- return;
}
- check_space_tuner(gc);
- return;
-}
-void gc_space_tune_before_gc_fixed_size(GC* gc, unsigned int cause)
-{
- if(gc_match_kind(gc, MINOR_COLLECTION)) return;
- Space_Tuner* tuner = gc->tuner;
- Blocked_Space* mspace = (Blocked_Space*)gc_get_mos((GC_Gen*)gc);
- Blocked_Space* fspace = (Blocked_Space*)gc_get_nos((GC_Gen*)gc);
- Space* lspace = (Space*)gc_get_los((GC_Gen*)gc);
-
- if(cause == GC_CAUSE_LOS_IS_FULL){
- tuner->kind = TRANS_FROM_MOS_TO_LOS;
- POINTER_SIZE_INT los_fail_sz = lspace_get_failure_size((Lspace*)lspace);
- if(los_fail_sz > GC_LOS_MIN_VARY_SIZE){
- /*Fixme: we should set the least_tuning_size after finding out the biggest free area in LOS, this number could be zero*/
- tuner->tuning_size = los_fail_sz;
- tuner->least_tuning_size = los_fail_sz;
- tuner->conservative_tuning_size = los_fail_sz;
- }else{
- tuner->tuning_size = GC_LOS_MIN_VARY_SIZE;
- tuner->least_tuning_size = los_fail_sz;
- tuner->conservative_tuning_size = ((tuner->tuning_size + tuner->min_tuning_size) >> 1);
- }
- POINTER_SIZE_INT none_los_size;
-#ifdef STATIC_NOS_MAPPING
- none_los_size = mspace->committed_heap_size;
-#else
- none_los_size = mspace->committed_heap_size + fspace->committed_heap_size;
-#endif
- if(tuner->tuning_size > none_los_size){
- tuner->tuning_size = tuner->conservative_tuning_size;
- }
- if(tuner->tuning_size > none_los_size){
- tuner->tuning_size = tuner->least_tuning_size;
- }
- if((tuner->tuning_size + gc->num_active_collectors * GC_BLOCK_SIZE_BYTES) >= none_los_size){
- tuner->tuning_size = 0;
- }
- }
- else
- /*LOS_Shrink: Fixme: Very simple strategy now. */
- {
- return;
- tuner->kind = TRANS_FROM_LOS_TO_MOS;
- lspace->move_object = TRUE;
- tuner->tuning_size = GC_LOS_MIN_VARY_SIZE >> 1;
- }
-
- /*Fixme: Should MOS heap_start must be 64k aligned?*/
- tuner->tuning_size = round_up_to_size(tuner->tuning_size, GC_BLOCK_SIZE_BYTES);
- if(tuner->tuning_size == 0){
+ /*If los or non-los is already the smallest size, there is no need to tune anymore.*/
+ if(((lspace->committed_heap_size <= min_los_size_bytes) && (tuner->kind == TRANS_FROM_LOS_TO_MOS)) ||
+ ((fspace->committed_heap_size + mspace->committed_heap_size <= min_none_los_size_bytes) && (tuner->kind == TRANS_FROM_MOS_TO_LOS))){
+ assert((lspace->committed_heap_size == min_los_size_bytes) || (fspace->committed_heap_size + mspace->committed_heap_size == min_none_los_size_bytes));
tuner->kind = TRANS_NOTHING;
+ tuner->tuning_size = 0;
lspace->move_object = 0;
}
+
+ if(tuner->force_tune){
+ if(tuner->kind == TRANS_FROM_LOS_TO_MOS){
+ tuner->kind = TRANS_FROM_MOS_TO_LOS;
+ tuner->reverse = 1;
+ }
+ }
- return;
+ return;
}
#include "../thread/collector.h"
#include "../mark_sweep/lspace.h"
-Boolean gc_space_retune(GC *gc)
+
+static POINTER_SIZE_INT non_los_live_obj_size;
+static POINTER_SIZE_INT los_live_obj_size;
+static void gc_compute_live_object_size_after_marking(GC* gc)
+{
+ non_los_live_obj_size = 0;
+ los_live_obj_size = 0;
+
+ unsigned int collector_num = gc->num_active_collectors;
+ for(unsigned int i = collector_num; i--;){
+ Collector *collector = gc->collectors[i];
+ non_los_live_obj_size += collector->non_los_live_obj_size;
+ los_live_obj_size += collector->los_live_obj_size;
+ }
+
+ non_los_live_obj_size += ((collector_num << 2) << GC_BLOCK_SHIFT_COUNT);
+ non_los_live_obj_size = round_up_to_size(non_los_live_obj_size, GC_BLOCK_SIZE_BYTES);
+
+ los_live_obj_size += ((collector_num << 2) << GC_BLOCK_SHIFT_COUNT);
+ los_live_obj_size = round_up_to_size(los_live_obj_size, GC_BLOCK_SIZE_BYTES);
+
+}
+
+void gc_compute_space_tune_size_after_marking(GC *gc)
{
- Lspace *los = (Lspace*)gc_get_los((GC_Gen*)gc);
+ gc_compute_live_object_size_after_marking(gc);
+
+ Blocked_Space* mspace = (Blocked_Space*)gc_get_mos((GC_Gen*)gc);
+ Blocked_Space* fspace = (Blocked_Space*)gc_get_nos((GC_Gen*)gc);
+ Lspace *lspace = (Lspace*)gc_get_los((GC_Gen*)gc);
Space_Tuner* tuner = gc->tuner;
- /*LOS_Extend:*/
- if(tuner->kind == TRANS_FROM_MOS_TO_LOS){
- POINTER_SIZE_INT non_los_live_obj_size = 0;
- unsigned int collector_num = gc->num_active_collectors;
- for(unsigned int i = collector_num; i--;){
- Collector *collector = gc->collectors[i];
- non_los_live_obj_size += collector->non_los_live_obj_size;
- }
- non_los_live_obj_size += GC_BLOCK_SIZE_BYTES * collector_num * 4;
- non_los_live_obj_size = round_up_to_size(non_los_live_obj_size, GC_BLOCK_SIZE_BYTES);
- POINTER_SIZE_INT max_free_for_tuning = 0;
- if (gc->committed_heap_size > los->committed_heap_size + non_los_live_obj_size)
- max_free_for_tuning = gc->committed_heap_size - los->committed_heap_size - non_los_live_obj_size;
-
- if(!tuner->force_tune){
- /*This should not happen! If GC is not issued by los, then it's not necessary to extend it*/
- if(max_free_for_tuning < tuner->tuning_size)
- tuner->tuning_size = max_free_for_tuning;
- if(tuner->tuning_size == 0){
+
+ POINTER_SIZE_INT max_tuning_size = 0;
+ POINTER_SIZE_INT non_los_size = mspace->committed_heap_size + fspace->committed_heap_size;
+ /*We should assure that the non_los area is no less than min_none_los_size_bytes*/
+ POINTER_SIZE_INT max_tune_for_min_non_los = 0;
+ if(non_los_size > min_none_los_size_bytes)
+ max_tune_for_min_non_los = non_los_size - min_none_los_size_bytes;
+ POINTER_SIZE_INT max_tune_for_min_los = 0;
+ //debug_adjust
+ assert(lspace->committed_heap_size >= min_los_size_bytes);
+ max_tune_for_min_los = lspace->committed_heap_size - min_los_size_bytes;
+
+ /*If the tuning strategy give a bigger tuning_size than failure size, we just follow the strategy and set noforce.*/
+ Boolean doforce = TRUE;
+ POINTER_SIZE_INT failure_size = lspace_get_failure_size((Lspace*)lspace);
+ if( (tuner->kind == TRANS_FROM_MOS_TO_LOS) && (!tuner->reverse) && (tuner->tuning_size > failure_size) )
+ doforce = FALSE;
+
+ /*If force tune*/
+ if( (tuner->force_tune) && (doforce) ){
+
+ tuner->tuning_size = failure_size;
+
+ /*We should assure that the tuning size is no more than the free space of non_los area*/
+ if( gc->committed_heap_size > lspace->committed_heap_size + non_los_live_obj_size )
+ max_tuning_size = gc->committed_heap_size - lspace->committed_heap_size - non_los_live_obj_size;
+
+ if(max_tuning_size > max_tune_for_min_non_los)
+ max_tuning_size = max_tune_for_min_non_los;
+
+ /*Round up to satisfy LOS alloc demand.*/
+ tuner->tuning_size = round_up_to_size(tuner->tuning_size, GC_BLOCK_SIZE_BYTES);
+ max_tuning_size = round_down_to_size(max_tuning_size, GC_BLOCK_SIZE_BYTES);
+
+ /*If the tuning size is too large, we did nothing and wait for the OOM of JVM*/
+ /*Fixme: if the heap size is not mx, we can extend the whole heap size*/
+ if(tuner->tuning_size > max_tuning_size){
+ tuner->tuning_size = round_up_to_size(tuner->tuning_size, SPACE_ALLOC_UNIT);
+ max_tuning_size = round_down_to_size(max_tuning_size, SPACE_ALLOC_UNIT);
+ //debug_adjust
+ assert(max_heap_size_bytes >= gc->committed_heap_size);
+ POINTER_SIZE_INT extend_heap_size = 0;
+ POINTER_SIZE_INT potential_max_heap_size = max_tuning_size + max_heap_size_bytes - gc->committed_heap_size;
+
+ //debug_adjust
+ assert(!(potential_max_heap_size % SPACE_ALLOC_UNIT));
+ if(tuner->tuning_size > potential_max_heap_size){
+ tuner->tuning_size = 0;
tuner->kind = TRANS_NOTHING;
- los->move_object = 0;
+ lspace->move_object = 0;
+ }else{
+ extend_heap_size = tuner->tuning_size - max_tuning_size;
+ blocked_space_extend(fspace, (unsigned int)extend_heap_size);
+ gc->committed_heap_size += extend_heap_size;
+ tuner->kind = TRANS_FROM_MOS_TO_LOS;
+ lspace->move_object = 0;
}
- return TRUE;
- }
- /*force tune here!*/
- POINTER_SIZE_INT min_tuning_uped = round_up_to_size(los->failure_size, GC_BLOCK_SIZE_BYTES);
- if(min_tuning_uped > max_free_for_tuning){
- tuner->tuning_size = 0;
- tuner->kind = TRANS_NOTHING;
- los->move_object = 0;
- return FALSE;
}
- if(tuner->tuning_size < min_tuning_uped){
- assert(tuner->tuning_size < max_free_for_tuning);
- tuner->tuning_size = min_tuning_uped;
- return TRUE;
- }else/*tuner->tuning_size >= min_tuning_uped*/{
- if(tuner->tuning_size > max_free_for_tuning)
- tuner->tuning_size = max_free_for_tuning;
- return TRUE;
+ else
+ {
+ tuner->kind = TRANS_FROM_MOS_TO_LOS;
+ lspace->move_object = 0;
}
}
- else// if(gc->tuner->kind == TRANS_FROM_LOS_TO_MOS)
+ /*No force tune, LOS_Extend:*/
+ else if(tuner->kind == TRANS_FROM_MOS_TO_LOS)
{
- POINTER_SIZE_INT los_live_obj_size = 0;
- unsigned int collector_num = gc->num_active_collectors;
- for(unsigned int i = collector_num; i--;){
- Collector *collector = gc->collectors[i];
- los_live_obj_size += collector->los_live_obj_size;
+ if (gc->committed_heap_size > lspace->committed_heap_size + non_los_live_obj_size){
+ max_tuning_size = gc->committed_heap_size - lspace->committed_heap_size - non_los_live_obj_size;
+ if(max_tuning_size > max_tune_for_min_non_los)
+ max_tuning_size = max_tune_for_min_non_los;
+ if( tuner->tuning_size > max_tuning_size)
+ tuner->tuning_size = max_tuning_size;
+ /*Round down so as not to break max_tuning_size*/
+ tuner->tuning_size = round_down_to_size(tuner->tuning_size, GC_BLOCK_SIZE_BYTES);
+ }else{
+ tuner->tuning_size = 0;
}
- los_live_obj_size = round_up_to_size(los_live_obj_size, GC_BLOCK_SIZE_BYTES);
- los_live_obj_size += (collector_num << 2 << GC_BLOCK_SHIFT_COUNT);
-
- Lspace *los = (Lspace*)gc_get_los((GC_Gen*)gc);
- Space_Tuner *tuner = gc->tuner;
- POINTER_SIZE_INT los_max_shrink_size = 0;
- if(los->committed_heap_size > los_live_obj_size)
- los_max_shrink_size = los->committed_heap_size - los_live_obj_size;
- if(tuner->tuning_size > los_max_shrink_size)
- tuner->tuning_size = los_max_shrink_size;
- assert(!(tuner->tuning_size % GC_BLOCK_SIZE_BYTES));
- if(tuner->tuning_size == 0){
- tuner->kind = TRANS_NOTHING;
- los->move_object = 0;
- return TRUE;
- }else
- return TRUE;
}
+ /*No force tune, LOS Shrink*/
+ else
+ {
+ if(lspace->committed_heap_size > los_live_obj_size){
+ max_tuning_size = lspace->committed_heap_size - los_live_obj_size;
+ if(max_tuning_size > max_tune_for_min_los)
+ max_tuning_size = max_tune_for_min_los;
+ if(tuner->tuning_size > max_tuning_size)
+ tuner->tuning_size = max_tuning_size;
+ /*Round down so as not to break max_tuning_size*/
+ tuner->tuning_size = round_down_to_size(tuner->tuning_size, GC_BLOCK_SIZE_BYTES);
+ }else{
+ /* this is possible because of the reservation in gc_compute_live_object_size_after_marking*/
+ tuner->tuning_size = 0;
+ }
+ }
+ if(tuner->tuning_size == 0){
+ tuner->kind = TRANS_NOTHING;
+ lspace->move_object = 0;
+ }
+ return;
+
}
void gc_space_tuner_reset(GC* gc)
{
+ Space_Tuner* tuner = gc->tuner;
if( !gc_match_kind(gc, MINOR_COLLECTION)){
- Space_Tuner* tuner = gc->tuner;
- POINTER_SIZE_INT old_slos = tuner->speed_los;
- POINTER_SIZE_INT old_smos = tuner->speed_mos;
- memset(tuner, 0, sizeof(Space_Tuner));
- tuner->old_speed_los = old_slos;
- tuner->old_speed_mos = old_smos;
+ /*Clear the fields every major collection except the wast area statistic.*/
+ tuner->tuning_size = 0;
+ tuner->interim_blocks = NULL;
+ tuner->need_tune = FALSE;
+ tuner->force_tune = FALSE;
+
+ tuner->old_speed_los = tuner->speed_los;
+ tuner->old_speed_mos = tuner->speed_mos;
+ tuner->speed_los = 0;
+ tuner->speed_mos = 0;
+
+ tuner->current_dw = 0;
+ tuner->current_ds = 0;
+
+ tuner->threshold_waste = 0;
+ tuner->min_tuning_size = 0;
+ /*Reset the sum up of wast area size only if los is changed.*/
+ if(tuner->kind != TRANS_NOTHING){
+ tuner->wast_los = 0;
+ tuner->wast_mos = 0;
+ }
+ tuner->kind = TRANS_NOTHING;
}
+
+ return;
+
}
void gc_space_tuner_initialize(GC* gc)
@@ -343,3 +334,61 @@
tuner->tuning_size = 0;
gc->tuner = tuner;
}
+
+/*Malloc and initialize fake blocks for LOS_Shrink*/
+void gc_space_tuner_init_fake_blocks_for_los_shrink(GC* gc)
+{
+ Blocked_Space* mspace = (Blocked_Space*)gc_get_mos((GC_Gen*)gc);
+ Space_Tuner* tuner = gc->tuner;
+ Block_Header* mos_first_block = (Block_Header*)&mspace->blocks[0];
+ unsigned int trans_blocks = (unsigned int)(tuner->tuning_size >> GC_BLOCK_SHIFT_COUNT);
+ tuner->interim_blocks = (Block_Header*)STD_MALLOC(trans_blocks * sizeof(Block_Header));
+ Block_Header* los_trans_fake_blocks = tuner->interim_blocks;
+ memset(los_trans_fake_blocks, 0, trans_blocks * sizeof(Block_Header));
+ void* trans_base = (void*)((POINTER_SIZE_INT)mos_first_block - tuner->tuning_size);
+ unsigned int start_idx = GC_BLOCK_INDEX_FROM(gc->heap_start, trans_base);
+ Block_Header* last_block = los_trans_fake_blocks;
+
+ for(unsigned int i = 0; i < trans_blocks; i ++){
+ Block_Header* curr_block = &los_trans_fake_blocks[i];
+ curr_block->block_idx = start_idx + i;
+ curr_block->base = (void*)((POINTER_SIZE_INT)trans_base + i * GC_BLOCK_SIZE_BYTES + GC_BLOCK_HEADER_SIZE_BYTES);
+ curr_block->free = curr_block->base ;
+ curr_block->new_free = curr_block->free;
+ curr_block->ceiling = (void*)((POINTER_SIZE_INT)curr_block->base + GC_BLOCK_BODY_SIZE_BYTES);
+ curr_block->status = BLOCK_COMPACTED;
+#ifdef USE_32BITS_HASHCODE
+ curr_block->hashcode_buf = hashcode_buf_create();
+#endif
+ last_block->next = curr_block;
+ last_block = curr_block;
+ }
+ last_block->next = mos_first_block;
+}
+
+/*Copy the fake blocks into real blocks, reconnect these new block into main list of mspace.
+ *Free the fake blocks. The infomation of mspace is not updated yet.
+ */
+void gc_space_tuner_release_fake_blocks_for_los_shrink(GC* gc)
+{
+ Space_Tuner *tuner = gc->tuner;
+ Blocked_Space* mspace = (Blocked_Space*)gc_get_mos((GC_Gen*)gc);
+
+ POINTER_SIZE_INT tune_size = tuner->tuning_size;
+ unsigned int tune_blocks = (unsigned int)(tune_size >> GC_BLOCK_SHIFT_COUNT);
+
+ Block* blocks = (Block*)((POINTER_SIZE_INT)mspace->blocks - tune_size);
+ Block_Header* last_real_block = (Block_Header*)blocks;
+ unsigned int i;
+ for(i=0; i < tune_blocks; i++){
+ Block_Header* real_block = (Block_Header*)&(blocks[i]);
+ Block_Header* fake_block = &tuner->interim_blocks[i];
+ memcpy((void*)real_block, (void*)fake_block, sizeof(Block_Header));
+ last_real_block->next = real_block;
+ last_real_block = real_block;
+ }
+ last_real_block->next = (Block_Header*)mspace->blocks;
+ STD_FREE(tuner->interim_blocks);
+ return;
+}
+
Modified: harmony/enhanced/drlvm/trunk/vm/gc_gen/src/common/space_tuner.h
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/gc_gen/src/common/space_tuner.h?view=diff&rev=541224&r1=541223&r2=541224
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/gc_gen/src/common/space_tuner.h (original)
+++ harmony/enhanced/drlvm/trunk/vm/gc_gen/src/common/space_tuner.h Thu May 24 01:17:25 2007
@@ -27,6 +27,8 @@
#define GC_LOS_MIN_VARY_SIZE ( 2 * MB )
//#define GC_FIXED_SIZE_TUNER
+extern POINTER_SIZE_INT max_heap_size_bytes;
+
//For_LOS_extend
enum Transform_Kind {
TRANS_NOTHING = 0,
@@ -36,19 +38,22 @@
typedef struct Space_Tuner{
Transform_Kind kind;
-
+ /*This flag is set if the los tuning status changes in the process of tuning*/
+ Boolean reverse;
POINTER_SIZE_INT tuning_size;
- POINTER_SIZE_INT conservative_tuning_size;
- POINTER_SIZE_INT least_tuning_size;
/*Used for LOS_Shrink*/
Block_Header* interim_blocks;
+ /*This flag is set when tuning strategy decide to tune los size.
+ *i.e. wasted memory is greater than wast_threshold.
+ */
Boolean need_tune;
+ /*This flag is set if gc is caused by los alloc failure.*/
Boolean force_tune;
- /*LOS alloc speed sciecne last los variation*/
+ /*LOS alloc speed since last major*/
POINTER_SIZE_INT speed_los;
POINTER_SIZE_INT old_speed_los;
- /*MOS alloc speed sciecne last los variation*/
+ /*MOS alloc speed since last major*/
POINTER_SIZE_INT speed_mos;
POINTER_SIZE_INT old_speed_mos;
@@ -61,22 +66,17 @@
/*NOS survive size of last minor, this could be the least meaningful space unit when talking about tuning.*/
POINTER_SIZE_INT current_ds;
- /*Threshold for deta wast*/
- POINTER_SIZE_INT threshold;
+ /*Threshold for deta waste*/
+ POINTER_SIZE_INT threshold_waste;
/*Minimun tuning size for los variation*/
POINTER_SIZE_INT min_tuning_size;
-
- /*Cost of normal major compaction*/
- unsigned int fast_cost;
- /*Cost of major compaction when changing LOS size*/
- unsigned int slow_cost;
}Space_Tuner;
-void gc_space_tune_prepare(GC* gc, unsigned int cause);
-void gc_space_tune_before_gc(GC* gc, unsigned int cause);
-void gc_space_tune_before_gc_fixed_size(GC* gc, unsigned int cause);
-Boolean gc_space_retune(GC *gc);
+void gc_compute_space_tune_size_before_marking(GC* gc, unsigned int cause);
+void gc_compute_space_tune_size_after_marking(GC *gc);
void gc_space_tuner_reset(GC* gc);
void gc_space_tuner_initialize(GC* gc);
+void gc_space_tuner_init_fake_blocks_for_los_shrink(GC* gc);
+void gc_space_tuner_release_fake_blocks_for_los_shrink(GC* gc);
#endif /* _SPACE_TUNER_H_ */
Modified: harmony/enhanced/drlvm/trunk/vm/gc_gen/src/finalizer_weakref/finalizer_weakref.cpp
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/gc_gen/src/finalizer_weakref/finalizer_weakref.cpp?view=diff&rev=541224&r1=541223&r2=541224
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/gc_gen/src/finalizer_weakref/finalizer_weakref.cpp (original)
+++ harmony/enhanced/drlvm/trunk/vm/gc_gen/src/finalizer_weakref/finalizer_weakref.cpp Thu May 24 01:17:25 2007
@@ -125,7 +125,7 @@
for(; !vector_block_iterator_end(block, iter); iter = vector_block_iterator_advance(block, iter)){
REF* p_ref = (REF *)iter;
if(IS_FALLBACK_COMPACTION)
- fallback_update_fw_ref(p_ref); // in case that this collection is FALLBACK_COLLECTION
+ fallback_update_fw_ref(p_ref); // in case that this collection is FALLBACK_COLLECTION
Partial_Reveal_Object *p_obj = read_slot(p_ref);
if(!p_obj)
continue;
@@ -281,7 +281,7 @@
assert(p_obj);
REF* p_referent_field = obj_get_referent_field(p_obj);
if(IS_FALLBACK_COMPACTION)
- fallback_update_fw_ref(p_referent_field);
+ fallback_update_fw_ref(p_referent_field);
Partial_Reveal_Object *p_referent = read_slot(p_referent_field);
if(!p_referent){ // referent field has been cleared
@@ -598,7 +598,7 @@
assert(p_obj);
REF* p_referent_field = obj_get_referent_field(p_obj);
if(IS_FALLBACK_COMPACTION)
- fallback_update_fw_ref(p_referent_field);
+ fallback_update_fw_ref(p_referent_field);
Partial_Reveal_Object* p_referent = read_slot(p_referent_field);
if(!p_referent){ // referent field has been cleared
Modified: harmony/enhanced/drlvm/trunk/vm/gc_gen/src/gen/gen.cpp
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/gc_gen/src/gen/gen.cpp?view=diff&rev=541224&r1=541223&r2=541224
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/gc_gen/src/gen/gen.cpp (original)
+++ harmony/enhanced/drlvm/trunk/vm/gc_gen/src/gen/gen.cpp Thu May 24 01:17:25 2007
@@ -74,14 +74,14 @@
min_nos_size_bytes *= gc_gen->_num_processors;
- POINTER_SIZE_INT min_nos_size_threshold = max_heap_size>>5;
+ POINTER_SIZE_INT min_nos_size_threshold = min_heap_size>>5;
if(min_nos_size_bytes > min_nos_size_threshold){
min_nos_size_bytes = round_down_to_size(min_nos_size_threshold,SPACE_ALLOC_UNIT);
}
if( MIN_NOS_SIZE ) min_nos_size_bytes = MIN_NOS_SIZE;
- POINTER_SIZE_INT los_size = max_heap_size >> 7;
+ POINTER_SIZE_INT los_size = min_heap_size >> 7;
if(INIT_LOS_SIZE) los_size = INIT_LOS_SIZE;
if(los_size < min_los_size_bytes )
los_size = min_los_size_bytes ;
@@ -95,25 +95,25 @@
POINTER_SIZE_INT mos_reserve_size, mos_commit_size;
POINTER_SIZE_INT los_mos_size;
- /*Give GC a hint of gc survive ratio.*/
+ /*Give GC a hint of gc survive ratio. And the last_survive_ratio field is used in heap size adjustment*/
gc_gen->survive_ratio = 0.2f;
if(NOS_SIZE){
- los_mos_size = max_heap_size - NOS_SIZE;
+ los_mos_size = min_heap_size - NOS_SIZE;
mos_reserve_size = los_mos_size - los_size;
nos_commit_size = NOS_SIZE;
nos_reserve_size = NOS_SIZE;
}else{
- los_mos_size = max_heap_size;
+ los_mos_size = min_heap_size;
mos_reserve_size = los_mos_size - los_size;
- nos_commit_size = (POINTER_SIZE_INT)(((float)(max_heap_size - los_size))/(1.0f + gc_gen->survive_ratio));
+ nos_commit_size = (POINTER_SIZE_INT)(((float)(min_heap_size - los_size))/(1.0f + gc_gen->survive_ratio));
nos_reserve_size = mos_reserve_size;
}
nos_commit_size = round_down_to_size(nos_commit_size, SPACE_ALLOC_UNIT);
- mos_commit_size = max_heap_size - los_size - nos_commit_size;
+ mos_commit_size = min_heap_size - los_size - nos_commit_size;
/* allocate memory for gc_gen */
void* reserved_base;
@@ -145,8 +145,8 @@
}
reserved_base = vm_reserve_mem(los_mos_base, los_mos_size);
}
-
-#else /* STATIC_NOS_MAPPING */
+/* NON_STATIC_NOS_MAPPING */
+#else
reserved_base = NULL;
if(large_page_hint){
@@ -160,18 +160,29 @@
}
}
- if(reserved_base==NULL){
+ if(reserved_base == NULL){
+ Boolean max_size_reduced = 0;
reserved_base = vm_reserve_mem((void*)0, max_heap_size + SPACE_ALLOC_UNIT);
- reserved_base = (void*)round_up_to_size((POINTER_SIZE_INT)reserved_base, SPACE_ALLOC_UNIT);
- assert((POINTER_SIZE_INT)reserved_base%SPACE_ALLOC_UNIT == 0);
-
while( !reserved_base ){
- printf("Non-static NOS mapping: Can't allocate memory at address %x for specified size %x", reserved_base, max_heap_size);
- exit(0);
+ max_size_reduced = 1;
+ max_heap_size -= SPACE_ALLOC_UNIT;
+ reserved_base = vm_reserve_mem((void*)0, max_heap_size + SPACE_ALLOC_UNIT);
+ }
+
+ if(max_size_reduced){
+ printf("Max heap size: can't be reserved, reduced to %d MB according to virtual memory limitation.\n", max_heap_size/MB);
+ }
+
+ if(max_heap_size < min_heap_size){
+ printf("Heap size: invalid, please reimput a smaller \"ms\" paramenter!\n");
+ exit(0);
}
+ reserved_base = (void*)round_up_to_size((POINTER_SIZE_INT)reserved_base, SPACE_ALLOC_UNIT);
+ assert((POINTER_SIZE_INT)reserved_base%SPACE_ALLOC_UNIT == 0);
}
reserved_end = (void*)((POINTER_SIZE_INT)reserved_base + max_heap_size);
+
/* compute first time nos_boundary */
nos_base = (void*)((POINTER_SIZE_INT)reserved_base + mos_commit_size + los_size);
@@ -208,9 +219,6 @@
nos->collect_algorithm = MINOR_ALGO;
mos->collect_algorithm = MAJOR_ALGO;
- /*Give GC a hint of space survive ratio.*/
-// nos->survive_ratio = gc_gen->survive_ratio;
-// mos->survive_ratio = gc_gen->survive_ratio;
gc_space_tuner_initialize((GC*)gc_gen);
gc_gen_mode_adapt_init(gc_gen);
@@ -219,7 +227,6 @@
space_committed_size((Space*)gc_gen->mos) +
space_committed_size((Space*)gc_gen->los);
-
set_native_finalizer_thread_flag(!IGNORE_FINREF);
set_native_ref_enqueue_thread_flag(!IGNORE_FINREF);
@@ -271,12 +278,6 @@
unsigned int gc_get_processor_num(GC_Gen* gc){ return gc->_num_processors;}
-
-static Boolean major_collection_needed(GC_Gen* gc)
-{
- return space_used_memory_size((Blocked_Space*)gc->nos)*gc->survive_ratio > (space_free_memory_size((Blocked_Space*)gc->mos));
-}
-
Boolean FORCE_FULL_COMPACT = FALSE;
void gc_decide_collection_kind(GC_Gen* gc, unsigned int cause)
@@ -356,6 +357,69 @@
return;
}
+void gc_gen_adjust_heap_size(GC_Gen* gc, int64 pause_time)
+{
+ if(gc_match_kind((GC*)gc, MINOR_COLLECTION)) return;
+ if(gc->committed_heap_size == max_heap_size_bytes) return;
+
+ Mspace* mos = gc->mos;
+ Fspace* nos = gc->nos;
+ Lspace* los = gc->los;
+ /*We can not tolerate gc->survive_ratio be greater than threshold twice continuously.
+ *Or, we must adjust heap size
+ */
+ static unsigned int tolerate = 0;
+
+ POINTER_SIZE_INT heap_total_size = los->committed_heap_size + mos->committed_heap_size + nos->committed_heap_size;
+ assert(heap_total_size == gc->committed_heap_size);
+
+ assert(nos->surviving_size == 0);
+ POINTER_SIZE_INT heap_surviving_size = mos->surviving_size + los->surviving_size;
+ assert(heap_total_size > heap_surviving_size);
+
+ float heap_survive_ratio = (float)heap_surviving_size / (float)heap_total_size;
+ float threshold_survive_ratio = 0.3f;
+ float regular_survive_ratio = 0.125f;
+
+ POINTER_SIZE_INT new_heap_total_size = 0;
+ POINTER_SIZE_INT adjust_size = 0;
+
+ if(heap_survive_ratio < threshold_survive_ratio) return;
+
+ if(++tolerate < 2) return;
+ tolerate = 0;
+
+ new_heap_total_size = (POINTER_SIZE_INT)((float)heap_surviving_size / regular_survive_ratio);
+ new_heap_total_size = round_down_to_size(new_heap_total_size, SPACE_ALLOC_UNIT);
+
+
+ if(new_heap_total_size <= heap_total_size) return;
+ if(new_heap_total_size > max_heap_size_bytes - LOS_HEAD_RESERVE_FOR_HEAP_NULL)
+ new_heap_total_size = max_heap_size_bytes - LOS_HEAD_RESERVE_FOR_HEAP_NULL;
+
+ adjust_size = new_heap_total_size - heap_total_size;
+ assert( !(adjust_size % SPACE_ALLOC_UNIT) );
+ if(adjust_size == 0) return;
+
+#ifdef STATIC_NOS_MAPPING
+ /*Fixme: Static mapping have other bugs to be fixed first.*/
+ assert(!large_page_hint);
+ return;
+#else
+ assert(!large_page_hint);
+ POINTER_SIZE_INT old_nos_size = nos->committed_heap_size;
+ blocked_space_extend(nos, (unsigned int)adjust_size);
+ nos->survive_ratio = (float)old_nos_size * nos->survive_ratio / (float)nos->committed_heap_size;
+ /*Fixme: gc fields should be modified according to nos extend*/
+ gc->committed_heap_size += adjust_size;
+ //debug_adjust
+ assert(gc->committed_heap_size == los->committed_heap_size + mos->committed_heap_size + nos->committed_heap_size);
+#endif
+
+// printf("heap_size: %x MB , heap_survive_ratio: %f\n", gc->committed_heap_size/MB, heap_survive_ratio);
+
+}
+
Boolean IS_FALLBACK_COMPACTION = FALSE; /* only for debugging, don't use it. */
void gc_gen_reclaim_heap(GC_Gen* gc)
@@ -372,41 +436,31 @@
if(gc_match_kind((GC*)gc, MINOR_COLLECTION)){
/* FIXME:: move_object is only useful for nongen_slide_copy */
gc->mos->move_object = FALSE;
-
fspace_collection(gc->nos);
-
gc->mos->move_object = TRUE;
-
-
}else{
-
/* process mos and nos together in one compaction */
mspace_collection(gc->mos); /* fspace collection is included */
lspace_collection(gc->los);
-
}
if(gc->collect_result == FALSE && gc_match_kind((GC*)gc, MINOR_COLLECTION)){
- if(gc_is_gen_mode())
- gc_clear_remset((GC*)gc);
+ if(gc_is_gen_mode()) gc_clear_remset((GC*)gc);
/* runout mspace in minor collection */
assert(mspace->free_block_idx == mspace->ceiling_block_idx + 1);
mspace->num_used_blocks = mspace->num_managed_blocks;
IS_FALLBACK_COMPACTION = TRUE;
-
gc_reset_collect_result((GC*)gc);
gc->collect_kind = FALLBACK_COLLECTION;
- if(verify_live_heap)
- event_gc_collect_kind_changed((GC*)gc);
+ if(verify_live_heap) event_gc_collect_kind_changed((GC*)gc);
mspace_collection(gc->mos); /* fspace collection is included */
lspace_collection(gc->los);
IS_FALLBACK_COMPACTION = FALSE;
-
}
if( gc->collect_result == FALSE){
@@ -423,7 +477,6 @@
#endif
assert(!gc->los->move_object);
-
return;
}
Modified: harmony/enhanced/drlvm/trunk/vm/gc_gen/src/gen/gen.h
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/gc_gen/src/gen/gen.h?view=diff&rev=541224&r1=541223&r2=541224
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/gc_gen/src/gen/gen.h (original)
+++ harmony/enhanced/drlvm/trunk/vm/gc_gen/src/gen/gen.h Thu May 24 01:17:25 2007
@@ -169,6 +169,8 @@
void gc_gen_reclaim_heap(GC_Gen* gc);
void gc_gen_assign_free_area_to_mutators(GC_Gen* gc);
+
+void gc_gen_adjust_heap_size(GC_Gen* gc, int64 pause_time);
void gc_gen_mode_adapt_init(GC_Gen *gc);
@@ -177,5 +179,6 @@
extern Boolean GEN_NONGEN_SWITCH ;
#endif /* ifndef _GC_GEN_H_ */
+
Modified: harmony/enhanced/drlvm/trunk/vm/gc_gen/src/gen/gen_adapt.cpp
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/gc_gen/src/gen/gen_adapt.cpp?view=diff&rev=541224&r1=541223&r2=541224
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/gc_gen/src/gen/gen_adapt.cpp (original)
+++ harmony/enhanced/drlvm/trunk/vm/gc_gen/src/gen/gen_adapt.cpp Thu May 24 01:17:25 2007
@@ -25,11 +25,9 @@
#define NOS_COPY_RESERVE_DELTA (GC_BLOCK_SIZE_BYTES<<1)
/*Tune this number in case that MOS could be too small, so as to avoid or put off fall back.*/
#define GC_MOS_MIN_EXTRA_REMAIN_SIZE (36*MB)
-/*Switch on this MACRO when we want lspace->survive_ratio to be sensitive.*/
-//#define NOS_SURVIVE_RATIO_SENSITIVE
struct Mspace;
-void mspace_set_expected_threshold(Mspace* mspace, POINTER_SIZE_INT threshold);
+void mspace_set_expected_threshold_ratio(Mspace* mspace, float threshold_ratio);
static float Tslow = 0.0f;
static POINTER_SIZE_INT SMax = 0;
@@ -187,7 +185,7 @@
return;
}
-void mspace_set_expected_threshold(Mspace* mspace, POINTER_SIZE_INT threshold);
+void mspace_set_expected_threshold_ratio(Mspace* mspace, float threshold_ratio);
static void gc_decide_next_collect(GC_Gen* gc, int64 pause_time)
{
@@ -200,7 +198,8 @@
POINTER_SIZE_INT nos_free_size = space_free_memory_size(fspace);
POINTER_SIZE_INT total_free_size = mos_free_size + nos_free_size;
if(!gc_match_kind((GC*)gc, MINOR_COLLECTION)) gc->force_gen_mode = FALSE;
- if(!gc->force_gen_mode){
+ if(!gc->force_gen_mode){
+ /*For major collection:*/
if(!gc_match_kind((GC*)gc, MINOR_COLLECTION)){
mspace->time_collections += pause_time;
@@ -213,48 +212,44 @@
/*If major is caused by LOS, or collection kind is EXTEND_COLLECTION, all survive ratio is not updated.*/
if((gc->cause != GC_CAUSE_LOS_IS_FULL) && (!gc_match_kind((GC*)gc, EXTEND_COLLECTION))){
- POINTER_SIZE_INT major_survive_size = space_committed_size((Space*)mspace) - mos_free_size;
- survive_ratio = (float)major_survive_size/(float)space_committed_size((Space*)mspace);
+ POINTER_SIZE_INT major_surviving_size = space_committed_size((Space*)mspace) - mos_free_size;
+ survive_ratio = (float)major_surviving_size/(float)space_committed_size((Space*)mspace);
mspace->survive_ratio = survive_ratio;
}
- /*For LOS_Shrink:*/
- if(gc->tuner->kind != TRANS_NOTHING){
- POINTER_SIZE_INT mspace_size_threshold = (space_committed_size((Space*)mspace) + space_committed_size((Space*)fspace)) >> 1;
- mspace_set_expected_threshold((Mspace *)mspace, mspace_size_threshold );
- }
- #ifdef NOS_SURVIVE_RATIO_SENSITIVE
- /*If this major is caused by fall back compaction,
- we must give fspace->survive_ratio a conservative and reasonable number to avoid next fall back.*/
- //fspace->survive_ratio = mspace->survive_ratio;
- /*In fallback compaction, the survive_ratio of mspace must be 1.*/
- if(gc_match_kind((GC*)gc, FALLBACK_COLLECTION))
- fspace->survive_ratio = 1;
-
- #endif
+ /*If there is no minor collection at all, we must give mspace expected threshold a reasonable value.*/
+ if((gc->tuner->kind != TRANS_NOTHING) && (fspace->num_collections == 0))
+ mspace_set_expected_threshold_ratio((Mspace *)mspace, 0.5f);
+ /*If this major is caused by fall back compaction, we must give fspace->survive_ratio
+ *a conservative and reasonable number to avoid next fall back.
+ *In fallback compaction, the survive_ratio of mspace must be 1.*/
+ if(gc_match_kind((GC*)gc, FALLBACK_COLLECTION)) fspace->survive_ratio = 1;
+ /*For minor collection:*/
}else{
/*Give a hint to mini_free_ratio. */
if(fspace->num_collections == 1){
/*fixme: This is only set for tuning the first warehouse!*/
Tslow = pause_time / gc->survive_ratio;
- SMax = (POINTER_SIZE_INT)((float)gc->committed_heap_size * ( 1 - gc->survive_ratio ));
+ SMax = (POINTER_SIZE_INT)((float)(gc->committed_heap_size - gc->los->committed_heap_size) * ( 1 - gc->survive_ratio ));
last_total_free_size = gc->committed_heap_size - gc->los->committed_heap_size;
}
fspace->time_collections += pause_time;
POINTER_SIZE_INT free_size_threshold;
-
- POINTER_SIZE_INT minor_survive_size = last_total_free_size - total_free_size;
+
+ POINTER_SIZE_INT minor_surviving_size = last_total_free_size - total_free_size;
float k = Tslow * fspace->num_collections/fspace->time_collections;
- float m = ((float)minor_survive_size)*1.0f/((float)(SMax - GC_MOS_MIN_EXTRA_REMAIN_SIZE ));
+ float m = ((float)minor_surviving_size)*1.0f/((float)(SMax - GC_MOS_MIN_EXTRA_REMAIN_SIZE ));
float free_ratio_threshold = mini_free_ratio(k, m);
- free_size_threshold = (POINTER_SIZE_INT)(free_ratio_threshold * (SMax - GC_MOS_MIN_EXTRA_REMAIN_SIZE ) + GC_MOS_MIN_EXTRA_REMAIN_SIZE );
+
+ if(SMax > GC_MOS_MIN_EXTRA_REMAIN_SIZE)
+ free_size_threshold = (POINTER_SIZE_INT)(free_ratio_threshold * (SMax - GC_MOS_MIN_EXTRA_REMAIN_SIZE ) + GC_MOS_MIN_EXTRA_REMAIN_SIZE );
+ else
+ free_size_threshold = (POINTER_SIZE_INT)(free_ratio_threshold * SMax);
- if ((mos_free_size + nos_free_size)< free_size_threshold) {
- gc->force_major_collect = TRUE;
- }
+ if ((mos_free_size + nos_free_size)< free_size_threshold) gc->force_major_collect = TRUE;
- survive_ratio = (float)minor_survive_size/(float)space_committed_size((Space*)fspace);
+ survive_ratio = (float)minor_surviving_size/(float)space_committed_size((Space*)fspace);
fspace->survive_ratio = survive_ratio;
/*For LOS_Adaptive*/
POINTER_SIZE_INT mspace_committed_size = space_committed_size((Space*)mspace);
@@ -262,12 +257,12 @@
if(mspace_committed_size + fspace_committed_size > free_size_threshold){
POINTER_SIZE_INT mspace_size_threshold;
mspace_size_threshold = mspace_committed_size + fspace_committed_size - free_size_threshold;
- mspace_set_expected_threshold((Mspace *)mspace, mspace_size_threshold );
+ float mspace_size_threshold_ratio = (float)mspace_size_threshold / (mspace_committed_size + fspace_committed_size);
+ mspace_set_expected_threshold_ratio((Mspace *)mspace, mspace_size_threshold_ratio);
}
}
-
- gc->survive_ratio = (gc->survive_ratio + survive_ratio)/2.0f;
+ gc->survive_ratio = (gc->survive_ratio + survive_ratio)/2.0f;
last_total_free_size = total_free_size;
}
@@ -295,7 +290,9 @@
#ifdef STATIC_NOS_MAPPING
total_size = max_heap_size_bytes - lspace->committed_heap_size;
#else
- total_size = (POINTER_SIZE_INT)gc->heap_end - (POINTER_SIZE_INT)mspace->heap_start;
+ POINTER_SIZE_INT curr_heap_commit_end =
+ (POINTER_SIZE_INT)gc->heap_start + LOS_HEAD_RESERVE_FOR_HEAP_NULL + gc->committed_heap_size;
+ total_size = curr_heap_commit_end - (POINTER_SIZE_INT)mspace->heap_start;
#endif
POINTER_SIZE_INT total_free = total_size - used_mos_size;
@@ -306,16 +303,15 @@
POINTER_SIZE_INT nos_reserve_size;
nos_reserve_size = (POINTER_SIZE_INT)(((float)total_free)/(1.0f + fspace->survive_ratio));
/*NOS should not be zero, if there is only one block in non-los, i.e. in the former if sentence,
- if total_free = GC_BLOCK_SIZE_BYTES, then the computed nos_reserve_size is between zero
- and GC_BLOCK_SIZE_BYTES. In this case, we assign this block to NOS*/
+ *if total_free = GC_BLOCK_SIZE_BYTES, then the computed nos_reserve_size is between zero
+ *and GC_BLOCK_SIZE_BYTES. In this case, we assign this block to NOS*/
if(nos_reserve_size <= GC_BLOCK_SIZE_BYTES) nos_reserve_size = GC_BLOCK_SIZE_BYTES;
#ifdef STATIC_NOS_MAPPING
if(nos_reserve_size > fspace->reserved_heap_size) nos_reserve_size = fspace->reserved_heap_size;
#endif
- //To reserve some MOS space to avoid fallback situation.
- //But we need ensure nos has at least one block
- //if(new_nos_size > GC_MOS_MIN_EXTRA_REMAIN_SIZE) new_nos_size -= GC_MOS_MIN_EXTRA_REMAIN_SIZE ;
+ /*To reserve some MOS space to avoid fallback situation.
+ *But we need ensure nos has at least one block */
POINTER_SIZE_INT reserve_in_mos = GC_MOS_MIN_EXTRA_REMAIN_SIZE;
while (reserve_in_mos >= GC_BLOCK_SIZE_BYTES){
if(nos_reserve_size >= reserve_in_mos + GC_BLOCK_SIZE_BYTES){
@@ -328,7 +324,7 @@
new_nos_size = round_down_to_size((POINTER_SIZE_INT)nos_reserve_size, GC_BLOCK_SIZE_BYTES);
if(gc->force_gen_mode){
- new_nos_size = min_nos_size_bytes;//round_down_to_size((unsigned int)(gc->gen_minor_adaptor->adapt_nos_size), SPACE_ALLOC_UNIT);
+ new_nos_size = min_nos_size_bytes;
}
new_mos_size = total_size - new_nos_size;
@@ -342,7 +338,6 @@
}
#ifndef STATIC_NOS_MAPPING
-
void gc_gen_adapt(GC_Gen* gc, int64 pause_time)
{
gc_decide_next_collect(gc, pause_time);
@@ -366,8 +361,9 @@
return;
/* below are ajustment */
-
- nos_boundary = (void*)((POINTER_SIZE_INT)gc->heap_end - new_nos_size);
+ POINTER_SIZE_INT curr_heap_commit_end =
+ (POINTER_SIZE_INT)gc->heap_start + LOS_HEAD_RESERVE_FOR_HEAP_NULL + gc->committed_heap_size;
+ nos_boundary = (void*)(curr_heap_commit_end - new_nos_size);
fspace->heap_start = nos_boundary;
fspace->blocks = (Block*)nos_boundary;
@@ -394,8 +390,8 @@
return;
}
-#else /* ifndef STATIC_NOS_MAPPING */
-
+/* ifdef STATIC_NOS_MAPPING */
+#else
void gc_gen_adapt(GC_Gen* gc, int64 pause_time)
{
gc_decide_next_collect(gc, pause_time);
Modified: harmony/enhanced/drlvm/trunk/vm/gc_gen/src/mark_compact/fallback_mark_scan.cpp
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/gc_gen/src/mark_compact/fallback_mark_scan.cpp?view=diff&rev=541224&r1=541223&r2=541224
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/gc_gen/src/mark_compact/fallback_mark_scan.cpp (original)
+++ harmony/enhanced/drlvm/trunk/vm/gc_gen/src/mark_compact/fallback_mark_scan.cpp Thu May 24 01:17:25 2007
@@ -96,7 +96,7 @@
/* for marking phase termination detection */
static volatile unsigned int num_finished_collectors = 0;
-void fallback_mark_scan_heap(Collector* collector)
+void mark_scan_heap_for_fallback(Collector* collector)
{
GC* gc = collector->gc;
GC_Metadata* metadata = gc->metadata;
@@ -208,4 +208,5 @@
fspace_block_iterate_init((Fspace*)((GC_Gen*)collector->gc)->nos);
}
#endif
+
Modified: harmony/enhanced/drlvm/trunk/vm/gc_gen/src/mark_compact/los_extention_mark_scan.cpp
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/gc_gen/src/mark_compact/los_extention_mark_scan.cpp?view=diff&rev=541224&r1=541223&r2=541224
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/gc_gen/src/mark_compact/los_extention_mark_scan.cpp (original)
+++ harmony/enhanced/drlvm/trunk/vm/gc_gen/src/mark_compact/los_extention_mark_scan.cpp Thu May 24 01:17:25 2007
@@ -108,7 +108,7 @@
So we abondoned this design. We no longer use the repset to remember repointed slots
*/
-void los_adaptation_mark_scan_heap(Collector *collector)
+void mark_scan_heap_for_space_tune(Collector *collector)
{
GC* gc = collector->gc;
GC_Metadata* metadata = gc->metadata;
Modified: harmony/enhanced/drlvm/trunk/vm/gc_gen/src/mark_compact/mspace.cpp
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/gc_gen/src/mark_compact/mspace.cpp?view=diff&rev=541224&r1=541223&r2=541224
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/gc_gen/src/mark_compact/mspace.cpp (original)
+++ harmony/enhanced/drlvm/trunk/vm/gc_gen/src/mark_compact/mspace.cpp Thu May 24 01:17:25 2007
@@ -75,8 +75,7 @@
mspace->move_object = TRUE;
mspace->gc = gc;
- /*For_LOS adaptive: The threshold is initiated by half of MOS + NOS commit size.*/
- mspace->expected_threshold = (unsigned int)( ( (float)mspace->committed_heap_size * (1.f + 1.f / gc->survive_ratio) ) * 0.5f );
+ mspace->expected_threshold_ratio = 0.5f;
gc_set_mos((GC_Gen*)gc, (Space*)mspace);
@@ -96,22 +95,13 @@
mspace->block_iterator = (Block_Header*)&mspace->blocks[mspace->free_block_idx - mspace->first_block_idx];
}
-//For_LOS_extend
#include "../common/space_tuner.h"
void mspace_block_iterator_init(Mspace* mspace)
{
- GC* gc = mspace->gc;
- if(gc->tuner->kind == TRANS_FROM_MOS_TO_LOS){
- unsigned int tuning_blocks = (unsigned int)((mspace->gc)->tuner->tuning_size >> GC_BLOCK_SHIFT_COUNT);
- mspace->block_iterator = (Block_Header*)&(mspace->blocks[tuning_blocks]);
- return;
- }
-
mspace->block_iterator = (Block_Header*)mspace->blocks;
return;
}
-
Block_Header* mspace_block_iterator_get(Mspace* mspace)
{
return (Block_Header*)mspace->block_iterator;
@@ -165,15 +155,15 @@
}
/*For_LOS adaptive.*/
-void mspace_set_expected_threshold(Mspace* mspace, POINTER_SIZE_INT threshold)
+void mspace_set_expected_threshold_ratio(Mspace* mspace, float threshold_ratio)
{
- mspace->expected_threshold = threshold;
+ mspace->expected_threshold_ratio = threshold_ratio;
return;
}
-POINTER_SIZE_INT mspace_get_expected_threshold(Mspace* mspace)
+float mspace_get_expected_threshold_ratio(Mspace* mspace)
{
- return mspace->expected_threshold;
+ return mspace->expected_threshold_ratio;
}
Modified: harmony/enhanced/drlvm/trunk/vm/gc_gen/src/mark_compact/mspace.h
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/gc_gen/src/mark_compact/mspace.h?view=diff&rev=541224&r1=541223&r2=541224
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/gc_gen/src/mark_compact/mspace.h (original)
+++ harmony/enhanced/drlvm/trunk/vm/gc_gen/src/mark_compact/mspace.h Thu May 24 01:17:25 2007
@@ -56,7 +56,7 @@
volatile Block_Header* block_iterator;
/*Threshold computed by NOS adaptive*/
- POINTER_SIZE_INT expected_threshold;
+ float expected_threshold_ratio;
}Mspace;
void mspace_initialize(GC* gc, void* reserved_base, POINTER_SIZE_INT mspace_size, POINTER_SIZE_INT commit_size);
@@ -72,6 +72,6 @@
void mspace_fix_after_copy_nursery(Collector* collector, Mspace* mspace);
-void mspace_set_expected_threshold(Mspace* mspace, unsigned int threshold);
+void mspace_set_expected_threshold_ratio(Mspace* mspace, float threshold_ratio);
#endif //#ifdef _MSC_SPACE_H_
Modified: harmony/enhanced/drlvm/trunk/vm/gc_gen/src/mark_compact/mspace_collect_compact.cpp
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/gc_gen/src/mark_compact/mspace_collect_compact.cpp?view=diff&rev=541224&r1=541223&r2=541224
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/gc_gen/src/mark_compact/mspace_collect_compact.cpp (original)
+++ harmony/enhanced/drlvm/trunk/vm/gc_gen/src/mark_compact/mspace_collect_compact.cpp Thu May 24 01:17:25 2007
@@ -29,72 +29,30 @@
static volatile Block_Header* next_block_for_compact;
static volatile Block_Header* next_block_for_target;
-void mspace_update_info_for_los_extension(Mspace *mspace)
-{
- Space_Tuner *tuner = mspace->gc->tuner;
-
- if(tuner->kind != TRANS_FROM_MOS_TO_LOS) return;
-
- POINTER_SIZE_INT tune_size = tuner->tuning_size;
- unsigned int tune_blocks = (unsigned int)(tune_size >> GC_BLOCK_SHIFT_COUNT);
-
-#ifdef USE_32BITS_HASHCODE
- unsigned int index = 0;
- for(; index < tune_blocks; index++){
- Block* curr_block = &mspace->blocks[index];
- hashcode_buf_destory(((Block_Header*)curr_block)->hashcode_buf);
- }
-#endif
-
- mspace->blocks = &mspace->blocks[tune_blocks];
- mspace->heap_start = mspace->blocks;
- mspace->committed_heap_size -= tune_size;
- mspace->reserved_heap_size -= tune_size;
- mspace->first_block_idx += tune_blocks;
- mspace->num_managed_blocks -= tune_blocks;
- mspace->num_total_blocks -= tune_blocks;
- if(mspace->num_used_blocks > tune_blocks)
- mspace->num_used_blocks -= tune_blocks;
- else
- mspace->num_used_blocks = 0;
-}
-
-void mspace_update_info_for_los_shrink(Mspace* mspace)
+void mspace_update_info_after_space_tuning(Mspace* mspace)
{
Space_Tuner *tuner = mspace->gc->tuner;
- if(tuner->kind != TRANS_FROM_LOS_TO_MOS) return;
-
- POINTER_SIZE_INT tune_size = tuner->tuning_size;
- unsigned int tune_blocks = (unsigned int)(tune_size >> GC_BLOCK_SHIFT_COUNT);
-
- /*Update mspace infomation.*/
- mspace->blocks = (Block*)((POINTER_SIZE_INT)mspace->blocks - tune_size);
- mspace->heap_start = (void*)(mspace->blocks);
- mspace->committed_heap_size += tune_size;
- mspace->first_block_idx -= tune_blocks;
- mspace->num_managed_blocks += tune_blocks;
- mspace->num_total_blocks += tune_blocks;
-}
-
-/*Copy the fake blocks into real blocks, reconnect these new block into main list of mspace.*/
-void mspace_settle_fake_blocks_for_los_shrink(Mspace* mspace)
-{
- Space_Tuner *tuner = mspace->gc->tuner;
- if(tuner->kind != TRANS_FROM_LOS_TO_MOS) return;
-
POINTER_SIZE_INT tune_size = tuner->tuning_size;
unsigned int tune_blocks = (unsigned int)(tune_size >> GC_BLOCK_SHIFT_COUNT);
-
- Block* blocks = (Block*)((POINTER_SIZE_INT)mspace->blocks - tune_size);
- unsigned int i;
- for(i=0; i < tune_blocks; i++){
- Block_Header* real_block = (Block_Header*)&(blocks[i]);
- Block_Header* fake_block = &tuner->interim_blocks[i];
- memcpy((void*)real_block, (void*)fake_block, sizeof(Block_Header));
- real_block->next = (Block_Header*)((POINTER_SIZE_INT)real_block + GC_BLOCK_SIZE_BYTES);
+
+ if(tuner->kind == TRANS_FROM_MOS_TO_LOS){
+ mspace->blocks = &mspace->blocks[tune_blocks];
+ mspace->heap_start = mspace->blocks;
+ mspace->committed_heap_size -= tune_size;
+ mspace->reserved_heap_size -= tune_size;
+ mspace->first_block_idx += tune_blocks;
+ mspace->num_managed_blocks -= tune_blocks;
+ mspace->num_total_blocks -= tune_blocks;
+ if(mspace->num_used_blocks > tune_blocks) mspace->num_used_blocks -= tune_blocks;
+ else mspace->num_used_blocks = 0;
+ }else if(tuner->kind == TRANS_FROM_LOS_TO_MOS){
+ mspace->blocks = (Block*)((POINTER_SIZE_INT)mspace->blocks - tune_size);
+ mspace->heap_start = (void*)(mspace->blocks);
+ mspace->committed_heap_size += tune_size;
+ mspace->first_block_idx -= tune_blocks;
+ mspace->num_managed_blocks += tune_blocks;
+ mspace->num_total_blocks += tune_blocks;
}
-
- return;
}
void mspace_reset_after_compaction(Mspace* mspace)
@@ -158,6 +116,9 @@
Block_Header* block;
Space_Tuner* tuner = gc->tuner;
Block_Header* nos_last_block;
+ Block_Header* mos_first_block = (Block_Header*)&mspace->blocks[0];
+ unsigned int trans_blocks = (unsigned int)(tuner->tuning_size >> GC_BLOCK_SHIFT_COUNT);
+
/*Needn't change LOS size.*/
if(tuner->kind == TRANS_NOTHING){
for(i=0; i<gc->num_active_collectors; i++){
@@ -182,8 +143,7 @@
else
/*If nos->num_managed_blocks is zero, we take mos_last_block as nos_last_block instead.*/
nos_last_block = (Block_Header*)&mspace->blocks[mspace->num_managed_blocks - 1];
- Block_Header* mos_first_block = (Block_Header*)&mspace->blocks[0];
- unsigned int trans_blocks = (unsigned int)(tuner->tuning_size >> GC_BLOCK_SHIFT_COUNT);
+
nos_last_block->next = mos_first_block;
((Block_Header*)&(mspace->blocks[trans_blocks - 1]))->next = NULL;
@@ -201,39 +161,17 @@
return;
}else
{
- Block_Header* mos_first_block = (Block_Header*)&mspace->blocks[0];
- unsigned int trans_blocks = (unsigned int)(tuner->tuning_size >> GC_BLOCK_SHIFT_COUNT);
- gc->tuner->interim_blocks = (Block_Header*)STD_MALLOC(trans_blocks * sizeof(Block_Header));
- Block_Header* los_trans_fake_blocks = gc->tuner->interim_blocks;
- memset(los_trans_fake_blocks, 0, trans_blocks * sizeof(Block_Header));
- void* trans_base = (void*)((POINTER_SIZE_INT)mos_first_block - tuner->tuning_size);
- unsigned int start_idx = GC_BLOCK_INDEX_FROM(gc->heap_start, trans_base);
- Block_Header* last_block = los_trans_fake_blocks;
-
- for(i = 0; i < trans_blocks; i ++){
- Block_Header* curr_block = &los_trans_fake_blocks[i];
- curr_block->block_idx = start_idx + i;
- curr_block->base = (void*)((POINTER_SIZE_INT)trans_base + i * GC_BLOCK_SIZE_BYTES + GC_BLOCK_HEADER_SIZE_BYTES);
- curr_block->free = curr_block->base ;
- curr_block->new_free = curr_block->free;
- curr_block->ceiling = (void*)((POINTER_SIZE_INT)curr_block->base + GC_BLOCK_BODY_SIZE_BYTES);
- curr_block->status = BLOCK_COMPACTED;
-#ifdef USE_32BITS_HASHCODE
- curr_block->hashcode_buf = hashcode_buf_create();
-#endif
- last_block->next = curr_block;
- last_block = curr_block;
- }
- last_block->next = mos_first_block;
+ gc_space_tuner_init_fake_blocks_for_los_shrink(gc);
Collector* collector = gc->collectors[0];
- collector->cur_target_block = los_trans_fake_blocks;
+ collector->cur_target_block = tuner->interim_blocks;
collector->cur_target_block->status = BLOCK_TARGET;
+
if(trans_blocks >= gc->num_active_collectors)
collector->cur_compact_block = mos_first_block;
else
- collector->cur_compact_block = los_trans_fake_blocks;
-
+ collector->cur_compact_block = gc->tuner->interim_blocks;
+
collector->cur_compact_block->status = BLOCK_IN_COMPACT;
for(i=1; i< gc->num_active_collectors; i++){
Modified: harmony/enhanced/drlvm/trunk/vm/gc_gen/src/mark_compact/mspace_collect_compact.h
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/gc_gen/src/mark_compact/mspace_collect_compact.h?view=diff&rev=541224&r1=541223&r2=541224
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/gc_gen/src/mark_compact/mspace_collect_compact.h (original)
+++ harmony/enhanced/drlvm/trunk/vm/gc_gen/src/mark_compact/mspace_collect_compact.h Thu May 24 01:17:25 2007
@@ -28,9 +28,7 @@
void gc_reset_block_for_collectors(GC* gc, Mspace* mspace);
void gc_init_block_for_collectors(GC* gc, Mspace* mspace);
-void mspace_update_info_for_los_extension(Mspace* mspace);
-void mspace_update_info_for_los_shrink(Mspace* mspace);
-void mspace_settle_fake_blocks_for_los_shrink(Mspace* mspace);
+void mspace_update_info_after_space_tuning(Mspace* mspace);
void mspace_reset_after_compaction(Mspace* mspace);
Block_Header* mspace_get_first_compact_block(Mspace* mspace);
@@ -41,8 +39,8 @@
void slide_compact_mspace(Collector* collector);
void move_compact_mspace(Collector* collector);
-void fallback_mark_scan_heap(Collector* collector);
-void los_adaptation_mark_scan_heap(Collector *collector);
+void mark_scan_heap_for_fallback(Collector* collector);
+void mark_scan_heap_for_space_tune(Collector *collector);
void mspace_extend_compact(Collector *collector);
Modified: harmony/enhanced/drlvm/trunk/vm/gc_gen/src/mark_compact/mspace_move_compact.cpp
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/gc_gen/src/mark_compact/mspace_move_compact.cpp?view=diff&rev=541224&r1=541223&r2=541224
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/gc_gen/src/mark_compact/mspace_move_compact.cpp (original)
+++ harmony/enhanced/drlvm/trunk/vm/gc_gen/src/mark_compact/mspace_move_compact.cpp Thu May 24 01:17:25 2007
@@ -170,7 +170,7 @@
if(!gc_match_kind(gc, FALLBACK_COLLECTION))
mark_scan_heap(collector);
else
- fallback_mark_scan_heap(collector);
+ mark_scan_heap_for_fallback(collector);
old_num = atomic_inc32(&num_marking_collectors);
if( ++old_num == num_active_collectors ){
@@ -225,7 +225,6 @@
/* last collector's world here */
lspace_fix_repointed_refs(collector, lspace);
gc_fix_rootset(collector);
- mspace_update_info_for_los_extension(mspace);
num_fixing_collectors++;
}
while(num_fixing_collectors != num_active_collectors + 1);