// getScore() // Description: calculate and return score (only white tiles count) // Return Val: current score int Grid::getScore(){ int score = 0; for(int i = 0;i < GRID_SIZE;i++){ if(m_data[i] < WHITE_BASE) continue; assert(_log2(m_data[i]/WHITE_BASE) > -1); assert(_log2(m_data[i]/WHITE_BASE) < WHITE_TYPE_NUM); score += _pow3[ _log2(m_data[i]/WHITE_BASE) ]; } return score; }
extern unsigned int descriptor_id_setup_2( /* creates a descriptor id setup 2 field out of the various field components */ unsigned int span_a_id, unsigned int span_b_id ) { unsigned int field; field = span_b_id & ~((-1) << _log2(SPANS)); field = (field << _log2(SPANS)) | (span_a_id & ~((-1) << _log2(SPANS))); return field; }
dhash_tbl_pt new_dhash_tbl(hash_type_t type,hash_func_t hash_func,equal_func_t equal_func){ dhash_tbl_pt table=(dhash_tbl_pt)malloc(sizeof(dhash_tbl_t)); memset(table,0,sizeof(dhash_tbl_t)); resize_directory(table,DEFAULT_DIR_SIZE); table->seg_shift=_log2(DEFAULT_SEG_SIZE); table->seg_arr[0]=new_slot_segment(); table->slot_max=DEFAULT_SEG_SIZE-1; table->high_mask=DEFAULT_SEG_SIZE-1; switch(type){ case HASH_CUSTOM: table->hash=hash_func; table->is_equal=equal_func; break; case HASH_STRING: table->hash=string_hash; table->is_equal=string_equal; break; case HASH_INTEGER: default: table->hash=integer_hash; table->is_equal=integer_equal; break; } return table; }
// setNextTile() // Description: determine the next random bonus tile or grab a basic tile from grab bag void Game::setNextTile(){ int maxTile = m_grid.getMaxTile(); if(maxTile >= BONUS_THRESHOLD && getRand() % BONUS_RATIO == BONUS_RATIO - 1){ int n = getRand() % (_log2(maxTile / BONUS_THRESHOLD) + 1); m_nextTile = (BONUS_BASE << n); } else{ int tileType; int nTile = m_grabBag[0] + m_grabBag[1] + m_grabBag[2]; assert(nTile > 0); int randTile = getRand() % nTile; if(randTile < m_grabBag[0]){ m_grabBag[0]--; tileType = 1; } else if(randTile < m_grabBag[0] + m_grabBag[1]){ m_grabBag[1]--; tileType = 2; } else{ m_grabBag[2]--; tileType = 3; } if(nTile == 1) resetGrabBag(); m_nextTile = tileType; } }
struct btree *bt_create(bt_cmp_t cmp, int size) { struct btree *btr = NULL; int textra = 0; size -= sizeof(struct btreenode); size -= sizeof(struct btreenode *); /*calculate maximum t that will fix in size, and that t >= 2 */ int n = size / (sizeof(struct btreenode *) + sizeof(bt_data_t)); assert(n > 0); int t = (n + 1) / 2; assert(t >= 2); n = 2 * t - 1; textra += sizeof btr->root + n * (sizeof(struct btreenode *) + sizeof(bt_data_t)); btr = allocbtree(); btr->cmp = cmp; btr->keyoff = sizeof(struct btreenode); unsigned int nodeptroff = btr->keyoff + n * sizeof(bt_data_t); assert(nodeptroff <= USHRT_MAX); btr->nodeptroff = (unsigned short)nodeptroff; assert(n <= USHRT_MAX); assert(t <= USHRT_MAX); btr->t = t; int nbits = _log2(n, sizeof(int) * 8) + 1; nbits = 1 << (_log2(nbits, sizeof(int) * 8) + 1); assert(nbits <= UCHAR_MAX); btr->nbits = nbits; assert(textra <= USHRT_MAX); btr->textra = textra; btr->numnodes++; btr->root = allocbtreenode(btr); assert(btr->root); //RL4 "BT t: %d nbits: %d textra: %d keyoff: %d nodeptroff: %d", //btr->t, btr->nbits, btr->textra, btr->keyoff, btr->nodeptroff); return btr; }
// Rescale BLOSUM matrix for query amino acid frequencies with conjugate gradient method. Used in kDP void Matrix::wn_rescale(Sequence *s) throw (std::exception){ init_p_query(s); parameter_wrapper pwrap; pwrap.matrix = original; pwrap.p_query = p_query; int code=0; double val_min; const int dim=20; const int max_iterations=40; double x[dim]; for( size_t a=0; a<20; ++a) x[a] = pow(p_query[a]/p_background[a], 0.7121); wn_conj_gradient_method(&code, &val_min, x, dim, &_func, &_grad, max_iterations, &pwrap); if( code!=WN_SUCCESS && code!=WN_SUBOPTIMAL) throw MyException("wn_conj_gradient_method failed: return-code is '%i'\n", code); for (int a=0; a<20; ++a) for (int b=0; b<20; ++b) matrix[a][b] = 2.0*_log2(x[a]*original[a][b]*x[b]/p_query[a]/p_query[b]); bool bprint=false; double za[20] = {0.0f}; for (int a=0; a<20; ++a){ if( x[a]<0.0 ) bprint=true; for (int b=0; b<20; ++b) za[a] += original[a][b] * x[b]; } double error=0.0; for (int a=0; a<20; ++a){ double tmp = 1.0-(za[a]*x[a])/p_query[a]; error += tmp*tmp; } error_sum += error; if(bprint) throw MyException("One or more negative scaling factor(s) occurred while rescaling the amino acid substitution matrix for '%s'!", s->get_header()); _init_main_diagonal_scores(); /* if(bprint || error >0.01){ if(bprint) ++negatives; printf("Error: %5.5f\n", error); fprintf(stderr, "Minimizing factors (x[])\n"); for( int i=0; i<20; ++i){ fprintf(stderr, "%2.4f ", x[i]); } fprintf(stderr, "\n"); for (int a=0; a<20; ++a){ fprintf(stderr, "%2.4f ", (za[a]*x[a])/p_query[a]); } fprintf(stderr, "\n"); }*/ }
void Matrix::reset(){ for(size_t i=0; i<20; ++i){ for(size_t j=0; j<20; ++j){ matrix[i][j] = _log2(original[i][j]/(p_background[i]*p_background[j])) / scale; // std::cout << matrix[i][j] << " "; } // std::cout << matrix[i][20] << "\n"; } /* std::cout << "\n"; for(size_t j=0; j<21; ++j){ std::cout << matrix[20][j] << " "; } std::cout << "\n";*/ _init_main_diagonal_scores(); }
unsigned int descriptor_id_setup_1( /* creates a descriptor id setup 1 field out of the various field components */ unsigned int unit_id, unsigned int terminal_a_id, unsigned int terminal_b_id, unsigned int channel_id ) { unsigned int field; field = channel_id & ~((-1) << _log2(CHANNELS)); field = (field << _log2(TERMINALS)) | (terminal_b_id & ~((-1) << _log2(TERMINALS))); field = (field << _log2(TERMINALS)) | (terminal_a_id & ~((-1) << _log2(TERMINALS))); field = (field << _log2(UNITS)) | (unit_id & ~((-1) << _log2(UNITS))); return field; }
/** * Setup a new FFT object. * Note - N must be a power of 2! */ FFT::FFT(int _n) { // setup FFT n = _n; log2n = (int)_log2((unsigned int) n); validSpectrumLength = (n / 2) + 1; // precompute tables COS_LOOKUP_TABLE = new float[n/2]; SIN_LOOKUP_TABLE = new float[n/2]; for(int i = 0; i < n/2; i++) { COS_LOOKUP_TABLE[i] = cosf(i * (2 * M_PI / n)); SIN_LOOKUP_TABLE[i] = -sinf(i * (2 * M_PI / n)); } imag = new float[n]; zeroPad = new float[n]; // used to zero this.imag without creating new array every time for(int i = 0; i < n; i++) zeroPad[i] = 0.0f; }
static int findkindex(struct btree *btr, struct btreenode *x, bt_data_t k, int *r, struct btIterator *iter) { int a, b, i, tr; int *rr; /* rr means key is greater than current entry */ if (r == NULL) rr = &tr; else rr = r; if (x->n == 0) return -1; i = 0; a = x->n - 1; while (a > 0) { b = _log2(a, (int)btr->nbits); int slot = (1 << b) + i; bt_data_t k2 = KEYS(btr, x)[slot]; if ((*rr = btr->cmp(k, k2)) < 0) { a = (1 << b) - 1; } else { a -= (1 << b); i |= (1 << b); } } if ((*rr = btr->cmp(k, KEYS(btr, x)[i])) < 0) i--; //RL7 "findkindex: i: %d r: %d", i, *rr); if (iter) { iter->bln->in = (i > 0) ? i : 0; iter->bln->ik = (i > 0) ? i : 0; } return i; }
static inline int32_t _ceil_log2(const uint32_t n) { return _log2(n - 1) + 1; }
void ULM_initializing(){ int i; int j; readcnt = 0; writecnt = 0; erasecnt = 0; inter_GC_cnt = 0; intra_GC_cnt = 0; maxblk_ulm_intra_cnt = 0; intra.erase = 0; intra.read = 0; intra.write = 0; inter.erase = 0; inter.read = 0; inter.write = 0; LUN_func.erase = 0; LUN_func.read = 0; LUN_func.write =0; UBN_func.erase = 0; UBN_func.read = 0; UBN_func.write = 0; IO.erase = 0; IO.write = 0; IO.read = 0; UBN_link_front = NULL; LUN_link_front = NULL; UBN_CMT_cnt = 0; LUN_CMT_cnt = 0; UBN_hit_cnt = 0; UBN_miss_cnt = 0; LUN_hit_cnt = 0; LUN_miss_cnt = 0; shortcut_inter_cnt = 0; shortcut_intra_cnt = 0; //FLASH_SECTOR = GB / SECTOR_SIZE * FLASH_SIZE; //FLASH_PAGE = FLASH_SECTOR / SECTOR_per_PAGE; BLOCK_per_FLASH = LOGICAL_FLASH_BLOCK + OVERPROVISIONING_FLASH_BLOCK; FLASH_PAGE = PAGE_per_BLOCK * BLOCK_per_FLASH; FLASH_SECTOR = FLASH_PAGE * SECTOR_per_PAGE; //BLOCK_per_FLASH = FLASH_SECTOR / (SECTOR_per_PAGE * PAGE_per_BLOCK); PAGE_per_FLASH = BLOCK_per_FLASH * PAGE_per_BLOCK; UNIT_per_FLASH = FLASH_SECTOR / (SECTOR_per_PAGE * PAGE_per_UNIT); LPN2UBN_SIZE = _log2(BLOCK_per_UNIT); //in bits UBN_offset_SIZE = _log2(PAGE_per_BLOCK); //in bits UBN_MAP_SIZE = LPN2UBN_SIZE + UBN_offset_SIZE; //in bits if(UBN_MAP_SIZE % 8 == 0) UBN_MAP_SIZE = UBN_MAP_SIZE / 8; //in bytes else UBN_MAP_SIZE = UBN_MAP_SIZE / 8 + 1; //in bytes //UBN MAP size fix to 4bytes UBN_MAP_SIZE = 4; LUN_MAP_SIZE = _log2(BLOCK_per_FLASH) + _log2(MAX_PB_per_UNIT * PAGE_per_BLOCK); //in bits with one segments if(LUN_MAP_SIZE%8 == 0) LUN_MAP_SIZE = LUN_MAP_SIZE/8; //in bytes with one segments else LUN_MAP_SIZE = LUN_MAP_SIZE/8 + 1;//in bytes with one segments LUN_MAP_SIZE = MAX_PB_per_UNIT * LUN_MAP_SIZE; UBN_ON_PAGE = PAGE_SIZE / UBN_MAP_SIZE; LUN_ON_PAGE = 1; if(LUN_MAP_SIZE < PAGE_SIZE){ LUN_PAGE_no = 1; LUN_ON_PAGE = PAGE_SIZE/ LUN_MAP_SIZE; }//LU map을 한 페이지에 하나씩 넣을 것인가 아니면 여러개 넣을 수 있다면 여러개 넣을것인가 else if(LUN_MAP_SIZE%PAGE_SIZE == 0) LUN_PAGE_no = LUN_MAP_SIZE/PAGE_SIZE; else LUN_PAGE_no = LUN_MAP_SIZE/PAGE_SIZE + 1; FLASH_MTB_SIZE = PAGE_per_FLASH * UBN_MAP_SIZE + UNIT_per_FLASH * LUN_MAP_SIZE; UBN_MTB_PAGE = PAGE_per_FLASH/UBN_ON_PAGE; LUN_MTB_PAGE = UNIT_per_FLASH/LUN_ON_PAGE*LUN_PAGE_no; FLASH_MTB_PAGE = UBN_MTB_PAGE + LUN_MTB_PAGE; LOGICAL_FLASH_BLOCK = LOGICAL_FLASH_BLOCK - (FLASH_MTB_PAGE % PAGE_per_BLOCK ? (FLASH_MTB_PAGE / PAGE_per_BLOCK + 1) : (FLASH_MTB_PAGE / PAGE_per_BLOCK)); LOGICAL_FLASH_PAGE = LOGICAL_FLASH_BLOCK * PAGE_per_BLOCK; //LOGICAL_FLASH_PAGE = (FLASH_PAGE - FLASH_MTB_PAGE)*97/100; LOGICAL_FLASH_UNIT = LOGICAL_FLASH_PAGE/PAGE_per_UNIT; /* UBN_CMT_SIZE = CMT_SIZE * UBN_CMT_PCT / 100; LUN_CMT_SIZE = CMT_SIZE * LUN_CMT_PCT / 100; */ LUN_CMT_SIZE = 5 * PAGE_SIZE; UBN_CMT_SIZE = CMT_SIZE - LUN_CMT_SIZE; //LUN이 맵에 항상 상주하도록 변경 #if 0 LUN_CMT_SIZE = LUN_MTB_PAGE * PAGE_SIZE; UBN_CMT_SIZE = CMT_SIZE - LUN_CMT_SIZE; #endif UBN_tb = (UBN_MAP *)malloc(sizeof(UBN_MAP)*PAGE_per_FLASH); LUN_tb = (LUN_MAP *)malloc(sizeof(LUN_MAP)*UNIT_per_FLASH); PBN = (PBN_MAP *)malloc(sizeof(PBN_MAP) * BLOCK_per_FLASH); for(i=0; i<PAGE_per_FLASH; i++){ UBN_tb[i].LPN2UBN = -1; UBN_tb[i].LPN2offset = -1; } for(i=0; i<UNIT_per_FLASH; i++){ LUN_tb[i].UBN = (UBN_ptr *)malloc(sizeof(UBN_ptr)*MAX_PB_per_UNIT); LUN_tb[i].AL_top = NULL; LUN_tb[i].UL_top = NULL; //LUN_tb[i].unit_valid_info = 0; LUN_tb[i].unit_invalid_info = 0; LUN_tb[i].intragc_cnt= 0; LUN_tb[i].intergc_cnt = 0; for(j=0; j<MAX_PB_per_UNIT ; j++){ LUN_tb[i].UBN[j] = (UBN_info *)malloc(sizeof(UBN_info)); LUN_tb[i].UBN[j]->invalid_info = 0; LUN_tb[i].UBN[j]->PBN_num = -1; LUN_tb[i].UBN[j]->top = -1; LUN_tb[i].UBN[j]->UBN_num = j; LUN_tb[i].UBN[j]->valid_info = 0; } LUN_tb[i].AL_top = LUN_tb[i].UBN[0]; for(j=0; j<MAX_PB_per_UNIT - 1 ; j++){ LUN_tb[i].UBN[j]->next = LUN_tb[i].UBN[j+1]; } LUN_tb[i].UBN[MAX_PB_per_UNIT - 1]->next = NULL; } FB_stack = (int *)malloc(sizeof(int)*BLOCK_per_FLASH); FB_top = -1; for(i=0; i<BLOCK_per_FLASH; i++){ FB_stack[i] = i; FB_top++; PBN[i].PPN2LPN = (int *)malloc(sizeof(int) * PAGE_per_BLOCK); PBN[i].valid = (int *)malloc(sizeof(int) * PAGE_per_BLOCK); for(j=0; j<PAGE_per_BLOCK ; j++){ PBN[i].PPN2LPN[j] = -1; PBN[i].valid[j] = -1; } } cl_info = (CL_INFO *) malloc(sizeof(CL_INFO) * UNIT_per_FLASH); memset(cl_info, 0x00, sizeof(CL_INFO) * UNIT_per_FLASH); printf("\ninitialize end\n"); }
/* a tristate buffer is used to handle fan-ins * The area of an unbalanced htree (rows != columns) * depends on how data is traversed. * In the following function, if ( no. of rows < no. of columns), * then data first traverse in excess hor. links until vertical * and horizontal nodes are same. * If no. of rows is bigger, then data traverse in * a hor. link followed by a ver. link in a repeated * fashion (similar to a balanced tree) until there are no * hor. links left. After this it goes through the remaining vertical * links. */ void Htree2::out_htree() { //temp var double s1 = 0, s2 = 0, s3 = 0; double l_eff = 0; Wire *wtemp1 = 0, *wtemp2 = 0, *wtemp3 = 0; double len = 0, ht = 0; int option = 0; int h = (int) _log2(ndwl); int v = (int) _log2(ndbl); double hdist; double vdist; if (ndwl == ndbl) { hdist = ndwl/2 - 1; vdist = hdist; } else if (ndwl > ndbl) { hdist = ndbl/2-1 + (_log2(ndwl/2) - _log2(ndbl/2)); vdist = pow(2, (_log2(ndwl/2) - _log2(ndbl/2))) * (ndbl/2-1); } else { hdist = ndwl/2-1; vdist = ndwl/2-1 + ((ndwl/2)/2)*(_log2(ndbl/2)-_log2(ndwl/2)); } double len_temp; double ht_temp; if (uca_tree) { ht_temp = (mat_height*ndbl /* mat height => bank height */ + (add_bits + data_in_bits + data_out_bits+ (search_data_in_bits + search_data_out_bits)) * hdist * g_tp.wire_outside_mat.pitch)/2; len_temp = (mat_width*ndwl /* mat width => bank width */ + (add_bits + data_in_bits + data_out_bits+ (search_data_in_bits + search_data_out_bits)) * g_tp.wire_outside_mat.pitch * vdist)/2; } else { if (ndwl == ndbl) { ht_temp = ((mat_height*ndbl/2) + ((add_bits + (search_data_in_bits + search_data_out_bits)) * hdist * g_tp.wire_outside_mat.pitch) + ((data_in_bits + data_out_bits) * g_tp.wire_outside_mat.pitch * hdist) )/2; } else if (ndwl > ndbl) { double excess_part = (_log2(ndwl/2) - _log2(ndbl/2)); ht_temp = ((mat_height*ndbl/2) + ((add_bits + (search_data_in_bits + search_data_out_bits)) * hdist * g_tp.wire_outside_mat.pitch) + (((data_in_bits + data_out_bits) * g_tp.wire_outside_mat.pitch * (ndbl/2-1)) + (2 *(data_in_bits + data_out_bits) * g_tp.wire_outside_mat.pitch * (1 - pow(0.5, excess_part+1)))) )/2; } else { ht_temp = ((mat_height*ndbl/2) + ((add_bits + (search_data_in_bits + search_data_out_bits)) * hdist * g_tp.wire_outside_mat.pitch) + ((data_in_bits + data_out_bits) * g_tp.wire_outside_mat.pitch * hdist) )/2; } len_temp = (mat_width*ndwl/2 + (add_bits + data_in_bits + data_out_bits + (search_data_in_bits + search_data_out_bits)) * g_tp.wire_outside_mat.pitch * vdist)/2; } area.h = ht_temp * 2; area.w = len_temp * 2; delay = 0; power.readOp.dynamic = 0; power.readOp.leakage = 0; power.readOp.gate_leakage = 0; //cout<<"power.readOp.gate_leakage"<<power.readOp.gate_leakage<<endl; len = len_temp; ht = ht_temp/2; while (v > 0 || h > 0) { //finds delay/power of each link in the tree if (wtemp1) delete wtemp1; if (wtemp2) delete wtemp2; if (wtemp3) delete wtemp3; if(h > v) { //the iteration considers only one horizontal link wtemp1 = new Wire(wt, len); // hor wtemp2 = new Wire(wt, len/2); // ver len_temp = len; len /= 2; wtemp3 = 0; h--; option = 0; } else if (v>0 && h>0) { //considers one horizontal link and one vertical link wtemp1 = new Wire(wt, len); // hor wtemp2 = new Wire(wt, ht); // ver wtemp3 = new Wire(wt, len/2); // next hor len_temp = len; ht_temp = ht; len /= 2; ht /= 2; v--; h--; option = 1; } else { // considers only one vertical link assert(h == 0); wtemp1 = new Wire(wt, ht); // hor wtemp2 = new Wire(wt, ht/2); // ver ht_temp = ht; ht /= 2; wtemp3 = 0; v--; option = 2; } delay += wtemp1->delay; power.readOp.dynamic += wtemp1->power.readOp.dynamic; power.searchOp.dynamic += wtemp1->power.readOp.dynamic*init_wire_bw; power.readOp.leakage += wtemp1->power.readOp.leakage*wire_bw; power.readOp.gate_leakage += wtemp1->power.readOp.gate_leakage*wire_bw; //cout<<"power.readOp.gate_leakage"<<power.readOp.gate_leakage<<endl; if ((uca_tree == false && option == 2) || search_tree==true) { wire_bw*=2; } if (uca_tree == false) { if (len_temp > wtemp1->repeater_spacing) { s1 = wtemp1->repeater_size; l_eff = wtemp1->repeater_spacing; } else { s1 = (len_temp/wtemp1->repeater_spacing) * wtemp1->repeater_size; l_eff = len_temp; } if (ht_temp > wtemp2->repeater_spacing) { s2 = wtemp2->repeater_size; } else { s2 = (len_temp/wtemp2->repeater_spacing) * wtemp2->repeater_size; } // first level output_buffer(s1, s2, l_eff); } if (option != 1) { continue; } // second level delay += wtemp2->delay; power.readOp.dynamic += wtemp2->power.readOp.dynamic; power.searchOp.dynamic += wtemp2->power.readOp.dynamic*init_wire_bw; power.readOp.leakage += wtemp2->power.readOp.leakage*wire_bw; power.readOp.gate_leakage += wtemp2->power.readOp.gate_leakage*wire_bw; //cout<<"power.readOp.gate_leakage"<<power.readOp.gate_leakage<<endl; if (uca_tree) { power.readOp.leakage += (wtemp2->power.readOp.leakage*wire_bw); power.readOp.gate_leakage += wtemp2->power.readOp.gate_leakage*wire_bw; } else { power.readOp.leakage += (wtemp2->power.readOp.leakage*wire_bw); power.readOp.gate_leakage += wtemp2->power.readOp.gate_leakage*wire_bw; wire_bw*=2; if (ht_temp > wtemp3->repeater_spacing) { s3 = wtemp3->repeater_size; l_eff = wtemp3->repeater_spacing; } else { s3 = (len_temp/wtemp3->repeater_spacing) * wtemp3->repeater_size; l_eff = ht_temp; } output_buffer(s2, s3, l_eff); } //cout<<"power.readOp.leakage"<<power.readOp.leakage<<endl; //cout<<"power.readOp.gate_leakage"<<power.readOp.gate_leakage<<endl; //cout<<"wtemp2->power.readOp.gate_leakage"<<wtemp2->power.readOp.gate_leakage<<endl; } if (wtemp1) delete wtemp1; if (wtemp2) delete wtemp2; if (wtemp3) delete wtemp3; }
/* calculates the input h-tree delay/power * A nand gate is used at each node to * limit the signal * The area of an unbalanced htree (rows != columns) * depends on how data is traversed. * In the following function, if ( no. of rows < no. of columns), * then data first traverse in excess hor. links until vertical * and horizontal nodes are same. * If no. of rows is bigger, then data traverse in * a hor. link followed by a ver. link in a repeated * fashion (similar to a balanced tree) until there are no * hor. links left. After this it goes through the remaining vertical * links. */ void Htree2::in_htree() { //temp var double s1 = 0, s2 = 0, s3 = 0; double l_eff = 0; Wire *wtemp1 = 0, *wtemp2 = 0, *wtemp3 = 0; double len = 0, ht = 0; int option = 0; int h = (int) _log2(ndwl); // horizontal nodes int v = (int) _log2(ndbl); // vertical nodes double hdist; double vdist; if (ndwl == ndbl) { hdist = ndwl/2 - 1; vdist = hdist; } else if (ndwl > ndbl) { // config with more h nodes than v nodes hdist = ndbl/2-1 + (_log2(ndwl/2) - _log2(ndbl/2)); // Data first traverse in h links till h nodes = v nodes // beyond this traversal is similar to a balanced htree vdist = pow(2, (_log2(ndwl/2) - _log2(ndbl/2))) * (ndbl/2-1); } else { // v nodes > h nodes // data traverse in a h link followed by a v link in a repeated fashion (similar to a balanced tree) until there are no h links left hdist = ndwl/2-1; vdist = ndwl/2-1 + ((ndwl/2)/2)*(_log2(ndbl/2)-_log2(ndwl/2)); } double len_temp; double ht_temp; if (uca_tree) { ht_temp = (mat_height*ndbl /* since uca_tree models interbank tree, mat_height => bank height */ + (add_bits + data_in_bits + data_out_bits + (search_data_in_bits + search_data_out_bits)) * hdist * g_tp.wire_outside_mat.pitch)/2; len_temp = (mat_width*ndwl /* mat width => bank width */ + (add_bits + data_in_bits + data_out_bits + (search_data_in_bits + search_data_out_bits)) * g_tp.wire_outside_mat.pitch * vdist)/2; } else { if (ndwl == ndbl) { ht_temp = ((mat_height*ndbl/2) + ((add_bits + (search_data_in_bits + search_data_out_bits)) * hdist * g_tp.wire_outside_mat.pitch) + ((data_in_bits + data_out_bits) * g_tp.wire_outside_mat.pitch * hdist) )/2; } else if (ndwl > ndbl) { double excess_part = (_log2(ndwl/2) - _log2(ndbl/2)); ht_temp = ((mat_height*ndbl/2) + ((add_bits + (search_data_in_bits + search_data_out_bits)) * hdist * g_tp.wire_outside_mat.pitch) + (((data_in_bits + data_out_bits) * g_tp.wire_outside_mat.pitch * (ndbl/2-1)) + (2 *(data_in_bits + data_out_bits) * g_tp.wire_outside_mat.pitch * (1 - pow(0.5, excess_part+1)))) )/2; } else { ht_temp = ((mat_height*ndbl/2) + ((add_bits + (search_data_in_bits + search_data_out_bits)) * hdist * g_tp.wire_outside_mat.pitch) + ((data_in_bits + data_out_bits) * g_tp.wire_outside_mat.pitch * hdist) )/2; } len_temp = (mat_width*ndwl/2 + (add_bits + data_in_bits + data_out_bits+ (search_data_in_bits + search_data_out_bits)) * g_tp.wire_outside_mat.pitch * vdist)/2; } area.h = ht_temp * 2; area.w = len_temp * 2; delay = 0; power.readOp.dynamic = 0; power.readOp.leakage = 0; power.searchOp.dynamic =0; len = len_temp; ht = ht_temp/2; while (v > 0 || h > 0) { if (wtemp1) delete wtemp1; if (wtemp2) delete wtemp2; if (wtemp3) delete wtemp3; if (h > v) { //the iteration considers only one horizontal link wtemp1 = new Wire(wt, len); // hor wtemp2 = new Wire(wt, len/2); // ver len_temp = len; len /= 2; wtemp3 = 0; h--; option = 0; } else if (v>0 && h>0) { //considers one horizontal link and one vertical link wtemp1 = new Wire(wt, len); // hor wtemp2 = new Wire(wt, ht); // ver wtemp3 = new Wire(wt, len/2); // next hor len_temp = len; ht_temp = ht; len /= 2; ht /= 2; v--; h--; option = 1; } else { // considers only one vertical link assert(h == 0); wtemp1 = new Wire(wt, ht); // ver wtemp2 = new Wire(wt, ht/2); // hor ht_temp = ht; ht /= 2; wtemp3 = 0; v--; option = 2; } delay += wtemp1->delay; power.readOp.dynamic += wtemp1->power.readOp.dynamic; power.searchOp.dynamic += wtemp1->power.readOp.dynamic*wire_bw; power.readOp.leakage += wtemp1->power.readOp.leakage*wire_bw; power.readOp.gate_leakage += wtemp1->power.readOp.gate_leakage*wire_bw; if ((uca_tree == false && option == 2) || search_tree==true) { wire_bw*=2; // wire bandwidth doubles only for vertical branches } if (uca_tree == false) { if (len_temp > wtemp1->repeater_spacing) { s1 = wtemp1->repeater_size; l_eff = wtemp1->repeater_spacing; } else { s1 = (len_temp/wtemp1->repeater_spacing) * wtemp1->repeater_size; l_eff = len_temp; } if (ht_temp > wtemp2->repeater_spacing) { s2 = wtemp2->repeater_size; } else { s2 = (len_temp/wtemp2->repeater_spacing) * wtemp2->repeater_size; } // first level input_nand(s1, s2, l_eff); } if (option != 1) { continue; } // second level delay += wtemp2->delay; power.readOp.dynamic += wtemp2->power.readOp.dynamic; power.searchOp.dynamic += wtemp2->power.readOp.dynamic*wire_bw; power.readOp.leakage += wtemp2->power.readOp.leakage*wire_bw; power.readOp.gate_leakage += wtemp2->power.readOp.gate_leakage*wire_bw; if (uca_tree) { power.readOp.leakage += (wtemp2->power.readOp.leakage*wire_bw); power.readOp.gate_leakage += wtemp2->power.readOp.gate_leakage*wire_bw; } else { power.readOp.leakage += (wtemp2->power.readOp.leakage*wire_bw); power.readOp.gate_leakage += wtemp2->power.readOp.gate_leakage*wire_bw; wire_bw*=2; if (ht_temp > wtemp3->repeater_spacing) { s3 = wtemp3->repeater_size; l_eff = wtemp3->repeater_spacing; } else { s3 = (len_temp/wtemp3->repeater_spacing) * wtemp3->repeater_size; l_eff = ht_temp; } input_nand(s2, s3, l_eff); } } if (wtemp1) delete wtemp1; if (wtemp2) delete wtemp2; if (wtemp3) delete wtemp3; }
//computes the logarithm base k of a positive integer inline int _logk ( unsigned int n, unsigned int k ) { return _log2 ( n ) / _log2 ( k ); }
int genSNT(Grid &myGrid) { int maxTile = myGrid.getMaxTile(); int n = rand() % (_log2(maxTile / BONUS_THRESHOLD) + 1); return (BONUS_BASE << n); }