// blockize the file, padding 0 if not divisible by BLOCK_SIZE
int blockize(FILE* fp)
{
unsigned long fileLen;
unsigned int file_blocks;
unsigned int i;
fseek(fp,0,SEEK_END);
fileLen = ftell(fp); // get file length
printf("\nfile size: %lu\n",fileLen);
if(fileLen % BLOCK_SIZE==0) {
// file divisible by block size
file_blocks = fileLen/BLOCK_SIZE;
printf("There are %d blocks\n",file_blocks);
}
else
{
// if not divisible, padding 0 at the end
file_blocks = fileLen/BLOCK_SIZE+1;
int padding = BLOCK_SIZE - fileLen % BLOCK_SIZE;
unsigned char paddingBytes[padding];
for (i=0;i<padding;i++)
paddingBytes[i] = 0;
write1StartTime = getCPUTime();
fwrite(paddingBytes,padding,1,fp);
write1Time += getCPUTime() - write1StartTime;
printf("After padding %d zeros, there are %d blocks\n",padding,file_blocks);
}
return file_blocks;
}
int main(int argc, char *argv[])
{
double startTime, endTime;
startTime = getCPUTime();
Func1();
endTime = getCPUTime();
std::cout << "startTime = " << startTime << " ms" <<std::endl;
std::cout << "endTime = " << endTime << " ms" << std::endl;
return 0;
}
bool TimeoutChecker::didTimeOut(ExecState* exec)
{
unsigned currentTime = getCPUTime();
if (!m_timeAtLastCheck) {
// Suspicious amount of looping in a script -- start timing it
m_timeAtLastCheck = currentTime;
return false;
}
unsigned timeDiff = currentTime - m_timeAtLastCheck;
if (timeDiff == 0)
timeDiff = 1;
m_timeExecuting += timeDiff;
m_timeAtLastCheck = currentTime;
// Adjust the tick threshold so we get the next checkTimeout call in the
// interval specified in intervalBetweenChecks.
m_ticksUntilNextCheck = static_cast<unsigned>((static_cast<float>(m_intervalBetweenChecks) / timeDiff) * m_ticksUntilNextCheck);
// If the new threshold is 0 reset it to the default threshold. This can happen if the timeDiff is higher than the
// preferred script check time interval.
if (m_ticksUntilNextCheck == 0)
m_ticksUntilNextCheck = ticksUntilFirstCheck;
if (m_timeoutInterval && m_timeExecuting > m_timeoutInterval) {
if (exec->dynamicGlobalObject()->shouldInterruptScript())
return true;
reset();
}
return false;
}
void Timer::dump(ostream& s, Size depth) const
{
BALL_DUMP_STREAM_PREFIX(s);
BALL_DUMP_DEPTH(s, depth);
BALL_DUMP_CLASS_HEADER(s, Timer, this);
BALL_DUMP_DEPTH(s, depth);
s << "CPU speed: " << cpu_speed_ << endl;
BALL_DUMP_DEPTH(s, depth);
s << "is running: " << (is_running_ ? "true" : "false") << endl;
BALL_DUMP_DEPTH(s, depth);
s << "last clock seconds: " << last_secs_ << endl;
BALL_DUMP_DEPTH(s, depth);
s << "last user seconds: " << last_usecs_ << endl;
BALL_DUMP_DEPTH(s, depth);
s << "last user time: " << last_user_time_ << endl;
BALL_DUMP_DEPTH(s, depth);
s << "last system time: " << last_system_time_ << endl;
BALL_DUMP_DEPTH(s, depth);
s << "current clock seconds: " << current_secs_ << endl;
BALL_DUMP_DEPTH(s, depth);
s << "current user seconds: " << current_usecs_ << endl;
BALL_DUMP_DEPTH(s, depth);
s << "current user time: " << current_user_time_ << endl;
BALL_DUMP_DEPTH(s, depth);
s << "current system time: " << current_system_time_ << endl;
BALL_DUMP_DEPTH(s, depth);
s << "effective clock time: " << getClockTime() << endl;
BALL_DUMP_DEPTH(s, depth);
s << "effective user time: " << getUserTime() << endl;
BALL_DUMP_DEPTH(s, depth);
s << "effective system time: " << getSystemTime() << endl;
BALL_DUMP_DEPTH(s, depth);
s << "effective CPU time: " << getCPUTime() << endl;
BALL_DUMP_STREAM_SUFFIX(s);
}
tarch::utils::Watch::~Watch() {
if (!_calledStopManually) {
stopTimer();
}
if (_plotResultInDestructor) {
std::ostringstream message;
message << "total number of clock ticks within block (cpu-time,calendar-time): "
<< "(" << getCPUTime() << "s"
<< "," << getCalendarTime() << "s"
<< ")";
_log.info( _operationName, message.str() );
}
}
int precompute_response(FILE* fp, Chal * c,char * key) {
unsigned char message[v*BLOCK_SIZE];
unsigned char codeword[w*BLOCK_SIZE];
char uth[BLOCK_SIZE];
char ct[BLOCK_SIZE];
int i,j,p;
enc_init(key);
// for each of the challenge
for (j=0;j<q;j++) {
int index = 0;
for (i=0;i<v;i++) {
// read in the random indexed blocks
fseek(fp,c[j].s[i]*BLOCK_SIZE,SEEK_SET);
unsigned char buffer[BLOCK_SIZE];
readStartTime = getCPUTime();
clock_gettime(CLOCK_MONOTONIC, &start);
fread(buffer, BLOCK_SIZE, 1, fp);
clock_gettime(CLOCK_MONOTONIC, &finish);
double addTime = finish.tv_sec - start.tv_sec;
addTime += (finish.tv_nsec - start.tv_nsec)/1000000000.0;
readTime += getCPUTime() - readStartTime+addTime;
for(p=0;p<BLOCK_SIZE;p++) {
message[index] = buffer[p];
index++;
}
fflush(stdout);
}
// perform a concatenated encoding
concat_encode(message,codeword);
for (i=0;i<BLOCK_SIZE;i++) {
// get the u-th symbol
uth[i] = codeword[BLOCK_SIZE*c[j].u+i];
}
clock_gettime(CLOCK_MONOTONIC, &start);
encStartTime = getCPUTime();
// encrypt the response and append at the end
encrypt(ct,uth,sizeof(uth));
clock_gettime(CLOCK_MONOTONIC, &finish);
double addTime = finish.tv_sec - start.tv_sec;
addTime += (finish.tv_nsec - start.tv_nsec)/1000000000.0;
encTime += getCPUTime()-encStartTime+addTime;
write2StartTime = getCPUTime();
clock_gettime(CLOCK_MONOTONIC, &start);
fwrite(ct,BLOCK_SIZE,1,fp);
clock_gettime(CLOCK_MONOTONIC, &finish);
addTime = finish.tv_sec - start.tv_sec;
addTime += (finish.tv_nsec - start.tv_nsec)/1000000000.0;
write2Time+=getCPUTime()-write2StartTime+addTime;
}
}
int initial_outer_decoding(FILE* fp1,unsigned char * mac) {
unsigned char newMac[16];
unsigned char buf[BLOCK_SIZE];
int i,j;
FILE * orifp, * parifp;
if ((orifp = fopen("original", "r+b")) == NULL){
printf("couldn't open input file for reading.\n");
return -1;
}
if ((parifp = fopen("parity", "w+b")) == NULL){
printf("couldn't open input file for reading.\n");
return -1;
}
fseek(fp1,m*BLOCK_SIZE,SEEK_SET);
for (i=0;i<t-m;i++) {
readStartTime = getCPUTime();
fread(buf, BLOCK_SIZE, 1, fp1);
readEndTime = getCPUTime();
readTime += readEndTime-readStartTime;
writeStartTime = getCPUTime();
fwrite(buf,BLOCK_SIZE,1,parifp);
writeEndTime = getCPUTime();
writeTime += writeEndTime-writeStartTime;
}
fclose(parifp);
if ((parifp = fopen("parity", "r+b")) == NULL){
printf("couldn't open input file for reading.\n");
return -1;
}
FILE* outer;
if ((outer = fopen("outerdec", "w+b")) == NULL){
printf("couldn't open input file for reading.\n");
return -1;
}
FILE* tempfp = fopen("tempfile", "w+b");
initialize_ecc();
outer_decoding(orifp, parifp, outer, tempfp, NULL);
macStartTime = getCPUTime();
printf("HMAC using key: ");
displayCharArray(k_mac,16);
hmac("outerdec",newMac,k_mac);
macEndTime = getCPUTime();
macTime = macEndTime - macStartTime;
printf("MAC of the file part: ");
displayCharArray(newMac,16);
for (i=0;i<16;i++) {
if (newMac[i]!=mac[i])
return -1;
}
return 0;
}
/**
@brief This function handles a system call request coming from a process running in Kernel Mode.
@return Void.
*/
HIDDEN void syscallKernelMode()
{
/* Identify and handle the system call */
switch (SYSBP_Old->a1)
{
case CREATEPROCESS:
CurrentProcess->p_s.a1 = createProcess((state_t *) SYSBP_Old->a2);
break;
case TERMINATEPROCESS:
terminateProcess();
break;
case VERHOGEN:
verhogen((int *) SYSBP_Old->a2);
break;
case PASSEREN:
passeren((int *) SYSBP_Old->a2);
break;
case GETCPUTIME:
CurrentProcess->p_s.a1 = getCPUTime();
break;
case WAITCLOCK:
waitClock();
break;
case WAITIO:
CurrentProcess->p_s.a1 = waitIO((int) SYSBP_Old->a2, (int) SYSBP_Old->a3, (int) SYSBP_Old->a4);
break;
case SPECTRAPVEC:
specTrapVec((int) SYSBP_Old->a2, (state_t *) SYSBP_Old->a3, (state_t *) SYSBP_Old->a4);
break;
default:
/* Distinguish whether SYS5 has been invoked or not */
checkSYS5(SYSBK_EXCEPTION, SYSBP_Old);
}
/* Call the scheduler */
scheduler();
}
/**
* @retval time Time in milliseconds
*/
double stopTimer( MTime* mtime )
{
double time = -1.0;
float milliseconds = 0;
switch(mtime->type)
{
case CPU_CLOCK_TIME:
time = (mtime->time=1000.0*(getCPUTime( ) - mtime->start));
break;
case CPU_WALL_TIME:
time = (mtime->time=1000.0*(getRealTime() - mtime->start));
break;
case GPU_TIME:
CHECK_ERROR(cudaEventRecord(mtime->gpustop));
CHECK_ERROR(cudaEventSynchronize(mtime->gpustop));
CHECK_ERROR(cudaEventElapsedTime(&milliseconds, mtime->gpustart, mtime->gpustop));
time = static_cast<double>(milliseconds);
break;
default:
throw std::invalid_argument("Unhandled TIME TYPE.");
}
return time;
}
int checkFile(FILE* fp1,unsigned char * mac) {
unsigned char newMac[16];
unsigned char buf[BLOCK_SIZE];
int i,j;
FILE * orifp;
fseek(fp1,0,SEEK_SET);
if ((orifp = fopen("original", "w+b")) == NULL){
printf("couldn't open input file for reading.\n");
return -1;
}
for (i=0;i<m;i++) {
readStartTime = getCPUTime();
fread(buf, BLOCK_SIZE, 1, fp1);
readEndTime = getCPUTime();
readTime += readEndTime-readStartTime;
writeStartTime = getCPUTime();
fwrite(buf,BLOCK_SIZE,1,orifp);
writeEndTime = getCPUTime();
writeTime += writeEndTime-writeStartTime;
}
fclose(orifp);
macStartTime = getCPUTime();
printf("HMAC using key: ");
displayCharArray(k_mac,16);
hmac("original",newMac,k_mac);
macEndTime = getCPUTime();
macTime = macEndTime - macStartTime;
printf("MAC of the file part: ");
displayCharArray(newMac,16);
for (i=0;i<16;i++) {
if (newMac[i]!=mac[i])
return -1;
}
return 0;
}
void checkInCPUTime( void )
{
startCPUTime = getCPUTime();
}
int main(int argc, char *argv[])
{
FILE *stream = NULL;
int i, j, r, count;
bool flag;
Matrix matrix = NULL;
Vector rhs = NULL;
VectorArray Lattice = NULL;
Vector vector = NULL;
LinearSystem initialsystem;
ZSolveContext ctx;
char *token;
int memory;
getopts(argc, argv);
puts(FORTY_TWO_BANNER);
if (OResume)
{
// START OF RESUME SECTION - READ FILES AND CREATE CONTEXT
strcat(BaseName, ".backup");
stream = fopen(BaseName, "r");
BaseName[BaseLength] = '\0';
if (stream==NULL)
{
printf("Unable to open backup file %s.backup\n", BaseName);
free(BaseName);
exit(1);
}
// options
if (fscanf(stream, "%d %d %d", &OVerbose, &OLogging, &OBackup)!=3 || OVerbose<0 || OVerbose>3 || OLogging<0 || OLogging>3 || OBackup<0)
{
fclose(stream);
printf("Backup file %s.backup does not contain valid data.\n", BaseName);
free(BaseName);
exit(2);
}
// get context
ctx = createZSolveContextFromBackup(stream, zsolveLogCallbackDefault, backupEvent);
fclose(stream);
// logfile
if (OLogging>0)
{
strcat(BaseName, ".log");
stream = fopen(BaseName, "a");
BaseName[BaseLength] = '\0';
if (stream==NULL)
{
printf("Unable to open log file %s.log\n", BaseName);
free(BaseName);
exit(1);
}
ctx->LogFile = LogFile = stream;
}
// END OF RESUME SECTION
}
else
{
// logfile
if (OLogging>0)
{
strcat(BaseName, ".log");
stream = fopen(BaseName, "w");
BaseName[BaseLength] = '\0';
if (stream==NULL)
{
printf("Unable to open log file %s.log\n", BaseName);
free(BaseName);
exit(1);
}
LogFile = stream;
}
// check for existance of solution files
if (!OForce)
{
strcat(BaseName, ".zhom");
stream = fopen(BaseName, "r");
BaseName[BaseLength] = '\0';
if (stream!=NULL)
{
fclose(stream);
if (OVerbose>0)
printf("%s.hom already exists! Use -f to force calculation.\n", BaseName);
if (OLogging>0)
{
fprintf(LogFile, "%s.hom already exists! Use -f to force calculation.\n", BaseName);
fclose(LogFile);
}
free(BaseName);
exit(1);
}
strcat(BaseName, ".zinhom");
stream = fopen(BaseName, "r");
BaseName[BaseLength] = '\0';
if (stream!=NULL)
{
fclose(stream);
if (OVerbose>0)
printf("%s.inhom already exists! Use -f to force calculation.\n", BaseName);
if (LogFile)
{
fprintf(LogFile, "%s.inhom already exists! Use -f to force calculation.\n", BaseName);
fclose(LogFile);
}
free(BaseName);
exit(1);
}
}
// matrix
strcat(BaseName, ".mat");
stream = fopen(BaseName, "r");
BaseName[BaseLength] = '\0';
if (stream == NULL)
{
stream = fopen(BaseName, "r");
if (stream) {
if (OVerbose>0)
printf("Matrix file %s.mat not found, falling back to project file %s.\n\n", BaseName, BaseName);
if (OLogging>0)
{
fprintf(LogFile, "Matrix file %s.mat not found, falling back to project file %s.\n\n", BaseName, BaseName);
fclose(LogFile);
}
}
}
if (stream==NULL)
{
strcat(BaseName, ".lat");
stream = fopen(BaseName, "r");
BaseName[BaseLength] = '\0';
if (stream==NULL)
{
// lattice
if (OVerbose>0)
printf("Neither matrix file %s.mat nor lattice file %s.lat exists!\n", BaseName, BaseName);
if (OLogging>0)
{
fprintf(LogFile, "Neither matrix file %s.mat nor lattice file %s.lat exists!\n", BaseName, BaseName);
fclose(LogFile);
}
free(BaseName);
exit(1);
}
else
{
// START OF LATTICE SECTION - READ FILES AND CREATE CONTEXT
Lattice = readVectorArray(stream, false);
fclose(stream);
if (Lattice == NULL)
{
if (OVerbose>0)
printf("Lattice file %s.lat does not contain valid data.\n", BaseName);
if (OLogging>0)
{
fprintf(LogFile, "Lattice file %s.lat does not contain valid data.\n", BaseName);
fclose(LogFile);
}
free(BaseName);
exit(1);
}
// rhs
if (ORightHandSide)
{
strcat(BaseName, ".rhs");
stream = fopen(BaseName, "r");
BaseName[BaseLength] = '\0';
if (stream!=NULL)
{
fscanf(stream, "%d", &i);
if (i!=1)
{
fclose(stream);
printf("Height of RHS must be 1!\n");
if (LogFile)
{
fprintf(LogFile, "Height of RHS must be 1!\n");
fclose(LogFile);
}
deleteMatrix(matrix);
free(BaseName);
exit(1);
}
fscanf(stream, "%d", &i);
while (i--)
{
if (fscanf(stream, "%d", &j) || j!=0)
{
printf("When reading from %s.lat, RHS file %s.rhs must contain a zero vector.\n", BaseName, BaseName);
if (LogFile)
{
fprintf(LogFile, "When reading from %s.lat, RHS file %s.rhs must contain a zero vector.\n", BaseName, BaseName);
fclose(LogFile);
}
deleteMatrix(matrix);
free(BaseName);
exit(1);
}
}
}
}
// variable properties
for (i=0; i<Lattice->Variables; i++)
{
Lattice->Properties[i].Column = i;
Lattice->Properties[i].Lower = OHilbert ? 0 : -MAXINT;
Lattice->Properties[i].Upper = MAXINT;
Lattice->Properties[i].Free = (!OGraver && !OHilbert);
}
// read .rel
strcat(BaseName, ".rel");
stream = fopen(BaseName, "r");
BaseName[BaseLength] = '\0';
if (stream!=NULL)
{
token = NULL;
memory = 0;
flag = false;
if (fscanf(stream, "%d %d", &r, &j)<2 || r != 1)
{
printf("RELATION file %s.rel must start with the dimensions.\n", BaseName);
flag = true;
}
for (i=0; i<j; i++)
{
if (readTokenFromFile(stream, "0123456789=<>", &token, &memory) == 0)
{
printf("RELATION file %s.rel ends unexpectedly.\n", BaseName);
flag = true;
}
else if (!strcmp(token, "<") || !strcmp(token, ">"))
{
printf("When reading from %s.lat, inequalities are not allowed.\n", BaseName);
flag = true;
}
else if (strcmp(token, "="))
{
printf("Unknown token '%s' in RELATION file %s.rel.\n", token, BaseName);
flag = true;
}
}
free(token);
fclose(stream);
if (flag)
{
free(BaseName);
exit(1);
}
}
// read .sign
strcat(BaseName, ".sign");
stream = fopen(BaseName, "r");
BaseName[BaseLength] = '\0';
if (stream!=NULL)
{
token = NULL;
memory = 0;
flag = false;
if (fscanf(stream, "%d %d", &r, &i)<2 || i != Lattice->Variables || r != 1)
{
printf("SIGN file %s.sign must start with '1 %d'.\n", BaseName, Lattice->Variables);
flag = true;
}
for (i=0; i<Lattice->Variables; i++)
{
if (readTokenFromFile(stream, "0123456789-abcdefghijklmnopqrstuvwxyz", &token, &memory) == 0)
{
printf("SIGN file %s.sign ends unexpectedly.\n", BaseName);
flag = true;
}
if (!strcmp(token, "0") || !strcmp(token, "free") || !strcmp(token, "f"))
{
Lattice->Properties[i].Upper = MAXINT;
Lattice->Properties[i].Lower = -MAXINT;
Lattice->Properties[i].Free = true;
}
else if (!strcmp(token, "1") || !strcmp(token, "hil") || !strcmp(token, "h"))
{
Lattice->Properties[i].Upper = MAXINT;
Lattice->Properties[i].Lower = 0;
Lattice->Properties[i].Free = false;
}
else if (!strcmp(token, "-1") || !strcmp(token, "-hil") || !strcmp(token, "-h"))
{
Lattice->Properties[i].Upper = 0;
Lattice->Properties[i].Lower = -MAXINT;
Lattice->Properties[i].Free = false;
}
else if (!strcmp(token, "2") || !strcmp(token, "graver") || !strcmp(token, "g"))
{
if (OHilbert)
{
printf("Input Error: Graver components for `hilbert' executable.\nInput Error: Use the `graver' executable instead.\n");
flag = true;
}
else
{
Lattice->Properties[i].Upper = MAXINT;
Lattice->Properties[i].Lower = -MAXINT;
Lattice->Properties[i].Free = false;
}
}
else
{
printf("Unknown token '%s' in SIGN file %s.sign.\n", token, BaseName);
flag = true;
}
}
free(token);
fclose(stream);
if (flag)
{
deleteVectorArray(Lattice);
free(BaseName);
exit(1);
}
}
// read .ub
strcat(BaseName, ".ub");
stream = fopen(BaseName, "r");
BaseName[BaseLength] = '\0';
if (stream!=NULL)
{
token = NULL;
memory = 0;
flag = false;
if (fscanf(stream, "%d %d", &r, &i)<2 || i != Lattice->Variables || r != 1)
{
printf("UPPER BOUNDS file %s.ub must start with '1 %d'.\n", BaseName, Lattice->Variables);
flag = true;
}
for (i=0; i<Lattice->Variables; i++)
{
if (readTokenFromFile(stream, "0123456789*-", &token, &memory) == 0)
{
printf("UPPER BOUNDS file %s.ub ends unexpectedly.\n", BaseName);
flag = true;
}
if (!strcmp(token, "*"))
Lattice->Properties[i].Upper = MAXINT;
else if (sscanf(token, "%d", &j) == 1)
{
if (Lattice->Properties[i].Free)
{
printf("Upper bound '%s' cannot be set for free variables.\n", token);
flag = true;
}
else if (j>=0)
Lattice->Properties[i].Upper = j;
else
{
printf("Negative upper bound '%s' in UPPER BOUNDS file %s.ub.\n", token, BaseName);
flag = true;
}
}
else
{
printf("Unknown token '%s' in UPPER BOUNDS file %s.ub.\n", token, BaseName);
flag = true;
}
}
free(token);
fclose(stream);
if (flag)
{
deleteVectorArray(Lattice);
free(BaseName);
exit(1);
}
}
// read .lb
strcat(BaseName, ".lb");
stream = fopen(BaseName, "r");
BaseName[BaseLength] = '\0';
if (stream!=NULL)
{
token = NULL;
memory = 0;
flag = false;
if (fscanf(stream, "%d %d", &r, &i)<2 || i != Lattice->Variables || r != 1)
{
printf("LOWER BOUNDS file %s.lb must start with '1 %d'.\n", BaseName, Lattice->Variables);
flag = true;
}
for (i=0; i<Lattice->Variables; i++)
{
if (readTokenFromFile(stream, "0123456789*-", &token, &memory) == 0)
{
printf("LOWER BOUNDS file %s.lb ends unexpectedly.\n", BaseName);
flag = true;
}
if (!strcmp(token, "*"))
Lattice->Properties[i].Lower = -MAXINT;
else if (sscanf(token, "%d", &j) == 1)
{
if (Lattice->Properties[i].Free)
{
printf("Lower bound '%s' cannot be set for free variables.\n", token);
flag = true;
}
else if (j<=0)
Lattice->Properties[i].Lower = j;
else
{
printf("Positive lower bound '%s' in LOWER BOUNDS file %s.lb.\n", token, BaseName);
flag = true;
}
}
else
{
printf("Unknown token '%s' in LOWER BOUNDS file %s.lb.\n", token, BaseName);
flag = true;
}
}
free(token);
fclose(stream);
if (flag)
{
deleteVectorArray(Lattice);
free(BaseName);
exit(1);
}
}
ctx = createZSolveContextFromLattice(Lattice, LogFile, OLogging, OVerbose, zsolveLogCallbackDefault, backupEvent);
// print lattice
if (ctx->Verbosity>0)
{
printf("\nLattice to use:\n\n");
printVectorArray(ctx->Lattice, false);
printf("\n\n");
}
if (ctx->LogLevel>0)
{
fprintf(ctx->LogFile, "\nLattice to use:\n\n");
fprintVectorArray(ctx->LogFile, ctx->Lattice, false);
fprintf(ctx->LogFile, "\n\n");
}
// END OF LATTICE SECTION
}
}
else
{
// START OF SYSTEM SECTION - READ FILES AND CREATE CONTEXT
matrix = readMatrix(stream);
fclose(stream);
if (matrix==NULL)
{
printf("Matrix file %s does not contain valid data.\n", BaseName);
if (LogFile)
{
fprintf(LogFile, "Matrix file %s does not contain valid data.\n", BaseName);
fclose(LogFile);
}
free(BaseName);
exit(1);
}
// rhs
if (ORightHandSide)
{
strcat(BaseName, ".rhs");
stream = fopen(BaseName, "r");
BaseName[BaseLength] = '\0';
if (stream!=NULL)
{
if (OGraver || OHilbert)
{
fclose(stream);
printf("Input Error: No rhs file is allowed with --graver and --hilbert!\n");
printf("Input Error: Please delete %s.rhs and rerun zsolve\n", BaseName);
if (LogFile)
{
fprintf(LogFile, "Input Error: No rhs file is allowed with --graver and --hilbert!\n");
fprintf(LogFile, "Input Error: Please delete %s.rhs and rerun zsolve\n", BaseName);
fclose(LogFile);
}
deleteMatrix(matrix);
free(BaseName);
exit(1);
}
fscanf(stream, "%d", &i);
if (i!=1)
{
fclose(stream);
printf("Height of RHS must be 1!\n");
if (LogFile)
{
fprintf(LogFile, "Height of RHS must be 1!\n");
fclose(LogFile);
}
deleteMatrix(matrix);
free(BaseName);
exit(1);
}
fscanf(stream, "%d", &i);
if (i!=matrix->Height)
{
fclose(stream);
printf("Matrix height conflicts with width of rhs!\n");
if (LogFile)
{
fprintf(LogFile, "Matrix height conflicts with width of rhs!\n");
fclose(LogFile);
}
deleteMatrix(matrix);
free(BaseName);
exit(1);
}
rhs = readVector(stream, matrix->Height);
fclose(stream);
if (rhs==NULL)
{
printf("RHS file %s.rhs does not contain valid data.\n", BaseName);
if (LogFile)
{
fprintf(LogFile, "RHS file %s.rhs does not contain valid data.\n", BaseName);
fclose(LogFile);
}
deleteMatrix(matrix);
free(BaseName);
exit(1);
}
}
}
// fill with zeros
if (rhs==NULL)
{
rhs = createVector(matrix->Height);
for (i=0; i<matrix->Height; i++)
rhs[i] = 0;
}
// create system
initialsystem = createLinearSystem();
setLinearSystemMatrix(initialsystem, matrix);
deleteMatrix(matrix);
setLinearSystemRHS(initialsystem, rhs);
deleteVector(rhs);
// default limits
if (OGraver)
setLinearSystemLimit(initialsystem, -1, -MAXINT, MAXINT, false);
else if (OHilbert)
setLinearSystemLimit(initialsystem, -1, 0, MAXINT, false);
else
setLinearSystemLimit(initialsystem, -1, -MAXINT, MAXINT, true);
// default equation type
setLinearSystemEquationType(initialsystem, -1, EQUATION_EQUAL, 0);
// read .rel
strcat(BaseName, ".rel");
stream = fopen(BaseName, "r");
BaseName[BaseLength] = '\0';
if (stream!=NULL)
{
token = NULL;
memory = 0;
flag = false;
if (fscanf(stream, "%d %d", &r, &i)<2 || i != initialsystem->Equations || r != 1)
{
printf("RELATION file %s.rel must start with '1 %d'.\n", BaseName, initialsystem->Equations);
flag = true;
}
for (i=0; i<initialsystem->Equations; i++)
{
if (readTokenFromFile(stream, "0123456789=<>", &token, &memory) == 0)
{
printf("RELATION file %s.rel ends unexpectedly.\n", BaseName);
flag = true;
}
if (!strcmp(token, "="))
setLinearSystemEquationType(initialsystem, i, EQUATION_EQUAL, 0);
// BUG: Not a real bug, but maybe misdefinition?? <= is not so hard to type :-)
else if (!strcmp(token, "<"))
setLinearSystemEquationType(initialsystem, i, EQUATION_LESSEREQUAL, 0);
else if (!strcmp(token, ">"))
setLinearSystemEquationType(initialsystem, i, EQUATION_GREATEREQUAL, 0);
else
{
printf("Unknown token '%s' in RELATION file %s.rel.\n", token, BaseName);
flag = true;
}
}
free(token);
fclose(stream);
if (flag)
{
deleteLinearSystem(initialsystem);
free(BaseName);
exit(1);
}
}
// read .sign
strcat(BaseName, ".sign");
stream = fopen(BaseName, "r");
BaseName[BaseLength] = '\0';
if (stream!=NULL)
{
token = NULL;
memory = 0;
flag = false;
if (fscanf(stream, "%d %d", &r, &i)<2 || i != initialsystem->Variables || r != 1)
{
printf("SIGN file %s.sign must start with '1 %d'.\n", BaseName, initialsystem->Variables);
flag = true;
}
for (i=0; i<initialsystem->Variables; i++)
{
if (readTokenFromFile(stream, "0123456789-abcdefghijklmnopqrstuvwxyz", &token, &memory) == 0)
{
printf("SIGN file %s.sign ends unexpectedly.\n", BaseName);
flag = true;
}
if (!strcmp(token, "0") || !strcmp(token, "free") || !strcmp(token, "f"))
setLinearSystemLimit(initialsystem, i, -MAXINT, MAXINT, true);
else if (!strcmp(token, "1") || !strcmp(token, "hil") || !strcmp(token, "h"))
setLinearSystemLimit(initialsystem, i, 0, MAXINT, false);
else if (!strcmp(token, "-1") || !strcmp(token, "-hil") || !strcmp(token, "-h"))
setLinearSystemLimit(initialsystem, i, -MAXINT, 0, false);
else if (!strcmp(token, "2") || !strcmp(token, "graver") || !strcmp(token, "g"))
{
if (OHilbert)
{
if (!flag)
printf("Input Error: Graver components for `hilbert' executable.\nInput Error: Use the `graver' executable instead.\n");
flag = true;
}
else
setLinearSystemLimit(initialsystem, i, -MAXINT, MAXINT, false);
}
else
{
printf("Unknown token '%s' in SIGN file %s.sign.\n", token, BaseName);
flag = true;
}
}
free(token);
fclose(stream);
if (flag)
{
deleteLinearSystem(initialsystem);
free(BaseName);
exit(1);
}
}
// read .ub
strcat(BaseName, ".ub");
stream = fopen(BaseName, "r");
BaseName[BaseLength] = '\0';
if (stream!=NULL)
{
token = NULL;
memory = 0;
flag = false;
if (fscanf(stream, "%d %d", &r, &i)<2 || i != initialsystem->Variables || r != 1)
{
printf("UPPER BOUNDS file %s.ub must start with '1 %d'.\n", BaseName, initialsystem->Variables);
flag = true;
}
for (i=0; i<initialsystem->Variables; i++)
{
if (readTokenFromFile(stream, "0123456789*-", &token, &memory) == 0)
{
printf("UPPER BOUNDS file %s.ub ends unexpectedly.\n", BaseName);
flag = true;
}
if (!strcmp(token, "*"))
setLinearSystemBound(initialsystem, i, 'u', MAXINT);
else if (sscanf(token, "%d", &j) == 1)
{
if (initialsystem->VarProperties[i].Free)
{
printf("Upper bound '%s' cannot be set for free variables.\n", token);
flag = true;
}
else if (j>=0)
setLinearSystemBound(initialsystem, i, 'u', j);
else
{
printf("Negative upper bound '%s' in UPPER BOUNDS file %s.ub.\n", token, BaseName);
flag = true;
}
}
else
{
printf("Unknown token '%s' in UPPER BOUNDS file %s.ub.\n", token, BaseName);
flag = true;
}
}
free(token);
fclose(stream);
if (flag)
{
deleteLinearSystem(initialsystem);
free(BaseName);
exit(1);
}
}
// read .lb
strcat(BaseName, ".lb");
stream = fopen(BaseName, "r");
BaseName[BaseLength] = '\0';
if (stream!=NULL)
{
token = NULL;
memory = 0;
flag = false;
if (fscanf(stream, "%d %d", &r, &i)<2 || i != initialsystem->Variables || r != 1)
{
printf("LOWER BOUNDS file %s.lb must start with '1 %d'.\n", BaseName, initialsystem->Variables);
flag = true;
}
for (i=0; i<initialsystem->Variables; i++)
{
if (readTokenFromFile(stream, "0123456789*-", &token, &memory) == 0)
{
printf("LOWER BOUNDS file %s.lb ends unexpectedly.\n", BaseName);
flag = true;
}
if (!strcmp(token, "*"))
setLinearSystemBound(initialsystem, i, 'l', -MAXINT);
else if (sscanf(token, "%d", &j) == 1)
{
if (initialsystem->VarProperties[i].Free)
{
printf("Lower bound '%s' cannot be set for free variables.\n", token);
flag = true;
}
else if (j<=0)
setLinearSystemBound(initialsystem, i, 'l', j);
else
{
printf("Positive lower bound '%s' in LOWER BOUNDS file %s.lb.\n", token, BaseName);
flag = true;
}
}
else
{
printf("Unknown token '%s' in LOWER BOUNDS file %s.lb.\n", token, BaseName);
flag = true;
}
}
free(token);
fclose(stream);
if (flag)
{
deleteLinearSystem(initialsystem);
free(BaseName);
exit(1);
}
}
ctx = createZSolveContextFromSystem(initialsystem, LogFile, OLogging, OVerbose, zsolveLogCallbackDefault, backupEvent);
// END OF SYSTEM SECTION
}
}
// DEBUG
// printVectorArray(ctx->Lattice, true);
zsolveSystem(ctx, !OResume);
if (OGraver)
{
printf("Writing %d vectors to graver file, with respect to symmetry.\n", ctx->Graver->Size);
if (LogFile)
fprintf(LogFile, "Writing %d vectors to graver file, with respect to symmetry.\n", ctx->Graver->Size);
strcat(BaseName, ".gra");
stream = fopen(BaseName, "w");
BaseName[BaseLength] = '\0';
if (stream)
{
fprintf(stream, "%d %d\n\n", ctx->Graver->Size, ctx->Graver->Variables);
fprintVectorArray(stream, ctx->Graver, false);
fclose(stream);
}
}
else if (OHilbert)
{
strcat(BaseName, ".hil");
stream = fopen(BaseName, "w");
BaseName[BaseLength] = '\0';
if (stream)
{
fprintf(stream, "%d %d\n\n", ctx->Homs->Size + ctx->Frees->Size, ctx->Homs->Variables);
fprintVectorArray(stream, ctx->Homs, false);
fprintf(stream, "\n");
fprintVectorArray(stream, ctx->Frees, false);
fclose(stream);
}
}
else
{
strcat(BaseName, ".zinhom");
stream = fopen(BaseName, "w");
BaseName[BaseLength] = '\0';
if (stream)
{
fprintf(stream, "%d %d\n\n", ctx->Inhoms->Size, ctx->Inhoms->Variables);
fprintVectorArray(stream, ctx->Inhoms, false);
fclose(stream);
}
strcat(BaseName, ".zhom");
stream = fopen(BaseName, "w");
BaseName[BaseLength] = '\0';
if (stream)
{
fprintf(stream, "%d %d\n\n", ctx->Homs->Size, ctx->Homs->Variables);
fprintVectorArray(stream, ctx->Homs, false);
fclose(stream);
}
if (ctx->Frees->Size>0)
{
strcat(BaseName, ".zfree");
stream = fopen(BaseName, "w");
BaseName[BaseLength] = '\0';
if (stream)
{
fprintf(stream, "%d %d\n\n", ctx->Frees->Size, ctx->Frees->Variables);
fprintVectorArray(stream, ctx->Frees, false);
fclose(stream);
}
}
}
printf("\n4ti2 Total Time: ");
printCPUTime(maxd(getCPUTime() - ctx->AllTime, 0.0));
printf("\n");
if (LogFile) {
fprintf(LogFile, "\n4ti2 Total Time: ");
fprintCPUTime(LogFile, maxd(getCPUTime() - ctx->AllTime, 0.0));
fprintf(LogFile, "\n");
}
deleteZSolveContext(ctx, true);
if (BaseName!=NULL)
free(BaseName);
if (LogFile)
fclose(LogFile);
return EXIT_SUCCESS;
}
int main(int argc,char** argv)
{
totalStartTime = getCPUTime();
//endTime = getCPUTime();
printf("start POR extract...\n");
char * filename = argv[1];
FILE *fp1,*fp2,*temp_fp;
//open encoded file for reading
if ((fp1 = fopen(argv[1], "r")) == NULL){
printf("couldn't open input file for reading.\n");
return -1;
}
int p;
//t = atoi(argv[3]);
unsigned long fileLen;
fseek(fp1,0,SEEK_END);
fileLen = ftell(fp1);
t = (fileLen-16-oldq*BLOCK_SIZE) / BLOCK_SIZE;
m = t*k/n;
printf("extract for file \"%s\" with size=%lu m=%lu and t=%lu\n",filename,fileLen,m,t);
//use master key and call keygen to generate all the keys here.
master_keygen(argv[2]);
//read mac from the end of the old file
unsigned char originalmac[16];
int bufLength=16;
readStartTime = getCPUTime();
fseek(fp1, fileLen-bufLength, SEEK_SET);
fread(originalmac, sizeof(originalmac), 1, fp1);
readEndTime = getCPUTime();
readTime += readEndTime-readStartTime;
printf("\nMAC attached at the end of the file: ");
displayCharArray(originalmac,16);
if (checkFile(fp1,originalmac)==0) {
printf("File is intact.\n");
fclose(fp1);
totalEndTime = getCPUTime();
totalTime = totalEndTime - totalStartTime;
printf("#RESULT#\n");
printf("%lf\n",totalTime);
printf("%lf\n",readTime);
printf("%lf\n",prpTime);
printf("%lf\n",eccTime);
printf("%lf\n",macTime);
printf("%lf\n",chalTime);
printf("%lf\n",writeTime);
exit(0);
}
else if (initial_outer_decoding(fp1,originalmac)==0){
//initial_outer_decoding(fp1, newfp);
//if (checkFile(newfp,originalmac)==0) {
printf("File is recovered after outer encoding.\n");
fclose(fp1);
totalEndTime = getCPUTime();
totalTime = totalEndTime - totalStartTime;
printf("#RESULT#\n");
printf("%lf\n",totalTime);
printf("%lf\n",readTime);
printf("%lf\n",prpTime);
printf("%lf\n",eccTime);
printf("%lf\n",macTime);
printf("%lf\n",chalTime);
printf("%lf\n",writeTime);
exit(0);
//}
}
//else {
//printf("File is corrupted.\n");
//exit(0);
//}
int tempv = v;
q = alpha * t / tempv;
decoded_blocks * db;
unsigned int i,j,u,size,index;
char * codeword,mac;
chal c[q];
unsigned char k_j_c[16];
char str[999];
char * temp_block;
// after writing new file, delete old file
char * r_file="recovered";
char * temp ="temp";
unsigned int * v_chal_indices;
//open output file for writing
if ((fp2 = fopen(r_file, "w+")) == NULL){
printf("couldn't open output file for writing.\n");
return -1;
}
//open temp file for writing
if ((temp_fp = fopen(temp, "w+")) == NULL){
printf("couldn't open temperory file for writing.\n");
return -1;
}
//allocate memory for d1
db = malloc (sizeof(struct d_b)*t);
//for(i=0;i<t;i++) {
// printf("for db[%d], sizeof frequency=%lu\n",i,sizeof(db[i].frequency));
// printf("display frequency[5] %d\n",db[i].frequency[5]);
//}
if(db == NULL) {
printf("failed to allocate memory for d.\n");
return -1;
}
//total number of challenges
size = alpha*(t/v);
//allocate memory for the challenge set
//if ((c = (chal *)malloc(sizeof(chal)*size))== NULL) {
// fprintf(stderr, "failed to allocate memory for challenges.\n");
// return -1;
//}
// populate challenge set
printf("\nstart inner layer decoding...\n");
printf("generate %lu challenges\n",q);
keygen_init();
seeding(k_chal);
for (j=0;j<q;j++){
keygen(c[j].k_j_c, 16);
c[j].j = j;
}
printf("kjc for each challenge generated\n");
// for each challenge
for (i=0;i<q;i++){
//unsigned char * codeword = (unsigned char *) malloc(sizeof(unsigned char)*32*w);
unsigned char codeword[32*w];
unsigned long indices[v];
index = 0;
//execute each challenge w times
for(u=0;u<w;u++){
unsigned char * subcode = execute_challenge(fp1,c[i].j, c[i].k_j_c, u, indices);
//printf("%d-th sub code\n",u);
//displayCharArray(subcode,32);
int tempI;
for(tempI=0;tempI<32;tempI++)
codeword[index++] = subcode[tempI];
}
//printf("codeword for challenge #%d\n",i);
//displayCharArray(codeword,4096);
// inner code decoding
printf("start decoding for challenge #%d\n",i);
inner_GMD(db,codeword,indices,fp1);
printf("finish decoding for challenge %d\n",i);
//free the memory
//free(codeword);
//free(indices);
//delete old file
//remove(filename);
}
for (i=0;i<t;i++){
int max_frequency=0;
int max_index=0;
for(j=0;j<sizeof(db[i].frequency);j++){
if(db[i].frequency[j] > max_frequency){
max_frequency = db[i].frequency[j];
max_index = j;
}
}
if(max_frequency==0) {
fseek(fp1,i*32,SEEK_SET);
unsigned char buffer[32];
fread(buffer, 32, 1, fp1);
fwrite(buffer,32,1,temp_fp);
}
else {
//check if the location can be corrected or has erasure
if(ceil(max_frequency / sizeof(db[i].frequency)) > (delta+0.5)){
fwrite(db[i].file_blocks[max_index],32,1,temp_fp);
}else{
fwrite(db[i].file_blocks[max_index],32,1,temp_fp);
//where to get the index from
//db[i].file_blocks[0]=NULL;
//-1 indicating erasure
db[i].frequency[0]=-1;
}
}
}
fclose(fp1);
fclose(temp_fp);
//perform outer decoding
//outer_decoding(temp_fp,fp2,db);
//compute mac
unsigned char newmac[16];
//hmac("temp",newmac,k_mac);
//printf("display MAC\n");
//displayCharArray(newmac,16);
//if verified, print the file. Else output the error
int flag=1;
for(i=0;i<MACSIZE;i++){
if(newmac[i]!=originalmac[i]){
flag=0;
break;
}
}
if (flag==1){
printf("Your file is recovered\n");
//while (fscanf(fp2, "%s", str)!=EOF){
// printf("%s",str);
//}
}else{
printf("Your file can not be recovered.\n");
//return -1;
}
fclose(fp2);
printf("#RESULT#\n");
printf("%lf\n",totalTime);
printf("%lf\n",readTime);
printf("%lf\n",prpTime);
printf("%lf\n",eccTime);
printf("%lf\n",macTime);
printf("%lf\n",chalTime);
printf("%lf\n",writeTime);
return 0;
}
int main(int argc, char *argv[])
{
//second argument is the file name to be permuted
//atoi converted string to integer, we get the file size directly.
if (argv[1])
blocks = atoi(argv[1]);
else {
printf("passing block number as parameter\n");
exit(0);
}
//printf("file size: %dG\n",filesize);
//calculate blocklength 30 - 5 = 25 ( 2^30 stands for 1 gb, 2^5 for 32 bytes)
//int temp = log2(GB) - log2(BLOCK_LENGTH);
//blocks = filesize * (1<<temp);
printf("block num: %d\n",blocks);
fflush(stdout);
//find the bit length of the each element of array to get number of blocks
index_bit_length = log2(blocks);
int bit = ceil(index_bit_length);
printf("bit num: %d\n",bit);
//declare for block indices table, and permuted indices table
int * blockindices;
int * prpblockindices;
//allocate memory for input and output table
blockindices = (int *)malloc(blocks*sizeof(int));
prpblockindices = (int *)malloc(blocks*sizeof(int));
//initialize block array to the block indices
int j=0;
int i;
for (i=0;i<blocks;i++) {
blockindices[i] = i;
}
//hardcoding 6 seeds
unsigned char * seed1 = "jiedai";
unsigned char * seed2 = "ruchashintre";
unsigned char * seed3 = "poojadesai";
unsigned char * seed4 = "CMUMSE";
unsigned char * seed5 = "BOSCH";
unsigned char * seed6 = "jorge";
double startTime, endTime;
startTime = getCPUTime();
//Generate 6 functions
round1table = malloc(blocks*sizeof(unsigned int));
generateRoundFunctions(seed1,round1table,blocks);
round2table = malloc(blocks*sizeof(unsigned int));
generateRoundFunctions(seed2,round2table,blocks);
round3table = malloc(blocks*sizeof(unsigned int));
generateRoundFunctions(seed3,round3table,blocks);
round4table = malloc(blocks*sizeof(unsigned int));
generateRoundFunctions(seed4,round4table,blocks);
round5table = malloc(blocks*sizeof(unsigned int));
generateRoundFunctions(seed5,round5table,blocks);
round6table = malloc(blocks*sizeof(unsigned int));
generateRoundFunctions(seed6,round6table,blocks);
printf("6 tables generated");
endTime = getCPUTime();
fprintf( stderr, "CPU time used for PRNG = %lf\n", (endTime - startTime) );
startTime = getCPUTime();
//using setting in the paper: change it later, to calculate a and b
int a = ceil(sqrt(blocks));
int b = ceil(sqrt(blocks))+1;
printf("a=%d,b=%d\n",a,b);
//get the keys for permutation
//unsigned char * keyseed = "anappleadaykeepsadoctoraway";
//int key = genkey(keyseed);
//do this for six rounds
for(i=0;i<blocks;i++){
prpblockindices[i]=Fe(NOOFROUNDS, a, b,i, blocks, bit);
}
//for(i=0;i<blocks;i++){
//printf("%d -> %d\n", blockindices[i], prpblockindices[i]);
//}
printf("a=%d,b=%d\n",a,b);
endTime = getCPUTime();
fprintf( stderr, "CPU time used for PRP = %lf\n", (endTime - startTime) );
}
void sysBpHandler(){
saveStateIn(sysbp_old, ¤tProcess->p_s);
unsigned int cause = CAUSE_EXCCODE_GET(sysbp_old->CP15_Cause);
unsigned int a0 = (*sysbp_old).a1;
unsigned int a1 = (*sysbp_old).a2;
unsigned int a2 = (*sysbp_old).a3;
unsigned int a3 = (*sysbp_old).a4;
/* Se l'eccezione è di tipo System call */
if(cause==EXC_SYSCALL){
/* Se il processo è in kernel mode gestisce adeguatamente */
if( (currentProcess->p_s.cpsr & STATUS_SYS_MODE) == STATUS_SYS_MODE){
/* Se è fra SYS1 e SYS8 richiama le funzioni adeguate */
switch(a0){
case CREATEPROCESS:
createProcess((state_t *) a1);
break;
case TERMINATEPROCESS:
terminateProcess(currentProcess);
break;
case VERHOGEN:
verhogen((int *) a1);
break;
case PASSEREN:
passeren((int *) a1);
break;
case SPECTRAPVEC:
specExStVec((int) a1, (state_t *) a2, (state_t *) a3);
break;
case GETCPUTIME:
getCPUTime();
break;
case WAITCLOCK:
waitForClock();
break;
case WAITIO:
waitForIO((int) a1, (int) a2, (int) a3);
break;
/* Altrimenti la gestione viene passata in alto */
default:
useExStVec(SPECSYSBP);
break;
}
/* Richiamo lo scheduler */
scheduler();
/* Se invece è in user mode */
} else if((currentProcess->p_s.cpsr & STATUS_USER_MODE) == STATUS_USER_MODE){
/* Se è una system call */
if(a0 >= CREATEPROCESS && a0 <= WAITIO){
/* Gestisco come fosse una program trap */
saveStateIn(sysbp_old, pgmtrap_old);
/* Setto il registro cause a Reserved Instruction */
pgmtrap_old->CP15_Cause = CAUSE_EXCCODE_SET(pgmtrap_old->CP15_Cause, EXC_RESERVEDINSTR);
/* Richiamo l'handler per le pgmtrap */
pgmHandler();
} else {
useExStVec(SPECSYSBP);
}
}
/* Altrimenti se l'eccezione è di tipo BreakPoint */
} else if(cause == EXC_BREAKPOINT){
useExStVec(SPECSYSBP);
}
PANIC();
}
int outer_decoding(FILE* orifp, FILE* parifp, FILE *output, FILE* tempfp, decoded_blocks *db)
{
int i,j,stripes,fileLen,index;
int* prp_table;
int* reverse_prp_table;
char message[k];
char codeword[n];
//unsigned char decodedfile[stripes][k];
int erasure[1];
//FILE* tempfp = fopen("tempfile", "w+b");
if (tempfp == NULL){
printf("couldn't open temperory file for writing.\n");
return -1;
}
//find the number of stripes in the file
fseek(parifp,0,SEEK_END);
fileLen = ftell(parifp);
printf("display fileLen of parity %d\n",fileLen);
//if(fileLen % n==0)
stripes = fileLen/d;
//else
//stripes = fileLen/n+1;
printf("number of stripes for outer decoding %d\n",stripes);
fflush(stdout);
unsigned char ** parity;//[stripes][d];
parity = (unsigned char **) malloc(stripes*sizeof(unsigned char *));
for (i = 0; i < stripes; i++) {
parity[i] = (unsigned char *) malloc(d*sizeof(unsigned char));
}
//call prp
prp_table =malloc(sizeof(int)*stripes);
reverse_prp_table = malloc(sizeof(int)*stripes);
//perform reverse prp
prp_table = prp(stripes, k_ecc_perm);
reverseprp(stripes,prp_table,reverse_prp_table);
/*for(i=0;i<stripes;i++){
printf("prp %d: %d\n",i,prp_table[i]);
printf("rev prp %d: %d\n",i,reverse_prp_table[i]);
}*/
//free(prp_table);
printf("check1\n");
enc_init(k_ecc_enc);
//decrypt parity part
rewind(parifp);
rewind(orifp);
///number of parity blocks = stripes/2
//read parity parts directly
//int parity_start = fileLen-(stripes/2)*d;
//fseek(temp_fp,parity_start,SEEK_SET);
unsigned char paritybytes[stripes][d];
for (i=0;i<stripes;i++) {
unsigned char ct[d];
//unsigned char pt[d];
fread(ct,sizeof(ct),1,parifp);
decrypt(ct,paritybytes[prp_table[i]],sizeof(ct));
//printf("prp rev for %d: ",i);
//displayCharArray(paritybytes[i],sizeof(ct));
//for(j=0;j<d;j++){
// parity[i][j]=ct[j];
//}
}
for (i=0;i<stripes;i++) {
printf("prp rev for %d: ",i);
displayCharArray(paritybytes[i],sizeof(paritybytes[i]));
}
free(reverse_prp_table);
reverse_prp_table = malloc(sizeof(int)*m);
prp_table =malloc(sizeof(int)*m);
prp_table = prp(m, k_file_perm);
reverseprp(m,prp_table,reverse_prp_table);
//get the message and the parity, create codeword and decode it
//rewind(temp_fp);
FILE * prp = fopen("prp","w+b");
for(i=0;i<m;i++) {
unsigned char prpbuf[BLOCK_SIZE];
fseek(orifp,prp_table[i]*32,SEEK_SET);
size_t br = fread(prpbuf,1,BLOCK_SIZE,orifp);
fwrite(prpbuf,1,BLOCK_SIZE,prp);
}
fclose(prp);
prp = fopen("prp","r+b");
for(i=0;i<stripes;i++) {
index=0;
unsigned char code[n];
size_t br = fread(code,1,k,prp);
int pad = k-br;
int ii;
for (ii=0;ii<pad;ii++)
code[br+ii] = 0;
for(j=0;j<d;j++) {
code[k+j] = paritybytes[i][j];
}
printf("whole code %d: ",i);
displayCharArray(code,n);
decode_data(code, n);
int syn = check_syndrome ();
printf("syndrome: %d\n",syn);
if (syn != 0) {
correct_errors_erasures(code,n,0,erasure);
}
printf("decoded code %d: ",i);
displayCharArray(code,n);
//calculate block index of the parity part
fwrite(code,1,br,tempfp);
}
fclose(tempfp);
for (i = 0; i < stripes; i++){
free(parity[i]);
}
free(parity);
if ((tempfp = fopen("tempfile", "r+b")) == NULL){
printf("couldn't open temperory file for writing.\n");
return -1;
}
// write data to the file by applying second level of permutation
//free(prp_table);
//free(reverse_prp_table);
//printf("display m = %lu\n",m);
rewind(tempfp);
rewind(output);
unsigned char buf[BLOCK_SIZE];
for(i=0;i<m;i++) {
readStartTime = getCPUTime();
fseek(tempfp,reverse_prp_table[i]*32,SEEK_SET);
fread(buf, BLOCK_SIZE, 1, tempfp);
readEndTime = getCPUTime();
readTime += readEndTime-readStartTime;
writeStartTime = getCPUTime();
fwrite(buf,BLOCK_SIZE,1,output);
writeEndTime = getCPUTime();
writeTime += writeEndTime-writeStartTime;
}
printf("check4\n");
fclose(tempfp);
fclose(output);
fclose(orifp);
fclose(parifp);
printf("check5\n");
//delete(temp_fp);
return 0;
}
int main(int argc, char* argv[])
{
totalStartTime = getCPUTime();
printf("%lf\n",totalStartTime);
int i;
FILE* fp = fopen(argv[1],"a+b");
if (fp==NULL) {
printf("fopen error: cannot open file\n");
exit(1);
}
int* prptable;
unsigned char mac[MAXBLOCKSIZE];
unsigned long fileLen1,fileLen2;
// get the file size
fseek(fp,0,SEEK_END);
fileLen1 = ftell(fp);
// generate keys
master_keygen(argv[2]);
printf("key for file permutation: ");
displayCharArray(k_file_perm,16);
printf("key for ecc permutation: ");
displayCharArray(k_ecc_perm,16);
printf("key for ecc encryption: ");
displayCharArray(k_ecc_enc,16);
printf("key for challenge generation: ");
displayCharArray(k_chal,16);
printf("key for random index generation: ");
displayCharArray(k_ind,16);
printf("key for response encryption: ");
displayCharArray(k_enc,16);
printf("key for MAC computation: ");
displayCharArray(k_mac,16);
// blockize the file
int blocks = blockize(fp);
t = blocks;
fclose(fp);
fp = fopen(argv[1],"a+b");
// computing MAC
printf("\nComputing file's MAC...\n");
printf("\nmac size %lu\n",sizeof(mac));
macStartTime = getCPUTime();
hmac(argv[1],mac,k_mac);
macTime = getCPUTime() - macStartTime;
printf("\nMAC = ");
displayCharArray(mac,16);
// perform a file level PRP
printf("\nSRF PRP for the entire file...\n");
prpStartTime = getCPUTime();
prptable = prp(blocks, k_file_perm);
prpTime += getCPUTime() - prpStartTime;
eccStartTime = getCPUTime();
initialize_ecc();
inc_encoding(fp,prptable);
eccTime = getCPUTime() - eccStartTime - readTime;
printf("\nFile blocks after outer layer encoding: %lu\n",t);
// precompute q challenge and responsess
printf("\nPrecomputation for %d challenges and responses\n",q);
chalStartTime = getCPUTime();
Chal c[q];
int j,p;
// use k_chal to generate kjc
keygen_init();
seeding(k_chal);
unsigned char * kjc[q];
for(j=0;j<q;j++) {
kjc[j] = malloc(16*sizeof(unsigned char *));
keygen(kjc[j], 16);
}
// use kjc to generate random indices
for(j=0;j<q;j++) {
keygen_init();
seeding(kjc[j]);
for(p=0;p<v;p++) {
unsigned long randomIndex;
char rand[8];
keygen(rand, 8);
randomIndex = *(unsigned long *)rand;
c[j].s[p] = randomIndex % t;
}
}
// use k_ind to generate random index u
keygen_init();
seeding(k_ind);
for(j=0;j<q;j++) {
unsigned int randomIndex;
char rand[4];
keygen(rand, 4);
randomIndex = *(unsigned int *)rand;
c[j].u = randomIndex % w;
}
printf("Precomputation for challenges finishes\n");
// precompute challenge responses
precompute_response(fp,c,k_enc);
printf("Precomputation for responses finishes\n");
chalTime+=getCPUTime()-chalStartTime - write2Time;
// append MAC at the end of the files
printf("\nAppend MAC to the end of the file...\n");
write2StartTime = getCPUTime();
clock_gettime(CLOCK_MONOTONIC, &start);
fwrite(mac,16,1,fp);
clock_gettime(CLOCK_MONOTONIC, &finish);
double addTime = finish.tv_sec - start.tv_sec;
addTime += (finish.tv_nsec - start.tv_nsec)/1000000000.0;
write2Time += getCPUTime() - write2StartTime+addTime;
fseek(fp,0,SEEK_END);
fileLen2 = ftell(fp);
fclose(fp);
printf("\nPOR encoding done\n");
// display time performance
totalTime = getCPUTime() - totalStartTime;
printf("#RESULT#\n");
printf("%lu\n",fileLen1);
printf("%lu\n",fileLen2);
printf("%lf\n",totalTime);
printf("%lf\n",readTime);
printf("%lf\n",prpTime);
printf("%lf\n",eccTime);
printf("%lf\n",macTime);
printf("%lf\n",chalTime);
printf("%lf\n",write1Time+write2Time);
printf("%lf\n",encTime);
}
int main()
{
double startTime;
double endTime;
double ElapsedTime;
sorter_data_t data[NUM_ELE];
sorter_data_t out_data[NUM_ELE];
sorter_data_t orig_data[NUM_ELE];
sorter_data_t *data_p;
bool i_state = 0;
for (int itn = 0; itn < NUM_ITR; itn++) {
if (itn == 0) {
for(int i=0;i<NUM_ELE;++i)
{
if (i == (NUM_ELE-1)) {
orig_data[i] = 111.32;
} else if (i == 0) {
orig_data[i] = -55.45;
} else {
if (i_state) {
orig_data[i] = ((float)i/2.3);
} else {
orig_data[i] = ((float)i/-2.3);
}
}
data[i] = orig_data[i];
out_data[i] = 0;
i_state = not i_state;
}
} else {
for(int i=0;i<NUM_ELE;++i)
{
if (i == (NUM_ELE-1)) {
orig_data[i] = 111.32;
} else if (i == 0) {
orig_data[i] = -55.45;
} else {
if (i_state) {
orig_data[i] = ((float)i*itn)/2.3;
} else {
orig_data[i] = ((float)i*itn)/-2.3;
}
}
data[i] = orig_data[i];
out_data[i] = 0;
i_state = not i_state;
}
}
//my_bubble_sorter.bubble_sort(data, out_data);
startTime = getCPUTime();
//-----------------------------------------------
bubble_sort_wrapper(data, out_data);
printf("In ascending order: \n");
//-----------------------------------------------
endTime = getCPUTime();
ElapsedTime = (endTime - startTime);
for(int i=0;i<NUM_ELE;++i)
printf("%f :: %f \n",(float)orig_data[i], (float)out_data[i]);
printf("\n");
printf (" Elapsed Time for algorithm = %1f sec\n", ElapsedTime);
}
return 0;
}
// outer layer ECC using incremental encoding
int inc_encoding (FILE* fp,int* prptable)
{
printf("\nIncremental encoding starts...\n");
int i,j,enc_blocks,d=n-k;
// get file length
fseek(fp,0,SEEK_END);
fileLen = ftell(fp);
// divide by message length k, get number of encoding blocks
if(fileLen % k==0)
enc_blocks = fileLen/k;
else
enc_blocks = fileLen/k+1;
printf("There are %d encoding blocks\n",enc_blocks);
unsigned char message[k];
unsigned char codeword[n];
unsigned char ** code; // used to store parity part
long filecounter = 0;
int blockcounter = 0;
int round = 0;
// code is enc_blocks * d
code = (unsigned char **) malloc(enc_blocks*sizeof(unsigned char *));
for (i = 0; i < enc_blocks; i++) {
code[i] = (unsigned char *) malloc(d*sizeof(unsigned char));
int ii;
for (ii=0;ii<d;ii++)
code[i][ii]=0;
}
rewind(fp);
while (!feof(fp))
{
unsigned char * buf;
if ((buf = malloc(sizeof(unsigned char)*readLen))==NULL) {
printf("malloc error: inc_encoding\n");
exit(1);
}
// incremental encoding, read reaLen each time
readStartTime = getCPUTime();
clock_gettime(CLOCK_MONOTONIC, &start);
printf("max read in %d bytes\n",readLen);
size_t br = fread(buf, 1, readLen, fp);
printf("Read in %lu bytes\n",br);
fflush(stdout);
clock_gettime(CLOCK_MONOTONIC, &finish);
double addTime = finish.tv_sec - start.tv_sec;
addTime += (finish.tv_nsec - start.tv_nsec)/1000000000.0;
readTime += getCPUTime() - readStartTime+addTime;
// keep a counter to know where the file pointer up to
filecounter = filecounter + br;
if (br!=0) {
printf("round %d\n",round);
printf("filecounter = %lu\n",filecounter);
for(i=0;i<enc_blocks;i++) {
for(j=0;j<k;j++) {
// for each byte in each message, compute index
int index = i*k+j;
// get block and byte index
int block_index = index/BLOCK_SIZE;
int byte_index = index%BLOCK_SIZE;
// if reach the end, padding 0s
if (index>=fileLen) {
int a;
for(a=j;a<k;a++)
message[a]=0;
break;
}
// compute the PRPed index in the file
unsigned long file_index = prptable[block_index]*BLOCK_SIZE+byte_index;
// check if this byte is read in the memory or not, copy if yes, put 0 otherwise
if(file_index<filecounter && file_index>=(filecounter-br)) {
unsigned long newind = file_index-filecounter+br;
message[j] = buf[newind];
}
else
message[j] = 0;
}
//printf("msg for block %d: ",i);
//displayCharArray(message,k);
// do a partial encoding on the message
encode_data(message,k,codeword);
// concatenate with previous code to get a whole
/*printf("code for block %d: ",i);
displayCharArray(codeword,n);
printf("parity (before) for block %d: ",i);
displayCharArray(code[i],n-k);*/
for(j=0;j<d;j++)
code[i][j] = code[i][j] ^ codeword[k+j];
//printf("parity for block %d: ",i);
//displayCharArray(code[i],n-k);
//printf("\n");
}
round = round + 1;
}
free(buf);
}
/*// ------------- for debugging
unsigned char a[fileLen],r[fileLen];
unsigned char newc[n],newm[k];
rewind(fp);
fread(a, 1, fileLen, fp);
printf("original:\n");
for (i=0;i<fileLen;i++) {
printf("%02x",a[i]);
}
printf("\n");
for (i=0;i<fileLen/32;i++) {
for (j=0;j<32;j++) {
r[i*32+j] = a[prptable[i]*32+j];
}
}
printf("prped:\n");
for (i=0;i<fileLen;i++) {
printf("%02x",r[i]);
}
printf("\n");
for (i=0;i<enc_blocks;i++) {
printf("parity part %d: ",i);
displayCharArray(code[i],d);
unsigned char newcode[n];
int iii;
int ii;
for(ii=0;ii<k;ii++) {
if (i*k+ii>=fileLen)
break;
newcode[ii] = r[i*k+ii];
newm[ii] = r[i*k+ii];
}
if (i==enc_blocks-1) {
for(ii=0;ii<k-fileLen%k;ii++){
newm[fileLen%k+ii]=0;
newcode[fileLen%k+ii] = 0;
}
}
encode_data(newm,k,newc);
printf("actual code %d: ",i);
displayCharArray(newc,n);
for(iii=0;iii<d;iii++) {
newcode[k+iii] = code[i][iii];
}
newcode[0] = 99;
printf("whole code %d: ",i);
displayCharArray(newcode,n);
decode_data(newcode, n);
int erasure[1];
int syn = check_syndrome ();
printf("syndrome: %d\n",syn);
if (syn != 0) {
correct_errors_erasures(newcode,n,0,erasure);
}
printf("decode %d: ",i);
displayCharArray(newcode,n);
}
//--------------- for debugging */
free(prptable);
prptable = NULL;
// perform another PRP for parity part
prptable = malloc(sizeof(int)*(enc_blocks));
printf("\nSRF PRP for the outer layer ECC...\n");
prpStartTime = getCPUTime();
prptable = prp(enc_blocks, k_ecc_perm);
prpTime += getCPUTime() - prpStartTime;
// encrypt parity part and append to the file with PRPed order
enc_init(k_ecc_enc);
for (i=0;i<enc_blocks;i++) {
unsigned char ct[d];
clock_gettime(CLOCK_MONOTONIC, &start);
encStartTime = getCPUTime();
encrypt(ct,code[prptable[i]],sizeof(ct));
clock_gettime(CLOCK_MONOTONIC, &finish);
double addTime = finish.tv_sec - start.tv_sec;
addTime += (finish.tv_nsec - start.tv_nsec)/1000000000.0;
encTime += getCPUTime()-encStartTime+addTime;
//printf("encrypted for %d: ",i);
//displayCharArray(ct,sizeof(ct));
//unsigned char pt[d];
//decrypt(ct,pt,sizeof(ct));
//printf("decrypted for %d: ",i);
//displayCharArray(pt,sizeof(ct));
clock_gettime(CLOCK_MONOTONIC, &start);
write1StartTime = getCPUTime();
fwrite(ct,d,1,fp);
clock_gettime(CLOCK_MONOTONIC, &finish);
addTime = finish.tv_sec - start.tv_sec;
addTime += (finish.tv_nsec - start.tv_nsec)/1000000000.0;
write1Time += getCPUTime()-write1StartTime;
}
// update t for later challenge computation
t = t+enc_blocks;
printf("\nIncremental encoding finishes...\n");
free(prptable);
for (i = 0; i < enc_blocks; i++){
free(code[i]);
}
free(code);
return 0;
}
double checkOutCPUTime( void )
{
double curCPUTime = getCPUTime();
return ( curCPUTime - startCPUTime );
}
void startTimer_CPU( MTime* mtime )
{
mtime->type = CPU_CLOCK_TIME;
mtime->start = getCPUTime();
}
double Game_Engine::Evaluate_Players(int num_repeats, int num_games, int output_depth, Player_Engine** players, bool rotate_starting_player, int return_score_player_num, Tom_Sample_Storage<double>** score_output, int intermediate_output, const int measure_time_per_move, double* winDraw_output_new)
{
int nextMove, feedback, bestPlayer, multipleWinners;
double bestOutcome;
int output_interval, next_output;
double cpu_time;
double cpu_time1;
double scr_out_time;
//check if players are correctly linked to game, otherwise exit procedure
players = Validate_Players(players);
if(players == NULL)
return -1;
//assign player IDs
for (int i = 0; i < number_players; i++){
players[i]->player_number = i;
}
//output depth 1
if(output_depth >= TOMGAME_OUTPUT_DEPTH1){
gmp->Print("\nEval on game %s [%d repeats %d games]", game_name.c_str(), num_repeats, num_games);
for(int i = 0; i < this->number_players; i++)
gmp->Print(", Player %d: %s", i+1, players[i]->player_name.c_str());
gmp->Print(" |");
if(output_depth == TOMGAME_OUTPUT_DEPTH1){
output_interval = (int)(num_games*num_repeats/10);
next_output = output_interval;
}
}
//allocate counters
int* win_count_total = new int[number_players+1]; //total counter for: draws | player1 | player2 | ...
int* win_count_local = new int[number_players+1]; //single repeat counter for: draws | player1 | player2 | ...
double* score_count_total = new double[number_players];
double* score_count_local = new double[number_players];
double* players_move_time_sum = new double[number_players];
int* players_move_count = new int[number_players];
//initialize counter values
win_count_total[0] = 0;
for(int i = 0; i < number_players; i++){
win_count_total[i+1] = 0;
score_count_total[i] = 0.0;
players_move_time_sum[i] = 0.0;
players_move_count[i] = 0;
}
//measure time
cpu_time = getCPUTime();
scr_out_time = getCPUTime();
//execute repeats
for(batch_repeat_index = 0; batch_repeat_index < num_repeats; batch_repeat_index++){
//reset counter values
win_count_local[0] = 0;
for(int i = 0; i < number_players; i++){
win_count_local[i+1] = 0;
score_count_local[i] = 0.0;
}
//reset players
for(int i = 0; i < number_players; i++)
if(players[i]->external_reset_enabled)
players[i]->Reset();
//execute games
for(game_repeat_index = 0; game_repeat_index < num_games; game_repeat_index++){
//reset game state (start new game)
Game_New();
//call new-game procedure for players
for(int i = 0; i < number_players; i++)
players[i]->New_Game();
//play game until end is signaled
feedback = game_ended;
while(feedback == 0){
//measure move time
cpu_time1 = getCPUTime();
//current player selects next move
nextMove = players[current_player]->Get_Move();
players_move_count[current_player]++;
//call before-move procedure for all players
for(int i = 0; i < number_players; i++){
players[i]->Before_Move(nextMove);
}
//remember cpu time (cumulative sum)
players_move_time_sum[current_player] += ( getCPUTime()-cpu_time1 );
//simulate game dynamics with selected move
#if(TOM_DEBUG)
feedback = Play_Move(nextMove);
#else
feedback = Play_Move_Unsafe(nextMove);
#endif
//call after-move procedure for all players
cpu_time1 = getCPUTime();
for(int i = 0; i < number_players; i++){
players[i]->After_Move(nextMove);
}
players_move_time_sum[current_player] += ( getCPUTime()-cpu_time1 );
}
//calculate score
Calculate_Score();
//call end-game procedure for players, game must not be resetted before this call
for(int i = 0; i < number_players; i++)
players[i]->End_Game();
// --- update evaluation statistics ---
//store score to external data structure
if(score_output != NULL){
score_output[0]->Add_Sample(score[0]);
score_output[1]->Add_Sample(score[1]);
}
//find winning player
if(number_players == 1){ //single player game
score_count_total[0] += score[0];
score_count_local[0] += score[0];
}else{
bestOutcome = -DBL_MAX;
bestPlayer = 0;
multipleWinners = 1;
for(int i = 0; i < number_players; i++){
if(score[i] > bestOutcome){
bestOutcome = score[i];
bestPlayer = i;
multipleWinners = 1;
}else if(score[i] == bestOutcome){
multipleWinners++;
}
//save score statistics
score_count_total[i] += score[i];
score_count_local[i] += score[i];
}
//single winner
if(multipleWinners == 1){
win_count_total[bestPlayer+1]++;
win_count_local[bestPlayer+1]++;
//multiple players with equal highest score
}else{
//game ended in draw (all players have equal score)
if(multipleWinners == number_players){
win_count_total[0]++;
win_count_local[0]++;
//multiple winners
}else{
for(int i = 0; i < number_players; i++){
if(score[i] == bestOutcome){
win_count_total[i+1]++;
win_count_local[i+1]++;
}
}
}
}
}
//output depth 3: after each game
if(output_depth >= TOMGAME_OUTPUT_DEPTH3){
if(number_players == 1){
gmp->Print("\nL3 game | %d\t score %6.5f", game_repeat_index+1, score[0]);
}else{
gmp->Print("\nL3 game | %d\t draws %4d\t wins", game_repeat_index+1, win_count_local[0]);
for(int i = 0; i < number_players; i++)
gmp->Print(" %4d", win_count_local[i+1]);
gmp->Print("\t scores");
for(int i = 0; i < number_players; i++)
gmp->Print(" %6.3f", score[i]);
}
}else if(output_depth == TOMGAME_OUTPUT_DEPTH1){
if(batch_repeat_index*num_games+game_repeat_index >= next_output){
gmp->Print(".");
next_output += output_interval;
}
}
if(score_output != NULL){
if(intermediate_output > 0){
if(((score_output[return_score_player_num]->n) % intermediate_output) == 0){
score_output[return_score_player_num]->Calc_AvgDev();
score_output[return_score_player_num]->Calc_Confidence();
gmp->Print("%8d %6.2f %6.2f %6.2f %9.3f\n",
score_output[return_score_player_num]->n,
score_output[return_score_player_num]->avg*100,
score_output[return_score_player_num]->Calc_Confidence()*100,
score_output[return_score_player_num]->dev*100,
getCPUTime()-cpu_time
);
if((scr_out_time < 0) || (scr_out_time > TOMGAME_OUTPUT_EVALUATE_INTERMEDIATE_FLUSH_TIMEINTERVAL)){
gmp->Flush();
}
scr_out_time = getCPUTime();
}
}
}
}
// END - games
//output depth 2: after series of games
if(output_depth >= TOMGAME_OUTPUT_DEPTH2){
if(number_players == 1){
gmp->Print("\nL2 REPEAT | %d\t average score %6.5f", batch_repeat_index+1, score_count_local[0] / num_games);
}else{
gmp->Print("\nL2 REPEAT | %d\t draws %4d\t wins", batch_repeat_index+1, win_count_local[0]);
for(int i = 0; i < number_players; i++)
gmp->Print(" %4d", win_count_local[i+1]);
gmp->Print("\t sum-scores");
for(int i = 0; i < number_players; i++)
gmp->Print(" %6.3f", score_count_local[i]);
gmp->Print("\t relative");
for(int i = 0; i < number_players+1; i++)
gmp->Print(" %5.3f", (float)win_count_local[i]/num_games);
}
}
//calculate avgerage and deviation in external score storing structure
if(score_output != NULL){
score_output[0]->Calc_AvgDev();
score_output[0]->Calc_Confidence();
score_output[1]->Calc_AvgDev();
score_output[1]->Calc_Confidence();
}
}
// END - repeats
//output depth 0: after all repeats, final results, players outputs
if(output_depth >= TOMGAME_OUTPUT_DEPTH0){
cpu_time = getCPUTime()-cpu_time;
if(number_players == 1){
gmp->Print("\naverage score %6.5f\t | Player: %s", score_count_total[0] / num_games / num_repeats, players[0]->player_name.c_str());
}else{
gmp->Print("\nPlayers: %s",players[0]->player_name.c_str());
for(int i = 1; i < this->number_players; i++)
gmp->Print(" vs %s", players[i]->player_name.c_str());
gmp->Print(":\t draws %4d\t wins", win_count_total[0]);
for(int i = 0; i < number_players; i++)
gmp->Print(" %4d", win_count_total[i+1]);
gmp->Print("\t sum-scores");
for(int i = 0; i < number_players; i++)
gmp->Print(" %6.3f", score_count_total[i]);
gmp->Print("\t relative");
for(int i = 0; i < number_players+1; i++)
gmp->Print(" %5.3f", (float)win_count_total[i]/num_games/num_repeats);
}
gmp->Print("\t[%d repeats %d games]\t Runtime: %9.3f s", num_repeats, num_games, cpu_time);
//output players info
for(int i = 0; i < number_players; i++)
if(players[i]->final_output_enabled)
players[i]->Output();
}
//output average time per move
if(measure_time_per_move){
for(int i = 0; i < number_players; i++)
gmp->Print("\nTIME P%d: %6.1lf ms/game %6.2lf ms/move (games %d moves %d totalTime %lf s)",i,players_move_time_sum[i] / (double)(num_repeats*num_games) * 1000.0, players_move_time_sum[i] / (double)(num_repeats*num_games*players_move_count[i]) * 1000.0 , num_repeats*num_games, players_move_count[i],players_move_time_sum[i]);
gmp->Print("\n\n");
}
if (winDraw_output_new != NULL){
winDraw_output_new[0] = (double)(win_count_total[0]); //num draws
winDraw_output_new[1] = (double)(win_count_total[1]); //num wins player 1
winDraw_output_new[2] = (double)(win_count_total[2]); //num wins player 2
}
//save return value
double tmpReturn = score_count_total[return_score_player_num];
//clean up
delete[] win_count_total;
delete[] win_count_local;
delete[] score_count_total;
delete[] score_count_local;
delete[] players_move_time_sum;
delete[] players_move_count;
//return score
return tmpReturn;
}
/**
Procedure executes given number of games with specified players, for player learning purpose.
@param output_depth sets how detailed is the output/visualization
*/
void Game_Engine::Learn_Players(int num_games, int output_depth, Player_Engine** players)
{
int nextMove, feedback;
int output_interval, next_output;
double cpu_time;
//check if players are correctly linked to game, otherwise exit procedure
players = Validate_Players(players);
if(players == NULL)
return;
//output depth 0
#if(!TOM_OUTPUT_TO_MATLAB)
if(output_depth >= TOMGAME_OUTPUT_DEPTH0){
gmp->Print("\nLearning game %s [%d games]", game_name.c_str(), num_games);
for(int i = 0; i < this->number_players; i++)
gmp->Print(", Player %d: %s", i+1, players[i]->player_name.c_str());
gmp->Print(" |");
if(output_depth == TOMGAME_OUTPUT_DEPTH0){
output_interval = (int)(num_games/10);
next_output = output_interval;
}
}
#endif
//measure time
cpu_time = getCPUTime();
//execute games
for(int g = 0; g < num_games; g++){
//reset game state (start new game)
Game_New();
//call new-game procedure for players
for(int i = 0; i < number_players; i++)
players[i]->New_Game();
//play game until end is signaled
feedback = game_ended;
while(feedback == 0){
//current player selects next move
nextMove = players[current_player]->Get_Move();
//call before-move procedure for all players
for(int i = 0; i < number_players; i++){
players[i]->Before_Move(nextMove);
}
//simulate game dynamics with selected move
#if(TOM_DEBUG)
feedback = Play_Move(nextMove);
#else
feedback = Play_Move_Unsafe(nextMove);
#endif
//call after-move procedure for all players
for(int i = 0; i < number_players; i++){
players[i]->After_Move(nextMove);
}
}
//calculate score
Calculate_Score();
//call end-game procedure for players, game must not be resetted before this call
for(int i = 0; i < number_players; i++)
players[i]->End_Game();
//output depth 1
#if(!TOM_OUTPUT_TO_MATLAB)
if(output_depth == TOMGAME_OUTPUT_DEPTH0){
if(g >= next_output){
gmp->Print(".");
next_output += output_interval;
}
}else if(output_depth >= TOMGAME_OUTPUT_DEPTH1){
gmp->Print("\nL1 Game num %3d \t plys %2d \t score",g+1,current_plys);
for(int i = 0; i < number_players; i++)
gmp->Print(" %3.1f", score[i]);
}
#endif
}
//output depth 0, with players final output
#if(!TOM_OUTPUT_TO_MATLAB)
if(output_depth >= TOMGAME_OUTPUT_DEPTH0){
cpu_time = getCPUTime()-cpu_time;
if(output_depth > TOMGAME_OUTPUT_DEPTH0)
gmp->Print("\n");
else
gmp->Print("\t ");
gmp->Print("Runtime: %9.3f s",cpu_time);
for(int i = 0; i < number_players; i++)
if(players[i]->final_output_enabled)
players[i]->Output();
}
#endif
}
