// Fourier descriptor int test_fourier_descriptor(vector_t *fd, point_list_t *plist) { int i, n; vector_t *time, *fourier, *fd; complex_t comp; assert(fd); assert(plist); assert(vecter_get_length(fd) == point_list_get_count(plist)); time = cvector_new_and_copy_point_list(plist); fourier = vector_new(vector_get_length(time), true); //fd = vector_new(vector_get_length(time), true); dft(fourier, time); n = vector_get_length(time); // filtering /* comp.real = comp.imag = 0.0; for (i = n / 2 - 16; i < n / 2 + 16; i++) { cvector_put_value(comp, i, fourier); } */ /////////////////////// Normalization //////////////////////////// vector_copy(fd, fourier); // For translation invariance, 0 frequency must have a zero value cvector_put_value(comp, 0, fd); // For scale invariance, // fourier descriptor must be divied by the absolute of 1 frequency component. cvector_read_value(&comp, 1, fd); val = complex_get_abs(&comp); vector_divide_scalar(fd, val); ivector_divide_scalar(fd, val); // For rotating and changes in starting point // remove all phase information and // consider only absolute values of the descriptor element //f = fopen("fourier_descriptor.txt", "a+"); //fprintf(f, "%s", fn); for (i = 0; i < vector_get_length(fd); i++) { cvector_read_value(&comp, i, fd); val = complex_get_abs(&comp); vector_put_value(val, i, fd); ivector_put_value(0, i, fd); //fprintf(f, ", %lf", val); } //fprintf(f, "\n"); //fclose(f); /////////////////////////////////////////////////////////////////// // idft(time, fourier); return n; }
void allocator_object_write_barrier(Partial_Reveal_Object* p_object, Collector* allocator) { if( addr_belongs_to_nos(p_object)) return; REF* p_slot; /* scan array object */ if (object_is_array((Partial_Reveal_Object*)p_object)) { Partial_Reveal_Object* array = p_object; assert(!obj_is_primitive_array(array)); I_32 array_length = vector_get_length((Vector_Handle) array); for (int i = 0; i < array_length; i++) { p_slot = (REF *)vector_get_element_address_ref((Vector_Handle)array, i); if( read_slot(p_slot) != NULL && addr_belongs_to_nos(read_slot(p_slot))){ collector_remset_add_entry(allocator, (Partial_Reveal_Object**)p_slot); } } return; } /* scan non-array object */ Partial_Reveal_Object* p_obj = (Partial_Reveal_Object*)p_object; unsigned int num_refs = object_ref_field_num(p_obj); int *ref_iterator = object_ref_iterator_init(p_obj); for(unsigned int i=0; i<num_refs; i++){ p_slot = object_ref_iterator_get(ref_iterator+i, p_obj); if( addr_belongs_to_nos(read_slot(p_slot))){ collector_remset_add_entry(allocator, (Partial_Reveal_Object**)p_slot); } } return; }
void vector_normalize(vector_t *v) { float length = vector_get_length(*v); v->x /= length; v->y /= length; v->z /= length; }
static FORCE_INLINE void scan_object(Collector* collector, Partial_Reveal_Object *p_obj) { assert((((POINTER_SIZE_INT)p_obj) % GC_OBJECT_ALIGNMENT) == 0); if (!object_has_ref_field(p_obj)) return; REF *p_ref; /* scan array object */ if (object_is_array(p_obj)) { Partial_Reveal_Object* array = p_obj; assert(!obj_is_primitive_array(array)); I_32 array_length = vector_get_length((Vector_Handle) array); for (int i = 0; i < array_length; i++) { p_ref= (REF *)vector_get_element_address_ref((Vector_Handle) array, i); scan_slot(collector, p_ref); } return; /* array can't be a reference object, directly return. */ } /* scan non-array object */ unsigned int num_refs = object_ref_field_num(p_obj); int *ref_iterator = object_ref_iterator_init(p_obj); for(unsigned int i=0; i<num_refs; i++){ REF* p_ref = object_ref_iterator_get(ref_iterator+i, p_obj); scan_slot(collector, p_ref); } #ifndef BUILD_IN_REFERENT scan_weak_reference(collector, p_obj, scan_slot); #endif return; }
/*This function is for concurrent mark.*/ static void write_barrier_rem_obj_snapshot(Managed_Object_Handle p_obj_holding_ref) { Mutator *mutator = (Mutator *)gc_get_tls(); REF* p_obj_slot; if(obj_need_take_snapshot((Partial_Reveal_Object*)p_obj_holding_ref)){ if (object_is_array((Partial_Reveal_Object*)p_obj_holding_ref)) { Partial_Reveal_Object* array = (Partial_Reveal_Object*)p_obj_holding_ref; assert(!obj_is_primitive_array(array)); Partial_Reveal_Object* obj_to_snapshot; I_32 array_length = vector_get_length((Vector_Handle) array); for (int i = 0; i < array_length; i++) { p_obj_slot = (REF*)vector_get_element_address_ref((Vector_Handle) array, i); obj_to_snapshot = (Partial_Reveal_Object*)read_slot(p_obj_slot); if (obj_to_snapshot != NULL) mutator_dirtyset_add_entry(mutator, obj_to_snapshot); } }else{ /* scan non-array object */ Partial_Reveal_Object* p_obj = (Partial_Reveal_Object*)p_obj_holding_ref; unsigned int num_refs = object_ref_field_num(p_obj); int *ref_iterator = object_ref_iterator_init(p_obj); Partial_Reveal_Object* obj_to_snapshot; for(unsigned int i=0; i<num_refs; i++){ p_obj_slot = object_ref_iterator_get(ref_iterator+i, p_obj); obj_to_snapshot = (Partial_Reveal_Object*)read_slot(p_obj_slot); if (obj_to_snapshot != NULL) mutator_dirtyset_add_entry(mutator, obj_to_snapshot); } if(is_reference_obj(p_obj)){ REF* p_referent_field = obj_get_referent_field(p_obj); obj_to_snapshot = (Partial_Reveal_Object*)read_slot(p_referent_field); if (obj_to_snapshot != NULL) mutator_dirtyset_add_entry(mutator, obj_to_snapshot); } } obj_mark_gray_in_table((Partial_Reveal_Object *) p_obj_holding_ref); // now, the black-only obj (no gray bit been set) will also be scaned by marker, here mark it to gray to prevent this, just a workaround obj_mark_black_in_table((Partial_Reveal_Object *) p_obj_holding_ref, mutator); obj_dirty_in_table((Partial_Reveal_Object *) p_obj_holding_ref); } }
static void scan_array(Object_With_Header *obj) { Vector_Handle vector = (Vector_Handle)obj->start(); int32 length = vector_get_length(vector); Type_Info_Handle tih = class_get_element_type_info(obj->vt()->gcvt->ch); if(type_info_is_reference(tih) || type_info_is_vector(tih) || type_info_is_general_array(tih)) { Managed_Object_Handle *first_elem_addr = vector_get_element_address_ref(vector, 0); if (GC::compressing_references) { for(int i = 0; i < length; i++) { COMPRESSED_REFERENCE elem = ((COMPRESSED_REFERENCE *)first_elem_addr)[i]; mark_recursive((void *)elem, /*is_compressed_root*/ true); } } else { for(int i = 0; i < length; i++) { mark_recursive(first_elem_addr[i], /*is_compressed_root*/ false); } } } else if(type_info_is_primitive(tih)) { } else if(type_info_is_unboxed(tih)) { Class_Handle ech = type_info_get_class(tih); assert(ech); int first_elem_offset = vector_first_element_offset_unboxed(ech); int base_offset = 0;//(int)class_get_unboxed_data_offset(ech); int elem_size = class_element_size(obj->vt()->gcvt->ch); Vtable_GC *evt = (Vtable_GC *)class_get_vtable(ech); uint16 *offsets = evt->gcvt->offsets; int curr_elem_offset = first_elem_offset; for(int i = 0; i < length; i++) { uint16 *o = offsets; while(*o) { int adjusted_offset = curr_elem_offset + *o - base_offset; Managed_Object_Handle *slot = (Managed_Object_Handle *)(((Byte *)vector) + adjusted_offset); mark_recursive(*slot, /*is_compressed_root*/ GC::compressing_references); o++; } curr_elem_offset += elem_size; } } else { ABORT("All possible cases should already be covered"); } } //scan_array