Estou estudando escalonamento e queria saber se existe ou é possível a implementação em java do ALgoritmo de escalonamento de Round Robin.
Eu sei implementar em C este algoritmo só que estou ultimamente
me dedicando mais a java.
Precisaria de uma Luz!!
Desde já agradeço.
Perfeitamente possivel. Onde vc esta tendo problemas?
Academicamente, para fins de demonstração, ou vc quer fazer um escalonador real?
Se for o segundo caso, fica complicado fazer em Java. Até porque, vc precisa da VM…
Se for o primeiro, não vejo onde vc poderia ter problemas… aí, faço minha a dúvida do colega e te pergunto, “onde está o seu problema?”
A minha seria a implementtação!!
Não cheguei a implementar e estou tendo dificuldade pra criar as threads
Só que a linguagem tá dificil!!!
Fiquei altas horas e não saiu nada!!!
Eu preciso de algumas dicas…
Teria um exemplo para eu visualisar??
abraço
Acho que isso pode te ajudar:
:arrow:https://quartz.dev.java.net/
:arrow:http://lass.cs.umass.edu/~shenoy/courses/fall00/labs/lab2_help.html
fw
[quote=Dieval Guizelini]Acho que isso pode te ajudar:
:arrow:https://quartz.dev.java.net/
:arrow:http://lass.cs.umass.edu/~shenoy/courses/fall00/labs/lab2_help.html
fw[/quote]
Valew pelos Link!!
Como eu posso alterar este Código para adapta-lo agora na versão Round Robin??
// This file contains the main() function for the Scheduling
// simulation. Init() initializes most of the variables by
// reading from a provided file. SchedulingAlgorithm.Run() is
// called from main() to run the simulation. Summary-Results
// is where the summary results are written, and Summary-Processes
// is where the process scheduling summary is written.
// Created by Alexander Reeder, 2001 January 06
import java.io.;
import java.util.;
import sProcess;
import Common;
import Results;
import SchedulingAlgorithm;
public class Scheduling
{
private static int processnum = 5;
private static int meanDev = 1000;
private static int standardDev = 100;
private static int runtime = 1000;
private static Vector processVector = new Vector();
private static Results result = new Results(“null”,“null”,0);
private static String resultsFile = “Summary-Results”;
private static void Init(String file)
{
File f = new File(file);
String line;
String tmp;
int cputime = 0;
int ioblocking = 0;
double X = 0.0;
try {
//BufferedReader in = new BufferedReader(new FileReader(f));
DataInputStream in = new DataInputStream(new FileInputStream(f));
while ((line = in.readLine()) != null) {
if (line.startsWith("numprocess")) {
StringTokenizer st = new StringTokenizer(line);
st.nextToken();
processnum = Common.s2i(st.nextToken());
}
if (line.startsWith("meandev")) {
StringTokenizer st = new StringTokenizer(line);
st.nextToken();
meanDev = Common.s2i(st.nextToken());
}
if (line.startsWith("standdev")) {
StringTokenizer st = new StringTokenizer(line);
st.nextToken();
standardDev = Common.s2i(st.nextToken());
}
if (line.startsWith("process")) {
StringTokenizer st = new StringTokenizer(line);
st.nextToken();
ioblocking = Common.s2i(st.nextToken());
X = Common.R1();
while (X == -1.0) {
X = Common.R1();
}
X = X * standardDev;
cputime = (int) X + meanDev;
processVector.addElement(new sProcess(cputime, ioblocking, 0, 0, 0));
}
if (line.startsWith("runtime")) {
StringTokenizer st = new StringTokenizer(line);
st.nextToken();
runtime = Common.s2i(st.nextToken());
}
}
in.close();
} catch (IOException e) { /* Handle exceptions */ }
}
private static void debug() {
int i = 0;
System.out.println("processnum " + processnum);
System.out.println("meandevm " + meanDev);
System.out.println("standdev " + standardDev);
int size = processVector.size();
for (i = 0; i < size; i++) {
sProcess process = (sProcess) processVector.elementAt(i);
System.out.println("process " + i + " " + process.cputime + " " + process.ioblocking + " " + process.cpudone + " " + process.numblocked);
}
System.out.println("runtime " + runtime);
}
public static void main(String[] args) {
int i = 0;
if (args.length != 1) {
System.out.println("Usage: 'java Scheduling <INIT FILE>'");
System.exit(-1);
}
File f = new File(args[0]);
if (!(f.exists())) {
System.out.println("Scheduling: error, file '" + f.getName() + "' does not exist.");
System.exit(-1);
}
if (!(f.canRead())) {
System.out.println("Scheduling: error, read of " + f.getName() + " failed.");
System.exit(-1);
}
System.out.println("Working...");
Init(args[0]);
if (processVector.size() < processnum) {
i = 0;
while (processVector.size() < processnum) {
double X = Common.R1();
while (X == -1.0) {
X = Common.R1();
}
X = X * standardDev;
int cputime = (int) X + meanDev;
processVector.addElement(new sProcess(cputime,i*100,0,0,0));
i++;
}
}
result = SchedulingAlgorithm.Run(runtime, processVector, result);
try {
try {
//BufferedWriter out = new BufferedWriter(new FileWriter(resultsFile));
PrintStream out = new PrintStream(new FileOutputStream(resultsFile));
out.println("Scheduling Type: " + result.schedulingType);
out.println("Scheduling Name: " + result.schedulingName);
out.println("Simulation Run Time: " + result.compuTime);
out.println("Mean: " + meanDev);
out.println("Standard Deviation: " + standardDev);
out.println("Process #\tCPU Time\tIO Blocking\tCPU Completed\tCPU Blocked");
for (i = 0; i < processVector.size(); i++) {
sProcess process = (sProcess) processVector.elementAt(i);
out.print(Integer.toString(i));
if (i < 100) { out.print("\t\t"); } else { out.print("\t"); }
out.print(Integer.toString(process.cputime));
if (process.cputime < 100) { out.print(" (ms)\t\t"); } else { out.print(" (ms)\t"); }
out.print(Integer.toString(process.ioblocking));
if (process.ioblocking < 100) { out.print(" (ms)\t\t"); } else { out.print(" (ms)\t"); }
out.print(Integer.toString(process.cpudone));
if (process.cpudone < 100) { out.print(" (ms)\t\t"); } else { out.print(" (ms)\t"); }
out.println(process.numblocked + " times");
}
out.close();
} catch (IOException e) { /* Handle exceptions */ }
System.out.println(“Completed.”);
}
}
// Run() is called from Scheduling.main() and is where
// the scheduling algorithm written by the user resides.
// User modification should occur within the Run() function.
import java.util.Vector;
import java.io.*;
public class SchedulingAlgorithm {
public static Results Run(int runtime, Vector processVector, Results result) {
int i = 0;
int comptime = 0;
int currentProcess = 0;
int previousProcess = 0;
int size = processVector.size();
int completed = 0;
String resultsFile = “Summary-Processes”;
result.schedulingType = "Batch (Nonpreemptive)";
result.schedulingName = "First-Come First-Served";
try {
//BufferedWriter out = new BufferedWriter(new FileWriter(resultsFile));
//OutputStream out = new FileOutputStream(resultsFile);
PrintStream out = new PrintStream(new FileOutputStream(resultsFile));
sProcess process = (sProcess) processVector.elementAt(currentProcess);
out.println("Process: " + currentProcess + " registered... (" + process.cputime + " " + process.ioblocking + " " + process.cpudone + " " + process.cpudone + ")");
while (comptime < runtime) {
if (process.cpudone == process.cputime) {
completed++;
out.println("Process: " + currentProcess + " completed... (" + process.cputime + " " + process.ioblocking + " " + process.cpudone + " " + process.cpudone + ")");
if (completed == size) {
result.compuTime = comptime;
out.close();
return result;
}
for (i = size - 1; i >= 0; i--) {
process = (sProcess) processVector.elementAt(i);
if (process.cpudone < process.cputime) {
currentProcess = i;
}
}
process = (sProcess) processVector.elementAt(currentProcess);
out.println("Process: " + currentProcess + " registered... (" + process.cputime + " " + process.ioblocking + " " + process.cpudone + " " + process.cpudone + ")");
}
if (process.ioblocking == process.ionext) {
out.println("Process: " + currentProcess + " I/O blocked... (" + process.cputime + " " + process.ioblocking + " " + process.cpudone + " " + process.cpudone + ")");
process.numblocked++;
process.ionext = 0;
previousProcess = currentProcess;
for (i = size - 1; i >= 0; i--) {
process = (sProcess) processVector.elementAt(i);
if (process.cpudone < process.cputime && previousProcess != i) {
currentProcess = i;
}
}
process = (sProcess) processVector.elementAt(currentProcess);
out.println("Process: " + currentProcess + " registered... (" + process.cputime + " " + process.ioblocking + " " + process.cpudone + " " + process.cpudone + ")");
}
process.cpudone++;
if (process.ioblocking > 0) {
process.ionext++;
}
comptime++;
}
out.close();
} catch (IOException e) { /* Handle exceptions */ }
result.compuTime = comptime;
return result;
}
}
[b]Alguém aí tem alguma solução para que este algoritmo se transforme em um Round Robin???
preciso de Susgestões…
Como ficaria a implementação???
valew
AlÕ Pessoal a minha dúvida é sobre como colocar a fila circular no codigo
Sei que utiliza a fila pra armazenar os processos…
Eu não sei como vou implementar…precisaria de um exemplo…
Neste código acima, preciso que eu altere alguma coisa…mas não sei onde!!
desde já agradeço!!!valew!!
Qual é a dificuldade? Quando ele chegar no último elemento, volte para o primeiro.
Só uma pergunta: Você quer fazer um escalonador de verdade ou só um simulador?
Parece que vc precisa estudar java básico antes de implementar um algoritmo desse porte.
[quote=Bruno Laturner]Qual é a dificuldade? Quando ele chegar no último elemento, volte para o primeiro.
[b]Só uma pergunta: Você quer fazer um escalonador de verdade ou só um simulador?[/quote]
Eu quero apenas um simulador ou melhor queria apenas modificar o código para que só que em Round Robin!!OK??[/b]
Será que é possível em JAVA??
Senão vou ter que fazer em C ou C++ só eu queria JAVA
se for possível como seria a implementação???
Qual é a solução pessoal???
Preciso urgente de dicas… para quem sabe!!!
Valew!!!
Posta o teu algoritmo em C, já que você sabe implementá-lo.