ThreadProfiler::~ThreadProfiler() {
FreeHeap(area_bottom);
area_bottom = NULL;
area_top = NULL;
area_limit = NULL;
FreeHeap(table);
table = NULL;
}
~CodeBlobCollector() {
if (_code_blobs != NULL) {
for (int i=0; i<_code_blobs->length(); i++) {
FreeHeap(_code_blobs->at(i));
}
delete _code_blobs;
}
}
/**
* This routine is similar to FreeHeap in that it
* deallocates the memory consumed by the heap. However, it
* also calls Deallocator for each item in the heap so that
* this data is also deallocated.
*
* @param Heap heap whose data is to be freed
* @param destructor function to be used to deallocate data
*
* Globals:
* - None
*
* @note Exceptions: none
* @note History: Tue May 15 08:52:04 1990, DSJ, Created.
*/
void FreeHeapData(HEAP *Heap, void_dest destructor) {
HEAPENTRY Entry;
while (GetTopOfHeap (Heap, &Entry) != EMPTY)
destructor (Entry.Data);
FreeHeap(Heap);
} /* FreeHeapData */
void InliningDatabase::reset_lookup_table() {
if (table) {
FreeHeap(table);
table = NULL;
table_size = 0;
table_size_mask = 0;
table_no = 0;
}
}
void ArrayAllocator<E, F>::free() {
if (_addr != NULL) {
if (_use_malloc) {
FreeHeap(_addr, F);
} else {
os::release_memory(_addr, _size);
}
_addr = NULL;
}
}
int main ()
{
int heapSize = 12;
int intArray[4] = {4, 6, 2, 8};
heapHndl testHeap, builtHeap;
testHeap = NewHeap (heapSize);
if (IsEmpty (testHeap))
{
printf ("working\n");
}
Insert (testHeap, 9);
Insert (testHeap, 3);
Insert (testHeap, 5);
Insert (testHeap, 2);
Insert (testHeap, 32);
Insert (testHeap, 6);
Insert (testHeap, 1);
Insert (testHeap, 43);
Insert (testHeap, 23);
Insert (testHeap, 42);
Insert (testHeap, 65);
Insert (testHeap, 57);
if (IsFull (testHeap))
{
printf ("heap currently full\n");
}
DeleteMax (testHeap);
builtHeap = BuildHeap (5, intArray, 4);
printf ("%d\n", MaxValue (testHeap));
printf ("%d\n", MaxValue (builtHeap));
FreeHeap (testHeap);
FreeHeap (builtHeap);
return 0;
}
~JvmtiGetLoadedClassesClosure() {
JvmtiGetLoadedClassesClosure* that = get_this();
assert(that != NULL, "JvmtiGetLoadedClassesClosure not found");
set_this(NULL);
_initiatingLoader = NULL;
_count = 0;
if (_list != NULL) {
FreeHeap(_list);
_list = NULL;
}
_index = 0;
}
void EventLog::resize() {
EL_Event* oldBuf = buf;
EL_Event* oldEnd = bufEnd;
EL_Event* oldNext = next;
init();
// copy events
for (EL_Event* e = nextEvent(oldNext, oldBuf, oldEnd); e != oldNext;
e = nextEvent(e, oldBuf, oldEnd), next = nextEvent(next, buf, bufEnd)) {
*next = *e;
}
FreeHeap( oldBuf);
}
void EventLog::resize() {
Event* oldBuf = buf;
Event* oldEnd = bufEnd;
Event* oldNext = next;
init();
// copy events
for (Event* e = nextEvent(oldNext, oldBuf, oldEnd); e != oldNext;
e = nextEvent(e, oldBuf, oldEnd), next = nextEvent(next, buf, bufEnd)) {
*next = *e;
}
FreeHeap( oldBuf); // cant use delete because this is an array -- dmu
}
bool set_value(char *value) {
if (writeable()) {
if (_value != NULL) {
FreeHeap(_value);
}
_value = AllocateHeap(strlen(value)+1, mtInternal);
if (_value != NULL) {
strcpy(_value, value);
}
return true;
}
return false;
}
void bootstrap::add(oop obj) {
if (number_of_oops >= max_number_of_oops) {
int new_size = max_number_of_oops * 2;
printf("Expanding boot table to %d\n", new_size);
oop* new_oop_table = NEW_C_HEAP_ARRAY(oop, new_size);
for(int index = 0; index < max_number_of_oops; index++)
new_oop_table[index] = oop_table[index];
max_number_of_oops = new_size;
FreeHeap(oop_table);
oop_table = new_oop_table;
}
oop_table[number_of_oops++] = obj;
}
NorlsAllocator::~NorlsAllocator()
{
#if NRLSTRACK
g_NrlsAllocTracker->RemoveAllocator(this);
#if NRLSTRACK_GETSTACKS
if (g_vbCommonHeap != TrackingHeapToUse ())
{
// VsDebHeapDestroy(TrackingHeapToUse (), true);
}
#endif NRLSTRACK_GETSTACKS
#endif NRLSTRACK
FreeHeap();
}
void
DisplayFatal(
const char *szFilename,
BOOL fDeleteFiles,
UINT ErrorNumber,
va_list valist
)
{
if (!fErr) {
fErr = TRUE;
// Close the PDB w/o committing.
if (fPdb) {
DBG_ClosePDB();
}
DisplayMessage(szFilename, FATALSTR, ErrorNumber, valist);
#ifdef ILINKLOG
IlinkLog(GetExternalErrorCode(ErrorNumber)); // full link failures
#endif // ILINKLOG
// free up memory reserved for ILK
if (fINCR && fDeleteFiles) {
FreeHeap();
}
FileCloseAll();
RemoveConvertTempFiles();
if (fDeleteFiles) {
if (OutFilename != NULL && OutFilename[0] != '\0') {
_unlink(OutFilename);
}
// in the incr case just blow away inc db which will
// be in an invalid state
if (fINCR && !_access(szIncrDbFilename, 0)) {
_unlink(szIncrDbFilename);
}
}
}
exit((int) ErrorNumber);
}
void InliningDatabase::add_lookup_entry(LookupKey* outer, LookupKey* inner) {
if (table_no * 2 >= table_size) {
if (table == NULL) {
allocate_table(4 * K);
} else {
// Expand table
InliningDatabaseKey* old_table = table;
unsigned int old_table_size = table_size;
allocate_table(table_size * 2);
for (unsigned int index = 0 ; index < old_table_size; index++) {
if (old_table[index].is_filled())
add_lookup_entry(&old_table[index].outer, &old_table[index].inner);
}
FreeHeap(old_table);
}
}
assert(table_no * 2 < table_size, "just checking density");
unsigned int index = index_for(outer, inner);
while (table[index].is_filled()) {
if (table[index].equal(outer, inner)) return;
index = next_index(index);
}
table[index].outer = *outer;
if (inner) {
table[index].inner = *inner;
}
table_no++;
if (TraceInliningDatabase) {
std->print_cr("InliningDatabase::add_lookup_entry @ %d", index);
if (inner) {
inner->print();
std->print(" ");
}
outer->print();
std->cr();
}
}
void append_value(const char *value) {
char *sp;
size_t len = 0;
if (value != NULL) {
len = strlen(value);
if (_value != NULL) {
len += strlen(_value);
}
sp = AllocateHeap(len+2, mtInternal);
if (sp != NULL) {
if (_value != NULL) {
strcpy(sp, _value);
strcat(sp, os::path_separator());
strcat(sp, value);
FreeHeap(_value);
} else {
strcpy(sp, value);
}
_value = sp;
}
}
}
static void releaseData(void* info, const void* data, size_t size) {
FreeHeap((void*)data);
}
static void Finalize(void)
{
FreeHeap(&FileHeap);
}
/* 结束 */
static void Finalize (void)
{
/* 释放文件堆 */
FreeHeap (&FileHeap);
}
OSStatus ATSUDisposeTextLayout_wrap(ATSUTextLayout lay) {
void* oText;
OSStatus e = ATSUGetTextLocation(lay, &oText, NULL, NULL, NULL, NULL);
if (!e) FreeHeap(oText);
return ATSUDisposeTextLayout(lay);
}
void MallocArrayAllocator<E, F>::free(E* addr, size_t /*length*/) {
FreeHeap(addr);
}
ResourceAreaChunk::~ResourceAreaChunk() {
FreeHeap(bottom);
}
void CHeapObj::operator delete(void* p){
assert( !resources.contains((char*)p),
"CHeapObj should not be in resource area");
FreeHeap(p);
}
template <MEMFLAGS F> void CHeapObj<F>::operator delete [](void* p){
FreeHeap(p, F);
}
bootstrap::~bootstrap() {
FreeHeap(oop_table);
}
/* The heap is being destroyed. Free everything if
* not done already.
*/
MEMHEAP::~MEMHEAP()
{
FreeHeap();
}
size_t WeightedMatching(RowStarts *rowptr,ColIndices *colind,ValueType *C,
ValueType *C1,ValueType *dist,ValueType *u,ValueType *v,Indices *p,
Indices *m_inv,Indices *m, Indices n,CompareFunction cmpFunc){
size_t i,j,i1,jend,k,m_inv_prev;
size_t match_size=0;
ValueType curr_shortest_path = (ValueType)0;
ValueType curr_aug_path = GetMaxTypeValue<ValueType>();
ValueType dist1; Indices itrace;
BitArray_t *col_marker = CreateBitArray(n);
BitArray_t *heap_marker = CreateBitArray(n);
C--;m--;C1--;dist--;u--;v--;p--;m_inv--;
rowptr--;colind--;
#if BINARY_HEAP
Heap *bin_heap = NewBinaryHeap(cmpFunc,n,GetDistKeyID);
ValueType *dist_ptr = NULL;
#endif
assert(C1 && dist && u && v && p);
ComputeInitialExtremeMatch<ValueType,Indices>(u,v,C1,C,m,m_inv,colind,rowptr,n,dist);
match_size=0;
for(i=1;i<=n;i++){
if(m_inv[i]){
match_size++;
continue;
}
/*
*Aim is to find a value for jend such that the path
*from i-->jend is the shortest
*/
i1 = i; p[i1] = 0; jend=0; itrace=i;
ResetAllBits(col_marker);
ResetAllBits(heap_marker);
#if BINARY_HEAP
bin_heap->n = 0;
dist_base = (unsigned long)&(dist[1]);
#endif
curr_shortest_path=(ValueType)0;
curr_aug_path=GetMaxTypeValue<ValueType>();
while(1){
for(k=rowptr[i1];k<rowptr[i1+1];k++){
j = colind[k];
if(CheckBit(col_marker,j)){
continue;
}
dist1 = curr_shortest_path + C1[k];
/*Prune any dist1's > curr_aug_path, since
*all the costs>0
*/
if(*((long long int *)&dist1) < *((long long int *)&curr_aug_path)){
if(!m[j]){
/*we need itrace because, the last i1 which
*we explore may not actually give the shortest
*augmenting path.*/
jend = j; itrace = i1;
curr_aug_path = dist1;
}else if(*((long long int *)&dist1) < *((long long int *)&(dist[j]))){
/*Update the dist*/
dist[j] = dist1; p[m[j]] = i1;
#if SIMPLE_HEAP
SetBit(heap_marker,j);
#elif BINARY_HEAP
if(CheckBit(heap_marker,j)){
DecreaseKey(bin_heap,j);
}else{
InsertHeap(bin_heap,&(dist[j]));
SetBit(heap_marker,j);
}
#endif
}
}
}
if(*((long long int *)&curr_aug_path) <= *((long long int *)&curr_shortest_path)){
break;
}
/*We now have a heap of matched cols, so pick the min*/
#ifdef SIMPLE_HEAP
j = SimplePickMin(heap_marker,dist,n);
if(j){
curr_shortest_path = dist[j];
UnsetBit(heap_marker,j);
#elif BINARY_HEAP
dist_ptr = (ValueType *) HeapDelete(bin_heap);
if(dist_ptr){
assert((unsigned long)dist_ptr >= (unsigned long)&dist[1]);
j = ((((unsigned long)dist_ptr -
(unsigned long)&dist[1]))/sizeof(double))+1;
assert(j>=1 && j<=n);
curr_shortest_path = dist[j];
UnsetBit(heap_marker,j);
#endif
SetBit(col_marker,j);
i1 = m[j];
}else{
break;
}
}
if(jend){ /*We found a shortest augmenting path*/
j=jend;
node_t itrace_prev;
//printf("Shortest augmenting Path {");
while(itrace){
m_inv_prev = m_inv[itrace];
m[j] = itrace; m_inv[itrace]=j;
//printf("(%u,%u)",itrace,j);
j=m_inv_prev;
itrace_prev = itrace;
itrace = p[itrace];
if(itrace){
// printf("(%u,%u)",itrace_prev,m_inv_prev);
}
}
match_size++;
//printf("}\n");
/*Update the cost with new match m*/
for(j=1;j<=n;j++){
if(CheckBit(col_marker,j)){
u[j] = (u[j]+dist[j])-curr_aug_path;
/*Reset the dist values*/
}
}
for(i1=1;i1<=n;i1++){
if(!m_inv[i1]) continue;
j = m_inv[i1];
for(k=rowptr[i1];k<rowptr[i1+1];k++){
if(colind[k] == j){
v[i1] = C[k] - u[j];
}
}
}
/*Update the cost*/
for(i1=1;i1<=n;i1++){
for(k=rowptr[i1];k<rowptr[i1+1];k++){
j = colind[k];
C1[k] = C[k]-(u[j]+v[i1]);
}
/*The index should be j rather than i1 but just
*avoiding another loop*/
dist[i1] = GetMaxTypeValue<double>();
}
}
}
FreeBitArray(col_marker);
FreeBitArray(heap_marker);
#ifdef BINARY_HEAP
FreeHeap(bin_heap);
#endif
return match_size;
}
/*O(n) time picking the maximum from the heap_marker */
node_t SimplePickMin(BitArray_t *bit_heap,double *dist,node_t n){
node_t min_j=0;node_t j;
double curr_min = MAX_DOUBLE_VALUE;
for(j=1;j<=n;j++){
if(CheckBit(bit_heap,j) && dist[j] < curr_min){
min_j = j;
curr_min = dist[j];
}
}
return min_j;
}
MonitorChunk::~MonitorChunk() {
FreeHeap(monitors());
}
void MemRegion::operator delete [](void* p) {
FreeHeap(p, mtGC);
}
void CHeapObj::operator delete(void* p){
FreeHeap(p);
}
size_t WeightedMatching(RowStarts rowptr,ColIndices colind,ValueTypePtr C,
ValueTypePtr dist,ValueTypePtr u,ValueTypePtr v,Indices *p,
Indices *m_inv,Indices *m, Indices n,CompareFunction cmpFunc){
typedef typename std::iterator_traits<ValueTypePtr>::value_type ValueType;
Indices i,j,i1,jend,k,m_inv_prev;
Indices match_size=0; Indices k0,j0;
ValueType curr_shortest_path = (ValueType)0;
ValueType curr_aug_path = GetMaxTypeValue<ValueType>(curr_aug_path);
ValueType dist1; Indices itrace;
/*Cost of the edges in the match if
*$(i,j) \in M$ then $clabel[i] = C[i][j]$*/
Indices *clabel = new Indices[n];
Indices *aug_label = new Indices[n];
Indices *update_stack = new Indices[n];
Indices update_stack_index;
/*Save The Operations on the Heap.*/
Indices save_heap_index;
Indices *save_heap_op = new Indices[n];
#ifdef TURN_ON_SAVE_HEAP
double close_factor = (double)1.0 + (double)1.0e-16;
#endif
/*Force the write back to memory to avoid floating point issues*/
ValueType force_mem_write[3];
#ifndef NO_LOCAL_PROFILING
CreateProfilingClocks();
#endif
/*Core Profiling Clock*/
Clock *core_clk = CreateClock();
#ifdef USE_BIT_ARRAY
BitArray_t *col_marker = CreateBitArray(n);
BitArray_t *heap_marker = CreateBitArray(n);
#else
Indices *col_marker = new Indices[n];
unsigned int *heap_marker = NULL;
col_marker--;
for(i=1;i<=n;i++){ /*Do we need Initialization?*/
col_marker[i] = (Indices)0;
}
#endif
#if BINARY_HEAP
Heap *bin_heap = NewBinaryHeap(cmpFunc,n,GetDistKeyID);
ValueType *dist_ptr = NULL;
heap_marker = bin_heap->keyMap;
#endif
/*Algorithm Uses 1-Indexing to be consistent*/
C--;m--;dist--;u--;v--;p--;m_inv--;
rowptr--;colind--;clabel--;save_heap_op--;
update_stack--;aug_label--;
assert(dist && u && v && p);
ComputeInitialExtremeMatch<ValueType,Indices>(u,v,clabel,C,m,m_inv,colind,
rowptr,n,dist);
match_size=0;
StartClock(core_clk);
for(i=1;i<=n;i++){
if(m_inv[i]){
match_size++;
continue;
}
/*
*Aim is to find a value for jend such that the path
*from i-->jend is the shortest
*/
i1 = i; p[i1] = 0; jend=0; itrace=i;
#ifdef USE_BIT_ARRAY
ResetAllBits(col_marker);
ResetAllBits(heap_marker);
#endif
#if BINARY_HEAP
bin_heap->n = 0;
dist_base = (unsigned long)&(dist[1]);
#endif
curr_shortest_path=(ValueType)0;
curr_aug_path=GetMaxTypeValue<ValueType>(curr_aug_path);
save_heap_index = (Indices)0;
update_stack_index = (Indices)0;
while(1){
for(k=rowptr[i1]+1;k<(rowptr[i1+1]+1);k++){
j = colind[k]+1;
#ifdef USE_BIT_ARRAY
if(CheckBit(col_marker,j)){
#else
if(col_marker[j]==i){
#endif
continue;
}
force_mem_write[k%3] = C[k]-(v[i1]+u[j]);
dist1 = curr_shortest_path + force_mem_write[k%3];
/*Prune any dist1's > curr_aug_path, since
*all the costs>0
*/
if(dist1 < curr_aug_path){
if(!m[j]){
/*we need itrace because, the last i1 which
*we explore may not actually give the shortest
*augmenting path.*/
jend = j; itrace = i1;
curr_aug_path = dist1;
aug_label[j] = k;
}else if(dist1 < dist[j]){
/*Update the dist*/
dist[j] = dist1; p[m[j]] = i1;
aug_label[j] = k;
#if SIMPLE_HEAP
#ifdef USE_BIT_ARRAY
SetBit(heap_marker,j);
#else
heap_marker[j] = i;
#endif
#elif BINARY_HEAP /*SIMPLE_HEAP*/
#ifdef USE_BIT_ARRAY
if(CheckBit(heap_marker,j)){
#else
if(heap_marker[j]){
#endif
#ifndef NO_LOCAL_PROFILING
StartClock(hupdate_clk);
#endif
/*Call the decrease Key Operation*/
DecreaseKey(bin_heap,j);
#ifndef NO_LOCAL_PROFILING
StopClock(hupdate_clk);
hupdate_ticks += GetClockTicks(hupdate_clk);
#endif
}
#ifdef TURN_ON_SAVE_HEAP
else if(curr_shortest_path &&
dist[j] <= (curr_shortest_path)*(close_factor)){
/*If dist[j] is close to root push it in
*save_heap_op*/
assert(save_heap_index < n);
save_heap_op[++save_heap_index] = j;
}
#endif
else{
#ifndef NO_LOCAL_PROFILING
StartClock(hins_clk);
#endif
InsertHeap(bin_heap,&(dist[j]));
#ifndef NO_LOCAL_PROFILING
StopClock(hins_clk);
hins_ticks += GetClockTicks(hins_clk);
#endif
#ifdef USE_BIT_ARRAY
SetBit(heap_marker,j);
#endif
}
#endif /*SIMPLE_HEAP*/
}
}
}
if(curr_aug_path <= curr_shortest_path){
break;
}
/*We now have a heap of matched cols, so pick the min*/
#ifdef SIMPLE_HEAP
j = SimplePickMin(heap_marker,dist,n);
if(j){
curr_shortest_path = dist[j];
UnsetBit(heap_marker,j);
#elif BINARY_HEAP
#ifndef NO_LOCAL_PROFILING
StartClock(hdel_clk);
#endif
if(save_heap_index){
j = save_heap_op[save_heap_index];
save_heap_index--;
curr_shortest_path = dist[j];
#ifdef USE_BIT_ARRAY
SetBit(col_marker,j);
#else
col_marker[j] = (Indices)i;
update_stack[++update_stack_index]=j;
#endif /*#ifdef USE_BIT_ARRAY*/
i1 = m[j];
}else if(dist_ptr = (ValueType *) HeapDelete(bin_heap)) {
#ifndef NO_LOCAL_PROFILING
StopClock(hdel_clk);
hdel_ticks += GetClockTicks(hdel_clk);
#endif
assert((unsigned long)dist_ptr >= (unsigned long)&dist[1]);
j = ((((unsigned long)dist_ptr -
(unsigned long)&dist[1]))/sizeof(ValueType))+1;
assert(j>=1 && j<=n);
curr_shortest_path = dist[j];
heap_marker[j] = 0; /*Setting the keyMap in Heap to 0*/
#endif /*#ifdef SIMPLE_HEAP */
#ifdef USE_BIT_ARRAY
SetBit(col_marker,j);
update_stack[++update_stack_index]=j;
#else
col_marker[j] = (Indices)i;
update_stack[++update_stack_index]=j;
#endif /*#ifdef USE_BIT_ARRAY*/
i1 = m[j];
}else{
break;
}
}
/*We found a shortest augmenting path*/
if(jend){
unsigned long **harray = bin_heap->heapArray;
#ifndef NO_LOCAL_PROFILING
StartClock(dual_clk);
#endif
/*NOTE1: We need a very fast way to update
*the dual variables and also reset the dist[]
*we avoid linear scan where ever we can to update
*these dual variables*/
while(update_stack_index){ /*Update u[j]: while*/
j=update_stack[update_stack_index--];
u[j] = (u[j]+dist[j])-curr_aug_path;
if(m[j]){ /*See NOTE1*/
i1 = m[j];
v[i1] = C[clabel[i1]] - u[j];
}
dist[j] = MAX_DOUBLE_VALUE;
if(bin_heap->n){
dist_ptr = (double *)harray[bin_heap->n];
j = ((((unsigned long)dist_ptr -
(unsigned long)&dist[1]))/sizeof(ValueType))+1;
heap_marker[j] = 0;
*((double *)harray[bin_heap->n]) = MAX_DOUBLE_VALUE;
bin_heap->n -= 1 ;
}
} /*Update u[j]: while*/
/*Uncomment if you need to print augmenting path*/
/*node_t itrace_prev;*/
/*printf("Shortest augmenting Path {");*/
j=jend;
while(itrace){
m_inv_prev = m_inv[itrace];
m[j] = itrace; m_inv[itrace]=j;
/*See NOTE1(above)*/
clabel[itrace] = aug_label[j];
v[itrace] = C[clabel[itrace]] - u[j];
/*printf("(%u,%u)",itrace,j);*/
j=m_inv_prev;
/*itrace_prev = itrace;*/
itrace = p[itrace];
/*
if(itrace){
printf("(%u,%u)",itrace_prev,m_inv_prev);
}*/
}
/*printf("}\n");*/
/*There may some dist[] still in the heap*/
while(bin_heap->n){
dist_ptr = (double *)harray[bin_heap->n];
j = ((((unsigned long)dist_ptr -
(unsigned long)&dist[1]))/sizeof(ValueType))+1;
heap_marker[j] = 0;
*((double *)harray[bin_heap->n]) = MAX_DOUBLE_VALUE;
bin_heap->n -= 1;
}
match_size++;
/*End Dual Update*/
#ifndef NO_LOCAL_PROFILING
StopClock(dual_clk);
dual_ticks += GetClockTicks(dual_clk);
#endif
} /*if(jend) : Found Augmeting Path*/
} /*for(i=1;i<=n;i++): Main Outer Loop*/
StopClock(core_clk);
WeightedMatchTicks = GetClockTicks(core_clk);
#ifndef NO_LOCAL_PROFILING
printf("Profile Summary\n");
printf("HINS=(%d) HDEL=(%d) HUPDATE=(%d)\n",(int)hins_ticks,(int)hdel_ticks,
(int)hupdate_ticks);
printf("DUAL=(%d) \n",(int)dual_ticks);
#endif
#ifdef USE_BIT_ARRAY
FreeBitArray(col_marker);
FreeBitArray(heap_marker);
#else
col_marker++;
delete col_marker;
#endif
#ifdef SIMPLE_HEAP
heap_marker++;
delete heap_marker;
#endif
aug_label++;
delete aug_label;
save_heap_op++;
delete save_heap_op;
clabel++;
delete clabel;
#ifdef BINARY_HEAP
FreeHeap(bin_heap);
#endif
return match_size;
}
/*O(n) time picking the maximum from the heap_marker */
node_t SimplePickMin(BitArray_t *bit_heap,double *dist,node_t n){
node_t min_j=0;node_t j;
double curr_min = HUGE_VAL;
for(j=1;j<=n;j++){
if(CheckBit(bit_heap,j) && dist[j] < curr_min){
min_j = j;
curr_min = dist[j];
}
}
return min_j;
}
#ifdef BINARY_HEAP
inline keyid_t GetDistKeyID(void *dist_ptr){ assert((unsigned long)dist_ptr >= dist_base);
return (((((unsigned long)dist_ptr-dist_base))/sizeof(double))+1);
}
#endif
BitArray_t* CreateBitArray(unsigned int size){
div_t d = div(size,SIZE_OF_BYTE_IN_BITS);
BitArray_t *bits = (BitArray_t *)malloc(sizeof(BitArray_t)*1);
assert(bits);
bits->size = (d.rem > 0)?(d.quot+1):d.quot;
bits->ba = (char *)malloc(sizeof(char)*(bits->size));
assert(bits->ba);
memset(bits->ba,'\0',bits->size);
return bits;
}
