main()
{
int error;
int i;
int pagenum,*buf;
int *buf1,*buf2;
int fd1,fd2;
/* create a few files */
if ((error=PF_CreateFile(FILE1))!= PFE_OK){
PF_PrintError("file1");
exit(1);
}
printf("file1 created\n");
if ((error=PF_CreateFile(FILE2))!= PFE_OK){
PF_PrintError("file2");
exit(1);
}
printf("file2 created\n");
/* write to file1 */
writefile(FILE1);
/* print it out */
readfile(FILE1);
/* write to file2 */
writefile(FILE2);
/* print it out */
readfile(FILE2);
/* open both files */
if ((fd1=PF_OpenFile(FILE1))<0){
PF_PrintError("open file1\n");
exit(1);
}
printf("opened file1\n");
if ((fd2=PF_OpenFile(FILE2))<0 ){
PF_PrintError("open file2\n");
exit(1);
}
printf("opened file2\n");
/* get rid of records 1, 3, 5, etc from file 1,
and 0,2,4,6 from file2 */
for (i=0; i < PF_MAX_BUFS; i++){
if (i & 1){
if ((error=PF_DisposePage(fd1,i))!= PFE_OK){
PF_PrintError("dispose\n");
exit(1);
}
printf("disposed %d of file1\n",i);
}
else {
if ((error=PF_DisposePage(fd2,i))!= PFE_OK){
PF_PrintError("dispose\n");
exit(1);
}
printf("disposed %d of file2\n",i);
}
}
if ((error=PF_CloseFile(fd1))!= PFE_OK){
PF_PrintError("close fd1");
exit(1);
}
printf("closed file1\n");
if ((error=PF_CloseFile(fd2))!= PFE_OK){
PF_PrintError("close fd2");
exit(1);
}
printf("closed file2\n");
/* print the files */
readfile(FILE1);
readfile(FILE2);
/* destroy the two files */
if ((error=PF_DestroyFile(FILE1))!= PFE_OK){
PF_PrintError("destroy file1");
exit(1);
}
if ((error=PF_DestroyFile(FILE2))!= PFE_OK){
PF_PrintError("destroy file2");
exit(1);
}
/* create them again */
if ((fd1=PF_CreateFile(FILE1))< 0){
PF_PrintError("create file1");
exit(1);
}
printf("file1 created\n");
if ((fd2=PF_CreateFile(FILE2))< 0){
PF_PrintError("create file2");
exit(1);
}
printf("file2 created\n");
/* put stuff into the two files */
writefile(FILE1);
writefile(FILE2);
/* Open the files, and see how the buffer manager
handles more insertions, and deletions */
/* open both files */
if ((fd1=PF_OpenFile(FILE1))<0){
PF_PrintError("open file1\n");
exit(1);
}
printf("opened file1\n");
if ((fd2=PF_OpenFile(FILE2))<0 ){
PF_PrintError("open file2\n");
exit(1);
}
printf("opened file2 ccex\n");
for (i=PF_MAX_BUFS; i < PF_MAX_BUFS*2 ; i++){
if ((error=PF_AllocPage(fd2,&pagenum,&buf))!= PFE_OK){
PF_PrintError("first buffer\n");
exit(1);
}
*((int *)buf) = i;
if ((error=PF_UnfixPage(fd2,pagenum,TRUE))!= PFE_OK){
PF_PrintError("unfix file1");
exit(1);
}
char *qt = malloc(sizeof(char)*10);
printf("alloc %d file1 \n",i,pagenum);
if ((error=PF_AllocPage(fd1,&pagenum,&qt))!= PFE_OK){
PF_PrintError("first buffer\n");
exit(1);
}
bcopy("fr", qt, 4*sizeof(char));
printf("\n ------ %s ------- \n",qt);
if ((error=PF_UnfixPage(fd1,pagenum,TRUE))!= PFE_OK){
PF_PrintError("dispose file1");
exit(1);
}
printf("alloc %d file2\n",i,pagenum);
}
for (i= PF_MAX_BUFS; i < PF_MAX_BUFS*2; i++){
if (i & 1){
if ((error=PF_DisposePage(fd1,i))!= PFE_OK){
PF_PrintError("dispose fd1");
exit(1);
}
printf("dispose fd1 page %d\n",i);
}
else {
if ((error=PF_DisposePage(fd2,i))!= PFE_OK){
PF_PrintError("dispose fd2");
exit(1);
}
printf("dispose fd2 page %d\n",i);
}
}
printf("getting file2\n");
for (i=PF_MAX_BUFS; i < PF_MAX_BUFS*2; i++){
if (i & 1){
if ((error=PF_GetThisPage(fd2,i,&buf))!=PFE_OK){
PF_PrintError("get this on fd2");
exit(1);
}
printf("%d %d\n",i,*buf);
if ((error=PF_UnfixPage(fd2,i,FALSE))!= PFE_OK){
PF_PrintError("get this on fd2");
exit(1);
}
}
}
printf("getting file1\n");
for (i=PF_MAX_BUFS; i < PF_MAX_BUFS*2; i++){
char *qw;
if (!(i&1)){
if ((error=PF_GetThisPage(fd1,i,&qw))!=PFE_OK){
PF_PrintError("get this on fd2");
exit(1);
}
printf("\n ------ %s ------- \n",qw);
if ((error=PF_UnfixPage(fd1,i,FALSE))!= PFE_OK){
PF_PrintError("get this on fd2");
exit(1);
}
}
}
/* print the files */
printfile(fd2);
printfile(fd1);
/*put some more stuff into file1 */
printf("putting stuff into holes in fd1\n");
for (i=0; i < (PF_MAX_BUFS/2 -1); i++){
if (PF_AllocPage(fd1,&pagenum,&buf)!= PFE_OK){
PF_PrintError("PF_AllocPage");
exit(1);
}
*buf =pagenum;
if (PF_UnfixPage(fd1,pagenum,TRUE)!= PFE_OK){
PF_PrintError("PF_UnfixPage");
exit(1);
}
}
printf("printing fd1");
printfile(fd1);
PF_CloseFile(fd1);
printf("closed file1\n");
PF_CloseFile(fd2);
printf("closed file2\n");
/* open file1 twice */
if ((fd1=PF_OpenFile(FILE1))<0){
PF_PrintError("open file1");
exit(1);
}
printf("opened file1\n");
/* try to destroy it while it's still open*/
error=PF_DestroyFile(FILE1);
PF_PrintError("destroy file1, should not succeed");
/* get rid of some invalid page */
error=PF_DisposePage(fd1,100);
PF_PrintError("dispose page 100, should fail");
/* get a valid page, and try to dispose it without unfixing.*/
if ((error=PF_GetThisPage(fd1,1,&buf))!=PFE_OK){
PF_PrintError("get this on fd2");
exit(1);
}
printf("got page%d\n",*buf);
error=PF_DisposePage(fd1,1);
PF_PrintError("dispose page1, should fail");
/* Now unfix it */
if ((error=PF_UnfixPage(fd1,1,FALSE))!= PFE_OK){
PF_PrintError("get this on fd2");
exit(1);
}
error=PF_UnfixPage(fd1,1,FALSE);
PF_PrintError("unfix fd1 again, should fail");
if ((fd2=PF_OpenFile(FILE1))<0 ){
PF_PrintError("open file1 again");
exit(1);
}
printf("opened file1 again\n");
printfile(fd1);
printfile(fd2);
if (PF_CloseFile(fd1) != PFE_OK){
PF_PrintError("close fd1");
exit(1);
}
if (PF_CloseFile(fd2)!= PFE_OK){
PF_PrintError("close fd2");
exit(1);
}
/* print the buffer */
printf("buffer:\n");
PFbufPrint();
/* print the hash table */
printf("hash table:\n");
PFhashPrint();
}
external_sort() {
int i, j, k, error;
int * buf;
int run_size = 1, run_count = B_R;
int MEM = PF_MAX_BUFS - 1, PREVMEM = MEM;
int fd_inpfile;
if ((fd_inpfile=PF_OpenFile(TMPFILE))<0){
PF_PrintError("Error in opening file");
exit(1);
}
int fd_finalfile;
if ((fd_finalfile=PF_OpenFile(FILE))<0){
PF_PrintError("Error in opening file");
exit(1);
}
// We assume that inpfile contains all the runs and then we merge them and put them in finalfile
// when 1 merge pass is over, we again write back everything to the tmpfile
// repeat
while(run_count > 1) {
int pagenum_finalfile = -1;
//printf("Run count: %d\n", run_count);
//printf("Run Size: %d\n", run_size);
MEM = PREVMEM;
int number_of_merges = run_count / MEM;
if(run_count % MEM != 0)
number_of_merges++;
//printf("Number of merges: %d\n", number_of_merges);
for(i = 0 ; i < number_of_merges ; i++) {
//MEM is the number of runs we merge at once. If say MEM = 4 and run_count = 11, then in the last merge step, we merge just 3 runs. So we set MEM accordingly to 3
if(run_count % MEM != 0 && i == number_of_merges - 1)
MEM = run_count % MEM;
int be[MEM], en[MEM]; // be[j] stores the beginning of j-th run and en[j] = 1 + ending of j-th run. Idea is that when be[j] == en[j], then that run is finished
for(j = 1; j <= MEM; j++) {
be[j - 1] = i * PREVMEM * run_size + (j - 1) * run_size; //simple arithmetic
en[j - 1] = i * PREVMEM * run_size + j * run_size;
}
if(i == number_of_merges - 1) //Since the extremely last run can be shorter than other runs, we need to take care of it. This run will come into picture only in the very last merging iteration
en[MEM - 1] = en[MEM - 1] < B_R ? en[MEM - 1] : B_R; //the ending of the very last run cannot be more than B_R
//for(j = 0; j < MEM; j++)
//printf("be: %d, en: %d\n", be[j], en[j]);
int blocks_written = run_size * (MEM - 1) + (en[MEM - 1] - be[MEM - 1]); //in 1 merge of iteration, we count the number of blocks we are going to write. Again, take care of the last run separately
//printf("blocks written: %d\n", blocks_written);
int *arr[MEM]; // the buffers for the runs that will be merged
for(j = 0 ; j < MEM ; j++) {
//printf("Getting page: %d\n", be[j]);
error = PF_GetThisPage(fd_inpfile, be[j], &arr[j]); // get the first page of each run in the buffer
if(error != PFE_OK)
printf("Error in getting page\n");
//printf("Page value: %d\n", *arr[j]);
}
//start writing blocks one by one
for(k = 0 ; k < blocks_written ; k++) { // here goes the actual merge step
int least = (1 << 30), least_index = -1 ; // least_index -> the run whose head is the smallest. least -> the value of the corresponding head
// Note -> be[j] also acts as a pointer to the starting of each run. during the merging process, the value of be[j] will increment
// if be[j] == en[j], then that particular run is finished
//printf("Yo\n");
for(j = 0 ; j < MEM ; j++) { // this for loop finds the run whose head is the smallest and also the smallest value of the head
if(en[j] != be[j] && *arr[j] < least) {
least = *arr[j];
least_index = j;
}
//if(en[j] == be[j])
//printf("Ignoring\n");
}
//printf("Least: %d\n", least);
//get the next page of the finalfile where the least block is to be written
//note that pagenum_finalfile will automatically be incremented by 1 after the line below
//printf("Getting page number %d of finalfile\n", pagenum_finalfile + 1);
if((error=PF_GetNextPage(fd_finalfile,&pagenum_finalfile,&buf))!= PFE_OK) {
PF_PrintError("Can't get page");
exit(1);
}
//printf("Value of pagenum_finalfile now: %d\n", pagenum_finalfile);
//printf("Writing it by changing buffer\n");
*((int *)buf) = least; // assign the buffer the least value
//printf("unfixing the written page\n");
//unfix the written page
if ((error=PF_UnfixPage(fd_finalfile,pagenum_finalfile,TRUE))!= PFE_OK){
PF_PrintError("unfix buffer\n");
exit(1);
}
//printf("Unfixing the least page\n");
//unfix the least page as well
if ((error=PF_UnfixPage(fd_inpfile,be[least_index],TRUE))!= PFE_OK){
PF_PrintError("unfix buffer\n");
exit(1);
}
be[least_index]++;
if(be[least_index] < en[least_index]) { // if the run which had the *least* head isn't finished, get its next page
be[least_index]--;
if((error=PF_GetNextPage(fd_inpfile , &be[least_index] , &arr[least_index]))!= PFE_OK) {
PF_PrintError("Can't get page");
exit(1);
}
//printf("Fetching next page: %d\n", *arr[least_index]);
}
}
//printf("End of 1 merge iteration\n");
}
copyfiles();
//printf("\n");
run_count = number_of_merges;
run_size = run_size * PREVMEM;
//printf("End of iteration\n");
//readfile(FILE);
}
//swap files here
if ((error=PF_CloseFile(fd_inpfile))!= PFE_OK){
PF_PrintError("Error in closing input file\n");
exit(1);
}
if ((error=PF_CloseFile(fd_finalfile))!= PFE_OK){
PF_PrintError("Error in closing temporary file\n");
exit(1);
}
}
main(int argc, char *argv[])
{
int error;
int i,fd;
int pagenum,*buf;
int *buf1,*buf2;
int fd1,fd2;
int nowrites;
//int stale_file[2][];
if( argc == 3 )
{
printf("output The argument supplied are %s, %s\n", argv[1], argv[2]);
//char temp[] = *argv[1];
//nowrites = *argv[2];
sscanf(argv[1], "%d", &filesize);
sscanf(argv[2], "%d", &nowrites);
filesize = filesize*PF_MAX_BUFS;
printf("output final The argument supplied are %d, %d\n", filesize, nowrites);
}
else
{
printf("One argument expected.\n");
filesize = 2*PF_MAX_BUFS;
nowrites = 20;
}
/* create a few files */
if ((error=PF_CreateFile(FILE1))!= PFE_OK){
PF_PrintError("file1");
exit(1);
}
printf("file size - %d", filesize);
int stale_file1[20000];
for (i=0; i<filesize; i++)
{
stale_file1[i] = 0;
}
printf("file1 created\n");
if ((error=PF_CreateFile(FILE2))!= PFE_OK){
PF_PrintError("file2");
exit(1);
}
int stale_file2[20000];
for (i=0; i<filesize; i++)
{
stale_file2[i] = 0;
}
printf("file2 created\n");
/* write to file1 */
writefile(FILE1,stale_file1);
/* print it out */
readfile(FILE1,stale_file1);
//Sequential Updates
reads = 0;
writes = 0;
erases = 0;
if ((fd=PF_OpenFile(FILE1))<0){
PF_PrintError("open file");
exit(1);
}
pagenum = -1;
int temp = 0;
printf("\noutput final Sequential Updates\n");
while (temp<nowrites && (error=PF_GetNextPage(fd,&pagenum,&buf))== PFE_OK)
//for(i=0; i<nowrites; i++)
{
i = pagenum;
temp++;
if ((error=PF_UnfixPage(fd,pagenum,FALSE))!= PFE_OK){
PF_PrintError("unfix");
exit(1);
}
updatefile(FILE1,stale_file1,i);
}
printf("reads - %d\n", reads);
printf("erases - %d\n", erases);
printf("writes - %d\n", writes);
garbagecollect(FILE1,stale_file1);
printf("output file size - %d\n", filesize);
printf("output Number of updates - %d\n", nowrites);
printf("output Number of pages in block - %d\n", PAGEINBLOCK);
printf("output After garbage collection\n");
printf("output final reads - %d\n", reads);
printf("output final erases(in units of blocks) - %d\n", erases/PAGEINBLOCK);
printf("output final writes - %d\n", writes);
if ((error=PF_CloseFile(fd))!= PFE_OK){
PF_PrintError("close file");
exit(1);
}
readfile(FILE1, stale_file1);
/* write to file2 */
writefile(FILE2,stale_file2);
/* print it out */
readfile(FILE2,stale_file2);
//Random Updates
reads = 0;
writes = 0;
erases = 0;
if ((fd=PF_OpenFile(FILE2))<0){
PF_PrintError("open file");
exit(1);
}
pagenum = -1;
temp = 0;
printf("\noutput final Random Updates\n");
while (temp<nowrites && ((error=PF_GetNextPage(fd,&pagenum,&buf))== PFE_OK || error == PFE_EOF) )
//for(i=0; i<nowrites; i++)
{
if(error == PFE_EOF)
{
printf("output EOF reached\n");
pagenum = -1;
continue;
}
i = pagenum;
if ((error=PF_UnfixPage(fd,pagenum,FALSE))!= PFE_OK){
printf("outputerror - %d\n", error);
PF_PrintError("unfix");
exit(1);
}
int j = rand();
if(j%2 == 0) continue;
temp++;
//printf("output i : %d", i);
//int j = rand() % filesize;
updatefile(FILE2,stale_file2,i);
if(temp==nowrites/2)
{
printf("output Before garbage collection1:-\n");
printf("output reads - %d\n", reads);
printf("output erases(in units of blocks) - %d\n", erases/PAGEINBLOCK);
printf("output writes - %d\n", writes);
numpages(FILE2,stale_file2);
printf("output total number of pages - %d, stale pages is - %d\n", numtotal,numstale);
garbagecollect(FILE2,stale_file2);
printf("output After garbage collection1:-\n");
printf("output reads - %d\n", reads);
printf("output erases(in units of blocks) - %d\n", erases/PAGEINBLOCK);
printf("output writes - %d\n", writes);
numpages(FILE2,stale_file2);
printf("output total number of pages - %d, stale pages is - %d\n", numtotal,numstale);
}
}
if(error != PFE_OK)
{
PF_PrintError("output");
}
printf("output Before garbage collection2\n");
printf("output reads - %d\n", reads);
printf("output erases(in units of blocks) - %d\n", erases/PAGEINBLOCK);
printf("output writes - %d\n", writes);
numpages(FILE2,stale_file2);
printf("output total number of pages - %d, stale pages is - %d\n", numtotal,numstale);
garbagecollect(FILE2,stale_file2);
printf("output file size - %d\n", filesize);
printf("output Number of updates - %d, %d\n", temp, nowrites);
printf("output Number of pages in block - %d\n", PAGEINBLOCK);
printf("output After garbage collection2\n");
printf("output final reads - %d\n", reads);
printf("output final erases(in units of blocks) - %d\n", erases/PAGEINBLOCK);
printf("output final writes - %d\n", writes);
numpages(FILE2,stale_file2);
printf("output total number of pages - %d, stale pages is - %d\n", numtotal,numstale);
if ((error=PF_CloseFile(fd))!= PFE_OK){
PF_PrintError("close file");
exit(1);
}
readfile(FILE2, stale_file2);
//readfile(FILE1,stale_file1);
//garbagecollect(FILE1,stale_file1);
//readfile(FILE1,stale_file1);
}
/* Deletes the recId from the list for value and deletes value if list
becomes empty */
AM_DeleteEntry(int fileDesc,char attrType,int attrLength,char* value,int recId)
{
char *pageBuf;/* buffer to hold the page */
int pageNum; /* page Number of the page in buffer */
int index;/* index where key is present */
int status; /* whether key is in tree or not */
short nextRec;/* contains the next record on the list */
short oldhead; /* contains the old head of the list */
short temp;
char *currRecPtr;/* pointer to the current record in the list */
AM_LEAFHEADER head,*header;/* header of the page */
int recSize; /* length of key,ptr pair for a leaf */
int tempRec; /* holds the recId of the current record */
int errVal; /* holds the return value of functions called within
this function */
int i; /* loop index */
/* check the parameters */
if ((attrType != 'c') && (attrType != 'f') && (attrType != 'i'))
{
AM_Errno = AME_INVALIDATTRTYPE;
return(AME_INVALIDATTRTYPE);
}
if (value == NULL)
{
AM_Errno = AME_INVALIDVALUE;
return(AME_INVALIDVALUE);
}
if (fileDesc < 0)
{
AM_Errno = AME_FD;
return(AME_FD);
}
/* initialise the header */
header = &head;
/* find the pagenumber and the index of the key to be deleted if it is
there */
status = AM_Search(fileDesc,attrType,attrLength,value,&pageNum,
&pageBuf,&index);
/* check if return value is an error */
if (status < 0)
{
AM_Errno = status;
return(status);
}
/* The key is not in the tree */
if (status == AM_NOT_FOUND)
{
AM_Errno = AME_NOTFOUND;
return(AME_NOTFOUND);
}
bcopy(pageBuf,header,AM_sl);
recSize = attrLength + AM_ss;
currRecPtr = pageBuf + AM_sl + (index - 1)*recSize + attrLength;
bcopy(currRecPtr,&nextRec,AM_ss);
/* search the list for recId */
while(nextRec != 0)
{
bcopy(pageBuf + nextRec,&tempRec,AM_si);
/* found the recId to be deleted */
if (recId == tempRec)
{
/* Delete recId */
bcopy(pageBuf + nextRec + AM_si,currRecPtr,AM_ss);
header->numinfreeList++;
oldhead = header->freeListPtr;
header->freeListPtr = nextRec;
bcopy(&oldhead,pageBuf + nextRec + AM_si,AM_ss);
break;
}
else
{
/* go over to the next item on the list */
currRecPtr = pageBuf + nextRec + AM_si;
bcopy(currRecPtr,&nextRec,AM_ss);
}
}
/* if end of list reached then key not in tree */
if (nextRec == AM_NULL)
{
AM_Errno = AME_NOTFOUND;
return(AME_NOTFOUND);
}
/* check if list is empty */
bcopy(pageBuf + AM_sl + (index - 1)*recSize + attrLength,&temp,AM_ss);
if (temp == 0)
{
/* list is empty , so delete key from the list */
for(i = index; i < (header->numKeys);i++)
bcopy(pageBuf + AM_sl + i*recSize,pageBuf + AM_sl +
(i-1)*recSize,recSize);
header->numKeys--;
header->keyPtr = header->keyPtr - recSize;
}
/* copy the header onto the buffer */
bcopy(header,pageBuf,AM_sl);
errVal = PF_UnfixPage(fileDesc,pageNum,TRUE);
/* empty the stack so that it is set for next amlayer call */
AM_EmptyStack();
{
AM_Errno = AME_OK;
return(AME_OK);
}
}
/* Inserts a value,recId pair into the tree */
AM_InsertEntry(int fileDesc,char attrType,int attrLength,char value,int recId)
{
char *pageBuf; /* buffer to hold page */
int pageNum; /* page number of the page in buffer */
int index; /* index where key can be found or can be inserted */
int status; /* whether key is old or new */
int inserted; /* Whether key has been inserted into the leaf or
splitting is needed */
int addtoparent; /* Whether key has to be added to the parent */
int errVal; /* return value of functions within this function */
char key[AM_MAXATTRLENGTH]; /* holds the attribute to be passed
back to the parent */
/* check the parameters */
if ((attrType != 'c') && (attrType != 'f') && (attrType != 'i'))
{
AM_Errno = AME_INVALIDATTRTYPE;
return(AME_INVALIDATTRTYPE);
}
if (value == NULL)
{
AM_Errno = AME_INVALIDVALUE;
return(AME_INVALIDVALUE);
}
if (fileDesc < 0)
{
AM_Errno = AME_FD;
return(AME_FD);
}
/* Search the leaf for the key */
status = AM_Search(fileDesc,attrType,attrLength,value,&pageNum,
&pageBuf,&index);
/* check if there is an error */
if (status < 0)
{
AM_EmptyStack();
AM_Errno = status;
return(status);
}
/* Insert into leaf the key,recId pair */
inserted = AM_InsertintoLeaf(pageBuf,attrLength,value,recId,index,
status);
/* if key has been inserted then done */
if (inserted == TRUE)
{
errVal = PF_UnfixPage(fileDesc,pageNum,TRUE);
AM_Check;
AM_EmptyStack();
return(AME_OK);
}
/* check if there is any error */
if (inserted < 0)
{
AM_EmptyStack();
AM_Errno = inserted;
return(inserted);
}
/* if not inserted then have to split */
if (inserted == FALSE)
{
/* Split the leaf page */
addtoparent = AM_SplitLeaf(fileDesc,pageBuf,&pageNum,
attrLength,recId,value, status,index,key);
/* check for errors */
if (addtoparent < 0)
{
AM_EmptyStack();
{
AM_Errno = addtoparent;
return(addtoparent);
}
}
/* if key has to be added to the parent */
if (addtoparent == TRUE)
{
errVal = AM_AddtoParent(fileDesc,pageNum,key,attrLength);
if (errVal < 0)
{
AM_EmptyStack();
AM_Errno = errVal;
return(errVal);
}
}
}
AM_EmptyStack();
return(AME_OK);
}
/* Creates a secondary idex file called fileName.indexNo */
AM_CreateIndex(char* fileName,int indexNo,char attrType,int attrLength)
{
char *pageBuf; /* buffer for holding a page */
char indexfName[AM_MAX_FNAME_LENGTH]; /* String to store the indexed
files name with extension */
int pageNum; /* page number of the root page(also the first page) */
int fileDesc; /* file Descriptor */
int errVal;
int maxKeys;/* Maximum keys that can be held on one internal page */
AM_LEAFHEADER head,*header;
/* Check the parameters */
if ((attrType != 'c') && (attrType != 'f') && (attrType != 'i'))
{
AM_Errno = AME_INVALIDATTRTYPE;
return(AME_INVALIDATTRTYPE);
}
if ((attrLength < 1) || (attrLength > 255))
{
AM_Errno = AME_INVALIDATTRLENGTH;
return(AME_INVALIDATTRLENGTH);
}
if (attrLength != 4)
if (attrType !='c')
{
AM_Errno = AME_INVALIDATTRLENGTH;
return(AME_INVALIDATTRLENGTH);
}
header = &head;
/* Get the filename with extension and create a paged file by that name*/
sprintf(indexfName,"%s.%d",fileName,indexNo);
errVal = PF_CreateFile(indexfName);
AM_Check;
/* open the new file */
fileDesc = PF_OpenFile(indexfName);
if (fileDesc < 0)
{
AM_Errno = AME_PF;
return(AME_PF);
}
/* allocate a new page for the root */
errVal = PF_AllocPage(fileDesc,&pageNum,&pageBuf);
AM_Check;
allocsDone++;
/* initialise the header */
header->pageType = 'l';
header->nextLeafPage = AM_NULL_PAGE;
header->recIdPtr = PF_PAGE_SIZE;
header->keyPtr = AM_sl;
header->freeListPtr = AM_NULL;
header->numinfreeList = 0;
header->attrLength = attrLength;
header->numKeys = 0;
/* the maximum keys in an internal node- has to be even always*/
maxKeys = (PF_PAGE_SIZE - AM_sint - AM_si)/(AM_si + attrLength);
if (( maxKeys % 2) != 0)
header->maxKeys = maxKeys - 1;
else
header->maxKeys = maxKeys;
/* copy the header onto the page */
bcopy(header,pageBuf,AM_sl);
errVal = PF_UnfixPage(fileDesc,pageNum,TRUE);
AM_Check;
/* Close the file */
errVal = PF_CloseFile(fileDesc);
AM_Check;
/* initialise the root page and the leftmost page numbers */
AM_RootPageNum = pageNum;
return(AME_OK);
}
AM_PrintTreeBulk(int fileDesc, int attrLength, int pageRoot){
char* pageBuf;
int pageNum = AM_RootPageNum;
int errVal = PF_GetThisPage(fileDesc, pageNum, &pageBuf);
AM_Check;
AM_LEAFHEADER leafhead;
AM_INTHEADER inthead;
AM_LEAFHEADER *leafheader = &leafhead;
AM_INTHEADER *intheader = &inthead;
bcopy(pageBuf, leafheader, AM_sl);
char c = leafheader->pageType;
printf("Node %d: ", pageNum);
if(c=='l'){
printf("Leaf : Value->Record: ");
int num = leafheader->numKeys;
int i;
for(i=0; i<num; i++){
int recSize = attrLength + AM_ss;
int offset = AM_sl + recSize*(i);
int temp;
int temp2;
int temp3;
bcopy(pageBuf + offset, &temp2, attrLength);
bcopy(pageBuf + offset + attrLength, &temp, AM_ss);
bcopy(pageBuf + temp, &temp3, attrLength);
printf("%d->%d", temp2, temp3);
if(i!=num-1) printf(", ");
}
PF_UnfixPage(fileDesc, pageNum, FALSE);
printf("\n");
return;
}
if(c=='i'){
printf("Internal: P/V/P/V :");
bcopy(pageBuf, intheader, AM_sint);
int num=intheader->numKeys;
int i;
int offset = AM_sint;
int temp, temp2;
bcopy(pageBuf + offset, &temp, AM_si);
bcopy(pageBuf + offset + AM_si, &temp2, attrLength);
//printf("internal first pointer %d %d\n", temp, temp2);
printf("%d ",temp);
for(i=1; i<num; i++){
int recSize = attrLength + AM_si;
offset = AM_sint + AM_si + (i-1)*recSize;
bcopy(pageBuf + offset, &temp, attrLength);
bcopy(pageBuf + offset + attrLength, &temp2, AM_si);
printf("%d %d ",temp,temp2);
}
printf("\n");
}
}
AM_BulkLoadInternal(int fileDesc, char* fileName,int indexNo,char attrType,int attrLength,int* pages, int* values, int* newPages, int* newValues, int* globalindex, int* leafSize, int earlyExit)
{
char *pageBuf; /* buffer for holding a page */
char indexfName[AM_MAX_FNAME_LENGTH]; /* String to store the indexed
files name with extension */
int pageNum=-1; /* page number of the root page(also the first page) */
int errVal;
int maxKeys;/* Maximum keys that can be held on one internal page */
// vector_init(&pagenNumNextLevel);
// vector_init(&valuesNextLevel);
maxKeys = (PF_PAGE_SIZE - AM_sint - AM_si)/(AM_si + attrLength);
if (( maxKeys % 2) != 0)
maxKeys--;
int numLeaves = globalindex[0];
globalindex[0]=0;
AM_INTHEADER head,*header;
int recSize = attrLength + AM_si;
/* Check the parameters */
if ((attrType != 'c') && (attrType != 'f') && (attrType != 'i'))
{
AM_Errno = AME_INVALIDATTRTYPE;
return(AME_INVALIDATTRTYPE);
}
if ((attrLength < 1) || (attrLength > 255))
{
AM_Errno = AME_INVALIDATTRLENGTH;
return(AME_INVALIDATTRLENGTH);
}
if (attrLength != 4)
if (attrType !='c')
{
AM_Errno = AME_INVALIDATTRLENGTH;
return(AME_INVALIDATTRLENGTH);
}
header = &head;
/* open the new file */
/* allocate a new page for the root */
int haveToAllocate = 1;
int recNum;
int index;
int first=1;
//printf("Numleaves %d\n", numLeaves);
for(recNum=0; recNum<numLeaves; ) {
//printf("Recnum: %d\n", recNum);
int value = values[recNum];
int page = pages[recNum];
if(haveToAllocate==1 && first!=1){
if(leafSize[0]==-1){
if(earlyExit==1){
leafSize[0]=index-1;
printf("exiting\n");
return (AME_OK);
}
}
}
if(haveToAllocate==1){
//printf("having to allocate\n");
first=0;
index=1;
if(pageNum>0) {
AM_LEAFHEADER thead,*theader;
theader=&thead;
bcopy(pageBuf,theader,AM_sl);
sizeallocated=sizeallocated+(theader->numKeys)*(AM_si+attrLength) + AM_sint;
PF_UnfixPage(fileDesc, pageNum, TRUE);
}
errVal = PF_AllocPage(fileDesc, &pageNum, &pageBuf);
AM_Check;
allocsDone++;
//help("alloced");
//printf("MARKER :%d\n", pageNum);
newPages[globalindex[0]]=pageNum;
newValues[globalindex[0]]=value;
globalindex[0]++;
// vector_add(&pagenNumNextLevel, temp1);
// vector_add(&valuesNextLevel, temp2);
/* initialise the header */
header->pageType = 'i';
header->numKeys=0;
header->maxKeys=maxKeys;
header->attrLength=attrLength;
/* copy the header onto the page */
bcopy(header,pageBuf,AM_sint);
haveToAllocate=0;
}
if(earlyExit==0){
int alreadyDone = index-1;
int leftInLeaf = leafSize[0]-alreadyDone;
int leftInFile = numLeaves - recNum;
if(leftInFile == (leafSize[0]+1)/2){
if(leftInLeaf < leftInFile){
haveToAllocate=1;
continue;
}
}
}
if(header->numKeys >= header->maxKeys || index>leafSize[0]&&leafSize[0]!=-1){
haveToAllocate=1;
continue;
}
if(index!=1){
//bcopy((char*) &values[recNum], pageBuf + AM_sl + (index-1)*recSize + AM_si, attrLength);
//bcopy((char*) &pages[recNum], pageBuf + AM_sl + (index-1)*recSize + attrLength, AM_si);
bcopy((char*) &values[recNum], pageBuf + AM_sint + (index-2)*recSize + AM_si, attrLength);
bcopy((char*) &pages[recNum], pageBuf + AM_sint + (index-2)*recSize + AM_si + attrLength, AM_si);
bcopy(pageBuf, header, AM_sint);
header->numKeys++;
bcopy(header, pageBuf, AM_sint);
}
if(index==1){
bcopy((char*) &pages[recNum], pageBuf + AM_sint, AM_si);
//bcopy((char*) &pages[recNum], pageBuf + AM_sl, AM_si);
// sizeallocated=sizeallocated+AM_si;
bcopy(pageBuf, header, AM_sint);
header->numKeys++;
bcopy(header, pageBuf, AM_sint);
}
index++;
recNum++;
}
if(leafSize[0]==-1)
leafSize[0]=numLeaves;
AM_LEAFHEADER thead1,*theader1;
theader1=&thead1;
bcopy(pageBuf,theader1,AM_sl);
sizeallocated=sizeallocated+(theader1->numKeys)*(AM_si+attrLength) + AM_sint;
errVal = PF_UnfixPage(fileDesc,pageNum,TRUE);
//AM_Check;
/* Close the file */
errVal = PF_CloseFile(fileDesc);
AM_Check;
return(AME_OK);
}
AM_BulkLoadLeaf(int fileDesc, char* fileName,int indexNo,char attrType,int attrLength,int MAXRECS, int* pagenNumNextLevel, int* valuesNextLevel, int* globalindex, int* leafSize, int earlyExit, char *readFilename)
{
char *pageBuf; /* buffer for holding a page */
char indexfName[AM_MAX_FNAME_LENGTH]; /* String to store the indexed
files name with extension */
int pageNum; /* page number of the root page(also the first page) */
int errVal;
int maxKeys;/* Maximum keys that can be held on one internal page */
// vector_init(&pagenNumNextLevel);
// vector_init(&valuesNextLevel);
globalindex[0]=0;
AM_LEAFHEADER head,*header;
int recSize = attrLength + AM_ss;
/* Check the parameters */
if ((attrType != 'c') && (attrType != 'f') && (attrType != 'i'))
{
AM_Errno = AME_INVALIDATTRTYPE;
return(AME_INVALIDATTRTYPE);
}
if ((attrLength < 1) || (attrLength > 255))
{
AM_Errno = AME_INVALIDATTRLENGTH;
return(AME_INVALIDATTRLENGTH);
}
if (attrLength != 4)
if (attrType !='c')
{
AM_Errno = AME_INVALIDATTRLENGTH;
return(AME_INVALIDATTRLENGTH);
}
header = &head;
/* Get the filename with extension and create a paged file by that name*/
sprintf(indexfName,"%s.%d",fileName,indexNo);
/* allocate a new page for the root */
int previousValue;
int haveToAllocate = 1;
// int recNum;
int index;
int first=1;
FILE* file = fopen(readFilename, "r");
int recNum = 0;
fscanf(file, "%d", &recNum);
// for(recNum=0; recNum<MAXRECS; ) {
while (!feof (file))
{
// printf("%d\n", recNum);
int value = recNum;
if(haveToAllocate ==1 && first==1){
first=0;
index=1;
previousValue=-1;
errVal = PF_AllocPage(fileDesc, &pageNum, &pageBuf);
AM_Check;
allocsDone++;
//if(earlyExit != 1)
//printf("MARKER :%d\n", pageNum);
pagenNumNextLevel[globalindex[0]]=pageNum;
valuesNextLevel[globalindex[0]]=value;
globalindex[0]++;
// vector_add(&pagenNumNextLevel, temp1);
// vector_add(&valuesNextLevel, temp2);
/* initialise the header */
header->pageType = 'l';
header->nextLeafPage = AM_NULL_PAGE;
header->recIdPtr = PF_PAGE_SIZE;
header->keyPtr = AM_sl;
header->freeListPtr = AM_NULL;
header->numinfreeList = 0;
header->attrLength = attrLength;
header->numKeys = 0;
/* the maximum keys in an internal node- has to be even always*/
maxKeys = (PF_PAGE_SIZE - AM_sint - AM_si)/(AM_si + attrLength);
if (( maxKeys % 2) != 0)
header->maxKeys = maxKeys - 1;
else
header->maxKeys = maxKeys;
/* copy the header onto the page */
bcopy(header,pageBuf,AM_sl);
// sizeallocated=sizeallocated+AM_sl;
AM_LeftPageNum = pageNum;
haveToAllocate=0;
}
else if(haveToAllocate==1 && first==0){
first=0;
haveToAllocate=0;
previousValue=-1;
// point old guy to new guy, unfix old guy
AM_LEAFHEADER temp;
AM_LEAFHEADER *tempheader=&temp;
int newPageNum;
char* newPageBuf;
if(leafSize[0]==-1){
if(earlyExit==1){
leafSize[0]=index-1;
return (AME_OK);
}
}
index=1;
errVal = PF_AllocPage(fileDesc,&newPageNum,&newPageBuf);
AM_Check;
allocsDone++;
//printf("MARKER old, page:%d, %d\n", pageNum, newPageNum);
bcopy(pageBuf,tempheader,AM_sl);
tempheader->nextLeafPage = newPageNum;
bcopy(tempheader,pageBuf,AM_sl);
// sizeallocated=sizeallocated+()AM_ss+attrLength;
AM_LEAFHEADER thead1,*theader1;
theader1=&thead1;
bcopy(pageBuf,theader1,AM_sl);
sizeallocated=sizeallocated+(theader1->numKeys)*(AM_ss+attrLength) + AM_sl;
errVal = PF_UnfixPage(fileDesc, pageNum, TRUE);
AM_Check;
pageNum = newPageNum;
pageBuf = newPageBuf;
pagenNumNextLevel[globalindex[0]]=pageNum;
valuesNextLevel[globalindex[0]]=value;
globalindex[0]++;
// char temp1[20];
// char temp2[20];
// sprintf(temp1, "%d", pageNum);
// sprintf(temp2, "%d", value);
// printf("%d\n",myAtoi(temp1) );
// vector_add(&pagenNumNextLevel, temp1);
// vector_add(&valuesNextLevel, temp2);
/* initialise the header */
header->pageType = 'l';
header->nextLeafPage = AM_NULL_PAGE;
header->recIdPtr = PF_PAGE_SIZE;
header->keyPtr = AM_sl;
header->freeListPtr = AM_NULL;
header->numinfreeList = 0;
header->attrLength = attrLength;
header->numKeys = 0;
/* the maximum keys in an internal node- has to be even always*/
maxKeys = (PF_PAGE_SIZE - AM_sint - AM_si)/(AM_si + attrLength);
if (( maxKeys % 2) != 0)
header->maxKeys = maxKeys - 1;
else
header->maxKeys = maxKeys;
/* copy the header onto the page */
bcopy(header,pageBuf,AM_sl);
}
if(earlyExit==0){
int alreadyDone = index-1;
int leftInLeaf = leafSize[0]-alreadyDone;
int leftInFile = MAXRECS - recNum;
if(leftInFile == (leafSize[0]+1)/2){
if(leftInLeaf < leftInFile){
haveToAllocate=1;
continue;
}
}
}
if(index> leafSize[0] && leafSize[0]!=-1){
haveToAllocate=1;
continue;
}
if (previousValue == value)
/* key is already present */
{
if (header->freeListPtr == 0)
if ((header->recIdPtr - header->keyPtr) <(AM_si + AM_ss) || index>=leafSize[0] && leafSize[0]!=-1)
{
/* no room for one more record */
haveToAllocate=1;
continue;
}
/* insert into leaf - no need to split */
AM_InsertToLeafFound(pageBuf,recNum,index,header);
// sizeallocated=sizeallocated+AM_ss+attrLength;
help("do not happen yet");
bcopy(header,pageBuf,AM_sl);
haveToAllocate=0;
// recNum++;
fscanf (file, "%d", &recNum);
index++;
previousValue=value;
continue;
}
if ((header->freeListPtr) == 0){
/* freelist empty */
if ((header->recIdPtr - header->keyPtr) < (AM_si + AM_ss + recSize)){
haveToAllocate=1;
continue;
}
else
{
int value2 = value;
AM_InsertToLeafNotFound(pageBuf,&value2,recNum,index,header);
header->numKeys++;
bcopy(header,pageBuf,AM_sl);
haveToAllocate=0;
// recNum++;
fscanf (file, "%d", &recNum);
index++;
previousValue=value;
continue;
}
}
else{ /* no place in the middle */
if (((header->numinfreeList)*(AM_si + AM_ss) + header->recIdPtr - header->keyPtr) > (recSize + AM_si + AM_ss))
/*there is enough space in the freelist and in the middle put together */
{
char tempPage[PF_PAGE_SIZE];
/* Compact the freelist so that we get enough space in the middle so that the new key can be inserted */
AM_Compact(1,header->numKeys,pageBuf,tempPage,header);
help("We think this should never happen\n");
bcopy(tempPage,pageBuf,PF_PAGE_SIZE);
bcopy(pageBuf,header,AM_sl);
/* Insert into leaf a new key - no need to split */
AM_InsertToLeafNotFound(pageBuf,&value,recNum,index,header);
// sizeallocated=sizeallocated+AM_ss+attrLength;
header->numKeys++;
bcopy(header,pageBuf,AM_sl);
haveToAllocate=0;
// recNum++;
fscanf (file, "%d", &recNum);
previousValue=value;
continue;
}
else{ /* there is not enough room in the page */
haveToAllocate=1;
// recNum++;
fscanf (file, "%d", &recNum);
index++;
previousValue=value;
}
}
}
if(leafSize[0]==-1)
leafSize[0]=MAXRECS;
AM_LEAFHEADER thead,*theader;
theader=&thead;
bcopy(pageBuf,theader,AM_sl);
sizeallocated=sizeallocated+(theader->numKeys)*(AM_ss+attrLength) + AM_sl;
errVal = PF_UnfixPage(fileDesc,pageNum,TRUE);
//AM_Check;
/* Close the file */
errVal = PF_CloseFile(fileDesc);
AM_Check;
fclose(file);
return(AME_OK);
}
void create_input_pages() {
int totalRecsAdded;
int error;
if ((error=PF_CreateFile(MERGESORTFILE))!= PFE_OK){
PF_PrintError( "Error in creating mergesortfile");
exit(1);
}
//- printf("mergesortfile created\n");
int fd,pagenum;
char *buf;
pagenum = -1;
if ((fd=PF_OpenFile(MERGESORTFILE))<0){
PF_PrintError("Error in opening mergesortfile");
exit(1);
}
//-printf("opened %s\n", MERGESORTFILE);
if ((error=PF_AllocPage(fd,&pagenum,&buf))!= PFE_OK) {
PF_PrintError("ERROR: failed allocating buffers in create_input_pages\n");
exit(1);
}
//-printf("allocated page %d in create_input_pages\n",pagenum);
//printf("f4f42");
FILE *file = fopen ( filename, "r" );
//printf("f4f42");
fflush(file);
if ( file != NULL ) {
char line[MAXATTRSIZE];
int recsAdded = 0;
totalRecsAdded = 0;
while ( fgets ( line, ATTRSIZE, file ) != NULL ) {
//puts(line);
//printf("%d \n", strlen(line));
if(recsAdded == MAXRECSPERPAGE) {
if ((error=PF_UnfixPage(fd, pagenum, TRUE))!= PFE_OK) {
PF_PrintError("Error in disposing page of mergesortfile");
exit(1);
}
//-printf("deallocated page %d in create_input_pages\n",pagenum);
if ((error=PF_AllocPage(fd,&pagenum,&buf))!= PFE_OK) {
PF_PrintError("ERROR: failed allocating buffers in create_input_pages\n");
exit(1);
}
//-printf("allocated page %d in create_input_pages\n",pagenum);
recsAdded = 0;
bcopy(&recsAdded, buf, si);
}
bcopy(line, buf + si + recsAdded * (ATTRSIZE + si), ATTRSIZE);
totalRecsAdded++;
bcopy((char*)&totalRecsAdded, buf + si + recsAdded * (ATTRSIZE + si) + ATTRSIZE, si);
int abc=recsAdded+1;
bcopy(&abc, buf, si);
// printf("%s ", line);
// bcopy(buf + si + recsAdded * (ATTRSIZE + si), line, ATTRSIZE);
// bcopy(buf + si + recsAdded * (ATTRSIZE + si) + ATTRSIZE, (char*)&totalRecsAdded, si);
// bcopy(buf, &recsAdded, si);
recsAdded++;
// printf("%s %d %d\n", line, totalRecsAdded, recsAdded);
}
//- printf("Totally %d records were added\n", totalRecsAdded);
fclose ( file );
}
else {
perror ( filename ); /* why didn't the file open? */
}
if ((error=PF_UnfixPage(fd, pagenum, TRUE))!= PFE_OK){
PF_PrintError("Error in disposing page of mergesortfile");
exit(1);
}
//-printf("deallocated page %d in create_input_pages\n", pagenum);
if ((error=PF_CloseFile(fd))!= PFE_OK) {
PF_PrintError("Error in closing mergesortfile---");
exit(1);
}
//-printf("mergesortfile closed\n");
}
