mosp1.java

这是由Java编写的小型模拟操作系统

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.util.LinkedList;

//进程P1，主要实现将作业送至输入井，同时启动通道1和通道3；

public class MosP1{
	int job_end=0;							//批作业结束地址;
	byte job_count=0;						//批作业中的作业个数;
	byte job_tot_length=0;					//用户作业的大小(以字为单位);
	int job_pro_start=0;					//用户作业程序区开始地址;
	int job_pro_end=0;						//用户作业程序区结束地址;
	int job_data_start=0;					//用户作业数据区开始地址;
	int job_data_end=0;						//用户作业数据区结束地址;
	int job_line_start=0;
	int job_line_end=0;
	int job_begin_start = 0;
	int p1_interrupt = 0;				//"0"为检查是否还有作业；＂１＂为检查通道１是否为忙；
//											＂２＂检查通道１是否启动完；＂３＂检查通道３是否为忙；
//											＂４＂检查通道３是否启动完；＂５＂检查是否还有下一页；
	int page_size = 0;
	byte[] jcb_name = new byte[4];
	byte[] jcb_supposed_time = new byte[4];
	byte[] jcb_supposed_output = new byte[4];
	String tot_job_word="";					//用于保存从文件读出的所有字符串;
	byte tom[]=new byte[25];				//用于保存逐次从文件读出的字符;
	String s;								//用于保存逐次从文件读出的字符串;
	byte page_tab[][][]=new byte[10][10][4];//每个作业最多10页,每页为10字,每字4个字节;
	int b;
	byte reg[]=new byte[40];
	MosMM mm = null;
	MosDisk disk = null;
	MosBlock mb = null;
	byte[] page_table = null;
	MosJCB mj = null;
	MosChannel1 chan1 = null;
	MosChannel3 chan3 = null;
	long chan1_time = 0;
	long chan3_time = 0;
	LinkedList que_jcb_ready = null;
	MosVar var = null;
	byte[] mm_data = new byte[4];
	byte[] disk_data = new byte[40];
	String s1 = "";
	int haddr = 0;
	
	public MosP1(MosMM mm,MosDisk disk,MosChannel1 chan1,MosChannel3 chan3,LinkedList que_jcb_ready,
			MosVar var) {
		this.mm = mm;
		this.disk = disk;
		this.chan1 = chan1;
		this.chan3 = chan3;
		this.que_jcb_ready = que_jcb_ready;
		this.var = var;
	}
	
	public String p1Read(String s1) {
//		读取作业文件并将字符串保存于tot_job_word中;
		try {
			tot_job_word = "";
			File f=new File(s1);
			FileInputStream refi=new FileInputStream(f);
			while((b=refi.read(tom,0,25))!=-1){
				s=new String(tom,0,b);
				tot_job_word=tot_job_word+s;				
			}
			refi.close();
		} catch (IOException e) {
			// TODO: handle exception
		}
		//		将作业中字符串"$JOE"的首地址保存于job_end,以便检测是否是批作业中的最后一个作业;
		job_end=tot_job_word.indexOf("$JOE");
		var.p1_switch = 1;
		return s;
	}
	
	public void p1Start() {
//		若有作业输入，则执行Ｐ１；
		if(var.p1_switch != 0) {
//			若p1_interrupt为０，则检查是否为最后一条作业；
			if(this.p1_interrupt == 0) {
		//		检测条件为字符串"$JOE"与"$POE"或"$DOE"的首地址相差6个unicode字符;
					if((job_end!=(job_data_end+5))&&(job_end!=(job_pro_end+6))){		
							
			//		用户作业程序大小(以字为单位);
					byte job_pro_length=0;		
							
			//		用户作业数据大小(以字为单位);
					byte job_data_length=0;			
						
			//		对每个保存作业的数组进行初始化;
					for(int i=0;i<10;i++){
						for(int j=0;j<10;j++){
							for(int k=0;k<4;k++)
								page_tab[i][j][k]=-1;
						}
					}
							
			//		每个作业程序区从"$POB"开始,到"$POE"结束,每次检测均以上一程序区结束首地址为检测新程序区
			//		的起始地址
					job_pro_start=job_pro_end;
					job_pro_end=job_pro_end+1;				
							
					job_pro_start=tot_job_word.indexOf("$POB",job_pro_start);
					job_pro_end=tot_job_word.indexOf("$POE",job_pro_end);
							
			//		已测试；
					job_begin_start =tot_job_word.indexOf("$BEGIN",job_begin_start+1);
					for(int i = 0;i < 4;i++) {
						jcb_name[i] = (byte)tot_job_word.charAt(job_begin_start+i+7);
						jcb_supposed_time[i] = (byte)tot_job_word.charAt(job_begin_start+i+12);
						jcb_supposed_output[i] = (byte)tot_job_word.charAt(job_begin_start+i+17);
					}
							
					haddr = -1;		
			//		读出每行的指令,用字节数组保存每一条指令
					job_line_end=job_line_start=job_pro_start;
					while(job_pro_end!=(job_line_start+7)){
						job_line_start=job_line_end;
						job_line_start=tot_job_word.indexOf(' ',job_line_start+1);
						job_line_end=tot_job_word.indexOf(' ',job_line_start+1)-2;
						char chartest =  tot_job_word.charAt(job_line_start+1);
						if(((byte)tot_job_word.charAt(job_line_start+1) != MosChar.H)&&((byte)tot_job_word.charAt(job_line_start+1) != MosChar.AT))
						{++haddr;}
						for(int i=0;i<4;i++){
							if((job_line_end-job_line_start-i-1)>0){
							    page_tab[job_pro_length/10][job_pro_length%10][i]=(byte)tot_job_word.charAt(job_line_start+i+1);
							}
							else{
								page_tab[job_pro_length/10][job_pro_length%10][i]=0;							
							}				
						}
							job_pro_length++;
						}
											
			//		作业数据区从"$DATA"开始,到"$DOE"结束,每次检测均以上一数据区结束首地址为检测新数据区的
			//		起始地址
					job_data_start=tot_job_word.indexOf("$DATA",job_data_start);
					job_data_end=tot_job_word.indexOf("$DOE",job_data_end);
							
			//		检测当前作业是否有数据区,检测条件为若存在数据区,则字符串"$POE"与"$DATA"的首地址相差6个
			//		unicode字符
						if(job_data_start==(job_pro_end+6)){
			//			保存数据区中的数据前加'*'以便识别程序中数据区的开始;
						page_tab[(job_pro_length)/10][(job_pro_length)%10][0]=(byte)'*';					
						for(int i=1;i<4;i++)
							page_tab[(job_pro_length)/10][(job_pro_length)%10][i]=0;
									
			//			若本作业有数据区,则应该读入输入井,每个作业的数据区从job_data_start开始至job_data_end
			//			结束,星号(*)前一个空格地址至"$DOE"首地址相差4个UNICODE字符,以此来判断本数据区的数据是否
			//			读完,数据包括'*'
						job_line_end=job_line_start=job_data_start;
						while(job_data_end!=(job_line_start+4)){
							job_line_start=job_line_end;
							job_line_start=tot_job_word.indexOf(' ',job_line_start);
							job_line_end=tot_job_word.indexOf(' ',job_line_start+1);
							for(int i=0;i<4;i++){	
								page_tab[(job_pro_length+job_data_length+1)/10][(job_pro_length+job_data_length+1)%10][i]=
									(byte)tot_job_word.charAt(job_line_start+i+1);
								if(((char)page_tab[(job_pro_length+job_data_length+1)/10][(job_pro_length+job_data_length+1)%10][0])=='*'){											//遇到"*"结束;并将其余三个字节置"0";
									page_tab[(job_pro_length+job_data_length+1)/10][(job_pro_length+job_data_length+1)%10][1]=
									page_tab[(job_pro_length+job_data_length+1)/10][(job_pro_length+job_data_length+1)%10][2]=
									page_tab[(job_pro_length+job_data_length+1)/10][(job_pro_length+job_data_length+1)%10][3]=0;
									break;		
								}					
							}
							job_data_length++;
						}
																									
						job_data_start=job_data_end;
						job_data_end=job_data_end+1;
									
//						System.out.println("data has come "+job_data_length);
					}
					else{
						job_data_length=0;
//						System.out.println("not data come "+job_data_length);
					}
							
					job_tot_length = (byte)(job_pro_length+job_data_length);
							
					
					this.p1_interrupt = 1;
					this.page_size = 0;
				}
				else {
					tot_job_word = "";
					var.p1_switch = 0;
					job_end=0;
					job_count=0;
					job_tot_length=0;
					job_pro_start=0;
					job_pro_end=0;
					job_data_start=0;
					job_data_end=0;	
					job_line_start=0;
					job_line_end=0;
					job_begin_start = 0;
					p1_interrupt = 0;
					page_size = 0;
				}
			}
//			当p1_interrupt为１时对输入井进行检查；
			if(this.p1_interrupt == 1) {
				this.page_table = disk.diskMalloc((byte)(job_tot_length/10+1), FinalVar.IN_BUFFER_ADDR);	
				if(this.page_table != null) {
					mb = new MosBlock(this.page_table);
					this.page_size = 0;
					this.p1_interrupt = 2;
				}				
			}
//			p1_interrupt为２时检查通道１是否为忙；
			if(this.p1_interrupt == 2) {
				if(chan1.getMosChst() == FinalVar.CHST_STAT_FREE) {
					chan1.setMosChst(FinalVar.CHST_STAT_BUSY);
					for(int j=0;j<10;j++){	
						if(page_tab[this.page_size][j][0]==-1)
							break;					
						for(int k=0;k<4;k++){
							reg[j*4+k]=page_tab[this.page_size][j][k];
						}
					}
					this.chan1_time = var.getTime();
					this.p1_interrupt = 3;
				}
			}
//			p1_interrupt为３表示当本进程启动通道１后，检测是否三个时间片已到，若到达则传送数据；
			if(this.p1_interrupt == 3) {
				if(var.getTime() >= (this.chan1_time + 3)) {
					chan1.startChannel1(reg);
					chan1.setMosChst(FinalVar.CHST_STAT_FREE);
					this.p1_interrupt = 4;
				}
			}
//			p1_interrupt为４表示检查通道３是否为忙；
			if(this.p1_interrupt == 4) {
				if(chan3.getMosChst() == FinalVar.CHST_STAT_FREE) {
					chan3.setMosChst(FinalVar.CHST_STAT_BUSY);
					this.chan3_time = var.getTime();
					this.p1_interrupt = 5;
				}
			}
//			p1_interrupt为５表示当本进程启动通道３后，检测是否一个时间片已到，若到达则传送数据；
			if(this.p1_interrupt == 5) {
				if(var.getTime() >= (this.chan3_time + 1)) {
					chan3.startChannel3(FinalVar.CHST3_READ, FinalVar.KB_BUFFER_ADDR, page_table[this.page_size]);
					this.page_size++;
					chan3.setMosChst(FinalVar.CHST_STAT_FREE);
					for(int l = 0;l < 40;l++) {
						reg[l] = 0;
					}
					this.p1_interrupt = 6;
				}
			}
//			p1_interrupt为６表示是否已传送完一个作业到输入井；
			if(this.p1_interrupt == 6) {
				if(this.page_size == (job_tot_length/10+1)) {
					mj = new MosJCB(job_count,jcb_name,jcb_supposed_time,jcb_supposed_output,mb);
					mj.setHaddr(haddr);
					que_jcb_ready.add(mj);
					job_count++;
					this.p1_interrupt = 0;
				}
				else {
					this.p1_interrupt = 2;
				}
			}
		}
	}
}