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;
}
