0

Hi,

I'm having problems with line 37 in my Driver class. I know that I get that error because, according to Java, the variable Task, in the Driver, has not been initialized, but I do not see how I'm not initializing it.

Thanks

import java.util.Scanner;
import java.io.*;

public class Driver 
{
	public static void main(String [] arg) throws IOException  
	{
		Scanner Scan = new Scanner(new File("mfq.txt"));
		LineWriter lw = new LineWriter("csci.txt");
		
		//numbers of queue in the system
		int queues = 5;
		
		//Array holding priority Queues of objects
		ObjectQueue [] objQueue = new ObjectQueue [queues];
		
		//Variable to hold any process/task to be pass to the CPU
		//from the text file or a queue
		Process Task;
	    
		//variable to finish all process when set to false
		boolean END;
		
		//CPU object
		CPU Core = new CPU();
		
		//variable to hold time elapsed in the machine
		int Machine_Time = 0;
		
		// q set to -1 as initial value
		//int q;
		
		//move all process into objQueue[0]
		while (Scan.hasNext())
		{
			Task = new Process (Scan.nextLine(), lw, 0);
			objQueue[0].insert(Task);
			
		}
		
		//set all process into the first priority queue
		do
		{
			//set END to false for a continuous loop until all queues are empty and q to -1 
			END = false;
			int q = -1;
			
			//check if there is any process in the input Queue
			if (!objQueue[0].isEmpty())
			{
				//check if process needs to be send to the CPU
				if (((Process)objQueue[0].query()).getSendTime() == Machine_Time)
				{
					q = 0;
				}
			}
			
			//if process does not have to be send to CPU, look in priority queues
			if (q != 0)
			{
				for (int i = 1; i < queues; i++)
				{
					if (!objQueue[i].isEmpty())
					{
						q = i;
						break;
					}
				}
			}
			
			if (q > -1)
			{
				Task = (Process) objQueue[q].remove();
				
				if (Core.Busy())
				{
					if (q < queues - 1)
						q++;
					
					Task.setQueue(q);
					objQueue[q].insert(Task);
				}
				else
				{
					if (q == 0)
						Core.getProcess(Task, Machine_Time);
					else
						Core.getProcess(Task);
				}
				
				Core.Process();
				
				//if  CPU is not busy
				if (!Core.Busy())
				{
					Task = Core.freeCPU(Machine_Time);
					
					if (Task.getTimer() == 0)
						Task.EndProcess();
					else
					{
						if (q < queues - 1)
							q++;
						
						Task.setQueue(q);
						objQueue[q].insert(Task);
					}
				}
				
				//check if all queues are empty
				for (int c = 0; c < queues; c++)
				{
					if (!objQueue[c].isEmpty())
					{
						END = true;
						break;
					}
				}
			}
		}while (END);
	}
}
public class Process 
{
	//current queue
	private int queue = 0;
	
	//time to send to CPU/Core
	private int submit_time;
	
	//process id
	private int id;
	
	//time for process to be completed
	private int timer;
	
	//time process arrives for the first time into the CPU
	private int time_in;
	
	//time process is completed
	private int time_out;
	
	private LineWriter lw;
	
	//initialize queue, id, timer and submit_time variables
	public Process(String str, LineWriter l, int q)
	{
		lw = l;
		queue = q;
		
		String temp = "";
		id = 0;
		timer = 0;
		submit_time = 0;
		
		for (int c = 0; c < str.length(); c++)
		{
			while (str.charAt(c) == ' ')
			{
				c++;
			}
			
			while ((c < str.length()) && (str.charAt(c) != ' '))
			{
				temp = temp + str.charAt(c);
				c++;
			}
			
			if (submit_time == 0)
				submit_time = Integer.valueOf(temp);
			else if (id == 0)
				id = Integer.valueOf(temp);
			else if (timer == 0)
				 timer = Integer.valueOf(temp);
			
			temp = "";
		}
	}
	
	//decrease time left for process to be completed
	public int getTimer()
	{
		return timer;
	}
	
	//set new time for process to be completed
	public void setTimer()
	{
		timer--;
	}
	//returns process id
	public int getId()
	{
		return id;
	}
	
	//set current queue
	public void setQueue(int x)
	{
		queue = x;
	}
	
	//return current queue
	public int getQueue()
	{
		return queue;
	}
	
	//return time when the process is send to the CPU
	public int getSendTime()
	{
		return submit_time;
	}
	
	//records the machine time that the process was send to the CPU
	public void setTimeIn( int x)
	{
		time_in = x;
	}
	
	//set the machine time when the CPU releases a process
	public void setTimeOut(int x)
	{
		time_out = x;
	}
	
	//retunrs machine time when process is completed
	public int getTimeOut()
	{
		return time_out;
	}
	
	public void EndProcess()
	{
		lw.println(time_in + "		" + "		" + id + "		" + time_out );
		//lw.println();
		
		System.out.println(time_in + "		" + "		" + id + "		" + time_out );
		//System.out.println();
	}
}
public class CPU 
{
	//time that the CPU will spend in a process
	private int CPU_Time;
	
	//process received by the CPU
	private Process Work;
	
	//variable to hold busy flag
	private boolean busy_flag;
	
	
	public CPU()
	{
		busy_flag = false;
		CPU_Time = 0;
	}
	
	//returns true or false if CPU_Time is not 0 (CPU busy)
	public boolean Busy()
	{
		return busy_flag;
	}
	
	//pass process for the first time to CPU
	public void getProcess(Process Task, int t)
	{
		Work = Task;
		Work.setTimeIn(t);
		CPU_Time = (int) java.lang.Math.pow(2, (double) Work.getQueue());
		busy_flag = true;
	}
	
	//pass process from queue into CPU
	public void getProcess(Process Task)
	{
		Work = Task;
		CPU_Time = (int) java.lang.Math.pow(2, (double) Work.getQueue());
		busy_flag = true;
	}
	
	//decrease CPU timer by 1 unit and increase and clears busy flag if CPU_Time = 0
	public void Process()
	{
		CPU_Time--;
		
		//decrease time needed to complete process
		Work.setTimer();
		
		if (CPU_Time == 0 || Work.getTimer() == 0)
			busy_flag = false;
	}
	
	//returns Process to be passed to queue
	public Process freeCPU(int x)
	{
		Work.setTimeOut(x);
		return Work;
	}
}
/**
 * Write a description of class ObjectQueue here.
 * 
 * @author (your name) 
 * @version (a version number or a date)
 */
public class ObjectQueue
{
    private Object[] item;
    private int front;
    private int rear;
    private int size;
    
    public ObjectQueue(){
        size = 100;
        item = new Object[size];
        front = size-1;
        rear = size-1;
    }
    
    public ObjectQueue(int max){
        size = max;
        item = new Object[size];
        front = size-1;
        rear = size-1;
    }
    
    public boolean isEmpty(){
        return front == rear;
    }
    
    public boolean isFull(){
        return rear == size-1 ? front == 0 : front == rear+1;
    }
    
    public void clear(){
        front = size-1;
        rear = size-1;
    }
    
    public void insert(Object x){
        if (isFull()){
            System.out.println("Insert Runtime Error: Queue Overflow");
            System.exit(1);
        }
        if (rear == size-1)
            rear = 0;
        else
            rear++;
        item[rear] = x;
    }
    
    public Object remove(){
        if (isEmpty()){
            System.out.println("Remove Runtime Error: Queue Underflow");
            System.exit(1);
        }
        if (front == size-1)
            front = 0;
        else
            front++;
        return item[front];
    }
    
    public Object query(){
        if (isEmpty()){
            System.out.println("Query Runtime Error: Queue Underflow");
            System.exit(1);
        }
        if (front == size-1)
            return item[0];
        else
            return item[front+1];
    }

    
    

}
// LineWriter.java

import java.io.*;

/* @author Richard Stegman
 * @version 2.1, 1/5/07
 * 
 * LineWriter provides simple methods for opening and writing to text files.
 * 
 * Example:
 * 
 *      LineWriter lw = new LineWriter(foo.txt");
 *      lw.println("This is a string.");
 *      lw.println();
 *      lw.println(108);
 *      lw.close(); 
 *
 */

public class LineWriter {
    private PrintWriter outFile;
    
    /*
     * LineWriter constructor. 
     * Creates a new file or overwrites an existing file.
     * @param fileName name of the file to be created
     */
    
    public LineWriter(String fileName) {
        try {
            FileWriter fw = new FileWriter(fileName);
            BufferedWriter bw = new BufferedWriter(fw);
            outFile = new PrintWriter(bw);
        }    
        catch (IOException e) {
            System.out.println("LineWriter cannot open output file: " + fileName);
            e.printStackTrace();
        }
    }

    /*
     * LineWriter constructor. 
     * Creates a new file. If the file exists can append to it.
     * @param fileName name of the file to be created
     * @param mode if equal to "a" opens in append mode
     */
    
    public LineWriter(String fileName, String mode) {
        try {
            FileWriter fw = new FileWriter(fileName, "a".equals(mode));
            BufferedWriter bw = new BufferedWriter(fw);
            outFile = new PrintWriter(bw);
        }    
        catch (IOException e) {
            System.out.println("LineWriter cannot open output file: " + fileName);
            e.printStackTrace();
        }
    }

    /**
     * Outputs a string and newline to the file.
     * @param s string to be output
     */
     
    public void println(String s) {
        outFile.println(s);
    }

    /**
     * Outputs a string to the file.
     * @param s string to be output
     */
     
    public void print(String s) {
        outFile.print(s);
    }

    /**
     * Outputs an integer and newline to the file.
     * @param i integer to be output
     */
     
    public void println(int i) {
        outFile.println(i);
    }

    /**
     * Outputs an integer to the file.
     * @param i integer to be output
     */
     
    public void print(int i) {
        outFile.print(i);
    }

    /**
     * Outputs a long and newline to the file.
     * @param l long to be output
     */
     
    public void println(long l) {
        outFile.println(l);
    }

    /**
     * Outputs a long to the file.
     * @param l long to be output
     */
     
    public void print(long l) {
        outFile.print(l);
    }

     /**
     * Outputs a short and newline to the file.
     * @param s short to be output
     */
     
    public void println(short s) {
        outFile.println(s);
    }

    /**
     * Outputs a short to the file.
     * @param s short to be output
     */
     
    public void print(short s) {
        outFile.print(s);
    }
    
    /**
     * Outputs a byte and newline to the file.
     * @param b byte to be output
     */
     
    public void println(byte b) {
        outFile.println(b);
    }

    /**
     * Outputs a byte to the file.
     * @param b byte to be output
     */
     
    public void print(byte b) {
        outFile.print(b);
    }
    
    /**
     * Outputs a boolean and newline to the file.
     * @param b boolean to be output
     */
     
    public void println(boolean b) {
        outFile.println(b);
    }

    /**
     * Outputs a boolean to the file.
     * @param b boolean to be output
     */
     
    public void print(boolean b) {
        outFile.print(b);
    }

    /**
     * Outputs a float and newline to the file.
     * @param f float to be output
     */
     
    public void println(float f) {
        outFile.println(f);
    }

    /**
     * Outputs a float to the file.
     * @param f float to be output
     */
     
    public void print(float f) {
        outFile.print(f);
    }

    /**
     * Outputs a double and newline to the file.
     * @param d double to be output
     */
     
    public void println(double d) {
        outFile.println(d);
    }

    /**
     * Outputs a double to the file.
     * @param d double to be output
     */
     
    public void print(double d) {
        outFile.print(d);
    }

    /**
     * Outputs a character and newline to the file.
     * @param c char to be output
     */
     
    public void println(char c) {
        outFile.println(c);
    }

    /**
     * Outputs a character to the file.
     * @param c char to be output
     */
     
    public void print(char c) {
        outFile.print(c);
    }

    /**
     * Outputs an object and newline to the file.
     * @param o object to be output
     */
     
    public void println(Object o) {
        outFile.println(o);
    }

    /**
     * Outputs an object to the file.
     * @param o object to be output
     */
     
    public void print(Object o) {
        outFile.print(o);
    }
    
    /**
     * Outputs a newline character to the file.
     */
     
    public void println() {
        outFile.println();
    }

    /**
     * Closes the file.
     */
     
    public void close() {
        outFile.flush();
        outFile.close();
    }
}
4
Contributors
4
Replies
5
Views
6 Years
Discussion Span
Last Post by dimasalang
0

no, it is objQueue[0] that is null. When you initiate an Object[], each of the elements initially contain null. You still have to define the individual elements of the array.

0

Thanks a lot, declaring a new queue before moving them into the array fix the problem

0

this is a shot in the dark, but i am wondering what "declaring a new queue before moving them into the array" means code-wise... i am working on a similar project for seemingly the same class as this was for, and it would be nice to see this work... as is, it does not work.

0

Hi. This thread is already dead, it's 2 years old and has been solved! Maybe you would want to start a new discussion.

Edited by dimasalang

This question has already been answered. Start a new discussion instead.
Have something to contribute to this discussion? Please be thoughtful, detailed and courteous, and be sure to adhere to our posting rules.