Thread: I need help with looping lowest priority values first

Starting with your code from the last message:

Code:

while(needToContinue)
{
needToContinue = false;

	for(num_procs=0;num_procs<199;++num_procs)//loop through the array
	{
	while (proc[num_procs].priority) {
	do { 
		while (proc[num_procs].priority == 0 ) 
		{
			proc[num_procs].quantum--; // this seems to be doing nothing 
			printf("%s %d %d \n",proc[num_procs].id, proc[num_procs].quantum, proc[num_procs].priority);
	 	} 
	   } 	while (proc[num_procs].quantum > 0 ); // ensure theres quatum left
	}	
		if(proc[num_procs].quantum > 0)
		{
		proc[num_procs].quantum--;
		printf("%s %d %d \n",proc[num_procs].id, proc[num_procs].quantum, proc[num_procs].priority);
		}
	}
}

I changed the indentation to make it readable to me. You did not have a consistent indentation style. You may not like mine; fine. But you need a consistent one. With a new indentation it looks like:

Code:

while(needToContinue)
{
   needToContinue = false;
 
   for(num_procs=0;num_procs<199;++num_procs)//loop through the array
   {
      while (proc[num_procs].priority) {
         do { 
            while (proc[num_procs].priority == 0 ) 
            {
               proc[num_procs].quantum--; // this seems to be doing nothing 
               printf("%s %d %d \n",
                       proc[num_procs].id, 
                       proc[num_procs].quantum, 
                       proc[num_procs].priority);
            } 
         } while (proc[num_procs].quantum > 0 ); // ensure theres quatum left
      }   
      if(proc[num_procs].quantum > 0)
      {
         proc[num_procs].quantum--;
         printf("%s %d %d \n",
                 proc[num_procs].id, 
	         proc[num_procs].quantum, 
                 proc[num_procs].priority);
      }
   }
}

So you have four layers of loop structures. Most people cannot manage code with four layers of loops.

But lets see what we can learn from some simple restructuring. I am NOT trying to change the function of the code. I am going to show you my thinking as we go.

I am NOT testing these changes so I could easily make an error.

I am not trying to fix this code, because I do not understand what you are trying to do. I do not think you have given a clear explanation of what you are trying to do.

Code:

while(needToContinue)
{
   needToContinue = false;
 
   .
   .
   .
}

OK, this is outter most loop. Unless, I missed something, needToContinue is not set anywhere else inside the loop. So this loop will execute 0 or 1 times depending on the initial value of needToContinue. Well, 0 or 1 times sounds like an if statement.

Code:

if (needToContinue)
{
   .
   .
   .
}

Inside the if statement, we have this for loop.

Code:

 
   for(num_procs=0;num_procs<199;++num_procs)//loop through the array
   {
       .
       .
       .
   }

It contains a while loop and an if statement. That for loop seems straight forward. Let's look at the while loop.

Code:

      while (proc[num_procs].priority) {
         .
         .
         .
      }

This while loop executes 0 times if proc[num_procs].priority is 0. Since this value is not changed inside the loop, if it is not zero this will be an infinite loop unless the value of the .priority changes during the loop or if there is a break or goto statement in the loop.

Since it is an infinite loop, the if statement that follows it will never be executed.

Inside the probably infinite while loop, we have a do ... while loop. And inside it is a while loop. It is only inside that inner while loop that we decrement the proc[num_procs].quantum which controls this loop. Since this is a do ... while loop we will execute at least one time.

Code:

         do { 
            while (proc[num_procs].priority == 0 ) 
            {
               proc[num_procs].quantum--; // this seems to be doing nothing 
               printf("%s %d %d \n",
                       proc[num_procs].id, 
                       proc[num_procs].quantum, 
                       proc[num_procs].priority);
            } 
         } while (proc[num_procs].quantum > 0 ); // ensure theres quatum left

Now to look at that inner while loop. It executes 0 times if proc[num_procs].priority is not 0 and probably infinite times if it is zero. But from the outer while loop that we looked at earlier (the one that probably is infinite), we know that proc[num_procs].priority is not zero. So the contents of this while loop will not execute. That would explain why the decrement statement that you put the comment on saying "this seems to be doing nothing" is correct because it never gets executed.

I hope this helps you to read your own code. And it provides a beginning to restructuring your code to do what you really want (whatever that is).

Thanks for your feedback guys, I have took what you said into consideration, but with some of the terminology used I didn't quite understand :\ sorry.

Right, after revising my code I have managed to do exactly what i wanted to do, but only with priorities that are of value 0. Which for me is better than nothing.

I know what i need to do know, and that is to get something that will reference where my first process of that priority group is at, so that i can return. As my index is at [0] on this line it only works for the priority group 0. But i need something that will do this for all priority values.

And again with the highest_priority variable i need this to jump back to the loop, increment by 1, return to back to the loop to process that priority value. You're probably laughing at me using something like the goto statement but as i said im new to C and i'm trying my hardest.

Sorry if i haven't written this very clear, i'm not the best at explaining myself
Thank you for any feed back

Code:

proc[num_procs].priority = proc[0].priority; // go back to the first process of

Code:

int highest_priority = 0;
bool needToContinue = 1;
while(needToContinue)
{
    priority: 
    //reset the flag each loop of the array
    needToContinue = false;
    
    //loop thru the entire array
    for(num_procs=0;num_procs<199;++num_procs) //loop through the array
    {
    do { 
        if (proc[num_procs].quantum > 0 ) // As long as theres qauntum left
        {
            if ( proc[num_procs].priority == highest_priority ) // and the priority is the current highest
            {
                proc[num_procs].quantum--; // give process time on cpu 
                printf("%s %d %d \n",
                proc[num_procs].id,
                proc[num_procs].quantum, 
                proc[num_procs].priority);
                ++num_procs; // move the index onto the next process
            }
            if ( proc[num_procs].priority != highest_priority ) // if its last process, of that priority group
            proc[num_procs].priority = proc[0].priority; // go back to the first process of that priority group

            needToContinue = true; // Return to outer while loop  
         } 
       }    
               while (proc[num_procs].quantum > 0); // checking process is 'still alive'          
    }
}

/* I was thinking something very roughly along the lines of this */
if ( highest_priority < 20 ) // return to outer while loop to go through the whole process again
{
++highest_priority; // go to next priority group 0, 1, 2, ... 20
goto priority;
}

You needed to just go back and do what Salem said in the first post.

Code:

#include<stdio.h>
#include<stdlib.h>
#define PRIORITIES 3
#define DEPTH 5
#define QUEUE 10

int main( void )
{
    struct pqueue
    {
        int priority;
        int value;
    } pq[ QUEUE ];
    
    /* fill the queue with random junk */
    for( int x = 0; x < QUEUE; x++ )
    {
        pq[ x ].priority = x / (1 + PRIORITIES);
        pq[ x ].value = 1 + (rand () % DEPTH);
        printf( "pq[ %d ].priority %d, pq[ %d ].value %d\n",
            x, pq[ x ].priority, x, pq[ x ].value );
    }
    
    /* process each priority */
    for( int sb = 0, nsb = 0, priority = 0; priority < PRIORITIES; priority++ )
    {
        sb = nsb; /* Set the start bucket to the next start bucket. */

        printf( "Starting priority %d.\n", priority );
        /* process this priority level */
        for( int fp = 1, vsum = 0, ntp = 0, pcur = 0; ; pcur++ )
        {

            /* If we have gone too far... */

            if( sb + pcur == QUEUE || pq[ sb + pcur ].priority > priority )
            {
                if( fp ) /* Is this the first pass? */
                {
                    nsb = sb + pcur; /* set next bucket */
                    fp = 0;
                    ntp += vsum;
                    
                    printf( "Priority %d, vsum %d\n", priority, vsum );
                }
                pcur = 0; /* reset bucket */

                if( ntp == 0 ) /* Do we have any that we need to process? */
                {
                    printf( "Priority %d finished.\n\n", priority );
                    break;
                }
            }

            /* If we have a value to process... */
            if( pq[ sb + pcur ].value > 0 )
            {
                if( fp ) /* On the first pass, sum bucket values. */
                {
                    vsum += pq[ sb + pcur ].value;
                }
                ntp--;

                printf( "Processing priority %d, bucket pq[ %d ], value %d, ntp %d\n",
                    priority, sb + pcur, pq[ sb + pcur ].value, ntp );
            
                pq[ sb + pcur ].value--;
            }      
        }
        
        
    }

    return 0;
}

Quzah.