Me ajudem a fazer esse código de um escalonador!

27 de junho de 2011 7 respostas

Metavenger 27 de junho de 2011

Ok, primeiro de tudo, prazer todo mundo, é minha primeira vez pedindo ajuda online com códigos de Java rsrs

Bom, vamos ao problema… Preciso construir um código que simule um Escalonador de curto prazo. Os parâmetros do programa são os seguintes:

-Atende até 5 processos
-Opera com Timeslice (round-robin)
-Trabalha com prioridade (Pre-emptivo): 0=Baixa, 1=Alta
-Opera com dispositivo I/O (Disco)

-Os processos são lidos de um arquivo em disco “proc.txt”
-O timeslice é informada pelo teclado (opcionalmente, o tempo de disco também é informado pelo teclado)
-O resultado do processamento é gravado em um arquivo no disco “res.txt”
-Cada processo pode ter até 10 instruções
-O tamanho máximo de tempo de disco é 5
-O processo só pode chamar o disco 2 vezes

o formato pelo qual as instruções são passadas é esse:

I
I
I
D
3
I
I
T
0

onde I = Instrução, D = Disco (onde o número seguinte é o tempo de disco), T = Terminou. O número após o T representa a prioridade do processo.

o formato de saída deve ser o seguinte:

1 2 3
I 00
I 01
I 02
I 03
I 04
D 05
I 1 06
D 2 07
D 3 08
e por aí vai. Como deu pra ver, se uma instrução I é executada, somente o tempo em disco pode executar simultaneamente (como qualquer bom aluno de sistemas operacionais aprendeu). Os números de dois dígitos (00, 01, 02, etc) é o tempo da CPU.

Alguém consegue achar um código válido para responder esse problema? Se não conseguir do modo requisitado, pode ser também sem utilizar prioridade.

7 Respostas

rogelgarcia 27 de jun. de 2011

Eu acho que os professores de Java poderiam começar a acessar o GUJ toda vez que derem um trabalho. Assim eles ficarão sabendo quem fez e quem copiou.

rafaelviny 27 de jun. de 2011

vc colocou quantos vc vai pagar para fazer seu trabalho?

aqui ninguem trabalha de graça

fernandosavio 27 de jun. de 2011

Concordo plenamente…
O bom seria vc idealizar como fará o trabalho e se tiver dúvidas em algo específico perguntar no fórum…
Pedir trabalho pronto é covardia e não te ajuda depois que tiver o diploma…

Metavenger 27 de jun. de 2011

Querem código? Eu dou código!

Taí tudo que consegui fazer até hoje. Não cheguei nem perto de fazer o código funcionar como devia. Só consigo separar a lista de entrada de instruções em até cinco processos (como pedido pelo trabalho, o escalonador roda até cinco processos, então, cria no máximo cinco listas de instruções. Usei arraylist porque, honestamente, nunca entendi como usar vetores e as instruções da API não funcionam quando eu tento usá-las, nem entendo os exemplos dados por outros foristas).

import java.util.Scanner;
import java.io.File;
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.ArrayList;

public class Escalonador {
	
	public static void main(String[] args) throws IOException{
		
		Scanner s = new Scanner(System.in);
		System.out.println("Digite o Timeslice desejado:");
		int timeSlice = s.nextInt();
		System.out.println("Digite o tempo de disco a ser utilizado:");
		int disco = s.nextInt();
		
		FileReader reader = new FileReader(new File("proc.txt"));
		FileWriter writer = new FileWriter(new File("res.txt"));
		PrintWriter saida = new PrintWriter(writer, true);
		BufferedReader leitor = new BufferedReader(reader); 
		
		
		ArrayList<String> listaComandos = new ArrayList<String>();
		ArrayList<String> processo1 = new ArrayList<String>();
		ArrayList<String> processo2 = new ArrayList<String>();
		ArrayList<String> processo3 = new ArrayList<String>();
		ArrayList<String> processo4 = new ArrayList<String>();
		ArrayList<String> processo5 = new ArrayList<String>();
		ArrayList<ArrayList> processoPrio1 = new ArrayList<ArrayList>();
		ArrayList<ArrayList> processoPrio0 = new ArrayList<ArrayList>();
		String prioridade1 = null;
		String prioridade2 = null;
		String prioridade3 = null;
		String prioridade4 = null;
		String prioridade5 = null;
		String linha = null;
		while((linha = leitor.readLine()) != null){
			if (linha.contentEquals("I") == true)
				listaComandos.add(linha);
			else if (linha.contentEquals("D") == true){
				listaComandos.add(linha);
				for(int c = 1; c <= disco; c++){
					String aux = "";
					aux = aux + c;
					listaComandos.add(aux);
				}
			}
			else if (linha.contentEquals("T") == true){
				listaComandos.add(linha);
			}
			else if (linha.contentEquals("0") || linha.contentEquals("1")){
				listaComandos.add(linha);
				if (processo1.isEmpty() == true){
					for(int i = 0; i < listaComandos.size(); i++){
						if(i + 1 == listaComandos.size()){
							String aux = listaComandos.get(i);
							prioridade1 = aux;
						}
						else{
							String aux = listaComandos.get(i);
							processo1.add(aux);
						}
					}
					if (prioridade1.contentEquals("1"))
						processoPrio1.add(0, processo1);
					else if(prioridade1.contentEquals("0"))
						processoPrio0.add(0, processo1);
					listaComandos.clear();
				}
				if (processo2.isEmpty() == true && listaComandos.isEmpty() != true){
					for(int i = 0; i < listaComandos.size(); i++){
						if(i + 1 == listaComandos.size()){
							String aux = listaComandos.get(i);
							prioridade2 = aux;
						}
						else{
							String aux = listaComandos.get(i);
							processo2.add(aux);
						}
					}
					if (prioridade2.contentEquals("1"))
						processoPrio1.add(1, processo2);
					else if(prioridade2.contentEquals("0"))
						processoPrio0.add(1, processo2);
					listaComandos.clear();
				}
				if (processo3.isEmpty() == true && listaComandos.isEmpty() != true){
					for(int i = 0; i < listaComandos.size(); i++){
						if(i + 1 == listaComandos.size()){
							String aux = listaComandos.get(i);
							prioridade3 = aux;
						}
						else{
							String aux = listaComandos.get(i);
							processo3.add(aux);
						}
					}
					if (prioridade3.contentEquals("1"))
						processoPrio1.add(2, processo3);
					else if(prioridade3.contentEquals("0"))
						processoPrio0.add(2, processo3);
					listaComandos.clear();
				}
				if (processo4.isEmpty() == true && listaComandos.isEmpty() != true){
					for(int i = 0; i < listaComandos.size(); i++){
						if(i + 1 == listaComandos.size()){
							String aux = listaComandos.get(i);
							prioridade4 = aux;
						}
						else{
							String aux = listaComandos.get(i);
							processo4.add(aux);
						}
					}
					if (prioridade4.contentEquals("1"))
						processoPrio1.add(3, processo4);
					else if(prioridade4.contentEquals("0"))
						processoPrio0.add(3, processo4);
					listaComandos.clear();
				}
				if (processo5.isEmpty() == true && listaComandos.isEmpty() != true){
					for(int i = 0; i < listaComandos.size(); i++){
						if(i + 1 == listaComandos.size()){
							String aux = listaComandos.get(i);
							prioridade5 = aux;
						}
						else{
							String aux = listaComandos.get(i);
							processo5.add(aux);
						}
					}
					if (prioridade5.contentEquals("1"))
						processoPrio1.add(4, processo5);
					else if(prioridade5.contentEquals("0"))
						processoPrio0.add(4, processo5);
					listaComandos.clear();
				}
			}
		}

		
//Em teoria, é aqui que vem a parte sólida do código, onde pegaria-se os 1-5 arraylists e executariamos as instruções. Mas não consigo implementar isso de maneira que ele possa verificar cada linha arraylist gerado para evitar duas instruções incompativeis em uso ao mesmo tempo, bem como não consigo achar um bom modo de avançar as listas separadamente para cada passo do timeslice e como gerar uma string a ser salva em cada linha do arquivo de saída. 

		
//		Linha de teste só pra ver se as listas estavam sendo geradas corretamente.
//		String teste = processo1.toString() + "\n" + processo2.toString() + "\n" + processo3.toString() + "\n" + processo4.toString() + "\n" + processo5.toString();
//		System.out.println(teste);
	}
}

é informação o bastante para vocês sobre mais ou menos qual é a minha linha de raciocinio? Alguem tem caminho melhor (e menos complexa) para alguém que perdeu totalmente a prática de Java?

Metavenger 28 de jun. de 2011

é que digamos assim. A lista de comandos é essa:

I
I
I
D
3
I
T
I
I
I
T

o timeslice tem que ser fornecido pelo teclado. ou seja, se fornecermos timeslice=2, então
Processo1
Processo1
Processo2
Processo2
e assim até executar todas instruções.

O fato de que o formato de saída tem que ser do modo que eu indiquei lá em cima complica as coisas. Mas se eu entendi bem, se eu criar uma classe processo, posso colocar um atributo para identificar de qual processo as instruções estão vindo e, do mesmo modo, salvar a instrução que está sendo executada. Assim, se p1 executa I, p2 não pode executar paralelamente, a menos que esteja acessando o disco desde o seu próprio timeslice.

Então, a classe Processo guarda a prioridade e guarda também a lista de comandos a serem executados. Vou tentar isso.

WellingtonRamos 28 de jun. de 2011

Metavenger:
Querem código? Eu dou código!

Taí tudo que consegui fazer até hoje. Não cheguei nem perto de fazer o código funcionar como devia. Só consigo separar a lista de entrada de instruções em até cinco processos (como pedido pelo trabalho, o escalonador roda até cinco processos, então, cria no máximo cinco listas de instruções. Usei arraylist porque, honestamente, nunca entendi como usar vetores e as instruções da API não funcionam quando eu tento usá-las, nem entendo os exemplos dados por outros foristas).

…

é informação o bastante para vocês sobre mais ou menos qual é a minha linha de raciocinio? Alguem tem caminho melhor (e menos complexa) para alguém que perdeu totalmente a prática de Java?

Lendo teu post, achei que, pra quem quer ajuda, poderia haver um pouco mais de educação (tudo bem que, quem respondeu a teu post, poderia compartilhar de igual educação hehehe). Desculpe se entendi errado mas é a impressão que passou.

Seguinte: Pelo meu entendimento de tua necessidade, você precisa de uma classe Processo que guarde as informações essenciais do teu processo (ex.: tipo, prioridade). Essa classe DEVERÁ implementar a interface Comparable que te fornece um método compareTo
Você precisará implementar o compareTo definindo quem terá maior prioridade que quem.

Ok. Feito isso, insira os mesmos numa List e reordene-os através de Collections.sort. Sua lista terá sido reordenada conforme as prioridades.
Obs.: Só pela quantidade de ifs/elses e de ArrayLists, creio que seu código esteja um pouco sujo (ou, pelo menos, de difícil manutenção).

A regra que define quem vai antes do outro deveria estar dentro do compareTo mas tenho apenas uma dúvida. O TimeSlice não deveria ser calculado a partir de uma pre-definição baseada na prioridade?

WellingtonRamos 29 de jun. de 2011

Tente aí, qualquer coisa, posta as dúvidas.

Criado 27 de junho de 2011

Ultima resposta 29 de jun. de 2011

Respostas 7

Participantes 5

7 Respostas

Topicos relacionados