static uint64_t calculate_next(struct AspeedTimer *t) { uint64_t next = 0; uint32_t rate = calculate_rate(t); while (!next) { /* We don't know the relationship between the values in the match * registers, so sort using MAX/MIN/zero. We sort in that order as the * timer counts down to zero. */ uint64_t seq[] = { calculate_time(t, MAX(t->match[0], t->match[1])), calculate_time(t, MIN(t->match[0], t->match[1])), calculate_time(t, 0), }; uint64_t reload_ns; uint64_t now = qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL); if (now < seq[0]) { next = seq[0]; } else if (now < seq[1]) { next = seq[1]; } else if (now < seq[2]) { next = seq[2]; } else if (t->reload) { reload_ns = muldiv64(t->reload, NANOSECONDS_PER_SECOND, rate); t->start = now - ((now - t->start) % reload_ns); } else { /* no reload value, return 0 */ break; } } return next; }
/** \brief Substract one day from the calendar */ static void tmg_cal_sub_one_day (GtkSatModule *mod) { gdouble jd; jd = calculate_time(mod); jd -= 1; mod->tmgCdnum = jd; tmg_update_widgets(mod); }
int dsk1interrupt(void) { request_desc_p target, prev; disk_desc *ptr; int ticks; double seek_time, rotate_time, transfer_time; STATWORD ps; disable(ps); ptr = (disk_desc *)devtab[DISK1].dvioblk; if(!ptr) { restore(ps); return SYSERR; } if(!ptr -> request_head) { disk1_preempt = MAXINT; restore(ps); return OK; } for(target = ptr -> request_head, prev = NULL;target -> next;prev = target, target = target -> next); if(prev != NULL) prev -> next = NULL; else ptr -> request_head = NULL; if(target -> type == READ_OPERATION) { ptr -> no_of_reads++; memncpy(target -> buffer, ptr -> disk + target -> block_no * ptr -> block_size, ptr -> block_size * target -> count); } else { ptr -> no_of_writes++; memncpy(ptr -> disk + target -> block_no * ptr -> block_size, target -> buffer, ptr -> block_size * target -> count); } ptr -> head_sector = target -> block_no + target -> count; ready(target -> process_id, RESCHNO); freemem(target, sizeof(request_desc)); // Disk Schedule dskschedule(ptr, PA4_DISK_SCHEDULE); if(ptr -> request_head) { for(target = ptr -> request_head;target -> next;target = target -> next); calculate_time(ptr, target -> block_no, &seek_time, &rotate_time); calculate_transfer_time(ptr, target -> block_no, target -> count, &transfer_time); ticks = ms_to_ticks(seek_time + rotate_time + transfer_time); target -> ticks = ticks; disk1_preempt = ticks; } else disk1_preempt = MAXINT; restore(ps); return OK; }
/* * dskread() is responsible for serving each read request. * It does: * check simple parameter integrity, * calculate seek time, rotate time, and transfer time * insert the current request into each queue * schedule the interrupt related to this request * make the current process into block state. * This function supports multiple continuous blocks. * Please notice that when calling this function, block_no + count does not have to * exceed the last block number. This function does not guarantee that block_no + count * does not exceed. * parameter: * pdev: device descriptor * buffer: a buffer to store read blocks * block_no: the start block number to be read * count: the number of continuous blocks to be read */ int dskread(struct devsw *pdev, char *buffer, int block_no, int count) { disk_desc *ptr; double seek_time = 0.0; double rotate_time = 0.0; double read_time = 0.0; int code, ticks; request_desc_p request; STATWORD ps; disable(ps); if(!pdev || !buffer || count <= 0) { restore(ps); return SYSERR; } ptr = (disk_desc *)pdev -> dvioblk; if(block_no < 0 || block_no + count > ptr -> logical_blocks) { restore(ps); return SYSERR; } request = (request_desc_p)getmem(sizeof(request_desc)); if(request == (request_desc_p)SYSERR) { restore(ps); return (int)request; } if(!ptr -> request_head) { calculate_time(ptr, block_no, &seek_time, &rotate_time); calculate_transfer_time(ptr, block_no, count, &read_time); ticks = ms_to_ticks(seek_time + rotate_time + read_time); if(pdev == &devtab[DISK0]) disk0_preempt = ticks; else if(pdev == &devtab[DISK1]) disk1_preempt = ticks; request -> ticks = ticks; } //kprintf("\n------------dsk read\n"); request -> type = READ_OPERATION; request -> block_no = block_no; request -> process_id = currpid; request -> buffer = buffer; request -> count = count; request -> next = ptr -> request_head; ptr -> request_head = request; //kprintf("\n req buf is %s\n", request->buffer); restore(ps); if(dskresched() == SYSERR) { return SYSERR; } return OK; }
int main(int argc,char *argv[]) { char data[1002]; int no_of_input; // printf("Enter the input\n"); scanf("%d",&no_of_input); getchar(); int i=0; for(i=0;i<no_of_input;i++) { fgets(data,1002,stdin); int time=calculate_time(data); // puts(data); printf("%d\n",time); } return 0; }
/** * \brief Set new date and time callback. * \param widget The widget that was modified. * \param data Pointer to the GtkSatModule structure. * * This function is called when the user changes the date or time in the time * controller. If we are in manual time control mode, the function reads the * date and time set in the control widget and calculates the new time for * the module. The function does nothing in real time and simulated real * time modes. */ static void tmg_time_set(GtkWidget * widget, gpointer data) { GtkSatModule *mod = GTK_SAT_MODULE(data); gdouble slider; gdouble jd; (void)widget; /* avoid unused parameter compiler warning */ /* update time only if we are in manual time control */ if (!mod->throttle && !mod->reset) { jd = calculate_time(mod); /* get slider offset */ slider = gtk_range_get_value(GTK_RANGE(mod->tmgSlider)); mod->tmgCdnum = jd + slider; } }
main() { double predeclength, wordlinelength, bitlinelength; double regfile_power, regfile_decoder, regfile_wordline, regfile_wordline16, regfile_wordline33, regfile_bitline; int scale_factor; int data_width; int rports, wports; int switch_arg; printf("1. Simple Register File\n"); printf("2. Simple Cache Structure\n"); printf("3. Simple CAM Structure\n"); printf("4. Complex Cache (Auto-Sized)\n"); scanf("%d",&switch_arg); printf("note these are MAX powers (assuming full switching)\n"); switch(switch_arg){ case 1: { printf("Enter Reg File Params:\n"); printf("Number of Registers: "); scanf("%d",&num_regs); printf("Data Width: "); scanf("%d",&data_width); printf("Number of Read Ports: "); scanf("%d",&rports); printf("Number of Write Ports: "); scanf("%d",&wports); printf("%d-entryx%d-width,%d-rdport,%d-wrport: %f (W)\n",num_regs,data_width,rports,wports,simple_array_power(num_regs,data_width,rports,wports,0)); printf(" decode_power (W): %f\n",simple_array_decoder_power(num_regs,data_width,rports,wports,0)); printf(" wordline_power (W): %f\n",simple_array_wordline_power(num_regs,data_width,rports,wports,0)); printf(" bitline_power (W): %f\n",simple_array_bitline_power(num_regs,data_width,rports,wports,0)); break; } case 2: { printf("Enter Cache Params:\n"); printf("Size of cache: "); scanf("%d",&num_regs); printf("Data Width: "); scanf("%d",&data_width); printf("Number of Read Ports: "); scanf("%d",&rports); printf("Number of Write Ports: "); scanf("%d",&wports); printf("%d-entryx%d-width,%d-rdport,%d-wrport: %f (W)\n",num_regs,data_width,rports,wports,simple_array_power(num_regs,data_width,rports,wports,1)); printf(" decode_power (W): %f\n",simple_array_decoder_power(num_regs,data_width,rports,wports,1)); printf(" wordline_power (W): %f\n",simple_array_wordline_power(num_regs,data_width,rports,wports,1)); printf(" bitline_power (W): %f\n",simple_array_bitline_power(num_regs,data_width,rports,wports,1)); break; } case 3: { printf("Enter CAM Params:\n"); printf("Entries in CAM: "); scanf("%d",&num_regs); printf("Tag Width: "); scanf("%d",&data_width); printf("Number of Read Ports: "); scanf("%d",&rports); printf("Number of Write Ports: "); scanf("%d",&wports); printf("%d-entryx%d-tagwidth,%d-rdport,%d-wrport: %f (W)\n",num_regs,data_width,rports,wports,cam_array(num_regs,data_width,rports,wports)); printf(" tagdrive_power (W): %f\n",cam_tagdrive(num_regs,data_width,rports,wports)); printf(" tagmatch_power (W): %f\n",cam_tagmatch(num_regs,data_width,rports,wports)); break; } case 4: { int nsets, bsize, assoc,res_memport, tagsize; int ndwl, ndbl, nspd, ntwl, ntbl, ntspd, c,b,a,cache, rowsb, colsb, trowsb, tcolsb; double cache_decoder, cache_wordline, cache_bitline, cache_senseamp, cache_tagarray, total_cache_power; time_result_type time_result; time_parameter_type time_parameters; int va_size = 48; printf("Enter Cache Params:\n"); printf("Number of Sets in cache: "); scanf("%d",&nsets); printf("Block Size (bytes): "); scanf("%d",&bsize); printf("Associativity: "); scanf("%d",&assoc); printf("Number of Memory Ports: "); scanf("%d",&res_memport); printf("note tagarray size is estimated based on assuming 48-bit virtual addresses\n"); cache = 1; time_parameters.cache_size = nsets * bsize * assoc; /* C */ time_parameters.block_size = bsize; /* B */ time_parameters.associativity = assoc; /* A */ time_parameters.number_of_sets = nsets; /* C/(B*A) */ calculate_time(&time_result,&time_parameters); output_data(&time_result,&time_parameters); ndwl=time_result.best_Ndwl; ndbl=time_result.best_Ndbl; nspd=time_result.best_Nspd; ntwl=time_result.best_Ntwl; ntbl=time_result.best_Ntbl; ntspd=time_result.best_Ntspd; c = time_parameters.cache_size; b = time_parameters.block_size; a = time_parameters.associativity; rowsb = c/(8*b*a*ndbl*nspd); colsb = 8*b*a*nspd/ndwl; tagsize = va_size - ((int)logtwo(nsets) + (int)logtwo(bsize)); trowsb = c/(8*b*a*ntbl*ntspd); tcolsb = a * (tagsize + 1 + 6) * ntspd/ntwl; predeclength = rowsb * (RegCellHeight + WordlineSpacing); wordlinelength = colsb * (RegCellWidth + BitlineSpacing); bitlinelength = rowsb * (RegCellHeight + WordlineSpacing); cache_decoder = res_memport*ndwl*ndbl*array_decoder_power(rowsb,colsb,predeclength,1,1,cache); cache_wordline = res_memport*ndwl*ndbl*array_wordline_power(rowsb,colsb,wordlinelength,1,1,cache); cache_bitline = res_memport*ndwl*ndbl*array_bitline_power(rowsb,colsb,bitlinelength,1,1,cache); cache_senseamp = res_memport*ndwl*ndbl*senseamp_power(colsb); cache_tagarray = res_memport*ntwl*ntbl*(simple_array_power(trowsb,tcolsb,1,1,cache)); total_cache_power = cache_decoder + cache_wordline + cache_bitline + cache_senseamp + cache_tagarray; fprintf(stderr,"%d KB %d-way cache (%d-byte block size):\n",c,a,b); fprintf(stderr,"ndwl == %d, ndbl == %d, nspd == %d\n",ndwl,ndbl,nspd); fprintf(stderr,"%d sets of %d rows x %d cols\n",ndwl*ndbl,rowsb,colsb); fprintf(stderr,"tagsize == %d\n",tagsize); fprintf(stderr,"\nntwl == %d, ntbl == %d, ntspd == %d\n",ntwl,ntbl,ntspd); fprintf(stderr,"%d sets of %d rows x %d cols\n",ntwl*ntbl,trowsb,tcolsb); printf("Total Power (W): %f\n",total_cache_power); printf(" decode_power (W): %f\n",cache_decoder); printf(" wordline_power (W): %f\n",cache_wordline); printf(" bitline_power (W): %f\n",cache_bitline); printf(" senseamp_power (W): %f\n",cache_senseamp); printf(" tagarray_power (W): %f\n",cache_tagarray); break; } default: } }
int main( int argc, char *argv[] ) { int32 k; char *tsuf; timing_t start; timing_t end; timing_t diff; real32 time; real32 secs; carray_t haystack; hthread_t *threads; arg_t *args; // Allocate the threads structure threads = (hthread_t*)malloc( tarsize * sizeof(hthread_t) ); // Allocate the argument structures args = (arg_t*)malloc( tarsize * sizeof(arg_t) ); // Create arrays for the search string carray_fromstr( &haystack, beowulf ); carray_concatstr( &haystack, britannica1 ); carray_concatstr( &haystack, britannica2 ); carray_concatstr( &haystack, britannica3 ); carray_concatstr( &haystack, caesar ); carray_concatstr( &haystack, hamlet ); carray_concatstr( &haystack, huckfinn ); carray_concatstr( &haystack, illiad ); carray_concatstr( &haystack, macbeth ); carray_concatstr( &haystack, pride ); carray_concatstr( &haystack, sense ); carray_concatstr( &haystack, tomsawyer ); carray_concatstr( &haystack, twist ); carray_concatstr( &haystack, ulysses ); carray_concatstr( &haystack, venice ); // Create all of the thread arguments for( k = 0; k < tarsize; k++ ) { args[k].search = &haystack; args[k].found = 0; carray_fromstr( &args[k].target, tar[k] ); boyermoore_init( &args[k].bm, &args[k].target ); } // Create worker threads for all of the search strings timing_get( &start ); for( k = 0; k < tarsize; k++ ) { hthread_create( &threads[k], NULL, search, &args[k] ); } // Wait for all of the worker threads to complete for( k = 0; k < tarsize; k++ ) { hthread_join( threads[k], (void*)&args[k].found ); } timing_get( &end ); timing_diff(diff,end,start); secs = timing_sec(diff); calculate_time( &tsuf, &time, secs ); printf( "Test Finished: %.2f %s\n", time, tsuf ); // Show the results and destroy the thread arguments for( k = 0; k < tarsize; k++ ) { printf( "Thread %d found %d matches of the string '%s'\n", k, args[k].found, tar[k] ); boyermoore_destroy( &args[k].bm ); carray_destroy( &args[k].target ); } // Exit the program return 0; }
total_result_type cacti_interface (int cache_size, int line_size, int associativity, int rw_ports, int excl_read_ports, int excl_write_ports, int single_ended_read_ports, int banks, double tech_node, int output_width, int specific_tag, int tag_width, int access_mode, int pure_sram) { int C, B, A, ERP, EWP, RWP, NSER; double tech; double logbanks; double logbanksfloor; int seq_access = 0; int fast_access = 0; int bits_output = output_width; int nr_args = 9; double NSubbanks = (double) banks; double ratioofbankstoports; extern int force_tag, force_tag_size; total_result_type endresult; endresult.result.subbanks = 0.0; result_type result; arearesult_type arearesult; area_type arearesult_subbanked; parameter_type parameters; /* input parameters: C B A ERP EWP */ /*dt: make sure we're using some simple leakage reduction */ dualVt = FALSE; //#ifdef XCACTI //parameters.latchsa = 0; //parameters.ignore_tag = 0; //#endif force_tag = 0; parameters.force_tag = 0; if (specific_tag) { force_tag = 1; force_tag_size = tag_width; parameters.force_tag = 1; parameters.tag_size = tag_width; //parameters.ignore_tag = 1; } switch (access_mode) { case 0: seq_access = fast_access = FALSE; break; case 1: seq_access = TRUE; fast_access = FALSE; break; case 2: seq_access = FALSE; fast_access = TRUE; break; } C = cache_size; A = associativity; B = line_size; if ((B < 1)) { printf ("Block size must >=1\n"); return endresult; //exit(1); } if ((B * 8 < bits_output)) { printf ("Block size must be at least %d\n", bits_output / 8); return endresult; //exit(1); } tech = tech_node; if ((tech <= 0)) { printf ("Feature size must be > 0\n"); return endresult; //exit(1); } if ((tech > 0.8)) { printf ("Feature size must be <= 0.80 (um)\n"); return endresult; //exit(1); } if (nr_args == 6) { RWP = 1; ERP = 0; EWP = 0; NSER = 0; } else if (nr_args == 8) { RWP = 1; ERP = 0; EWP = 0; NSER = 0; bits_output = output_width; seq_access = 1; } else if (nr_args == 9) { RWP = rw_ports; ERP = excl_read_ports; EWP = excl_write_ports; NSER = single_ended_read_ports; } else if (nr_args >= 10) { RWP = rw_ports; ERP = excl_read_ports; EWP = excl_write_ports; NSER = single_ended_read_ports; seq_access = 1; } if ((RWP < 0) || (EWP < 0) || (ERP < 0)) { printf ("Ports must >=0\n"); return endresult; //exit(1); } if (RWP > 2) { printf ("Maximum of 2 read/write ports\n"); return endresult; //exit(1); } if ((RWP + ERP + EWP) < 1) { printf ("Must have at least one port\n"); return endresult; //exit(1); } if (NSubbanks < 1) { printf ("Number of subbanks should be greater than or equal to 1 and should be a power of 2\n"); return endresult; //exit(1); } logbanks = logtwo ((double) (NSubbanks)); logbanksfloor = floor (logbanks); if (logbanks > logbanksfloor) { printf ("Number of subbanks should be greater than or equal to 1 and should be a power of 2\n"); return endresult; //exit(1); } if (C == B * A) { parameters.fully_assoc = 1; A = C / B; } else { parameters.fully_assoc = 0; } C = cache_size / ((int) (NSubbanks)); if ((C < 64)) { printf ("Cache size must >=64\n"); return endresult; //exit(1); } //A = C/B; if (A > 16) { parameters.fully_assoc = 1; A = 16; } /*if ((associativity == 0) || (A == C/B)) { A = C/B; parameters.fully_assoc = 1; } else { if (associativity == 1) { A=1; parameters.fully_assoc = 0; } else { parameters.fully_assoc = 0; A = associativity; if ((A < 1)) { printf("Associativity must >= 1\n"); return endresult; //exit(1); } assoc = logtwo((double)(A)); assocfloor = floor(assoc); if(assoc > assocfloor){ printf("Associativity should be a power of 2\n"); return endresult; //exit(1); } if ((A > 32)) { printf("Associativity must <= 32\n or try FA (fully associative)\n"); return endresult; //exit(1); } } } if (C/(B*A)<=1 && !parameters.fully_assoc) { //printf("Number of sets is too small:\n Need to either increase cache size, or decrease associativity or block size\n (or use fully associative cache)\n"); //return endresult; A = C/B; parameters.fully_assoc = 1; //exit(1); } */ printf ("\n########### Printing input for params for testing...###"); printf ("\n C = %d, B = %d, A = %d", C, B, A); printf ("\n RWP = %d, ERP = %d, EWP = %d, NSER = %d", RWP, ERP, EWP, NSER); printf ("\n banks = %d, tech = %f, bits_output = %d, fast_access = %d, pure_sram = %d", banks, tech, bits_output, fast_access, pure_sram); printf ("\n force_tag = %d, force_tag_size = %d", force_tag, force_tag_size); printf ("\n #################\n"); parameters.cache_size = C; parameters.block_size = B; parameters.nr_bits_out = bits_output; /*dt: testing sequential access mode */ if (seq_access) { parameters.tag_associativity = A; parameters.data_associativity = 1; parameters.sequential_access = 1; } else { parameters.tag_associativity = parameters.data_associativity = A; parameters.sequential_access = 0; } if (fast_access) { parameters.fast_access = 1; } else { parameters.fast_access = 0; } parameters.num_readwrite_ports = RWP; parameters.num_read_ports = ERP; parameters.num_write_ports = EWP; parameters.NSubbanks = banks; parameters.num_single_ended_read_ports = NSER; parameters.number_of_sets = C / (B * A); parameters.fudgefactor = .8 / tech; parameters.tech_size = (double) tech; parameters.pure_sram = pure_sram; //If multiple banks and multiple ports are specified, then if number of banks/total number //of ports > 1 then assume that the multiple ports are implemented via the multiple banks. //Also assume that each bank has only 1 RWP port. There are some problems with this logic that //will be fixed in v5.0 ratioofbankstoports = NSubbanks / (RWP + ERP + EWP); if (ratioofbankstoports >= 1.0) { //We assume that each bank has 1 RWP port. parameters.num_readwrite_ports = 1; parameters.num_read_ports = 0; parameters.num_write_ports = 0; parameters.num_single_ended_read_ports = 0; } if (parameters.number_of_sets < 1) { printf ("Less than one set...\n"); return endresult; //exit(1); } parameters.VddPow = 4.5 / (pow (parameters.fudgefactor, (2.0 / 3.0))); if (parameters.VddPow < 0.7) parameters.VddPow = 0.7; if (parameters.VddPow > 5.0) parameters.VddPow = 5.0; printf ("\n##### Printing parameters for testing...#####\n"); output_params (¶meters); init_tech_params_default_process (); //v4.1: First initialize all tech variables //to 0.8 micron values. init_tech_params function below then reinitializes tech variables to //given process values init_tech_params (parameters.tech_size); calculate_time (&result, &arearesult, &arearesult_subbanked, ¶meters, &NSubbanks); //v4.1: No longer using calculate_area function as area has already been //computed for the given tech node /*arearesult.dataarray_area.scaled_area = calculate_area(arearesult.dataarray_area,parameters.fudgefactor)*CONVERT_TO_MMSQUARE; arearesult.datapredecode_area.scaled_area = calculate_area(arearesult.datapredecode_area,parameters.fudgefactor)*CONVERT_TO_MMSQUARE; arearesult.datacolmuxpredecode_area.scaled_area = calculate_area(arearesult.datacolmuxpredecode_area,parameters.fudgefactor)*CONVERT_TO_MMSQUARE; arearesult.datacolmuxpostdecode_area.scaled_area = calculate_area(arearesult.datacolmuxpostdecode_area,parameters.fudgefactor)*CONVERT_TO_MMSQUARE; arearesult.datawritesig_area.scaled_area = (parameters.num_readwrite_ports+parameters.num_read_ports+parameters.num_write_ports)*calculate_area(arearesult.datawritesig_area,parameters.fudgefactor)*CONVERT_TO_MMSQUARE; arearesult.tagarray_area.scaled_area = calculate_area(arearesult.tagarray_area,parameters.fudgefactor)*CONVERT_TO_MMSQUARE; arearesult.tagpredecode_area.scaled_area = calculate_area(arearesult.tagpredecode_area,parameters.fudgefactor)*CONVERT_TO_MMSQUARE; arearesult.tagcolmuxpredecode_area.scaled_area = calculate_area(arearesult.tagcolmuxpredecode_area,parameters.fudgefactor)*CONVERT_TO_MMSQUARE; arearesult.tagcolmuxpostdecode_area.scaled_area = calculate_area(arearesult.tagcolmuxpostdecode_area,parameters.fudgefactor)*CONVERT_TO_MMSQUARE; arearesult.tagoutdrvdecode_area.scaled_area = calculate_area(arearesult.tagoutdrvdecode_area,parameters.fudgefactor)*CONVERT_TO_MMSQUARE; arearesult.tagoutdrvsig_area.scaled_area = (parameters.num_readwrite_ports+parameters.num_read_ports+parameters.num_write_ports)* calculate_area(arearesult.tagoutdrvsig_area,parameters.fudgefactor)*CONVERT_TO_MMSQUARE; arearesult.perc_data = 100*area_all_dataramcells/(arearesult.totalarea*CONVERT_TO_MMSQUARE); arearesult.perc_tag = 100*area_all_tagramcells/(arearesult.totalarea*CONVERT_TO_MMSQUARE); arearesult.perc_cont = 100*(arearesult.totalarea*CONVERT_TO_MMSQUARE-area_all_dataramcells-area_all_tagramcells)/(arearesult.totalarea*CONVERT_TO_MMSQUARE); arearesult.sub_eff = (area_all_dataramcells+area_all_tagramcells)*100/(arearesult.totalarea/100000000.0); arearesult.total_eff = (NSubbanks)*(area_all_dataramcells+area_all_tagramcells)*100/ (calculate_area(arearesult_subbanked,parameters.fudgefactor)*CONVERT_TO_MMSQUARE); arearesult.totalarea *= CONVERT_TO_MMSQUARE; arearesult.subbankarea = calculate_area(arearesult_subbanked,parameters.fudgefactor)*CONVERT_TO_MMSQUARE; */ arearesult.dataarray_area.scaled_area = arearesult.dataarray_area.height * arearesult.dataarray_area.width * CONVERT_TO_MMSQUARE; arearesult.datapredecode_area.scaled_area = arearesult.datapredecode_area.height * arearesult.datapredecode_area.width * CONVERT_TO_MMSQUARE; arearesult.datacolmuxpredecode_area.scaled_area = arearesult.datacolmuxpredecode_area.height * arearesult.datacolmuxpredecode_area.width * CONVERT_TO_MMSQUARE; arearesult.datacolmuxpostdecode_area.scaled_area = arearesult.datacolmuxpostdecode_area.height * arearesult.datacolmuxpostdecode_area.width * CONVERT_TO_MMSQUARE; arearesult.datawritesig_area.scaled_area = (parameters.num_readwrite_ports + parameters.num_read_ports + parameters.num_write_ports) * arearesult.datawritesig_area.height * arearesult.datawritesig_area.width * CONVERT_TO_MMSQUARE; arearesult.tagarray_area.scaled_area = arearesult.tagarray_area.height * arearesult.tagarray_area.width * CONVERT_TO_MMSQUARE; arearesult.tagpredecode_area.scaled_area = arearesult.tagpredecode_area.height * arearesult.tagpredecode_area.width * CONVERT_TO_MMSQUARE; arearesult.tagcolmuxpredecode_area.scaled_area = arearesult.tagcolmuxpredecode_area.height * arearesult.tagcolmuxpredecode_area.width * CONVERT_TO_MMSQUARE; arearesult.tagcolmuxpostdecode_area.scaled_area = arearesult.tagcolmuxpostdecode_area.height * arearesult.tagcolmuxpostdecode_area.width * CONVERT_TO_MMSQUARE; arearesult.tagoutdrvdecode_area.scaled_area = arearesult.tagoutdrvdecode_area.height * arearesult.tagoutdrvdecode_area.width * CONVERT_TO_MMSQUARE; arearesult.tagoutdrvsig_area.scaled_area = (parameters.num_readwrite_ports + parameters.num_read_ports + parameters.num_write_ports) * arearesult.tagoutdrvsig_area.height * arearesult.tagoutdrvsig_area.width * CONVERT_TO_MMSQUARE; arearesult.perc_data = 100 * area_all_dataramcells / (arearesult.totalarea * CONVERT_TO_MMSQUARE); arearesult.perc_tag = 100 * area_all_tagramcells / (arearesult.totalarea * CONVERT_TO_MMSQUARE); arearesult.perc_cont = 100 * (arearesult.totalarea * CONVERT_TO_MMSQUARE - area_all_dataramcells - area_all_tagramcells) / (arearesult.totalarea * CONVERT_TO_MMSQUARE); arearesult.sub_eff = (area_all_dataramcells + area_all_tagramcells) * 100 / (arearesult.totalarea / 100000000.0); arearesult.total_eff = (NSubbanks) * (area_all_dataramcells + area_all_tagramcells) * 100 / (arearesult_subbanked.height * arearesult_subbanked.width * CONVERT_TO_MMSQUARE); arearesult.totalarea *= CONVERT_TO_MMSQUARE; arearesult.subbankarea = arearesult_subbanked.height * arearesult_subbanked.width * CONVERT_TO_MMSQUARE; if (result.bitline_delay_data < 0.0) { result.bitline_delay_data = 10 ^ -12; } if (result.bitline_delay_tag < 0.0) { result.bitline_delay_tag = 10 ^ -13; } endresult.result = result; endresult.result.subbanks = banks; endresult.area = arearesult; endresult.params = parameters; return endresult; }
static void apm_battery_apm_get_power_status(struct apm_power_info *info) { union power_supply_propval status; union power_supply_propval capacity, time_to_full, time_to_empty; mutex_lock(&apm_mutex); find_main_battery(); if (!main_battery) { mutex_unlock(&apm_mutex); return; } /* status */ if (MPSY_PROP(STATUS, &status)) status.intval = POWER_SUPPLY_STATUS_UNKNOWN; /* ac line status */ #ifdef CONFIG_ARCH_BCM4760 { union power_supply_propval online; MPSY_PROP(ONLINE, &online); if(online.intval){ info->ac_line_status = APM_AC_ONLINE; } else { info->ac_line_status = APM_AC_OFFLINE; } } #else if ((status.intval == POWER_SUPPLY_STATUS_CHARGING) || (status.intval == POWER_SUPPLY_STATUS_NOT_CHARGING) || (status.intval == POWER_SUPPLY_STATUS_FULL)) info->ac_line_status = APM_AC_ONLINE; else info->ac_line_status = APM_AC_OFFLINE; #endif /* battery life (i.e. capacity, in percents) */ if (MPSY_PROP(CAPACITY, &capacity) == 0) { info->battery_life = capacity.intval; } else { /* try calculate using energy */ info->battery_life = calculate_capacity(SOURCE_ENERGY); /* if failed try calculate using charge instead */ if (info->battery_life == -1) info->battery_life = calculate_capacity(SOURCE_CHARGE); if (info->battery_life == -1) info->battery_life = calculate_capacity(SOURCE_VOLTAGE); } /* charging status */ if (status.intval == POWER_SUPPLY_STATUS_CHARGING) { info->battery_status = APM_BATTERY_STATUS_CHARGING; } else { if (info->battery_life > 50) info->battery_status = APM_BATTERY_STATUS_HIGH; else if (info->battery_life > 5) info->battery_status = APM_BATTERY_STATUS_LOW; else info->battery_status = APM_BATTERY_STATUS_CRITICAL; } info->battery_flag = info->battery_status; /* time */ info->units = APM_UNITS_MINS; if (status.intval == POWER_SUPPLY_STATUS_CHARGING) { if (!MPSY_PROP(TIME_TO_FULL_AVG, &time_to_full) || !MPSY_PROP(TIME_TO_FULL_NOW, &time_to_full)) info->time = time_to_full.intval / 60; else info->time = calculate_time(status.intval); } else { if (!MPSY_PROP(TIME_TO_EMPTY_AVG, &time_to_empty) || !MPSY_PROP(TIME_TO_EMPTY_NOW, &time_to_empty)) info->time = time_to_empty.intval / 60; else info->time = calculate_time(status.intval); } mutex_unlock(&apm_mutex); }
static void apm_battery_apm_get_power_status(struct apm_power_info *info) { union power_supply_propval status; union power_supply_propval capacity, time_to_full, time_to_empty; mutex_lock(&apm_mutex); find_main_battery(); if (!main_battery) { mutex_unlock(&apm_mutex); return; } if (MPSY_PROP(STATUS, &status)) status.intval = POWER_SUPPLY_STATUS_UNKNOWN; if ((status.intval == POWER_SUPPLY_STATUS_CHARGING) || (status.intval == POWER_SUPPLY_STATUS_NOT_CHARGING) || (status.intval == POWER_SUPPLY_STATUS_FULL)) info->ac_line_status = APM_AC_ONLINE; else info->ac_line_status = APM_AC_OFFLINE; if (MPSY_PROP(CAPACITY, &capacity) == 0) { info->battery_life = capacity.intval; } else { info->battery_life = calculate_capacity(SOURCE_ENERGY); if (info->battery_life == -1) info->battery_life = calculate_capacity(SOURCE_CHARGE); if (info->battery_life == -1) info->battery_life = calculate_capacity(SOURCE_VOLTAGE); } if (status.intval == POWER_SUPPLY_STATUS_CHARGING) { info->battery_status = APM_BATTERY_STATUS_CHARGING; } else { if (info->battery_life > 50) info->battery_status = APM_BATTERY_STATUS_HIGH; else if (info->battery_life > 5) info->battery_status = APM_BATTERY_STATUS_LOW; else info->battery_status = APM_BATTERY_STATUS_CRITICAL; } info->battery_flag = info->battery_status; info->units = APM_UNITS_MINS; if (status.intval == POWER_SUPPLY_STATUS_CHARGING) { if (!MPSY_PROP(TIME_TO_FULL_AVG, &time_to_full) || !MPSY_PROP(TIME_TO_FULL_NOW, &time_to_full)) info->time = time_to_full.intval / 60; else info->time = calculate_time(status.intval); } else { if (!MPSY_PROP(TIME_TO_EMPTY_AVG, &time_to_empty) || !MPSY_PROP(TIME_TO_EMPTY_NOW, &time_to_empty)) info->time = time_to_empty.intval / 60; else info->time = calculate_time(status.intval); } mutex_unlock(&apm_mutex); }