void pq_clear( fibonacci_heap *queue ) { mm_clear( queue->map ); queue->minimum = NULL; memset( queue->roots, 0, MAXRANK * sizeof( fibonacci_node* ) ); queue->largest_rank = 0; queue->size = 0; }
void pq_clear( binomial_queue *queue ) { mm_clear( queue->map ); queue->minimum = NULL; queue->registry = 0; memset( queue->roots, 0, MAXRANK * sizeof( binomial_node* ) ); queue->size = 0; }
void mm_initialize(MazeMap *mm, int r, int c, Dir dir) { mm_clear(mm); mm->loc.r = r; mm->loc.c = c; mm->dir = dir; mm->border.top = r; mm->border.left = c; mm->border.bottom = (r + 1)%WIDTH; mm->border.right = (c + 1)%HEIGHT; SET_SQUARE(mm, r, c, PRESENT); }
void pq_clear( strict_fibonacci_heap *queue ) { mm_clear( queue->map ); queue->size = 0; queue->root = NULL; queue->q_head = NULL; queue->active = NULL; queue->rank_list = NULL; queue->fix_list[0] = NULL; queue->fix_list[1] = NULL; }
void pq_clear( implicit_heap *queue ) { mm_clear( queue->map ); queue->size = 0; }
void mm_tst_cases(int NTRIALS, int Ndim, int Mdim, int Pdim, TYPE* A, TYPE* B, TYPE* C, void (*mm_func)(int, int, int, TYPE *, TYPE *, TYPE *)) { int nerr, itrials; double err, errsq, mflops; double start_time, run_time; double min_t, max_t, ave_t; TYPE *Cref; Cref = (TYPE *) malloc (Ndim * Mdim * sizeof(TYPE)); /* Initialize matrices */ init_const_matrix (Ndim, Mdim, Pdim, A, B, Cref); printf("\n constant matrices %d %d %d\n", Ndim, Mdim, Pdim); nerr = 0; min_t = BIG; max_t = SMALL; ave_t = (double) 0.0; for (itrials = 0; itrials<NTRIALS; itrials++){ mm_clear(Ndim, Mdim, C); start_time = omp_get_wtime(); mm_func(Ndim, Mdim, Pdim, A, B, C); run_time = omp_get_wtime() - start_time; errsq = errsqr(Ndim, Mdim, C, Cref); if (errsq > TOL) nerr++; if(run_time < min_t) min_t = run_time; if(run_time > max_t) max_t = run_time; ave_t += run_time; } ave_t = ave_t/(double)NTRIALS; output_results(Ndim, Mdim, Pdim, nerr, ave_t, min_t, max_t); init_progression_matrix (Ndim, Mdim, Pdim, A, B, Cref); #ifdef DEBUG printf(" A progression Matrix input\n"); mm_print(Ndim, Pdim, A); printf(" B progression Matrix input\n"); mm_print(Pdim, Mdim, B); printf(" C Reference Matrix\n"); mm_print(Ndim, Mdim, Cref); #endif printf("\n progression matrices %d %d %d\n", Ndim, Mdim, Pdim); nerr = 0; min_t = BIG; max_t = SMALL; ave_t = (double) 0.0; for (itrials = 0; itrials<NTRIALS; itrials++){ mm_clear(Ndim, Mdim, C); start_time = omp_get_wtime(); mm_func(Ndim, Mdim, Pdim, A, B, C); run_time = omp_get_wtime() - start_time; #ifdef DEBUG printf(" C progression Matrix result\n"); mm_print(Ndim, Mdim, C); #endif errsq = errsqr(Ndim, Mdim, C, Cref); if (errsq > TOL) nerr++; if(run_time < min_t) min_t = run_time; if(run_time > max_t) max_t = run_time; ave_t += run_time; } ave_t = ave_t/(double)NTRIALS; output_results(Ndim, Mdim, Pdim, nerr, ave_t, min_t, max_t); }
int main( int argc, char** argv ) { uint64_t i; // pointers for casting pq_op_create *op_create; pq_op_destroy *op_destroy; pq_op_clear *op_clear; pq_op_get_key *op_get_key; pq_op_get_item *op_get_item; pq_op_get_size *op_get_size; pq_op_insert *op_insert; pq_op_find_min *op_find_min; pq_op_delete *op_delete; pq_op_delete_min *op_delete_min; pq_op_decrease_key *op_decrease_key; //pq_op_meld *op_meld; pq_op_empty *op_empty; // temp dummies for readability pq_type *q;//, *r; pq_node_type *n; if( argc < 2 ) exit( -1 ); int trace_file = open( argv[1], O_RDONLY ); if( trace_file < 0 ) { fprintf( stderr, "Could not open file.\n" ); return -1; } pq_trace_header header; pq_trace_read_header( trace_file, &header ); close( trace_file ); //printf("Header: (%llu,%lu,%lu)\n",header.op_count,header.pq_ids, // header.node_ids); pq_op_blank *ops = calloc( MIN( header.op_count, CHUNK_SIZE ), sizeof( pq_op_blank ) ); pq_type **pq_index = calloc( header.pq_ids, sizeof( pq_type* ) ); pq_node_type **node_index = calloc( header.node_ids, sizeof( pq_node_type* ) ); if( ops == NULL || pq_index == NULL || node_index == NULL ) { fprintf( stderr, "Calloc fail.\n" ); return -1; } #ifdef USE_QUAKE mem_capacities[0] = header.node_ids << 2; #else mem_capacities[0] = header.node_ids; #endif #ifdef USE_EAGER mem_map *map = mm_create( mem_types, mem_sizes, mem_capacities ); #else mem_map *map = mm_create( mem_types, mem_sizes ); #endif uint64_t op_remaining, op_chunk; int status; struct timeval t0, t1; uint32_t iterations = 0; uint32_t total_time = 0; key_type k; //pq_node_type *min; #ifndef CACHEGRIND while( iterations < 5 || total_time < PQ_MIN_USEC ) { mm_clear( map ); iterations++; #endif trace_file = open( argv[1], O_RDONLY ); if( trace_file < 0 ) { fprintf( stderr, "Could not open file.\n" ); return -1; } pq_trace_read_header( trace_file, &header ); op_remaining = header.op_count; while( op_remaining > 0 ) { op_chunk = MIN( CHUNK_SIZE, op_remaining ); op_remaining -= op_chunk; for( i = 0; i < op_chunk; i++ ) { status = pq_trace_read_op( trace_file, ops + i ); if( status == -1 ) { fprintf( stderr, "Invalid operation!" ); return -1; } } #ifndef CACHEGRIND gettimeofday(&t0, NULL); #endif for( i = 0; i < op_chunk; i++ ) { switch( ops[i].code ) { case PQ_OP_CREATE: op_create = (pq_op_create*) ( ops + i ); //printf("pq_create(%d)\n", op_create->pq_id); pq_index[op_create->pq_id] = pq_create( map ); break; case PQ_OP_DESTROY: op_destroy = (pq_op_destroy*) ( ops + i ); //printf("pq_destroy(%d)\n", op_destroy->pq_id); q = pq_index[op_destroy->pq_id]; pq_destroy( q ); pq_index[op_destroy->pq_id] = NULL; break; case PQ_OP_CLEAR: op_clear = (pq_op_clear*) ( ops + i ); //printf("pq_clear(%d)\n", op_clear->pq_id ); q = pq_index[op_clear->pq_id]; pq_clear( q ); break; case PQ_OP_GET_KEY: op_get_key = (pq_op_get_key*) ( ops + i ); //printf("pq_get_key(%d,%d)\n", op_get_key->pq_id, // op_get_key->node_id ); q = pq_index[op_get_key->pq_id]; n = node_index[op_get_key->node_id]; pq_get_key( q, n ); break; case PQ_OP_GET_ITEM: op_get_item = (pq_op_get_item*) ( ops + i ); //printf("pq_get_item(%d,%d)\n", op_get_item->pq_id, // op_get_item->node_id); q = pq_index[op_get_item->pq_id]; n = node_index[op_get_item->node_id]; pq_get_item( q, n ); break; case PQ_OP_GET_SIZE: op_get_size = (pq_op_get_size*) ( ops + i ); //printf("pq_get_size(%d)\n", op_get_size->pq_id); q = pq_index[op_get_size->pq_id]; pq_get_size( q ); break; case PQ_OP_INSERT: op_insert = (pq_op_insert*) ( ops + i ); //printf("pq_insert(%d,%d,%llu,%d)\n", op_insert->pq_id, // op_insert->node_id, op_insert->key, op_insert->item ); q = pq_index[op_insert->pq_id]; node_index[op_insert->node_id] = pq_insert( q, op_insert->item, op_insert->key ); break; case PQ_OP_FIND_MIN: op_find_min = (pq_op_find_min*) ( ops + i ); //printf("pq_find_min(%d)\n", op_find_min->pq_id ); q = pq_index[op_find_min->pq_id]; pq_find_min( q ); break; case PQ_OP_DELETE: op_delete = (pq_op_delete*) ( ops + i ); //printf("pq_delete(%d,%d)\n", op_delete->pq_id, // op_delete->node_id ); q = pq_index[op_delete->pq_id]; n = node_index[op_delete->node_id]; pq_delete( q, n ); break; case PQ_OP_DELETE_MIN: op_delete_min = (pq_op_delete_min*) ( ops + i ); //printf("pq_delete_min(%d)\n", op_delete_min->pq_id); q = pq_index[op_delete_min->pq_id]; //min = pq_find_min( q ); k = pq_delete_min( q ); #ifdef CACHEGRIND if( argc > 2 ) printf("%llu\n",k); #endif break; case PQ_OP_DECREASE_KEY: op_decrease_key = (pq_op_decrease_key*) ( ops + i ); //printf("pq_decrease_key(%d,%d,%llu)\n", op_decrease_key->pq_id, // op_decrease_key->node_id, op_decrease_key->key); q = pq_index[op_decrease_key->pq_id]; n = node_index[op_decrease_key->node_id]; pq_decrease_key( q, n, op_decrease_key->key ); break; /*case PQ_OP_MELD: printf("Meld.\n"); op_meld = (pq_op_meld*) ( ops + i ); q = pq_index[op_meld->pq_src1_id]; r = pq_index[op_meld->pq_src2_id]; pq_index[op_meld->pq_dst_id] = pq_meld( q, r ); break;*/ case PQ_OP_EMPTY: op_empty = (pq_op_empty*) ( ops + i ); //printf("pq_empty(%d)\n", op_empty->pq_id); q = pq_index[op_empty->pq_id]; pq_empty( q ); break; default: break; } //verify_queue( pq_index[0], header.node_ids ); } #ifndef CACHEGRIND gettimeofday(&t1, NULL); total_time += (t1.tv_sec - t0.tv_sec) * 1000000 + (t1.tv_usec - t0.tv_usec); #endif } close( trace_file ); #ifndef CACHEGRIND } #endif for( i = 0; i < header.pq_ids; i++ ) { if( pq_index[i] != NULL ) pq_destroy( pq_index[i] ); } mm_destroy( map ); free( pq_index ); free( node_index ); free( ops ); #ifndef CACHEGRIND printf( "%d\n", total_time / iterations ); #endif return 0; }