Tạo bài viết
Đăng ký
30/09/2018, 19:54

Lỗi không đọc được file trong chương trình điều mô phỏng điều phối tiến trình

Đây là lỗi

Pasted image1273x704 137 KB

Đây là code

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.IO;


namespace NLDH3
{
    class Program
    {
        static String INP = "input.txt";
        public struct process
        {
            public string name;
            public int timeRQ, timeCPU, priortity;
            public int timeOUT, timeIN, timewait, timesave;
            public int index;
        }
        static int quantum;
        static int set;
        static void input(ref process[] pr, ref int n, ref int timeOUT)
        {
            try
            {
                StreamReader  sr = File.OpenText(INP);
                string[] line = sr.ReadLine().Split(' ');
                n = int.Parse(line[0]);
                set = int.Parse(line[1]);
                quantum = int.Parse(line[2]);
                for (int i = 0; i < n; i++)
                {
                    line = sr.ReadLine().Split(' ');
                    pr[i].name = line[0];
                    pr[i].timeRQ = int.Parse(line[1]);
                    pr[i].timeCPU = int.Parse(line[2]);
                    pr[i].priortity = int.Parse(line[3]);
                    if (timeOUT < pr[i].timeRQ)
                    {
                        timeOUT = pr[i].timeRQ + pr[i].timeCPU;

                    }
                    else
                        timeOUT += pr[i].timeCPU;
                    pr[i].index = i;

                }
            }
            catch (Exception e)
            {
                Console.WriteLine(e.Message);

            }
        }
        static void output_input(process[] pr, int n)
        {
            Console.WriteLine("-------------INPUT-------------");
            Console.WriteLine();
            Console.WriteLine("{0}	{1}	{2}	{3}", "name", "TimeRQ", "TimeCPU", "Priority");
            for (int i = 0; i < n; i++)
            {
                Console.WriteLine("[0]	{1}	{2}	{3}", pr[i].name, pr[i].timeRQ, pr[i].timeCPU, pr[i].priortity);
            }
            Console.WriteLine();
            Console.WriteLine("------OUTPUT---------");

        }




        //thực hiện điều phối FIFO
        static void process_FIFO(ref process[] pr, int n, int timeOUT)
        {
            process[] RQ = new process[n];
            int m = -1;
            for (int t = 0; t < timeOUT; t++)
                for (int i = 0; i < n; i++)
                    if (t == pr[i].timeRQ)
                        RQ[++m] = pr[i];

            timeOUT = 0;
            for (int i = 0; i <= m; i++)
            {
                if (timeOUT <= RQ[i].timeRQ)
                {
                    timeOUT = RQ[i].timeRQ + RQ[i].timeCPU;
                    RQ[i].timeIN = RQ[i].timeRQ;
                }
                else
                {
                    timeOUT += RQ[i].timeCPU;
                    RQ[i].timeIN = RQ[i - 1].timeOUT;

                }
                RQ[i].timeOUT = timeOUT;
                RQ[i].timewait = RQ[i].timeOUT - (RQ[i].timeRQ + RQ[i].timeCPU);
                RQ[i].timesave = RQ[i].timeOUT - RQ[i].timeRQ;
            }

            pr = RQ;
        }
        // th5c hiện điều phối do uu tien doc quyen
        static void process_PRIORITY_preemptive(process[] pr, int n, int timeOUT)
        {
            process[] RQ = new process[n];
            int m = 0;
            int j = 0;
            int temptime = 0;
            for (int t = 0; t <= timeOUT; t++)
            {
                if (m > 0 && j < m)
                {


                    if (temptime < RQ[j].timeCPU)
                        temptime++;
                    if (temptime == RQ[j].timeCPU)
                    {
                        RQ[j].timeIN = t - RQ[j].timeCPU;
                        RQ[j].timeOUT = RQ[j].timeIN + RQ[j].timeCPU;
                        RQ[j].timewait = RQ[j].timeOUT - (RQ[j].timeRQ + RQ[j].timeCPU);
                        RQ[j].timesave = RQ[j].timeOUT - RQ[j].timeRQ;
                        temptime = 0;
                        j++;
                    }
                }
                for (int i = 0; i < n; i++)
                    if (t == pr[i].timeRQ)
                    {
                        int k = m;
                        while (k > j + 1 && pr[i].priortity < RQ[k - 1].priortity)
                        {
                            RQ[k] = RQ[k - 1];
                            k--;
                        }
                        RQ[k] = pr[i];
                        m++;
                    }
            }
            pr = RQ;
        }
        //Do uu tien khong doc quyen
        static void process_PRIORITY_nopreemptive(process[] pr, int n, int m, int timeOUT)
        {
            process[] RQ = new process[n];


            int j = 0;
            m = 0;
            int temptime = 0;
            for (int t = 0; t <= timeOUT; t++)
            {
                if (m > 0 && j < m)
                {
                    if (temptime < RQ[j].timeCPU)
                        temptime++;
                    if (temptime == RQ[j].timeCPU)
                    {
                        RQ[j].timeIN = t - RQ[j].timeCPU;
                        RQ[j].timeOUT = RQ[j].timeIN + RQ[j].timeCPU;
                        RQ[j].timewait = RQ[j].timeOUT - (RQ[j].timeRQ + RQ[j].timeCPU);
                        RQ[j].timesave = RQ[j].timeOUT - RQ[j].timeRQ;

                        pr[RQ[j].index].timeOUT = t;
                        pr[RQ[j].index].timewait = pr[RQ[j].index].timeOUT
                                - (pr[RQ[j].index].timeRQ + pr[RQ[j].index].timeCPU);
                        pr[RQ[j].index].timesave = pr[RQ[j].index].timeOUT - pr[RQ[j].index].timeRQ;

                        temptime = 0;
                        j++;
                    }
                }
                for (int i = 0; i < n; i++)
                    if (t == pr[i].timeRQ)
                    {
                        m++;
                        int k = m - 1;
                        if (temptime > 0 && pr[i].priortity < RQ[j].priortity)
                        {
                            m++;
                            k = m - 1;
                            for (k = m - 1; k > j + 1; k--)
                                RQ[k] = RQ[k - 2];
                            RQ[j + 1] = pr[i];

                            RQ[j + 2] = RQ[j];
                            RQ[j + 2].timeCPU -= temptime;

                            RQ[j].timeIN = t - temptime;
                            RQ[j].timeOUT = t;
                            RQ[j].timeCPU = temptime;
                            temptime = 0;
                            j++;
                        }
                        else
                        {
                            while (k > j && pr[i].priortity < RQ[k - 1].priortity)
                            {
                                RQ[k] = RQ[k - 1];
                                k--;
                            }
                            RQ[k] = pr[i];
                        }
                    }
            }
        }





        //In ket qua thuc hien dieu phoi FiFO
        static void output_FIFO(process[] pr, int n, int timeOUT)
        {
            Console.WriteLine("
FIFO 

PROCESS

");

            Console.WriteLine("{0}	{1}	{2}	{3}	{4}	{5}	{6}	{7}
",
                "Name", "TimeRQ", "TimeCPU", "Priority", "TimeIN", "TimeOUT", "Timewait",
                "Timesave");

            for (int i = 0; i < n; i++)
            {
                Console.WriteLine("{0}	{1}	{2}	{3}		{4}	{5}	{6}		{7}
",
                    pr[i].name, pr[i].timeRQ, pr[i].timeCPU, pr[i].priortity, pr[i].timeIN,
                    pr[i].timeOUT, pr[i].timewait, pr[i].timesave);
            }
        }
        //In ket qua thuc hien do uu tien doc quyen
        static void output_PRIORITY_preemptive(process[] pr, int n, int timeOUT)
        {
            Console.WriteLine("
PRIORITY preemptive

PROCESS");
            Console.WriteLine("{0}	{1}	{2}	{3}	{4}	{5}	{6}	{7}
",
                "Name", "TimeRQ", "TimeCPU", "Priority", "TimeIN", "TimeOUT", "Timewait",
                "Timesave");
            for (int i = 0; i < n; i++)
                Console.WriteLine("{0}	{1}	{2}	{3}		{4}	{5}	{6}		{7}
",
                    pr[i].name, pr[i].timeRQ, pr[i].timeCPU, pr[i].priortity, pr[i].timeIN,
                    pr[i].timeOUT, pr[i].timewait, pr[i].timesave);

        }
        ////In ket qua thuc hien do uu tien khong doc quyen
        static void output_PRIORITY_nopreemptive(process[] pr, process[] RL, int n, int m, int timeOUT)
        {
            Console.WriteLine("
PRIORITY nopreemptive

OUTPUT");
            Console.WriteLine("{0}	{1}	{2}	{3}", "Name", "TimeOUT", "Timewait", "Timesave");
            for (int i = 0; i < n; i++)
                Console.WriteLine("{0}	{1}	{2}	{3}", pr[i].name, pr[i].timeOUT, pr[i].timewait, pr[i].timesave);

            Console.WriteLine("-------PROCESS------");
            Console.WriteLine("{0}	{1}	{2}	{3}	{4}	{5}", "Name", "TimeRQ", "TimeCPU", "priority", "TimeOUT", "TimeIN");
            for (int i = 0; i < m; i++)
                Console.WriteLine("{0}	{1}	{2}	{3}	{4}	{5}", RL[i].name, RL[i].timeRQ, RL[i].timeCPU, RL[i].priortity, RL[i].timeIN, RL[i].timeOUT);
        }
        ////In ket qua thuc hien SJF doc quyen
        static void output_SJF_preemptive(process[] pr, int n, int timeOUT)
        {
            Console.WriteLine("
SJFpreemptive

PROCESS");
            Console.WriteLine("{0}	{1}	{2}	{3}	{4}	{5}	{6}	{7}", "name", "TimeRQ", "TimeCPU", "Priority", "TimeIN", "TimeOUT", "Timewait", "Timesave");
            for (int i = 0; i < n; i++)
                Console.WriteLine("{0}	{1}	{2}	{3}	{4}	{5}	{6}	{7}", pr[i].name, pr[i].timeRQ, pr[i].timeCPU, pr[i].priortity, pr[i].timeIN, pr[i].timeOUT, pr[i].timewait, pr[i].timesave);

        }
        static void output_SJF_nopreemptive(process[] pr, process[] RL, int n, int m, int timeOUT)
        {
            Console.WriteLine("
SJF nopreemptive

OUTPUT");
            Console.WriteLine("{0}	{1}	{2}	{3}", "Name", "TimeOUT", "Timewait", "Timesave");
            for (int i = 0; i < n; i++)
                Console.WriteLine("{0}	{1}	{2}	{3}", pr[i].name, pr[i].timeOUT, pr[i].timewait, pr[i].timesave);

            Console.WriteLine("-------PROCESS------");
            Console.WriteLine("{0}	{1}	{2}	{3}	{4}	{5}", "Name", "TimeRQ", "TimeCPU", "priority", "TimeOUT", "TimeIN");
            for (int i = 0; i < m; i++)
                Console.WriteLine("{0}	{1}	{2}	{3}	{4}	{5}", RL[i].name, RL[i].timeRQ, RL[i].timeCPU, RL[i].priortity, RL[i].timeIN, RL[i].timeOUT);
        }

        //Thuc hien dieu phoi RoundRobin
        static void process_RR(ref process[] pr, ref process[] RQ, int n, ref int m, int timeOUT, int quantum)
        {

            m = 0;
            int count = 0;
            int j = 0;
            int temptime = 0;
            for (int t = 0; t <= timeOUT; t++)
            {
                if (m > 0 && j < m)
                {
                    count++;

                    if (count <= quantum && RQ[j].timeCPU - temptime > 0)
                        temptime++;
                    if (count == quantum && RQ[j].timeCPU - temptime > 0)
                    {
                        m++;
                        RQ[m - 1] = RQ[j];
                        RQ[m - 1].timeCPU -= temptime;
                    }

                    if (RQ[j].timeCPU - temptime == 0)
                    {
                        pr[RQ[j].index].timeOUT = t;
                        pr[RQ[j].index].timewait = pr[RQ[j].index].timeOUT
                                - (pr[RQ[j].index].timeRQ + pr[RQ[j].index].timeCPU);
                        pr[RQ[j].index].timesave = pr[RQ[j].index].timeOUT - pr[RQ[j].index].timeRQ;
                    }
                    if (count == quantum || RQ[j].timeCPU - temptime == 0)
                    {
                        RQ[j].timeOUT = t;
                        RQ[j].timeCPU = temptime;
                        RQ[j].timeIN = t - RQ[j].timeCPU;
                        j++;
                        temptime = 0;
                        count = 0;
                    }
                }
                for (int i = 0; i < n; i++)
                    if (t == pr[i].timeRQ)
                    {
                        m++;

                        RQ[m - 1] = pr[i];
                    }
            }
        }
        //In ket qua dieu phoi RoundRobin
        static void output_RR(process[] pr, process[] RQ, int n, int m, int timeOUT)
        {

            Console.WriteLine("
ROUND ROBIN

OUTPUT

");

            Console.WriteLine("{0}	{1}	{2}	{3}", "Name", "TimeOUT", "Timewait", "Timesave");

            for (int i = 0; i < n; i++)
            {
                Console.WriteLine("{0}	{1}	{2}		{3}", pr[i].name, pr[i].timeOUT,
                                   pr[i].timewait, pr[i].timesave);
            }
            Console.WriteLine("

---PROCESS---

");

            Console.WriteLine("{0}	{1}	{2}	{3}	{4}", "Name", "TimeRQ", "TimeCPU",
                               "TimeIN", "TimeOUT");
            for (int i = 0; i < m; i++)
            {
                Console.WriteLine("{0}	{1}	{2}	{3}	{4}
", RQ[i].name, RQ[i].timeRQ,
                                  RQ[i].timeCPU, RQ[i].timeIN, RQ[i].timeOUT);
            }
        }
        //sjf docquyem
        static void process_SJF_preemptive(process[] pr, int n, int timeOUT)
        {

            process[] RQ = new process[n];

            int j = 0, m = 0;
            int temptime = 0;
            for (int t = 0; t <= timeOUT; t++)
            {
                if (m > 0 && j < m)
                {
                    if (temptime < RQ[j].timeCPU)
                        temptime++;
                    if (temptime == RQ[j].timeCPU)
                    {
                        RQ[j].timeIN = t - RQ[j].timeCPU;
                        RQ[j].timeOUT = RQ[j].timeIN + RQ[j].timeCPU;
                        RQ[j].timewait = RQ[j].timeOUT - (RQ[j].timeRQ + RQ[j].timeCPU);
                        RQ[j].timesave = RQ[j].timeOUT - RQ[j].timeRQ;
                        temptime = 0;
                        j++;
                    }
                }
                for (int i = 0; i < n; i++)
                    if (t == pr[i].timeRQ)
                    {
                        int k = m;
                        while (k > j + 1 && pr[i].timeCPU < RQ[k - 1].timeCPU)
                        {
                            RQ[k] = RQ[k - 1];
                            k--;
                        }
                        RQ[k] = pr[i];
                        m++;
                    }
            }
            pr = RQ;
        }

        //jsf ko doc quyen
        static void process_SJF_nopreemptive(process[] pr, int n, int m, int timeOUT)
        {

            process[] RQ = new process[n];


            int j = 0;
            m = 0;
            int temptime = 0;
            for (int t = 0; t <= timeOUT; t++)
            {
                if (m > 0 && j < m)
                {
                    if (temptime < RQ[j].timeCPU)
                        temptime++;
                    if (temptime == RQ[j].timeCPU)
                    {
                        RQ[j].timeIN = t - RQ[j].timeCPU;
                        RQ[j].timeOUT = RQ`indent preformatted text by 4 spaces`[j].timeIN + RQ[j].timeCPU;
                        RQ[j].timewait = RQ[j].timeOUT - (RQ[j].timeRQ + RQ[j].timeCPU);
                        RQ[j].timesave = RQ[j].timeOUT - RQ[j].timeRQ;

                        pr[RQ[j].index].timeOUT = t;
                        pr[RQ[j].index].timewait = pr[RQ[j].index].timeOUT
                                - (pr[RQ[j].index].timeRQ + pr[RQ[j].index].timeCPU);
                        pr[RQ[j].index].timesave = pr[RQ[j].index].timeOUT - pr[RQ[j].index].timeRQ;

                        temptime = 0;
                        j++;
                    }
                }
                for (int i = 0; i < n; i++)
                    if (t == pr[i].timeRQ)
                    {
                        m++;
                        int k = m - 1;

                        if (temptime > 0 && pr[i].timeCPU < RQ[j].timeCPU - temptime)
                        {
                            m++;
                            k = m - 1;

                            for (k = m - 1; k > j + 1; k--)
                                RQ[k] = RQ[k - 2];
                            RQ[j + 1] = pr[i];

                            RQ[j + 2] = RQ[j];
                            RQ[j + 2].timeCPU -= temptime;

                            RQ[j].timeIN = t - temptime;
                            RQ[j].timeOUT = t;
                            RQ[j].timeCPU = temptime;
                            temptime = 0;
                            j++;
                        }
                        else
                        {
                            while (k > j + 1 && pr[i].timeCPU < RQ[k - 1].timeCPU)
                            {
                                RQ[k] = RQ[k - 1];
                                k--;
                                if (k == j + 1
                                        && pr[i].timeCPU < RQ[k - 1].timeCPU - temptime)
                                {
                                    RQ[k] = RQ[k - 1];
                                    k--;
                                }
                            }
                            RQ[k] = pr[i];
                        }
                    }
            }
        }




        //Thuc hien dieu phoi
        static void PROCESS(ref process[] pr, ref process[] RQ ,int n, ref int m, int timeOUT, int
                    select)
        {
            switch (select)
            {
                case 1:
                    process_FIFO(ref pr, n, timeOUT);
                    break;
                case 2:

                    process_RR(ref pr, ref RQ, n, ref m, timeOUT, quantum);
                    break;
                case 3:
                    process_PRIORITY_preemptive(pr, n, timeOUT);
                    break;
                case 4:
                    process_PRIORITY_nopreemptive(pr, n, m, timeOUT);
                    break;
                case 5:
                    process_SJF_preemptive(pr, n, timeOUT);
                    break;
                case 6:
                    process_SJF_nopreemptive(pr,  n, m, timeOUT);
                    break;
            }
        }


        //In ket quan dieu phoi
        static void OUTPUT(process[] pr, process[] RQ, int n, int m, int timeOUT, int select)
        {
            switch (select)
            {
                case 1:
                    output_FIFO(pr, n, timeOUT);
                    break;
                case 2:
                    output_RR(pr, RQ, n, m, timeOUT);
                    break;
                case 3:
                    output_PRIORITY_preemptive(pr, n, timeOUT);
                    break;
                case 4:
                    output_PRIORITY_nopreemptive(pr, RQ, n, m, timeOUT);
                    break;
                case 5:
                    output_SJF_preemptive(pr, n, timeOUT);
                    break;
                case 6:
                    output_SJF_nopreemptive(pr, RQ, n, m, timeOUT);
                    break;
            }
            Console.WriteLine("-----------------END-----------------");
        }
        static void Main(string[] args)
        {
            process[] pr = new process[100]; //Danh sach cac tien trinh
            process[] RQ = new process[100]; //Danh sach cac tien trinh trong RQ
            int n = 0;       //So tien trinh dang xu ly
            int m = 0;       //So tien trinh trong RQ
            int timeOUT = 0; //Thoi diem ket cua tat ca cac tien trinh

            input(ref pr, ref n, ref timeOUT); //Doc File du lieu dau vao => xac dinh pr, n, 

            output_input(pr, n);
            PROCESS(ref pr, ref RQ, n, ref m, timeOUT, set);
            OUTPUT(pr, RQ, n, m, timeOUT, set);
            Console.ReadLine();
        }
    }
Nhuyngo Nhuyngo95 viết 22:09 ngày 30/09/2018

@ltd giúp em với anh đạt ơi

Nguyên Nguyễn Tùng viết 21:59 ngày 30/09/2018

bạn ơi mình không hiểu rõ ý tưởng bài của bạn lắm @@ bạn có thể nói rõ hơn đc không

Bài liên quan

Nhuyngo Nhuyngo95

0 chủ đề

0 bài viết

Tác giả nổi bật
Từ khóa nổi bật
AngularJS Blog Bootstrap C / C++ Cấu trúc dữ liệu & Giải thuật Cơ sở dữ liệu Codeigniter Công cụ lập trình CSS CSS cơ bản CSS3 Học Excel HTML HTML cơ bản HTML5 Java Javascript jQuery Json Lập trình mobile Laravel Linux MongoDB MySQL NodeJS Oracle Pascal PHP PHP cơ bản PHP nâng cao Python React Native ReactJS Ruby SEO SQL Server Swift Visual Basic VueJS WordPress XML
Chủ đề nổi bật
0
Các chủ đề đang được quan tâm
phần mềm lập trình php | lập trình web php + mysql | khóa học lập trình php | tự học lập trình php | học php cơ bản thachpham | Giảm giá khuyến mãi thùng rác giá rẻ, thùng rác 120l 240l 660l màu xanh lh 0911.082.000 | Chi phí vận chuyển (Giao hàng đến các địa điểm theo yêu cầu của Công ty). | Xe nâng tay giá rẻ, xe nâng 3 tấn và tải trọng thông dụng nhất hiện nay-lh 0911.082.000 | Code24h | Cho thuê phòng trọ hà nội | Cho thuê phòng trọ bình thạnh | Cho thuê phòng trọ | Cho thuê nhà trọ
Đăng ký

Đăng ký nhận thông báo

Các bài học thú vị sẽ được gửi đến inbox của bạn

HỖ TRỢ HỌC VIÊN
VỀ CODE24H
HỢP TÁC VÀ LIÊN KẾT
KẾT NỐI VỚI CHÚNG TÔI
TẢI ỨNG DỤNG TRÊN ĐIỆN THOẠI

CCode 24h, code mọi lúc, mọi nơi

© Copy right 2018 - 2024