Beispiel #1
0
        //Gera a lista para gerenciar espaços livres
        private List <EspacoLivre> GeraListaLivres(Memory memory, List <Frame> InitialFrames)
        {
            //lista de espacos livres na memoria
            List <EspacoLivre> listaEspacoLivre = new List <EspacoLivre>();

            //long -> RegB, int -> id(Frame),
            Dictionary <long, int> mapFrame = new Dictionary <long, int>();

            //Mapeia todos os frames utilizados
            foreach (var item in InitialFrames)
            {
                mapFrame.Add(item.RegB, item.ID);
            }

            //frames disponiveis
            int framesLivres = 0;

            //guarda o regB do primeiro frame livre
            long regB = 0;

            //passa por todos registradores base da memória
            for (long i = 0; i < memory.Size; i += memory.FramesSize)
            {
                //verifica se o frame está livre
                //(está livre)
                if (!mapFrame.ContainsKey(i))
                {
                    //guarda o registrador base do primerio frame disponivel
                    if (framesLivres == 0)
                    {
                        regB = i;
                    }

                    //soma a quantidade de frames livres
                    framesLivres++;
                }
                //(Não está livre)
                else
                {
                    //Verifica se é necessário criar o objeto
                    if (framesLivres != 0)
                    {
                        EspacoLivre espacoLivre = new EspacoLivre
                        {
                            EspacosLivres = framesLivres,
                            RegB          = regB
                        };

                        listaEspacoLivre.Add(espacoLivre);

                        //reseta a quantidade de frames livres
                        framesLivres = 0;
                    }
                }
            }

            return(listaEspacoLivre);
        }
Beispiel #2
0
        public JsonResult AlgSimulation(int?id, string Alg)
        {
            try
            {
                if (id != null)
                {
                    Memory memory = _context.Memories.Find(id);

                    if (!memory.IsGeneratedProcessList)
                    {
                        throw new Exception("É necessário gerar a lista de processos.");
                    }

                    string algSimuExistenteError = "Já foi gerada a simulação para esse algoritmo.";

                    if (memory.IsFirstFitCompleted && Alg == "FirstFit")
                    {
                        throw new Exception(algSimuExistenteError);
                    }

                    if (memory.IsNextFitCompleted && Alg == "NextFit")
                    {
                        throw new Exception(algSimuExistenteError);
                    }

                    if (memory.IsBestFitCompleted && Alg == "BestFit")
                    {
                        throw new Exception(algSimuExistenteError);
                    }

                    if (memory.IsWorstFitCompleted && Alg == "WorstFit")
                    {
                        throw new Exception(algSimuExistenteError);
                    }

                    List <Process>     processToInsert = GetProcessesToInsert(id);
                    List <Frame>       initialFrames   = GetInitialFrames(id);
                    List <Frame>       framesToInsert  = new List <Frame>();
                    List <EspacoLivre> espacosLivres   = GeraListaLivres(memory, initialFrames);

                    int processInserted = 0;

                    // tempo de execução para acha o index do processo
                    var watch = System.Diagnostics.Stopwatch.StartNew();

                    foreach (var process in processToInsert)
                    {
                        watch.Start();
                        int framesNeeded = (int)(process.Size / memory.FramesSize);
                        framesNeeded = process.Size % memory.FramesSize > 0 ? framesNeeded + 1 : framesNeeded;

                        if (Alg == "FirstFit")
                        {
                            for (int i = 0; i < espacosLivres.Count; ++i)
                            {
                                //se o processo caber no espaco disponivel na memória
                                if (espacosLivres[i].EspacosLivres >= framesNeeded)
                                {
                                    for (int j = 0; j < framesNeeded; ++j)
                                    {
                                        Frame newFrame = new Frame
                                        {
                                            IsInitial = false,
                                            RegB      = espacosLivres[i].RegB + (memory.FramesSize * j),
                                            TipoAlg   = Frame.TipoAlgVal.FirstFit,
                                            MemoryID  = memory.ID,
                                            ProcessID = process.ID,
                                            Name      = process.Name,
                                            FrameSize = (int)memory.FramesSize
                                        };

                                        newFrame.FrameNumber = newFrame.RegB > 0 ? (int)(newFrame.RegB / memory.FramesSize) : 0;

                                        //se for o ultimo frame, verifica qual a capacidade utilizada do mesmo
                                        if (j + 1 == framesNeeded)
                                        {
                                            newFrame.CapacidadeUtilizada = (int)(process.Size % memory.FramesSize);
                                        }
                                        else
                                        {
                                            newFrame.CapacidadeUtilizada = (int)memory.FramesSize;
                                        }

                                        framesToInsert.Add(newFrame);
                                    }

                                    //se for necessario remove o item da lista de livre
                                    if (espacosLivres[i].EspacosLivres - framesNeeded == 0)
                                    {
                                        espacosLivres.RemoveAt(i);
                                    }
                                    else
                                    {
                                        //Atualiza a lista de espacos livres
                                        int  quantidadeLivreAnt = espacosLivres[i].EspacosLivres;
                                        long regBAnt            = espacosLivres[i].RegB;

                                        espacosLivres[i] = new EspacoLivre
                                        {
                                            RegB          = regBAnt + (memory.FramesSize * framesNeeded),
                                            EspacosLivres = quantidadeLivreAnt - framesNeeded
                                        };
                                    }

                                    watch.Stop();
                                    // Get the elapsed time as a TimeSpan value.
                                    TimeSpan ts = watch.Elapsed;
                                    process.TimeToFindIndexFirst = ts.Milliseconds;

                                    processInserted++;
                                    break;
                                }
                            }
                        }

                        if (Alg == "NextFit")
                        {
                            bool isFirst = true;

                            for (int i = 0; i < espacosLivres.Count; ++i)
                            {
                                //se o processo caber no espaco disponivel na memória
                                if (espacosLivres[i].EspacosLivres >= framesNeeded && !isFirst)
                                {
                                    for (int j = 0; j < framesNeeded; ++j)
                                    {
                                        Frame newFrame = new Frame
                                        {
                                            IsInitial = false,
                                            RegB      = espacosLivres[i].RegB + (memory.FramesSize * j),
                                            TipoAlg   = Frame.TipoAlgVal.NextFit,
                                            MemoryID  = memory.ID,
                                            ProcessID = process.ID,
                                            Name      = process.Name,
                                            FrameSize = (int)memory.FramesSize
                                        };

                                        newFrame.FrameNumber = newFrame.RegB > 0 ? (int)(newFrame.RegB / memory.FramesSize) : 0;

                                        //se for o ultimo frame, verifica qual a capacidade utilizada do mesmo
                                        if (j + 1 == framesNeeded)
                                        {
                                            newFrame.CapacidadeUtilizada = (int)(process.Size % memory.FramesSize);
                                        }
                                        else
                                        {
                                            newFrame.CapacidadeUtilizada = (int)memory.FramesSize;
                                        }

                                        framesToInsert.Add(newFrame);
                                    }

                                    //se for necessario remove o item da lista de livre
                                    if (espacosLivres[i].EspacosLivres - framesNeeded == 0)
                                    {
                                        espacosLivres.RemoveAt(i);
                                    }
                                    else
                                    {
                                        //Atualiza a lista de espacos livres
                                        int  quantidadeLivreAnt = espacosLivres[i].EspacosLivres;
                                        long regBAnt            = espacosLivres[i].RegB;

                                        espacosLivres[i] = new EspacoLivre
                                        {
                                            RegB          = regBAnt + (memory.FramesSize * framesNeeded),
                                            EspacosLivres = quantidadeLivreAnt - framesNeeded
                                        };
                                    }

                                    processInserted++;

                                    watch.Stop();
                                    // Get the elapsed time as a TimeSpan value.
                                    TimeSpan ts = watch.Elapsed;
                                    process.TimeToFindIndexNext = ts.Milliseconds;
                                    break;
                                }

                                if (espacosLivres[i].EspacosLivres >= framesNeeded)
                                {
                                    if (isFirst)
                                    {
                                        isFirst = false;
                                    }
                                }
                            }
                        }

                        if (Alg == "BestFit")
                        {
                            int?melhorEspaco = null;

                            for (int i = 0; i < espacosLivres.Count; ++i)
                            {
                                if (espacosLivres[i].EspacosLivres >= framesNeeded)
                                {
                                    if (melhorEspaco == null)
                                    {
                                        melhorEspaco = i;
                                    }
                                    else
                                    {
                                        if (espacosLivres[(int)melhorEspaco].EspacosLivres > espacosLivres[i].EspacosLivres)
                                        {
                                            melhorEspaco = i;
                                        }
                                    }
                                }
                            }

                            //se o processo caber no espaco disponivel na memória
                            if (melhorEspaco != null)
                            {
                                for (int j = 0; j < framesNeeded; ++j)
                                {
                                    Frame newFrame = new Frame
                                    {
                                        IsInitial = false,
                                        RegB      = espacosLivres[(int)melhorEspaco].RegB + (memory.FramesSize * j),
                                        TipoAlg   = Frame.TipoAlgVal.BestFit,
                                        MemoryID  = memory.ID,
                                        ProcessID = process.ID,
                                        Name      = process.Name,
                                        FrameSize = (int)memory.FramesSize
                                    };

                                    newFrame.FrameNumber = newFrame.RegB > 0 ? (int)(newFrame.RegB / memory.FramesSize) : 0;

                                    //se for o ultimo frame, verifica qual a capacidade utilizada do mesmo
                                    if (j + 1 == framesNeeded)
                                    {
                                        newFrame.CapacidadeUtilizada = (int)(process.Size % memory.FramesSize);
                                    }
                                    else
                                    {
                                        newFrame.CapacidadeUtilizada = (int)memory.FramesSize;
                                    }

                                    framesToInsert.Add(newFrame);
                                }

                                //se for necessario remove o item da lista de livre
                                if (espacosLivres[(int)melhorEspaco].EspacosLivres - framesNeeded == 0)
                                {
                                    espacosLivres.RemoveAt((int)melhorEspaco);
                                }
                                else
                                {
                                    //Atualiza a lista de espacos livres
                                    int  quantidadeLivreAnt = espacosLivres[(int)melhorEspaco].EspacosLivres;
                                    long regBAnt            = espacosLivres[(int)melhorEspaco].RegB;

                                    espacosLivres[(int)melhorEspaco] = new EspacoLivre
                                    {
                                        RegB          = regBAnt + (memory.FramesSize * framesNeeded),
                                        EspacosLivres = quantidadeLivreAnt - framesNeeded
                                    };
                                }

                                processInserted++;

                                watch.Stop();
                                // Get the elapsed time as a TimeSpan value.
                                TimeSpan ts = watch.Elapsed;

                                process.TimeToFindIndexBest = ts.Milliseconds;
                            }
                        }

                        if (Alg == "WorstFit")
                        {
                            int?piorEspaco = null;

                            for (int i = 0; i < espacosLivres.Count; ++i)
                            {
                                if (espacosLivres[i].EspacosLivres >= framesNeeded)
                                {
                                    if (piorEspaco == null)
                                    {
                                        piorEspaco = i;
                                    }
                                    else
                                    {
                                        if (espacosLivres[(int)piorEspaco].EspacosLivres < espacosLivres[i].EspacosLivres)
                                        {
                                            piorEspaco = i;
                                        }
                                    }
                                }
                            }

                            //se o processo caber no espaco disponivel na memória
                            if (piorEspaco != null)
                            {
                                for (int j = 0; j < framesNeeded; ++j)
                                {
                                    Frame newFrame = new Frame
                                    {
                                        IsInitial = false,
                                        RegB      = espacosLivres[(int)piorEspaco].RegB + (memory.FramesSize * j),
                                        TipoAlg   = Frame.TipoAlgVal.WorstFit,
                                        MemoryID  = memory.ID,
                                        ProcessID = process.ID,
                                        Name      = process.Name,
                                        FrameSize = (int)memory.FramesSize
                                    };

                                    newFrame.FrameNumber = newFrame.RegB > 0 ? (int)(newFrame.RegB / memory.FramesSize) : 0;

                                    //se for o ultimo frame, verifica qual a capacidade utilizada do mesmo
                                    if (j + 1 == framesNeeded)
                                    {
                                        newFrame.CapacidadeUtilizada = (int)(process.Size % memory.FramesSize);
                                    }
                                    else
                                    {
                                        newFrame.CapacidadeUtilizada = (int)memory.FramesSize;
                                    }

                                    framesToInsert.Add(newFrame);
                                }

                                //se for necessario remove o item da lista de livre
                                if (espacosLivres[(int)piorEspaco].EspacosLivres - framesNeeded == 0)
                                {
                                    espacosLivres.RemoveAt((int)piorEspaco);
                                }
                                else
                                {
                                    //Atualiza a lista de espacos livres
                                    int  quantidadeLivreAnt = espacosLivres[(int)piorEspaco].EspacosLivres;
                                    long regBAnt            = espacosLivres[(int)piorEspaco].RegB;

                                    espacosLivres[(int)piorEspaco] = new EspacoLivre
                                    {
                                        RegB          = regBAnt + (memory.FramesSize * framesNeeded),
                                        EspacosLivres = quantidadeLivreAnt - framesNeeded
                                    };
                                }

                                processInserted++;

                                watch.Stop();
                                // Get the elapsed time as a TimeSpan value.
                                TimeSpan ts = watch.Elapsed;

                                process.TimeToFindIndexWorst = ts.Milliseconds;
                            }
                        }
                    }

                    switch (Alg)
                    {
                    case "FirstFit":
                        memory.IsFirstFitCompleted = true;
                        memory.FirstFitInseridos   = processInserted;
                        break;

                    case "NextFit":
                        memory.IsNextFitCompleted = true;
                        memory.NextFitInseridos   = processInserted;
                        break;

                    case "BestFit":
                        memory.IsBestFitCompleted = true;
                        memory.BestFitInseridos   = processInserted;
                        break;

                    case "WorstFit":
                        memory.IsWorstFitCompleted = true;
                        memory.WorstFitInseridos   = processInserted;
                        break;
                    }

                    _context.Frames.AddRange(framesToInsert);
                    _context.Processes.UpdateRange(processToInsert);
                    _context.Memories.Update(memory);
                    _context.SaveChanges();

                    return(Json(
                               new
                    {
                        processos = processInserted,
                        success = true
                    }
                               ));
                }
                else
                {
                    throw new Exception("Mémoria não informada!");
                }
            }
            catch (Exception e)
            {
                return(Json(
                           new
                {
                    success = false,
                    error = e.Message
                }
                           ));
            }
        }