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 ma…

Dúvidas:::Escalonador Round Robin :::Como implementar?

cv1 11 de out. de 2008

Perfeitamente possivel. Onde vc esta tendo problemas?

ViniGodoy 12 de out. de 2008

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?”

Mr_Smith 12 de out. de 2008

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

Dieval_Guizelini 12 de out. de 2008

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

Mr_Smith 13 de out. de 2008

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

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 <a href="http://java.io">java.io</a>.<em>;

import java.util.</em>;

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

Mr_Smith 13 de out. de 2008

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!!

B

Bruno_Laturner 13 de out. de 2008

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?

peczenyj 13 de out. de 2008

Parece que vc precisa estudar java básico antes de implementar um algoritmo desse porte.

Mr_Smith 13 de out. de 2008

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?

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???

Mr_Smith 14 de out. de 2008

Qual é a solução pessoal???
Preciso urgente de dicas… para quem sabe!!!

Valew!!!

B

Bruno_Laturner 14 de out. de 2008

Posta o teu algoritmo em C, já que você sabe implementá-lo.

11 Respostas

Topicos relacionados