process.cpp

一、 进程控制 目的：利用简单的结构和控制方法模拟进程结构、进程状态转换和进程控制。 方法：用PCB表示整个进程实体

// process.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"
#include "stdio.h"
#include "stdlib.h"
#include "string.h"
#include "iostream.h"

//定义“空”
#define null 0
//定义不再切割的剩余分区大小
#define size 5
//定义内存总量大小
#define memory_totalsize 100

//定义进程结构体
struct process
{
	char name[40];
	float memory_need;
	struct process *next;
}*process_ready, *process_blocked, *process_e;//将正在执行的进程设置为一全局变量

//定义内存分配结构体
struct memory_allocation
{
	struct memory_allocation *forward;
	char process_name[40];
	float start_address;
	float memory_size;
	int state;
	struct memory_allocation *after;
}*free_chain;
//occupy_chain备用
//*occupy_chain

void process_excute();
void process_ready_delete();
void process_blocked_delete();
struct memory_allocation *memory_largestselect();
int process_createjudge(struct process *process_temp);
void memory_allo(struct process *temp_process);
void memory_free(struct process *temp_process);
struct memory_allocation *memory_bestselect(struct process *temp_process);

//初始化内存
void memory_init(){
	free_chain = (struct memory_allocation *)malloc(sizeof(struct memory_allocation));
	strcpy(free_chain->process_name, "null");
	free_chain->start_address = 0;
	free_chain->memory_size = memory_totalsize;
	free_chain->state = 0;
	free_chain->forward = null;
	free_chain->after = null;
}

//创建进程函数 process_create()
void process_create()
{
	struct process *process_temp, *process_p;

	//申请内存空间并赋值
	process_temp = (struct process *)malloc(sizeof(struct process));
	printf("\n请依次输入所要创建\n进程的“名称”和“内存需求”：\n");
	scanf("%s %f", process_temp->name, &process_temp->memory_need);
	process_temp->next = null;
	
	int temp = process_createjudge(process_temp);
	if(temp == 0){
		//分配内存
		memory_allo(process_temp);

		//将新建的进程加入到就绪队列中
		if(process_ready == null){
			process_ready = process_temp;
		}else{
			process_p = process_ready;
			while(process_p->next != null){
				process_p = process_p->next;
			}
			process_p->next = process_temp;
		}

		printf("进程 %s 已经创建成功并加入到就绪队列中...\n", process_temp->name);
		//判断是否有处于执行态的进程，并对就绪队列的第一位进程进行状态处理
		if(process_e == null || process_e->memory_need == -1){
			process_excute();
		}
	}else if(temp == 1){
		printf("无法创建进程！系统中已经存在名称为 %s 的进程...\n", process_temp->name);
	}else if(temp == -1){
		printf("无法创建进程！系统中内存不足(剩余容量过少) 或 进程内存需求过大！\n");
	}
}

//将就绪队列中的第一位进程把状态由就绪转变为执行态
void process_excute()
{
	if(process_e == null){
		process_e = (struct process *)malloc(sizeof(struct process));
		strcpy(process_e->name, "目前没有处于执行态的进程...");
		process_e->memory_need = -1;
		process_e->next = null;
	}
	else
		;
	if(process_ready == null){
		printf("目前就绪进程队列为空...\n");
	}else{
		strcpy(process_e->name, process_ready->name);
		process_e->memory_need = process_ready->memory_need;
		process_e->next = null;
		process_ready_delete();
		printf("进程 %s 已经转为执行态...\n", process_e->name);
	}
}

//调度进程函数 process_pro()
void process_pro()
{
	//为了保证在没有 就绪态进程的时，调度进程而产生错误，特添加if条件判断语句
	if(process_ready != null){
		//保存正在执行的进程
		struct process *process_temp, *process_p;
		process_temp = (struct process *)malloc(sizeof(struct process));
		strcpy(process_temp->name,process_e->name);
		process_temp->memory_need = process_e->memory_need;
		process_temp->next = null;
	
		//将就绪队列中的第一位进程运行执行
		process_excute();

		//将process_temp（以前正在执行的进程process_e）添加到就绪队列的最后....
		if(process_ready == null){
			process_ready = process_temp;
		}else{
			process_p = process_ready;
			while(process_p->next != null){
				process_p = process_p->next;
			}
			process_p->next = process_temp;
		}
	}else{
		printf("目前就绪队列为空，无法调度进程...\n");
	}
}

//调度进程函数 process_block()
void process_block()
{
	//为了保证在没有执行态进程的时，继续阻塞进程而产生错误，特添加if条件判断语句
	//if((process_ready != null) && (process_e->memory_need != -1)){             //??????
	if(process_e->memory_need != -1){
		//保存正在执行的进程
		struct process *process_temp, *process_p;
		process_temp = (struct process *)malloc(sizeof(struct process));
		strcpy(process_temp->name, process_e->name);
		process_temp->memory_need = process_e->memory_need;
		process_temp->next = null;

		//将正在执行的进程添加到阻塞队列
		if(process_blocked == null){
			process_blocked = process_temp;
		}else{
			process_p = process_blocked;
			while(process_p->next != null){
				process_p = process_p->next;
			}
			process_p->next = process_temp;
		}
		printf("\n进程 %s 已经被阻塞且加入到阻塞队列中...\n", process_temp->name);
		//运行就绪队列中第一位进程
		process_e = null;//由于执行状态的进程只有一个，所以只需将process_e置为空即可，没有必要删除操作
		process_excute();
	}else{
		//printf("目前就绪队列为空 或 没有处于执行态的进程...");
		printf("目前没有处于执行态的进程...\n");
	}
}

//唤醒进程函数 process_wake()
void process_wake()
{
	//为了保证在没有 阻塞态进程的时，继续唤醒进程而产生错误，特添加if条件判断语句
	if(process_blocked != null){
		//保存阻塞队列中第一位进程
		struct process *process_temp, *process_p;
		process_temp = (struct process *)malloc(sizeof(struct process));
		strcpy(process_temp->name,process_blocked->name);
		process_temp->memory_need = process_blocked->memory_need;
		process_temp->next = null;

		//将process_temp添加到就绪队列的最后....
		if(process_ready == null){
			process_ready = process_temp;
		}else{
			process_p = process_ready;
			while(process_p->next != null){
				process_p = process_p->next;
			}
			process_p->next = process_temp;
		}

		//处理阻塞队列
		process_blocked_delete();
		printf("进程 %s 已经被唤醒且加入到就绪队列中...\n", process_temp->name);
		if(process_e->memory_need == -1){
			process_excute();
		}
	}else{
		printf("目前没有处于阻塞态的进程...\n");
	}
}

//结束进程函数 process_end()
void process_end()
{
	//为了保证在没有执行态进程的时，继续结束进程而产生错误，特添加if条件判断语句
	//if((process_ready != null) && (process_e->memory_need != -1)){
		if(process_e->memory_need != -1){
		//保存正在执行的进程
		struct process *process_temp;
		process_temp = (struct process *)malloc(sizeof(struct process));
		strcpy(process_temp->name,process_e->name);
		process_temp->memory_need = process_e->memory_need;
		process_temp->next = null;

		//free(process_e);
		process_e = null;
		
		memory_free(process_temp);
		//释放内存、内存回收
		printf("进程%s 已经被系统结束...\n", process_temp->name);
		process_excute();
	}else{
		//printf("目前就绪队列为空 或 没有处于执行态的进程...");
		printf("目前没有处于执行态的进程...\n");
	}
}

//进程时间片到函数 process_time()
void process_time()
{
	if((process_e != null) && (process_e->memory_need != -1)){
		//保存正在执行的进程
		struct process *process_temp, *process_p;
		process_temp = (struct process *)malloc(sizeof(struct process));
		strcpy(process_temp->name,process_e->name);
		process_temp->memory_need = process_e->memory_need;
		process_temp->next = null;
	
		//将process_temp添加到就绪队列的最后....
		if(process_ready == null){
			process_ready = process_temp;
		}else{
			process_p = process_ready;
			while(process_p->next != null){
				process_p = process_p->next;
			}
			process_p->next = process_temp;
		}

		//运行就绪队列中第一位进程
		//free(process_e);
		process_e = null;
		process_excute();
	}else{
		//printf("目前就绪队列为空 或 没有处于执行态的进程...");
		printf("目前没有处于执行态的进程...\n");
	}
}

//显示就绪队列、执行状态、阻塞队列中的进程
void process_display(){
	struct process *p;
	
	//显示就绪状态中的进程
	p = process_ready;
	printf("\n就绪队列中的程序有: ");
	if(process_ready == null){
		printf("就绪队列为空！");
	}else{
		do{
			printf("%s ", p->name);
			p = p->next;
		}while(p != null);
	}
	printf("\n");
	
	//显示处于执行状态的进程
	if(process_e == null){
		printf("目前没有处于执行态的进程...\n");
	}else{
		printf("正在执行的进程是：%s\n", process_e->name);
	}

	//显示阻塞状态中的进程
	p = process_blocked;
	printf("阻塞队列中的程序有: ");
	if(process_blocked == null){
		printf("阻塞队列为空！\n");
	}else{
		while(p->next != null){
			printf("%s ", p->name);
			p = p->next;
		}
		printf("%s\n", p->name);
	}
}

//就绪队列的删除操作（删除第一位进程）
void process_ready_delete(){
	if(process_ready == null){
		printf("就绪队列中没有进程...");
	}else{
		process_ready = process_ready->next;
	}
}

//阻塞队列的删除操作（删除第一位进程）
void process_blocked_delete(){
	if(process_blocked == null){
		printf("阻塞队列中没有进程...");
	}else{
		process_blocked = process_blocked->next;
	}
}

//创建进程时，名称的重复判断、以及内存容量空间判断
int process_createjudge(struct process *process_temp){
	struct process *process_p;
	struct memory_allocation *memory_p;
	float memory_temp = 0;
	//依次与就绪队列、执行态、阻塞队列中的进程比较，查看是否有与正要创建的进程名称相同
	process_p = process_ready;
	if(process_ready != null){
		do{
			if(strcmp(process_p->name, process_temp->name) != 0){
				process_p = process_p->next;
			}else{
				return 1;//返回 1 表示不能创建进程，原因：进程名称重复
			}
		}while(process_p != null);
	}
	
	

	process_p = process_e;
	if(process_e != null){
		if(strcmp(process_p->name, process_temp->name) != 0){
			//return 0;//返回 0 表示可以创建进程
		}else{
			return 1;
		}
	}
	

	process_p = process_blocked;
	if(process_blocked != null){
		do{
			if(strcmp(process_p->name, process_temp->name) != 0){
				process_p = process_p->next;
			}else{
				return 1;//返回 1 表示不能创建进程，原因：进程名称重复
			}
		}while(process_p != null);
	}

	memory_p = free_chain;
	if((memory_p->forward == null) && (memory_p->after == null)){
		if(memory_p->memory_size < process_temp->memory_need){
			return -1;//返回 -1 表示不可以创建进程，原因：没有足够的内存空间块
		}
	}else{
		//除去最后一块内存空间，前n-1块内存的总和
		do{
			memory_temp = memory_temp + memory_p->memory_size;