int main(){ Grade g = 10; int x = g; GradeArray grades = {10,20,30,40}; printf("Average: %f\n", compute_average(grades)); return 0; }
static orcm_value_t* compute_agg(char* op, char* data_key, opal_list_t* compute, orcm_analytics_aggregate* aggregate) { orcm_value_t *temp = NULL; orcm_value_t *agg_value = NULL; if(NULL == compute || NULL == aggregate || NULL == data_key) { return NULL; } temp = (orcm_value_t*)opal_list_get_first(compute); ON_NULL_RETURN(temp); agg_value = orcm_util_load_orcm_value(data_key, &temp->value.data,OPAL_DOUBLE,temp->units); ON_NULL_RETURN(agg_value); if(0 == strncmp(op,"average", strlen(op))) { compute_average(agg_value, aggregate, compute); } else if (0 == strncmp(op, "min", strlen(op))){ compute_min(agg_value, aggregate, compute); } else if (0 == strncmp(op,"max", strlen(op))){ compute_max(agg_value, aggregate, compute); } else { SAFEFREE(agg_value); } return agg_value; }
int main(int argc, char **argv) { SDDS_DATASET SDDSnew, SDDSold; long i, j, iArg; SCANNED_ARG *scArg; char *input, *output, *columnName; long mode, matchCode, rows, rowsMinus1, tmpfile_used; double gapAmount, *columnData, gapFactor; char *matchPattern; long matchPatternAfter = 0; double changeAmount, changeBase; long retval, newStart, rowLimit, breakNext; int32_t dataType, overlap=0; unsigned long flags, pipeFlags, changeFlags; char **stringData; SDDS_RegisterProgramName(argv[0]); argc = scanargs(&scArg, argc, argv); if (argc<2) { fprintf(stderr, "%s", USAGE); return(1); } columnData = NULL; stringData = NULL; input = output = columnName = NULL; mode = -1; pipeFlags = flags = 0; gapAmount = changeAmount = rowLimit = gapFactor = 0; matchPattern = NULL; for (iArg=1; iArg<argc; iArg++) { if (scArg[iArg].arg_type==OPTION) { switch (matchCode=match_string(scArg[iArg].list[0], option, N_OPTIONS, 0)) { case SET_GAPIN: if ((scArg[iArg].n_items-=2)<0 || !scanItemList(&flags, scArg[iArg].list+2, &scArg[iArg].n_items, 0, "amount", SDDS_DOUBLE, &gapAmount, 1, GAPIN_AMOUNT, "factor", SDDS_DOUBLE, &gapFactor, 1, GAPIN_FACTOR, NULL) || (flags&GAPIN_AMOUNT && gapAmount<=0) || (flags&GAPIN_FACTOR && gapFactor<=0)) { fprintf(stderr, "Error: invalid -gapin syntax/values\n"); return(1); } columnName = scArg[iArg].list[1]; mode = matchCode; break; case SET_INCREASEOF: case SET_DECREASEOF: if (scArg[iArg].n_items!=2) { fprintf(stderr, "Error: invalid option syntax---specify column-name with -increaseof and -decreaseof\n"); return(1); } columnName = scArg[iArg].list[1]; mode = matchCode; break; case SET_CHANGEOF: if ((scArg[iArg].n_items-=2)<0 || !scanItemList(&changeFlags, scArg[iArg].list+2, &scArg[iArg].n_items, 0, "amount", SDDS_DOUBLE, &changeAmount, 1, CHANGEOF_AMOUNT, "base", SDDS_DOUBLE, &changeBase, 1, CHANGEOF_BASE, NULL) || (changeFlags&CHANGEOF_AMOUNT && changeAmount<=0)) { fprintf(stderr, "Error: invalid -changeof syntax/values\n"); return(1); } columnName = scArg[iArg].list[1]; mode = matchCode; break; case SET_ROWLIMIT: if (scArg[iArg].n_items<2) { fprintf(stderr, "Error: invalid -rowlimit syntax\n"); return(1); } if (sscanf(scArg[iArg].list[1], "%ld", &rowLimit)!=1 || rowLimit<=0) { fprintf(stderr, "Error: invalid -rowlimit syntax\n"); return(1); } if (scArg[iArg].n_items>2) { scArg[iArg].n_items-=2; if (!scanItemList(&flags, scArg[iArg].list+2, &scArg[iArg].n_items, 0, "overlap", SDDS_LONG, &overlap, NULL) || overlap<0) { fprintf(stderr, "Error: invalid overlap given in -rowlimit syntax\n"); return(1); } } mode = matchCode; break; case SET_PIPE: if (!processPipeOption(scArg[iArg].list+1, scArg[iArg].n_items-1, &pipeFlags)) { fprintf(stderr, "Error: invalid -pipe syntax\n"); return(1); } break; case SET_MATCHTO: if ((scArg[iArg].n_items!=3 && scArg[iArg].n_items!=4) || strlen(columnName=scArg[iArg].list[1])==0 || strlen(matchPattern=scArg[iArg].list[2])==0) { fprintf(stderr, "Error: invalid -matchTo syntax\n"); return(1); } if (scArg[iArg].n_items==4) { if (strncmp(scArg[iArg].list[3], "after", strlen(scArg[iArg].list[3]))==0) matchPatternAfter = 1; else { fprintf(stderr, "Error: invalid -matchTo syntax\n"); return(1); } } mode = matchCode; break; default: fprintf(stderr, "Error: unknown switch: %s\n", scArg[iArg].list[0]); fprintf(stderr, "%s", USAGE); return(1); } } else { if (input==NULL) input = scArg[iArg].list[0]; else if (output==NULL) output = scArg[iArg].list[0]; else { fprintf(stderr, "Error: too many filenames given\n"); return(1); } } } processFilenames("sddsbreak", &input, &output, pipeFlags, 0, &tmpfile_used); if (mode==-1) { fprintf(stderr, "Error: no break mode specified\n"); return(1); } if (!SDDS_InitializeInput(&SDDSold, input) || !SDDS_InitializeCopy(&SDDSnew, &SDDSold, output, "w")) { SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors); return(1); } SDDSnew.layout.data_mode.no_row_counts = 0; if (!SDDS_WriteLayout(&SDDSnew)) { SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors); return(1); } if (mode!=SET_ROWLIMIT) { if (SDDS_GetColumnInformation(&SDDSold, "type", &dataType, SDDS_BY_NAME, columnName)!=SDDS_LONG) { SDDS_SetError("problem getting type information on given column"); SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors); return(1); } if (mode==SET_MATCHTO) { if (!(dataType==SDDS_STRING)) { fprintf(stderr, "Error: given column does not contain string data\n"); return(1); } } else if (!SDDS_NUMERIC_TYPE(dataType)) { if (!(mode==SET_CHANGEOF && !(changeFlags&CHANGEOF_AMOUNT) && !(changeFlags&CHANGEOF_BASE))) { fprintf(stderr, "Error: given column does not contain numeric data\n"); return(1); } } } while ((retval=SDDS_ReadPage(&SDDSold))>0) { if ((rows = SDDS_CountRowsOfInterest(&SDDSold))<0) { SDDS_SetError("Problem getting number of rows of tabular data"); SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors); return(1); } rowsMinus1 = rows-1; if (!SDDS_StartPage(&SDDSnew, rows) || !SDDS_CopyParameters(&SDDSnew, &SDDSold) || !SDDS_CopyArrays(&SDDSnew, &SDDSold)) { SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors); return(1); } if (rows==0) { if (!SDDS_WritePage(&SDDSnew)) { SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors); return(1); } continue; } switch (mode) { case SET_GAPIN: if (!(columnData=SDDS_GetColumnInDoubles(&SDDSold, columnName))) { SDDS_SetError("unable to read specified column"); SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors); return(1); } if (!gapAmount && rows>1) { double *gap; gap = tmalloc(sizeof(*gap)*rows); for (i=1; i<rows; i++) gap[i-1] = fabs(columnData[i]-columnData[i-1]); if (!compute_average(&gapAmount, gap, rows-1)) { fprintf(stderr, "Error: unable to determine default gap amount--couldn't find median gap\n"); return(1); } gapAmount *= (gapFactor?gapFactor:2); free(gap); } newStart = 0; for (i=1; i<=rows; i++) { if (i!=rows && fabs(columnData[i]-columnData[i-1])<gapAmount) continue; if (!SDDS_SetRowFlags(&SDDSold, 0) || !SDDS_AssertRowFlags(&SDDSold, SDDS_INDEX_LIMITS, newStart, i-1, 1) || !SDDS_CopyRowsOfInterest(&SDDSnew, &SDDSold) || !SDDS_WritePage(&SDDSnew)) { SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors); return(1); } newStart = i; } free(columnData); break; case SET_INCREASEOF: if (!(columnData=SDDS_GetColumnInDoubles(&SDDSold, columnName))) { SDDS_SetError("unable to read specified column"); SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors); return(1); } newStart = 0; for (i=1; i<=rows; i++) { if (i!=rows && columnData[i]<=columnData[i-1]) continue; if (!SDDS_SetRowFlags(&SDDSold, 0) || !SDDS_AssertRowFlags(&SDDSold, SDDS_INDEX_LIMITS, newStart, i-1, 1) || !SDDS_CopyRowsOfInterest(&SDDSnew, &SDDSold) || !SDDS_WritePage(&SDDSnew)) { SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors); return(1); } newStart = i; } free(columnData); break; case SET_DECREASEOF: if (!(columnData=SDDS_GetColumnInDoubles(&SDDSold, columnName))) { SDDS_SetError("unable to read specified column"); SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors); return(1); } newStart = 0; for (i=1; i<=rows; i++) { if (i!=rows && columnData[i]>=columnData[i-1]) continue; if (!SDDS_SetRowFlags(&SDDSold, 0) || !SDDS_AssertRowFlags(&SDDSold, SDDS_INDEX_LIMITS, newStart, i-1, 1) || !SDDS_CopyRowsOfInterest(&SDDSnew, &SDDSold) || !SDDS_WritePage(&SDDSnew)) { SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors); return(1); } newStart = i; } free(columnData); break; case SET_CHANGEOF: if (dataType!=SDDS_STRING) { if (!(columnData=SDDS_GetColumnInDoubles(&SDDSold, columnName))) { SDDS_SetError("unable to read specified column"); SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors); return(1); } } else { if (!(stringData=SDDS_GetColumn(&SDDSold, columnName))) { SDDS_SetError("unable to read specified column"); SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors); return(1); } } newStart = 0; if (dataType==SDDS_STRING || !changeAmount) { for (i=1; i<=rows; i++) { if (i!=rows && ((dataType==SDDS_STRING && strcmp(stringData[i], stringData[i-1])==0) || (dataType!=SDDS_STRING && columnData[i]==columnData[i-1]))) continue; if (!SDDS_SetRowFlags(&SDDSold, 0) || !SDDS_AssertRowFlags(&SDDSold, SDDS_INDEX_LIMITS, newStart, i-1, 1) || !SDDS_CopyRowsOfInterest(&SDDSnew, &SDDSold) || !SDDS_WritePage(&SDDSnew)) { SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors); return(1); } newStart = i; } } else { long region, lastRegion; region = lastRegion = 0; if (!(changeFlags&CHANGEOF_BASE) && rows>=1) changeBase = columnData[0]; if (rows>1) lastRegion = (columnData[0]-changeBase)/changeAmount; #ifdef DEBUG fprintf(stderr, "change base=%e, lastRegion=%ld\n", changeBase, lastRegion); fprintf(stderr, "start value = %e\n", columnData[0]); #endif newStart = 0; for (i=1; i<=rows; i++) { if (i!=rows) region = (columnData[i]-changeBase)/changeAmount; if (i!=rows && region==lastRegion) continue; #ifdef DEBUG fprintf(stderr, "split after %e, before %e, region = %d\n", columnData[i-1], columnData[i], region); #endif if (!SDDS_SetRowFlags(&SDDSold, 0) || !SDDS_AssertRowFlags(&SDDSold, SDDS_INDEX_LIMITS, newStart, i-1, 1) || !SDDS_CopyRowsOfInterest(&SDDSnew, &SDDSold) || !SDDS_WritePage(&SDDSnew)) { SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors); return(1); } newStart = i; lastRegion = region; #ifdef DEBUG fprintf(stderr, "start value = %e\n", columnData[i]); #endif } } if (dataType!=SDDS_STRING) free(columnData); else SDDS_FreeStringArray(stringData, rows); break; case SET_MATCHTO: if (!(stringData=SDDS_GetColumn(&SDDSold, columnName))) { SDDS_SetError("unable to read specified column"); SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors); return(1); } newStart = 0; breakNext = 0; for (i=1; i<=rows; i++) { if (i!=rows && !breakNext) { if (wild_match(stringData[i], matchPattern)) { if (matchPatternAfter) { breakNext = 1; continue; } } else continue; } if (!SDDS_SetRowFlags(&SDDSold, 0) || !SDDS_AssertRowFlags(&SDDSold, SDDS_INDEX_LIMITS, newStart, i-1, 1) || !SDDS_CopyRowsOfInterest(&SDDSnew, &SDDSold) || !SDDS_WritePage(&SDDSnew)) { SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors); return(1); } breakNext = 0; newStart = i; } SDDS_FreeStringArray(stringData, rows); break; case SET_ROWLIMIT: for (i=0; i<rows; i+=rowLimit-overlap) { if ((j=i+rowLimit-1)>=rows) j = rows-1; if (!SDDS_SetRowFlags(&SDDSold, 0) || !SDDS_AssertRowFlags(&SDDSold, SDDS_INDEX_LIMITS, i, j, 1) || !SDDS_CopyRowsOfInterest(&SDDSnew, &SDDSold) || !SDDS_WritePage(&SDDSnew)) { SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors); return(1); } if (j==rows-1) break; } break; default: fprintf(stderr, "Error: unknown break mode code seen---this can't happen\n"); return(1); } } if (retval==0) { SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors); return(1); } if (!SDDS_Terminate(&SDDSold)) { SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors); return(1); } if (tmpfile_used && !replaceFileAndBackUp(input, output)) { return(1); } return(0); }
// -------------------------------------------- // get curvature metrics void RegionGrowingSegmentation::getCurvatureMetrics(NormalCloud::Ptr &normalcloud)/*const int& segcount, const double& df, NormalCloud::Ptr &normalcloud, const double& feature_average, const double& N, const double& N_abs)*/ { double sum = 0.0; double dev_sum = 0.0; double npss_sum = 0.0; double yang_sum = 0.0; for (int segindex = 0; segindex < m_mv.segcount; ++segindex) { stringstream filename_normals; filename_normals << "normals/segment_" << segindex << ".pcd"; //std::cout<<"points on segment_"<<num_seg<<std::endl; pcl::PointCloud<pcl::Normal>::Ptr normalcloud_seg(new pcl::PointCloud<pcl::Normal>); if (pcl::io::loadPCDFile<pcl::Normal>(filename_normals.str(), *normalcloud_seg) == -1) { PCL_ERROR("Couldn't read file point cloud file \n"); } else { double mean_f = compute_average(normalcloud_seg->points.size(), normalcloud_seg);// mean feature value for the segment double variance = compute_v(mean_f, normalcloud_seg); double abs_deviation = compute_abs(mean_f, normalcloud_seg->points.size(), normalcloud_seg); //computing double max_v = (m_mv.df * m_mv.df) / 2.0; sum += ((normalcloud_seg->points.size() * variance) / m_mv.N); dev_sum += ((normalcloud_seg->points.size() * abs_deviation) / m_mv.N_abs); /////////////////////////////////////////////////////////////////////////////////// double npss_var; npss_var = normalcloud_seg->points.size() * (m_mv.feature_average - mean_f) * (m_mv.feature_average - mean_f); npss_sum += npss_var; ///////////////////////////////////////////////////////////////////// } } double yang_function = yang_sum; double point_var = compute_v(m_mv.feature_average, normalcloud); //point variance double seg_stddev = sqrt(npss_sum / (normalcloud->points.size() * point_var)); m_metrics.sum = sum; m_metrics.seg_stddev = seg_stddev; m_metrics.NPSS = 1.0 - seg_stddev; m_metrics.IntraRegionUniformity = 1.0 - sum; m_metrics.AverageAbsoluteDeviation = 1.0 - dev_sum; m_metrics.CurvatureHeterogeneity = m_metrics.sum / m_mv.segcount; m_metrics.P = (m_metrics.seg_stddev + 1) / (m_metrics.sum + m_metrics.seg_stddev + 1); cout << "--------------------------------------------" << endl; cout << "Curvature Metrics" << endl; cout << "NPSS = " << m_metrics.NPSS << endl; cout << "Curvature: Intra Region Uniformity = " << m_metrics.IntraRegionUniformity << endl; cout << "Curvature: Average Absolute Deviation = " << m_metrics.AverageAbsoluteDeviation << endl; cout << "Curvature Heterogeneity: " << m_metrics.CurvatureHeterogeneity << endl; cout << "P: " << m_metrics.P << endl; }
/*--------------------------------------------------------------------------- Function: main Purpose : benchmark entry point In : none Out : none Return : status History ---------------------------------------------------------------------------- Date : Author Modification ---------------------------------------------------------------------------- 04/16/2009 Jamel Tayeb Creation. */ int main(void) { //---------------------------------------------------------------------- // timing data //---------------------------------------------------------------------- #ifdef __PL_WINDOWS__ __int64 start_counter = 0; __int64 stop_counter = 0; __int64 average_counter = 0; __int64 base_average_cycles = 0; __int64 pl_write_average_cycles = 0; __int64 pl_read_average_cycles = 0; #endif // __PL_WINDOWS__ #if defined (__PL_LINUX__) || (__PL_SOLARIS__) || (__PL_MACOSX__) unsigned long long start_counter = 0; unsigned long long stop_counter = 0; unsigned long long average_counter = 0; unsigned long long base_average_cycles = 0; unsigned long long pl_write_average_cycles = 0; unsigned long long pl_read_average_cycles = 0; #endif // __PL_LINUX__ || __PL_SOLARIS__ || __PL_MACOSX__ //---------------------------------------------------------------------- // Test PL data //---------------------------------------------------------------------- PL_STATUS ret = PL_FAILURE; int pld = PL_INVALID_DESCRIPTOR; uuid_t uuid; char application_name[] = "benchmark"; const char *counter_names[] = { "test_counter" }; unsigned int counter_count = 1; unsigned long long i = 0; unsigned long long x = 0; int j = 0; //----------------------------------------------------------------------- // open test PL //----------------------------------------------------------------------- fprintf(stdout, "\n"); fprintf(stdout, "************************************************************\n"); fprintf(stdout, "* This micro-benchmark uses RDTSC / _IA64_REG_AR_ITC to *\n"); fprintf(stdout, "* evaluate the processor cycles required to carry-out the *\n"); fprintf(stdout, "* pl_write() and pl_read() Productivity Link API calls *\n"); #ifdef __PL_WINDOWS__ fprintf(stdout, "* (%12I64u write and read operations are performed *\n", (unsigned long long)(MAX_ITERATIONS * MAX_OPERATIONS)); #endif // __PL_WINDOWS__ #if defined (__PL_LINUX__) || (__PL_SOLARIS__) || (__PL_MACOSX__) fprintf(stdout, "* (%12llu write and read operations are performed *\n", (unsigned long long)(MAX_ITERATIONS * MAX_OPERATIONS)); #endif // __PL_LINUX__ || __PL_SOLARIS__ || __PL_MACOSX__ fprintf(stdout, "* in sequence). *\n"); fprintf(stdout, "* *\n"); fprintf(stdout, "* This method is imperfect as it will catch cycles *\n"); fprintf(stdout, "* consumed by interrupt routines. Therefore, consider *\n"); fprintf(stdout, "* numbers as indications, not exact values. *\n"); fprintf(stdout, "* When running the benchmark, stop all other applications. *\n"); fprintf(stdout, "* *\n"); fprintf(stdout, "* When compiling the benchmark, deactivate all compiler *\n"); fprintf(stdout, "* optimizations. Run in single processor configuration. *\n"); fprintf(stdout, "* Deactivate all frequency and voltage adjustment *\n"); fprintf(stdout, "* features before running this micro-benchmark. *\n"); fprintf(stdout, "************************************************************\n"); fprintf(stdout, "\n"); fprintf(stdout, "Opening Test PL:\n"); pld = pl_open(application_name, counter_count, counter_names, &uuid); assert(pld != PL_INVALID_DESCRIPTOR); //-- test zone ---------------------------------------------------------- /* @@@@@ @@ @@@@ @@@@@@ @@@@@ @@@@@@ @@@@ @@@@@ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @@@@@ @ @ @@@@ @@@@@@ @ @@@@@@ @@@@ @ @ @ @@@@@@ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @@@@@ @ @ @@@@@ @@@@@@ @ @@@@@@ @@@@@ @ */ //----------------------------------------------------------------------- // reference loop //----------------------------------------------------------------------- init_average(); fprintf(stdout, "Measuring Base Data : "); for(j = 0; j < MAX_ITERATIONS; j++) { fprintf(stdout, "*"); start_timer(); for(i = 0; i < MAX_OPERATIONS; i++) { ; } stop_timer(); x = i; // consume i in case optimization is activated sum_average(); } print_timer(); fprintf(stdout, "\n"); compute_average(MAX_ITERATIONS * MAX_OPERATIONS); base_average_cycles = average_counter; /* @ @ @@@@@ @@@@@ @@@@@ @@@@@@ @@@@@ @@@@@@ @@@@ @@@@@ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @@@@@ @ @ @@@@@@ @ @@@@@@ @@@@ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @@@@@ @ @@@@@@ @ @@@@@@ @@@@@ @ */ //---------------------------------------------------------------------- // write loop //---------------------------------------------------------------------- init_average(); fprintf(stdout, "Measuring pl_write() Data : "); for(j = 0; j < MAX_ITERATIONS; j++) { fprintf(stdout, "*"); start_timer(); for(i = 0; i < MAX_OPERATIONS; i++) { pl_write(pld, &i, 0); } stop_timer(); sum_average(); } print_timer(); fprintf(stdout, "\n"); compute_average(MAX_ITERATIONS * MAX_OPERATIONS); pl_write_average_cycles = average_counter; /* @@@@@ @@@@@@ @@ @@@@@ @@@@@ @@@@@@ @@@@ @@@@@ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @@@@@ @@@@@@ @ @ @ @ @ @@@@@@ @@@@ @ @ @ @ @@@@@@ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @@@@@@ @ @ @@@@@ @ @@@@@@ @@@@@ @ */ //---------------------------------------------------------------------- // read loop //---------------------------------------------------------------------- init_average(); fprintf(stdout, "Measuring pl_read() Data : "); for(j = 0; j < MAX_ITERATIONS; j++) { fprintf(stdout, "*"); start_timer(); for(i = 0; i < MAX_OPERATIONS; i++) { pl_read(pld, &x, 0); } stop_timer(); sum_average(); } print_timer(); fprintf(stdout, "\n"); compute_average(MAX_ITERATIONS * MAX_OPERATIONS); pl_read_average_cycles = average_counter; //-- end test zone ----------------------------------------------------- //---------------------------------------------------------------------- // close test PL //---------------------------------------------------------------------- fprintf(stdout, "Closing Test PL.\n"); ret = pl_close(pld); assert(ret == PL_SUCCESS); //---------------------------------------------------------------------- // report test results //---------------------------------------------------------------------- fprintf(stdout, "\n"); fprintf(stdout, "Test Report:\n"); fprintf(stdout, "=============\n"); fprintf(stdout, "\n"); #ifdef __PL_WINDOWS__ fprintf(stdout, "Average CPU cycles per pl_write() call : %12I64u.\n", pl_write_average_cycles); fprintf(stdout, "Average CPU cycles per pl_read() call : %12I64u.\n", pl_read_average_cycles); #endif // __PL_WINDOWS__ #if defined (__PL_LINUX__) || (__PL_SOLARIS__) || (__PL_MACOSX__) fprintf(stdout, "Average CPU cycles per pl_write() call : %12llu.\n", pl_write_average_cycles); fprintf(stdout, "Average CPU cycles per pl_read() call : %12llu.\n", pl_read_average_cycles); #endif // __PL_LINUX__ || __PL_SOLARIS__ || __PL_MACOSX__ fprintf(stdout, "\n"); fprintf(stdout, "Notes:\n"); fprintf(stdout, "======\n"); fprintf(stdout, " * A 2.0 GHz processor with two cores processes ~4 billion\n"); fprintf(stdout, "instructions per second (~2 billion per core). Allocation\n"); fprintf(stdout, "of system CPU cycles under the following conditions:\n"); #ifdef __PL_WINDOWS__ fprintf(stdout, "1000 pl_write() calls per second: ~%1.3f%%\n", (double)pl_write_average_cycles / 40000.0); fprintf(stdout, "1000 pl_read() calls per second: ~%1.3f%%\n", (double)pl_read_average_cycles / 40000.0); #endif // __PL_WINDOWS__ #if defined (__PL_LINUX__) || (__PL_SOLARIS__) || (__PL_MACOSX__) fprintf(stdout, "1000 pl_write() calls per second: ~%1.3f%%\n", (double)pl_write_average_cycles / 40000.0); fprintf(stdout, "1000 pl_read() calls per second: ~%1.3f%%\n", (double)pl_read_average_cycles / 40000.0); #endif // __PL_LINUX__ || __PL_SOLARIS__ || __PL_MACOSX__ fprintf(stdout, "\n"); fprintf(stdout, "\n"); fprintf(stdout, " * 1.0 GHz cycle = 1.0 nanosecond = 1.0 x 10-9 second.\n"); fprintf(stdout, " 10 nanoseconds = 1.0 x 10-5 millisecond.\n"); fprintf(stdout, " 100 nanoseconds = 0.0001 millisecond.\n"); fprintf(stdout, " 1,000 nanoseconds = 0.001 millisecond.\n"); fprintf(stdout, " 10,000 nanoseconds = 0.01 millisecond.\n"); fprintf(stdout, " 100,000 nanoseconds = 0.1 millisecond.\n"); fprintf(stdout, " 1,000,000 nanoseconds = 1 millisecond.\n"); fprintf(stdout, "\n"); fprintf(stdout, "************************************************************\n"); fprintf(stdout, "* End of micro-benchmark *\n"); fprintf(stdout, "************************************************************\n"); fprintf(stdout, "\n"); return(PL_SUCCESS); }
int main() { const char *message = "Hristos a in"; unsigned char candidate_hash[16]; unsigned long long t_start, t_end; //show_goodtag(message); memset(candidate_hash, 0, 16); /* * iterate through the first 15 bytes of the hash * and try all possibilities for them */ t_start = PS_getTimeStamp(); int again = 1; for (int i = 0; i < 15; i++) { unsigned long long max_delta = 0; unsigned char current_byte = 0; unsigned long long start_ts, end_ts; for (int j = 0; j < 256; j++) { unsigned long long delta[SAMPLE_NO], avg_delta; candidate_hash[i] = j; for (int k = 0; k < SAMPLE_NO; k++) { start_ts = PS_getTimeStamp(); verify(message, candidate_hash, i); end_ts = PS_getTimeStamp(); delta[k] = end_ts - start_ts; } avg_delta = compute_average(delta); //printf("delta is %llu\n", avg_delta); if (avg_delta > max_delta) { current_byte = j; max_delta = avg_delta; } } // printf("\n"); if (again) { i--; again = 0; } candidate_hash[i] = current_byte; //show_tag(candidate_hash); } /* try all possibilities for last byte */ for (int i = 0; i < 256; i++) { candidate_hash[15] = i; if (verify(message, candidate_hash, 0) == TRUE) { //printf ("Found hash\n"); } } t_end = PS_getTimeStamp(); printf("%llu\n", t_end - t_start); return 0; }