Surajit Das Ответов: 2

Обзор циклического кода на языке c++


После множества исследований в интернете и изучения различных исходных кодов. Я подумал о том, чтобы попробовать самому придумать способ написания циклического кода.
Я пытался, но получаю ошибки в определенной части моего вывода. Я не могу сгенерировать диаграмму Гейнта, а также, пожалуйста, может ли кто-нибудь объяснить мне, где я допустил ошибку в расчете моего алгоритма времени ожидания.

Может ли кто-нибудь специально объяснить мне, как я могу получить время ожидания каждого процесса и любезно исправить свой алгоритм .Пожалуйста, у меня есть искренняя просьба. Я сам учусь, и в принципе нет никого, кроме онлайн-статей или книг, которые помогли бы мне понять код. Итак, если вы исправите мою ошибку, пожалуйста, объясните мне вместе с исправлением. Я действительно хочу получить концепцию, потому что я не хочу повторять ту же ошибку снова. Спасибо.


вот мой код:-

#include<iostream>

using namespace std;

int main()
{
	int k,j,q,i,n,ts,temp;
     int aw;                      float awt;
     int bt[10],wt[10],te[10],rt[10],at[10];j=0; //te array stores the number of times a process comes to CPU before completion

	 //bt is my burst time store array
	 //wt is my waiting time array
	 //te keeps a count of the number of times a process enters the CPU before completion
	 //at is the arrival time


	cout<<"Enter number of processes"<<endl;
	 cin>>n;

	 

	 for(i=0;i<n;i++)
	 {
		 
	 cout<<"Enter burst time"<<endl; 

		 cin>>bt[i];

		 cout<<"Enter arrival times"<<endl;
		 cin>>at[i];

		 te[i] = 0; wt[i] = 0;
	 }

	 for(i=0;i<n;i++)
	 {
		 for(j = i+1;j<n;j++)
		 {
			 if(at[j]<at[i])
			 {
				 temp = at[i];
			     at[i] = at[j];
				 at[j] = temp;
             if(at[j] ==at[i])
				 temp = bt[i];
			     bt[i] = bt[j];
				 bt[j] = temp;
			 }
		 }
	 }


	 cout<<"Enter time slice"<<endl;
	 cin>>ts;

	 cout<<"process:"<<endl;

	 
	    for(i=0;i<n;i++)
	 {
		 cout<<"\t"<<i+1<<endl;
	 } 

	 
	 
	cout<<"Burst time:"<<endl;
	for(i=0;i<n;i++)
	{
		cout<<"  "<<bt[i]<<endl;
		rt[i] = bt[i];
	}

	cout<<"arrival time:"<<endl;
	for(i=0;i<n;i++)
	{
		cout<<"  "<<at[i]<<endl;
	}

	cout<<"Gaint chart"<<endl;

	while (j<=n)
	{
		
		j++;

		for(i = 0;i<n;i++)
		{
			if(rt[i] ==0) continue;
			if(rt[i]>=ts)
			{
				cout<<"\t"<<q<<i+1<<endl;
				q = q + ts;
				rt[i] = rt[i] - ts;
				te[i] = te[i] + 1;
			}

			else
			{
				cout<<"  "<<q<<i+1<<endl;
				wt[i] = q-te[i]*ts;
				q = q +rt[i];
				rt[i] = rt[i] - rt[i];
			}
		}
	}

	awt = 0;


	cout<<"Process Waiting Time"<<endl;
	for(i =0;i<n;i++)
	{
		wt[i] = wt[i] - at[i];
		cout<<"  "<<i+1<<endl;
			cout<<wt[i]<<endl;
		awt = awt + wt[i];
	}
	aw = awt;
	cout<<"Total waiting time"<<aw<<endl;
	cout<<"Average waiting time "<<awt/n<<endl;
	
	return 0;


}

2 Ответов

Рейтинг:
2

Andreas Gieriet

Я понимаю, что вы хотите для удовольствия (например, чтобы узнать что-то; -)) *имитировать* простой круговой арбитраж.
Исходя из этого предположения, есть несколько вопросов для обсуждения:
- вы смешиваете все аспекты проблемы в плоскую и неструктурированную кучу вложенных ifs и fors
- вы не используете структуры данных (классы) и функции для соединения вещей, которые принадлежат друг другу
- нет никакого разделения между алгоритмом, входными данными и статистикой.

Давайте начнем со статига прпоблема. Если вы не можете сказать, что вы хотите в прозе или псевдокоде, вам не нужно начинать кодирование - это не приведет к плодотворному концу.

карусель
Простой циклический алгоритм берет из пула N кандидатов следующий, дает ему необходимые ресурсы, пока остальные ждут, и через 1/N времени переходит к следующему (снова идет за последним кандидатом к первому).

For processes on one CPU, that would be implemented in some kind of timer which does the context switch after each Nth time slice (each time slice is 1/N duration). In such a situation, there is no point in doing statistics since each process gets *always* its 1/N time slice after all (N-1) other candidates were served. A process may be in some waiting state, where it kind of gives up on his time slice, so, the next process would benefit in terms of being started earlier - but it may not become a larger time slice. Round Robin guarantees that there is *no* starving of any process: every process always gets executed at latest after every (N-1) time slice.

Моделирование кругового движения
Чтобы смоделировать циклическую арбитрацию, вы можете смоделировать процессы по некоторому классу, который находится в двух возможных состояниях: приостановлено или запущено (эта модель процесса является самой простой для циклического моделирования).

Затем вы можете определить класс планировщика, который принимает вектор процессов и стратегию планирования (например, циклический перебор).

Например, следующий скелет может быть отправной точкой:

class Process {
public:
    Process(const string& name): _name(name) {}
    bool resume()  const { cout << "resuming " << name << endl; return true; }
    bool suspend() const { cout << "suspending " << name << endl; return true; }
private:
    const string _name;
};

class SchedulingStrategy {
public:
   virtual void next(const vector<Process*> &processes) = 0;
};

class RoundRobinStrategy: public SchedulingStrategy {
public:
   RoundRobinStrategy(): _current(-1) {}
   virtual void next(const vector<Process*> &processes)
   {
       // only active if there are processes
       if (processes.size() > 0)
       {
          if (_current < 0)
          {
             // special initial handling
             _current = 0;
          }
          else
          {
             // stady state handling
             processes[_current]->suspend();
             _current++;
             _current %= processes.size();
          }  
          processes[_current]->resume();
       }
   }
private:
   int _current;
};

class Scheduler {
public:
   Scheduler(SchedulingStrategy &strategy)
   : _strategy(strategy), processes()
   {}
   void addProcess(const string& name) { _processes.push_back(new Process(name)); }
   void run(int n)
   {
       while(--n > 0) _strategy.next(_processes);
   }
private:
   SchedulingStrategy &_strategy;
   const vector<Process*> _processes;
};

int main()
{
    RoundRobinStrategy rr;
    Scheduler scheduler(rr);
    scheduler.addProcess("A");
    scheduler.addProcess("B");
    scheduler.addProcess("C");
    scheduler.addProcess("D");
    scheduler.run(10); // won't call a final suspend in this simple implementation
}


Получайте удовольствие!
Энди


Member 12977920

что такое композиция и агрегация в этом коде?

Andreas Gieriet

Есть предложения?
Энди

Рейтинг:
2

Member 13834863


#include<iostream>
using namespace std; 
int main()
{  
int wtime[10],btime[10],rtime[10],num,quantum,total;
cout<<"Enter number of processes(MAX 10): "; 
cin>>num;
 
cout<<"Enter burst time";
for(int i=0;i<num;i++)
{  cout<<"\nP["<<i+1<<"]: "; cin>>btime[i];
   rtime[i] = btime[i];
   wtime[i]=0;
}
cout<<"\n\nEnter quantum: "; cin>>quantum;
int rp = num;
int i=0;
int time=0;
cout<<"0"; 
wtime[0]=0; 
while(rp!=0) { 
 if(rtime[i]>quantum)
 {
   rtime[i]=rtime[i]-quantum;
   cout<<" | P["<<i+1<<"] | ";
   time+=quantum;
   cout<<time;
   }
 else if(rtime[i]<=quantum && rtime[i]>0)
 {time+=rtime[i];
  rtime[i]=rtime[i]-rtime[i];
  cout<<" | P["<<i+1<<"] | ";
  rp--;
  cout<<time;
 }
 
i++;
if(i==num)
{
i=0;
}
}
system("pause"); 
return 0;
}


Richard MacCutchan

Ответили Четыре года назад.