static char *pfout(CSOUND *csound, SRTBLK *bp, char *p,
int lincnt, int pcnt, CORFIL *sco)
{
switch (*p) {
case 'n':
p = nextp(csound, bp,p, lincnt, pcnt, sco);
break;
case 'p':
p = prevp(csound, bp,p, lincnt, pcnt, sco);
break;
case '<':
case '>':
p = ramp(csound, bp,p, lincnt, pcnt, sco);
break;
case '(':
case ')':
p = expramp(csound, bp, p, lincnt, pcnt, sco);
break;
case '~':
p = randramp(csound, bp, p, lincnt, pcnt, sco);
break;
case '"':
p = pfStr(csound, p, lincnt, pcnt, sco);
break;
default:
p = fpnum(csound, p, lincnt, pcnt, sco);
break;
}
return(p);
}
uint DecodeBlock(uchar *bin, FILE *fo) {
register int i,pos; step();
if(!(n=px.Decode(bin))) return 0;
baza = px.ran_decode(0);
memset(rb, 0, 0x100*sizeof(int));
step(); //Heh
for(i=0; i<n; i++) rb[bin[i]]++;
#define nextp(id) p[rb[bin[id]]++] = id
cumulate(); nextp(baza);
for(i=0; i<baza; i++) nextp(i);
for(i=baza+1; i<n; i++) nextp(i);
#undef nextp
for(pos=baza,i=0; i<n; i++) {
putc(bin[pos = p[pos]],fo);
assert(pos>=0 && pos<n);
}return n;
}
int RoundRobin(int line_number,struct proc process[MAXPROC])
{
front =0;
rear = 0;
frontp =0;
rearp = 0;
int time = 0;
int i,j,k,flag;
int itime = 0;
bool run;
int exec_no;
int quantum=0;
printf("Enter quantun \n:");
scanf("%d",&quantum);
int ariv=9999;
int min=9999;
int ariv_p=-1;
printf("RoundRobin-------------------------------------\n");
int arrival[line_number];
for (i = 0; i < MAXSIZE; i++)
qp[i]=-2;
{
/* code */
}
for (i = 0; i < line_number; i++)
{
arrival[i]=9999;
}
for( i=0; i<line_number; i++)
{
for( j=0; j<line_number; j++)
{
if(process[j].arrival < ariv)
{
flag = 1;
for(k=0; k<i; k++)
{
if (j==arrival[k])
flag=0;
}
if (flag)
{
ariv=process[j].arrival;
ariv_p=j;
}
}
}
arrival[i]=ariv_p;
ariv=9999;
}
for (i = 0; i < line_number; i++)
{
printf("%d\t",arrival[i] );
}
exec_no = arrival[0];
int plast=0;
time=0;
min = process[exec_no].cpu[process[exec_no].pointer];
while(finish(process))
{
//min=9999;
for (i = 0; i < line_number; i++)
{
if(time==process[i].arrival)
if(frontp==rearp)
addp(i);
else
if(qp[rearp-1]!=i)
add(i);
}
i=frontp+1; j=frontp;
if(nextp())
{
if(process[qp[i]].arrival<=time)
{
int temp = qp[i];
if(process[qp[i]].cpuf==true)
{
if(process[qp[i]].pointer < process[qp[i]].max)
{
min = process[qp[i]].cpu[process[qp[i]].pointer];
if(min>0)
{
exec_no = qp[i];
if(!qp_empty())
delp();
addp(qp[j]);
break;
}
}
}
}
}else{
exec_no = qp[frontp];
min = process[qp[frontp]].cpu[process[qp[frontp]].pointer];
}
//printf("%d\n", exec_no);
if (exec_no==-1)
{
run = false;
}
itime=0;
while(process[exec_no].cpu[process[exec_no].pointer] > 0 && (exec_no!=-1))
{
time++;
for (i = 0; i < line_number; i++)
{
if(time==process[i].arrival)
addp(i);
}
if((front != rear) && process[q[front]].cpu[process[q[front]].pointer] > 0 && (process[q[front]].cpuf == false))
{
process[q[front]].cpu[process[q[front]].pointer]--;
}
else if((front != rear) && (q[front] >=0) && (process[q[front]].cpuf == false))
{
process[q[front]].cpuf = true;
//printf("io%d",time);
process[q[front]].pointer++;
del();
}
process[exec_no].cpu[process[exec_no].pointer]--;
itime++;
if (itime>=quantum)
{
break;
}
}
if(exec_no==-1)
{
time++;
if(process[q[front]].cpu[process[q[front]].pointer] > 0 && (front != rear) && (process[q[front]].cpuf == false))
{
process[q[front]].cpu[process[q[front]].pointer]--;
}
else if((q[front] >=0) && front != rear && (process[q[front]].cpuf == false))
{
process[q[front]].cpuf = true;
//printf("io%d",time);
process[q[front]].pointer++;
del();
}
itime++;
if (itime>=quantum)
{
break;
}
}
if (exec_no!=-1 && min!=0)
{
printf("P%d\t: %d\t %d\n",process[exec_no].number,min,itime );
}
if(exec_no!=-1 && (process[exec_no].cpu[process[exec_no].pointer] <= 0))
{
add(exec_no);
plast=exec_no;
process[exec_no].pointer++;
process[exec_no].cpuf = false;
exec_no = -1;
}
}
return 0;
}
int main(int argc, char **argv) {
/* SIMULATION VARIABLES */
int n = 0; // processes
int cs_t = 13; // context switch time (in ms)
int cur_t; // current time (in ms)
FILE* inf; // input file (processes.txt)
if(argc != 1) {
printf("There are no arguments associated with this simulation. Input is read from processes.txt.\n");
return 1;
}
// processes array, beginning with 10
// realloc when necessary
int capacity = 10;
struct process *processes = malloc(capacity * sizeof(struct process));
/* read file */
if((inf = fopen("processes.txt", "r")) != NULL) {
// get current line
char *line = NULL;
size_t nbytes = 0;
while(getline(&line, &nbytes, inf) != -1) {
// preemptive check for capacity
if(n == capacity) {
capacity += 10;
processes = realloc(processes, capacity * sizeof(struct process));
}
// trim the string first
char *newline;
newline = trim(line);
if(*newline != 0) {
// get values
int pn, bt, bn, it;
sscanf(newline, "%i|%i|%i|%i", &pn, &bt, &bn, &it);
// store values
processes[n].num = pn;
processes[n].b_t = bt;
processes[n].b_n = bn;
processes[n].io_t = it;
processes[n].enq = n;
++n;
}
}
// free memory
free(line);
/* ===begin simulation=== */
/**
* status is a numerical indicator of the state
* the current process is in:
* 0 - not running / terminated
* 1 - using cpu
* 2 - performing i/o
*/
// initialize timekeeping
cur_t = 0;
int cur_cs_t = cs_t; // current context switch time
int proc_t[sizeof(processes)] = { -1 }; // individual prcess times
int proc_s[sizeof(processes)] = { 0 }; // individual process status
int i; // for loop iterator
int in_use = 0; // defines whether a processor is in use or not
// copy processes to queue
struct process queue[sizeof(processes)];
memcpy(queue, processes, sizeof(struct process) * sizeof(processes));
event_call(cur_t, 0, '0', queue);
// start timer!
while(cur_t != -1) {
++cur_t;
// switching context
if(cur_cs_t > 0) --cur_cs_t;
// switched context
if(cur_cs_t == 0) {
--cur_cs_t;
// check if open process available and run it if possible
int idx = nextp(queue);
if(idx != -1 && !in_use) {
in_use = 1;
int process = queue[idx].num;
proc_s[idx] = 1; // set status to using cpu
proc_t[idx] = queue[idx].b_t + 1; // start timer
--queue[idx].b_n; // decrement burst number
pop(queue); // pop the highest process
event_call(cur_t, process, '1', queue);
}
}
// process timers
for(i = 0; i < sizeof(processes); ++i) {
// check if theres a timer associated with that process
if(proc_t[i] > 0) {
--proc_t[i];
// handle events
if(proc_t[i] == 0) {
// completed cpu burst
if(proc_s[i] == 1) {
proc_s[i] = 2;
proc_t[i] = queue[i].io_t;
in_use = 0;
cur_cs_t = cs_t; // switch contexts if possible
// if process does not require i/o
if(proc_t[i] == 0) {
if(queue[i].b_n <= 0) {
event_call(cur_t, queue[i].num, '5', queue);
if(done(queue)) {
event_call(cur_t, 0, '6', queue);
cur_t = -1;
}
}
else {
push(queue, i);
event_call(cur_t, queue[i].num, '2', queue);
}
proc_s[i] = 0;
}
else {
if(queue[i].b_n != 0) {
event_call(cur_t, queue[i].num, '2', queue);
event_call(cur_t, queue[i].num, '3', queue);
}
// terminate process
else {
proc_t[i] = 0;
proc_s[i] = 0;
event_call(cur_t, queue[i].num, '5', queue);
if(done(queue)) {
event_call(cur_t, 0, '6', queue);
cur_t = -1;
}
}
}
}
// completed i/o
else if(proc_s[i] == 2) {
proc_s[i] = 0;
if(!in_use) cur_cs_t = cs_t;
// finished burst
if(queue[i].b_n <= 0) {
if(done(queue)) {
event_call(cur_t, 0, '6', queue);
cur_t = -1;
}
else event_call(cur_t, queue[i].num, '5', queue);
}
else {
push(queue, i);
event_call(cur_t, queue[i].num, '4', queue);
}
}
}
}
}
}
}
else {
printf("Error: Couldn't open processes.txt for reading.\n");
}
// free memory and exit gracefully
free(processes);
return 0;
}
