این جلسه ما را با ادامه آموزش الگوریتم‌های زمان‌بندی همراهی کنید. در این قسمت به آموزش الگوریتم زمان‌بندی LJF در سی شارپ می‌پردازیم. ابتدا این الگوریتم را معرفی و سپس به پیاده‌سازی آن خواهیم پرداخت. پیشنهاد می‌کنیم قبل از مطالعه این جلسه، آموزش‌های زیر را مطالعه کنید:

  1. الگوریتم Round Robin در سی شارپ
  2. الگوریتم FCFS در سی شارپ
  3. متد در سی شارپ
  4. شی گرایی در سی شارپ
  5. Constructor در سی شارپ
  6. حلقه for در سی شارپ
  7. حلقه while در سی شارپ
  8. If در سی شارپ

الگوریتم زمان‌بندی LJF

Longest Job First یا به اختصار LJF یک الگوریتم زمان‌بندی در سیستم عامل است. در این الگوریتم، همه فرآیند‌ها بررسی و از بین فرایندهای منتظر در صف اجرا، فرایندی انتخاب می‌شود که به طولانی‌ترین زمان برای اجرا شدن(burst Time) نیاز داشته باشد. به این جا به چند ویژگی LJF اشاره می‌کنیم:

  • در این الگوریتم می‌تواند Starvation رخ دهد.
  • زمان اتمام فرآیندها نزدیک به یکدیگر است.
  • این روش مقدار Average time بالا است.

پیاده‌سازی الگوریتم زمان‌بندی LJF در سی شارپ

برای پیاده سازی الگوریتم زمان‌بندی LJF در سی شارپ مراحل زیر را انجام می‌دهیم:

  1. فرآیند‌های خود را تعریف می‌کنیم.
  2. بر اساس arrival Time ، فرآیند‌ها را وارد صف انتظار می‌کنیم.
  3. فرآیند‌های درون صف انتظار را بر اساس Burst Time مرتب می‌کنیم(به صورت نزولی).
  4. به طولانی‌ترین فرآیند CPU اختصاص می‌یابد.
  5.  مراحل 2 تا 5 را تا زمان اتمام فرآیند‌ها ادامه می‌دهیم.

کد الگوریتم LJF در سی شارپ به صورت زیر است:

class MainClass
	{
		public static void Main (string[] args)
		{
			ArrayList p = new ArrayList();
			p.Add(new MyProcess(1, 6, 1));
			p.Add(new MyProcess(2, 8, 1));
			p.Add(new MyProcess(3, 7, 2));
			p.Add(new MyProcess(4, 3, 3));
			LJF(p);
			CalWaitingTime(p);
			CalTurnAroundTime(p);
			display(p);
			Console.WriteLine("Press any key to finish program");
			Console.ReadKey ();
		}
		private static void CalTurnAroundTime(ArrayList p) {
			for (int i = 0; i < p.Count; i++) {
				MyProcess temp = (MyProcess)p[i];
				temp.tat = temp.waiting_time + temp.bt;
			}
		}
		public static void display(ArrayList p) {
			Console.WriteLine("Processes " + " Burst time " +
 " Waiting time " + " Turn around time" + " Completion Time "
				+ " Arrival Time");
			for (int i = 0; i < p.Count; i++) {
				MyProcess temp = (MyProcess)p [i];
				Console.WriteLine(" " + temp.pid +
 "\t\t" + temp.bt + "\t\t " + temp.waiting_time + "\t\t "
					+ temp.tat + "\t\t" + temp.completion_time + "\t\t" +temp.art);
			}
		}
		public static void LJF(ArrayList AllProcess) {
			ArrayList waitingProcess = new ArrayList();
			int time = 0;
			int complete_process = 0;
			while (AllProcess.Count != complete_process) {
				CheckArrivalTime(AllProcess, waitingProcess, time);
				if (waitingProcess.Count <= 0) {
					time++;
					continue;
				}
				Sort(waitingProcess);
				MyProcess LongestProcess = (MyProcess)waitingProcess[0];
				time += LongestProcess.bt;
				LongestProcess.completion_time = time;
				LongestProcess.is_finished = true;
				waitingProcess.RemoveAt(0);
				complete_process++;
			}
		}
		public static void CalWaitingTime(ArrayList p) {
			for (int i = 0; i < p.Count; i++) {
				MyProcess p1 = (MyProcess)p[i];
				p1.waiting_time = p1.completion_time - p1.bt - p1.art;
				if (p1.waiting_time < 0) {
					p1.waiting_time = 0;
				}
			}
		}
		public static void Sort(ArrayList waitingProcess) {
			for (int i = 0; i < waitingProcess.Count; i++) {
				for (int j = 0; j < waitingProcess.Count - 1; j++) {
					MyProcess p1 = (MyProcess) waitingProcess[j];
					MyProcess p2 =  (MyProcess) waitingProcess[j + 1];
					if (p2.bt > p1.bt) {
						waitingProcess [j] = waitingProcess [j + 1];
						waitingProcess [j + 1] = p1;
					}
				}
			}
		}
		public static void CheckArrivalTime
(ArrayList Process, ArrayList waitingProcess, int time) {
			for (int i = 0; i < Process.Count; i++) {
				MyProcess p =  (MyProcess) Process[i];
				if (p.art <= time && !p.addTowaiting) {
					p.addTowaiting = true;
					waitingProcess.Add(p);
				}
			}
		}
	}
	public class MyProcess {
		public int pid; // Process ID
		public int bt; // Burst Time
		public int art; // Arrival Time
		public int completion_time;
		public int waiting_time;
		public int tat;//turn around time
		public bool is_finished = false;
		public bool addTowaiting = false;
		public MyProcess(int pid, int bt, int art) {
			this.pid = pid;
			this.bt = bt;
			this.art = art;
		}
	}

ما برای پیاده‌سازی الگوریتم LJF از دو کلاس زیر استفاده کردیم:

  • MyProcess: این کلاس برای تعریف یک فرآیند استفاده می‌شود و مواردی همچون Burst Time، arrival Time و waiting time و …. در آن تعریف شده است.
  • LJF: در این کلاس الگوریتم LJF پیاده سازی شده است.

متدهای کد فوق شامل موارد زیر است:

  • CheckArrivalTime: این متد زمان ورود فرآیندها را به صف انتظار بررسی می‌کند.
  • Sort: این متد صف انتظار ما را با روش مرتب سازی حبابی، مرتب می‌کند(به صورت نزولی).
  • CalWaitingTime: محاسبه waiting time فرآیندها در این متد انجام می‌شود.
  • LJF: با کمک متدهای موارد بالا، الگوریتم LJF در این متد به اجرا در می‌آید.
  • Display: جهت نمایش فرآیند ها در خروجی از display استفاده می‌شود.

متغیرهای کد فوق:

  •  AllProcess یا p یا process: تمامی فرآیندها در Arraylist به نام AllProcess (p یا process) ذخیره می‌شوند.
  • waitingProcess: منظور صف انتظار ما است.
  • Bt: منظور burst time فرآیند است.
  • Art: منظور arrival Time است.
  • Tat: منظور turn around time است.

خروجی کد فوق به صورت زیر است:

الگوریتم زمان‌بندی LJF در سی شارپ

Download “الگوریتم زمان‌بندی LJF در سی شارپ” LJF-algorithm-in-Csharp-www.codegate.ir_.zip – 87 بار دانلود شده است – 2 کیلوبایت

پسورد: www.codegate.ir