ScopLib::ScopLib(Scop *S) : PollyScop(S) {
scoplib = scoplib_scop_malloc();
initializeArrays();
initializeParameters();
initializeScattering();
initializeStatements();
}
// REQUIRES: sudokustring only comprises of characters 0 <= x <= 9
// MODIFIES: none
// EFFECTS: Tests the validity of a sudoku string. If the sudokustring is a valid sudoku solution, returns 1. Else, returns 0.
int testSudokuString(char *sudokustring)
{
int **sudokuarray;
// Return -1 if the length of the input string isn't exactly 81.
if(strlen(sudokustring) != 81){
printf("Invalid input size %d.\n", strlen(sudokustring));
return -1;
}
// Decode the string into a 9x9 array
sudokuarray = decodeSudokuString(sudokustring);
printSudokuPuzzle(sudokuarray);
// Declare/Initialize the structs based on the number of threads for each one
NumberArray row_NumberArrays[NUM_ROW_THREADS];
NumberArray column_NumberArrays[NUM_COL_THREADS];
NumberArray block_NumberArrays[NUM_BLOCK_THREADS];
initializeArrays(row_NumberArrays, column_NumberArrays, block_NumberArrays);
int i, row_cursor, col_cursor, block_cursor;
i = 0;
// Allocate 9-element arrays to each of the structs, with rollover cursors that
// depend on the number of structs available
while(i < 9)
{
row_cursor = i % NUM_ROW_THREADS;
col_cursor = i % NUM_COL_THREADS;
block_cursor = i % NUM_BLOCK_THREADS;
if(VERBOSE) printf("i : %d. row_cursor: %d.\n", i, row_cursor);
// Create a copy of the row, column, block, and allocate the copy to a portion in the struct for the current cursor position for row, column and block
row_NumberArrays[row_cursor].elements[row_NumberArrays[row_cursor].array_count++] = copyOfRow(sudokuarray, i);
column_NumberArrays[col_cursor].elements[column_NumberArrays[col_cursor].array_count++] = copyOfColumn(sudokuarray, i);
block_NumberArrays[block_cursor].elements[block_NumberArrays[block_cursor].array_count++] = copyOfBlock(sudokuarray, i);
i++;
if(VERBOSE) printf("array_count: %d\n\n", row_NumberArrays[row_cursor].array_count);
}
// Allocate the result to the 'result' variable
int result = testNumberArrays(row_NumberArrays, column_NumberArrays, block_NumberArrays);
// Free the dynamic memory
freeNumberArrays(row_NumberArrays, column_NumberArrays, block_NumberArrays);
for(i = 0; i < 9; i++)
free(sudokuarray[i]);
free(sudokuarray);
return result;
}
void launchInitialization() {
initializeArrays();
}
void modified(char *fName) {
int physicalAddress;
initializeArrays();
readFile(fName);
int pageTableHits = 0;
int tlbHits = 0;
int pageFaults = 0;
int totalAddresses = 0;
int i;
int frameNum = 0;
int tlbIndex = 0;
for (i = 0; i < 1000; i++) {
int pageNum = pageNums[i];
int offset = offsets[i];
int signedByte;
frameNum = frameNum%128;
int tlbCheck = checkTLB(pageNum);
if (tlbCheck != -1) {
physicalAddress = logicalToPhysical(i);
signedByte = (int) frames[tlbCheck][offset];
tlbHits++;
} if (pageTable[pageNum] == -1) {
pageTable[pageNum] = frameNum;
physicalAddress = logicalToPhysical(i);
char *f = malloc(256 * sizeof(char));
f = getPage(pageNum, offset, f);
if ( pageFrames[frameNum] != -1) {
int oldPageNum = pageFrames[frameNum];
/*if (checkTLB(oldPageNum) != -1) {
int tlbI = getTLBIndex(pageNum);
patchTLBHole(tlbI);
printf("was in tlb\n");
}*/
pageTable[oldPageNum] = -1;
}
pageFrames[frameNum] = pageNum;
frames[frameNum] = f;
signedByte = (int) frames[frameNum][offset];
updateTLB(pageNum, frameNum, tlbIndex);
tlbIndex++;
frameNum++;
pageFaults++;
} else {
physicalAddress = logicalToPhysical(i);
int fNum = pageTable[pageNum];
signedByte = (int) frames[fNum][offset];
updateTLB(pageNum, frameNum, tlbIndex);
tlbIndex++;
pageTableHits++;
}
printf("Virtual address: %d Physical address: %d Value: %d\n", lAddresses[i], physicalAddress, signedByte );
}
printf("Number of Translated Addresses = %d\n", 1000);
printf("Page Faults = %d\n", pageFaults);
printf("Page Fault Rate = %.3f\n", (double) pageFaults / 1000 );
printf("TLB Hits = %d\n", tlbHits);
printf("TLB Hit Rate = %.3f\n", (double) tlbHits / 1000);
}
int main(int argc, char** argv) {
FILE* fileIn = NULL;
FILE* fileOut = NULL;
Symbol symbols[ARRAY_LENGTH];
Symbol* symbolsOrd[ARRAY_LENGTH]; //ordered pointers (by frequency)
u64 fileLen = 0;
BinTree* temp[2];
BinTree* root;
Stack stack;
if ( !argv[1] ) {
printHelp();
return EXIT_FAIL;
}
if ( !strcmp(argv[1], "-e") || !strcmp("--encode", argv[1]) ) {
if ( !argv[2] || !argv[3] ) {
printHelp();
return EXIT_FAIL;
}
fileIn = (FILE*)fopen(argv[2], "rt");
if ( !fileIn ) {
printf("Error: file <<%s>> doesn't exists\n", argv[2]);
return EXIT_FAIL;
}
stackInit(&stack);
initializeArrays(symbols, symbolsOrd, ARRAY_LENGTH);
fileLen = readFile(fileIn, symbols); //read symbols; first pass
if ( fileLen == 0 ) {
printf("Error: file <<%s>> is empty\n", argv[2]);
fclose(fileIn);
return EXIT_FAIL;
}
fileOut = (FILE*)fopen(argv[3], "wb");
if ( !fileOut ) {
printf("Error: cannot create file <<%s>>\n", argv[3]);
fclose(fileIn);
return EXIT_FAIL;
}
//sort symbols by frequencies from lower to greatest
qsort(symbolsOrd, ARRAY_LENGTH, sizeof(Symbol*), compareSym);
fillStack(symbolsOrd, &stack, ARRAY_LENGTH); //prepare stack
root = buildTree(&stack);
createPath(root, 0); //0 - starting depth
rewind(fileIn); //reopen fileIn; prepare second pass
//write all compressed data
saveToFile(fileIn, fileOut, symbols, root, argv[2], fileLen);
//memory cleanup
binTreeRemove(root);
fclose(fileOut);
fclose(fileIn);
} else if ( !strcmp(argv[1], "-d") || !strcmp("--decode", argv[1]) ) {
if ( !argv[2] ) {
printHelp();
return EXIT_FAIL;
}
fileIn = fopen(argv[2], "rb");
if ( !fileIn ) {
printf("Error: file <<%s>> doesn't exists\n", argv[2]);
return EXIT_FAIL;
}
if ( !loadFromFile(fileIn, argv[3] ? argv[3] : NULL) ) {
printf("Error: file <<%s>> corrupted or cannot create file <<%s>>\n",
argv[2], argv[3]);
fclose(fileIn);
return EXIT_FAIL;
}
fclose(fileIn);
} else {
printHelp();
}
return EXIT_SUCCESS;
}
