process.cpp

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

			memory_p = memory_p->after;
		}while(memory_p->after != null);
		//printf("%f \n", memory_temp);//----用于测试
		//判断是否还有剩余的足够大的内存空间用于创建新的进程
		if(memory_p->state == 0){
			//当剩余内存容量空间最大的内存块为最后块时，判断所创建的进程是否容量越界
			if(memory_largestselect()->after == null){
				if(memory_temp + process_temp->memory_need > memory_totalsize){
					return -1;
				}
			}
			
		}else{
			//当最后一块内存也被占用时，返回-1表示内存不足(没有足够的内存空间块)
			return -1;
		}
	}
	
	return 0;//返回 0 表示可以创建进程
}

//内存分配
void memory_allo(struct process *temp_process)
{
	struct memory_allocation *bestmemory_p;
	bestmemory_p = free_chain;
	//寻找最佳内存空间
    bestmemory_p = memory_bestselect(temp_process);
	strcpy(bestmemory_p->process_name, temp_process->name);
	if(bestmemory_p->forward == null){
		bestmemory_p->start_address = free_chain->start_address;
	}else{
		bestmemory_p->start_address = bestmemory_p->forward->start_address + bestmemory_p->forward->memory_size;
	}
	bestmemory_p->state = 1;
	if(bestmemory_p->memory_size - temp_process->memory_need < size){
		//由于前面已经将process_name、start_address、state赋值，这里就不再赋值
	}else{
		struct memory_allocation *memory_left, *p;
		memory_left = (struct memory_allocation *)malloc(sizeof(struct memory_allocation));
		strcpy(memory_left->process_name, "null");
		memory_left->start_address = bestmemory_p->start_address + temp_process->memory_need;
		memory_left->memory_size = bestmemory_p->memory_size - temp_process->memory_need;
		memory_left->state = 0;
		memory_left->forward = null;
		memory_left->after =null;

		bestmemory_p->memory_size = temp_process->memory_need;

		p = bestmemory_p->after;
				
		if(p == null){
			bestmemory_p->after = memory_left;
			memory_left->forward = bestmemory_p;
		}else{
			bestmemory_p->after = memory_left;
			memory_left->forward = bestmemory_p;
			memory_left->after = p;
			p->forward = memory_left;
		}
	}
}

void memory_free(struct process *temp_process)
{
	//释放内存,回收内存

	struct memory_allocation *memory_recovery;
	memory_recovery = free_chain;
	do{
		if(memory_recovery->state != 1){
			memory_recovery = memory_recovery->after;
		}else{
			if(strcmp(memory_recovery->process_name, temp_process->name) == 0){

				//正常一般情况
				if((memory_recovery->forward != null) && (memory_recovery->after != null) && (memory_recovery->after->after != null)){
					//上空下占
					if(memory_recovery->forward->state == 0 && memory_recovery->after->state == 1){
						memory_recovery->forward->memory_size = memory_recovery->forward->memory_size + memory_recovery->memory_size;
						memory_recovery->forward->after = memory_recovery->after;
						memory_recovery->after->forward = memory_recovery->forward;
					}
					//上占下占
					if(memory_recovery->forward->state == 1 && memory_recovery->after->state == 1){
						strcpy(memory_recovery->process_name, "null");
						memory_recovery->state = 0;
					}
					//上占下空
					if(memory_recovery->forward->state == 1 && memory_recovery->after->state ==0){
						memory_recovery->memory_size = memory_recovery->memory_size + memory_recovery->after->memory_size;
						strcpy(memory_recovery->process_name, "null");
						memory_recovery->state = 0;
						memory_recovery->after->after->forward = memory_recovery;
						memory_recovery->after = memory_recovery->after->after;
					}
					//上空下空
					if(memory_recovery->forward->state == 0 && memory_recovery->after->state ==0){
						memory_recovery->forward->memory_size = memory_recovery->forward->memory_size + memory_recovery->memory_size + memory_recovery->after->memory_size;
						memory_recovery->after->after->forward = memory_recovery->forward;
						memory_recovery->forward->after = memory_recovery->after->after;
					}
				}
				//回收区为内存中第一块 且 不为倒数第二块
				if((memory_recovery->forward == null) && (memory_recovery->after != null) && (memory_recovery->after->after != null)){
					//下占
					if(memory_recovery->after->state == 1){
						strcpy(memory_recovery->process_name, "null");
						memory_recovery->state = 0;
					}
					//下空
					if(memory_recovery->after->state == 0){
						strcpy(memory_recovery->process_name, "null");
						memory_recovery->memory_size = memory_recovery->memory_size + memory_recovery->after->memory_size;
						memory_recovery->state = 0;
						memory_recovery->after->after->forward = memory_recovery;
						memory_recovery->after = memory_recovery->after->after;
						
					}
				}

				//回收区为内存中第一块 且 为倒数第二块
				if((memory_recovery->forward == null) && (memory_recovery->after != null) && (memory_recovery->after->after == null)){
					//下占
					if(memory_recovery->after->state == 1){
						strcpy(memory_recovery->process_name, "null");
						memory_recovery->state = 0;
					}
					//下空
					if(memory_recovery->after->state == 0){
						strcpy(memory_recovery->process_name, "null");
						memory_recovery->memory_size = memory_recovery->memory_size + memory_recovery->after->memory_size;
						memory_recovery->state = 0;
						memory_recovery->after = null;
					}
				}

				//回收区为内存中第一块 且 不为倒数第一块(省略)
				/*if((memory_recovery->forward == null) && (memory_recovery->after != null)){
					
				}*/

				//回收区为内存中第一块 且 为倒数第一块
				if((memory_recovery->forward == null) && (memory_recovery->after == null)){
					strcpy(memory_recovery->process_name, "null");
					memory_recovery->state = 0;
				}

				//回收区不为内存中第一块 且 不为倒数第二块(省略)
				/*if((memory_recovery->forward != null) && (memory_recovery->after->after != null)){
					
				}*/

				//回收区不为内存中第一块 且 为倒数第二块
				if((memory_recovery->forward != null) && (memory_recovery->after != null) && (memory_recovery->after->after == null)){
					//上空下占
					if(memory_recovery->forward->state == 0 && memory_recovery->after->state == 1){
						memory_recovery->forward->memory_size = memory_recovery->forward->memory_size + memory_recovery->memory_size;
						memory_recovery->forward->after = memory_recovery->after;
						memory_recovery->after->forward = memory_recovery->forward;
					}
					//上占下占
					if(memory_recovery->forward->state == 1 && memory_recovery->after->state == 1){
						strcpy(memory_recovery->process_name, "null");
						memory_recovery->state = 0;
					}
					//上占下空
					if(memory_recovery->forward->state == 1 && memory_recovery->after->state ==0){
						memory_recovery->memory_size = memory_recovery->memory_size + memory_recovery->after->memory_size;
						strcpy(memory_recovery->process_name, "null");
						memory_recovery->state = 0;
						memory_recovery->after = null;

					}
					//上空下空
					if(memory_recovery->forward->state == 0 && memory_recovery->after->state ==0){
						memory_recovery->forward->memory_size = memory_recovery->forward->memory_size + memory_recovery->memory_size + memory_recovery->after->memory_size;
						memory_recovery->forward->after = null;
					}
				}

				//回收区不为内存中第一块 且 不为倒数第一块
				/*if((memory_recovery->forward != null) && (memory_recovery->after != null)){
					
				}*/

				//回收区不为内存中第一块 且 为倒数第一块
				if((memory_recovery->forward != null) && (memory_recovery->after == null)){
					//上占
					if(memory_recovery->forward->state == 1){
						strcpy(memory_recovery->process_name, "null");
						memory_recovery->state = 0;
					}
					//上空
					if(memory_recovery->forward->state == 0){
						memory_recovery->forward->memory_size = memory_recovery->forward->memory_size + memory_recovery->memory_size;
						memory_recovery->forward->after = null;
					}
				}
				
				break;
			}else{
				memory_recovery = memory_recovery->after;
			}
		}
	}while(memory_recovery != null);
}

struct memory_allocation *memory_bestselect(struct process *temp_process)
{
	struct memory_allocation *memory_past, *memory_present;
	float temp_past = 100, temp_present = 100;
	memory_present = free_chain;
	do{
		if((memory_present->memory_size < temp_process->memory_need) || (memory_present->state == 1)){
			memory_present = memory_present->after;
		}else{
			temp_past = temp_present;
			temp_present = memory_present->memory_size - temp_process->memory_need;
			if(temp_past < temp_present){
				memory_present = memory_present->after;
			}else{
				memory_past = memory_present;
				temp_past = temp_present;
				memory_present = memory_present->after;
			}
		}
	}while(memory_present != null);
  return memory_past;
}

//寻找空闲内存区域中容量最大的内存块
struct memory_allocation *memory_largestselect()
{
	struct memory_allocation *memory_largest, *memory_present;
	float temp_largest = 0, temp_present = 0;
	memory_present = free_chain;
	do{
		if((memory_present->memory_size <= temp_largest) || (memory_present->state == 1)){
			memory_present = memory_present->after;
		}else{
			temp_largest = memory_present->memory_size;
			//temp_present = memory_present->memory_size - temp_process->memory_need;
			/*if(temp_past < temp_present){
				memory_present = memory_present->after;
			}else{
				memory_past = memory_present;
				temp_past = temp_present;
				memory_present = memory_present->after;
			}*/
			memory_largest = memory_present;
		}
	}while(memory_present != null);
  return memory_largest;
}

void memory_display(){
	struct memory_allocation *p;
	
	//显示内存管理链表信息
	p = free_chain;
	printf("\n内存中存储的进程有: \n\n");
	if(free_chain == null){
		printf("内存管理链表为空！");
	}else{
		printf("进程名称\t起始地址\t内存容量\t内存状态  \n");
		do{
			printf("  %s\t", p->process_name);
			printf("	%f\t", p->start_address);
			printf("%f\t", p->memory_size);
			printf("    %d   \t", p->state);
			if(p->state == 0){
				printf("<<---\n");
			}else{
				printf("\n");
			}
			p = p->after;
		}while(p != null);
	}
	printf("\n");
}

//产生随机数操作
char random_operation(){
	char random_operate = 'P';
	int x = rand()%8;
	//printf("%d ", x);
	switch(x){
	//case 0: random_operate = 'C';break;
	case 0: break;
	case 1: random_operate = 'P';break;
	case 2: random_operate = 'E';break;
	case 3: random_operate = 'B';break;
	case 4: random_operate = 'W';break;
	case 5: random_operate = 'T';break;
	case 6: random_operate = 'D';break;
	case 7: random_operate = 'L';break;
	}
	//printf("%c \n", random_operate);
	return random_operate;
}

void help(){
	printf("\n帮助文档:\n\n");
	printf("  C(c)------------创建进程。\n");
	printf("  P(p)------------调度进程。\n");
	printf("  E(e)------------结束当前正在运行的进程。\n");
	printf("  B(b)------------阻塞当前正在运行的进程。\n");
	printf("  W(w)------------唤醒阻塞队列中的进程。\n");
	printf("  T(t)------------执行态进程时间片到。\n");
	printf("  D(d)------------显示系统进程。\n");
	printf("  L(l)------------显示系统内存信息。\n");
	printf("  R(r)------------随机操作。\n");
	printf("  H(h)------------获取帮助。\n");
	printf("  O(o)------------退出系统。\n");
	printf("\n  注：程序为了模拟操作系统的进程管理原理，\n  随机操作中并没有产生“创建进程”操作项。\n  若要创建进程，可以自行创建任意进程...\n");
}

//定义主函数main()
int main(int argc, char* argv[])
{
	memory_init();
	char operate;
	printf("\n  ----------- 操作系统实验一 -----------\n\n");
	printf("  C(c)------------创建进程。\n");
	printf("  P(p)------------调度进程。\n");
	printf("  E(e)------------结束当前正在运行的进程。\n");
	printf("  B(b)------------阻塞当前正在运行的进程。\n");
	printf("  W(w)------------唤醒阻塞队列中的进程。\n");
	printf("  T(t)------------执行态进程时间片到。\n");
	printf("  D(d)------------显示系统进程。\n");
	printf("  L(l)------------显示系统内存信息。\n");
	printf("  R(r)------------随机操作。\n");
	printf("  H(h)------------获取帮助。\n");
	printf("  O(o)------------退出系统。\n");
	printf("\n  注：程序为了模拟操作系统的进程管理原理，\n  随机操作中并没有产生“创建进程”操作项。\n  若要创建进程，可以自行创建任意进程...\n");

	while(1){
		printf("\n请选择相应的操作：");
		//scanf("%c", &operate);
		cin>>operate;
		if((operate == 'R') || (operate == 'r')){
			operate = random_operation();
		}
		switch(operate){
			case 'c':
			case 'C': process_create();break;
			case 'p':
			case 'P': process_pro();break;
			case 'e':
			case 'E': process_end();break;
			case 'b':
			case 'B': process_block();break;
			case 'w':
			case 'W': process_wake();break;
			case 't':
			case 'T': process_time();break;
			case 'd':
			case 'D': process_display();break;
			case 'h':
			case 'H': help();break;
			case 'l':
			case 'L': memory_display();break;
			case 'o':
			case 'O': 
				{
					printf("\n谢谢使用 ^_^ ...\n\n");
					printf("\t计算机科学技术学院 \n\t\t\t   ----- 阳勇 (20061995)。 \n\n");
					exit(0);
				}break;
			default:printf("错误操作！请重新输入...\n");
		}
	}
	printf("\n");
	return 0;
}