macmanage.h

一个简单的机器调度模拟程序。根据任务的时长

	int mac_num ;
	//执行任务的机器
	mac * doer ;
	//车间是否可用
	bool en_work ;
	//工作效率最低的机器
	int MinMac ;
	//暂存任务，用以暂存返回任务
	task * tmp_task ;
public :
	//车间工作状态,在工作则为true,不在工作则为false
	bool is_work ;
	//机房总任务数
	int total ;
	//返回某机器数据
	mac * doer_inf ( int id ) {	return &doer [ id ] ;	}
	//返回机器数
	int macnum ( ) {	return mac_num ;	}
	//优化标志，已优化为1，未优化为0
	bool is_optimize;
	//最大效率机器与最小效率机器工作时间差，返回时设置MaxMac和MinMac
	int Max_Min ( ) ;
	//最大效率机器
	int MaxMac ;
	//添加任务给予车间
	//添加任务给车间中指定机器任务
	void add_task ( task tmp , int mac_id = 0 ) ;
	//撤销车间任务
	void del_task ( int mac_id , int ts_time ) ;
	//优化车间任务分配
	void optimize ( ) ;
	//得出一个优化方案
	void get_optimize () ;
	//查看任务执行计划
	void show_plan ( ) ;
	//初试化车间
	wplace ( ) ;
	wplace ( int num ) ;
	~wplace ( ) ;
	//清除车间所有任有任务
	void clear ( ) ;
	//返回计划执行任务数最多的机器计划执行的任务数目
	int MostTaskMac ( ) ;
	//将所有任务回收，分配给机器0
	void TaskToMacOne ( ) ;
	//两机器任务时间差
	int TwoMacTimeDif ( int a_id , int b_id ) ;
	//交换两台机器的所有计划任务
	void ExchTwoMac ( int a_id , int b_id ) ;
	//设置机器数目
	void SetMacNum ( int m ) ;
	//执行一时间片的任务
	void OneStep ( ) ;
	//设置任务开关
	void Set_Conduct ( bool state ) ;
	//计算总任务时间,设置total
	void CountTotal ( ) ;
	//计算计划执行任务总数
	int CountPlanTask ( ) ;
private:
	int test;
} ;
/*------------------------------------------------------------*/
//计算计划执行任务总数
int wplace ::CountPlanTask ( )
{
	int t = 0 ;
	for ( int i = 0 ; i < mac_num ; i ++ )
		t = doer [ i ].task_num + t;
	return t ;
}
//计算总任务时间,设置total
void wplace ::CountTotal ( ) 
{
	total = 0 ;
	for ( int i = 0 ; i < mac_num ; i ++ )
		total = doer [ i ].all_time + total ;
}
//设置任务开关
void wplace ::Set_Conduct ( bool state )
{
	if ( is_work == state )
		return ;
	is_work = state ;
	for ( int i = 0 ; i < mac_num ; i ++ )
		doer [ i ].is_work = is_work ;
}
//执行任务运行一时间片
void wplace ::OneStep ( )
{
	if ( en_work == false )
		return ;
	for ( int i = 0 ; i < mac_num ; i ++ )
	{
		if ( doer [ i ].is_work != true )
			continue ;
		while ( !doer [ i ].DoOnePiece ( ) && doer [ i ].all_time > 0 )
			doer [ i ].DoTask ( ) ;
	}
}

//设置机器数目
void wplace ::SetMacNum ( int m )
{
	if ( m <= 0 || en_work == false )
		return ;
	mac tmp ;
	//机房无作业任务
	if ( total == 0 )
	{
		clear ( ) ;
		delete [] doer ;
		doer = new mac [ m ] ;
		mac_num = m ;
	}
	//将所有任务回收至机器0
	TaskToMacOne ( ) ;
	while ( CountPlanTask ( ) != 0 )
	{
		del_task ( 0 , doer [ 0 ].bList ->next ->time ) ;
		tmp.add_task ( *tmp_task ) ;
	}
	clear ( ) ;
	delete [] doer ;
	doer = new mac [ m ] ;
	mac_num = m ;
	while ( tmp.all_time != 0 )
	{
		tmp.del_task ( tmp.bList ->next ->time ) ;
		add_task ( tmp.tmp_reg ) ;
	}
	get_optimize ( ) ;
}
//交换两台机器的所有计划任务
void wplace :: ExchTwoMac ( int a_id , int b_id )
{
	if ( en_work == false )
		return ;
	mac tmp , nop ;
	//任务表首地址存放在寄存器上，表头指针不发生变化
	tmp = doer [ a_id ] ;
	doer [ a_id ] = doer [ b_id ] ;
	doer [ b_id ] = tmp ;
	tmp = nop ;//避免析构函数将tmp中包含的有用内容清除
	//修正表头指针
	doer [ a_id ].bList = & doer [ a_id ].tmp_reg ;
	doer [ b_id ].bList = & doer [ b_id ].tmp_reg ;
	
}
//两机器任务时间差
int wplace ::TwoMacTimeDif ( int a_id , int b_id )
{
	if ( en_work == false )
		return 0 ;
	return ( doer [ a_id ].all_time - doer [ b_id ].all_time ) ;
}
//将所有任务回收，分配给机器0
void wplace ::TaskToMacOne ( )
{
	if ( en_work == false )
		return ;
	for ( int i = 1 ; i < mac_num ; i ++ )
	{
		while ( doer [ i ].task_num > 0 )
		{
			doer [ i ].del_task ( doer [ i ].bList ->next ->time ) ;
			doer [ 0 ].add_task ( doer [ i ].tmp_reg ) ;
		}
	}
}
//撤销车间任务
void wplace ::del_task ( int mac_id , int ts_time ) 
{
	if ( en_work == false )
		return ;
	total = total - doer [ mac_id ].all_time ;
	doer [ mac_id ].del_task ( ts_time ) ;
	total = total + doer [ mac_id ].all_time ;
	tmp_task = &doer [ mac_id ].tmp_reg ;
}
//得出一个最终优化方案
void wplace ::get_optimize ( ) 
{
	if ( en_work == false )
		return ;
	int pre = 0 , num = 0 ;
	if ( is_optimize == true )
	{
		TaskToMacOne ( ) ;
		is_optimize = false ;
	}
	while ( !is_optimize && num != 20 )
	{	
		pre = doer [ MaxMac ].all_time ;
		optimize ( ) ;
		Max_Min ( ) ;
		if ( pre == doer [ MaxMac ].all_time )
			num ++ ;
		else 
			num = 0 ;
	}
	if ( MaxMac == 0 || num == 20)
	{
		is_optimize = true ;
		return ;
	}
	/*------------------------------------------------------*/
	//优化所有机器
	int mac_tmp = mac_num ;

	Max_Min ( ) ;
	ExchTwoMac ( MaxMac , mac_num - 1 ) ;
	mac_num -- ;

	get_optimize ( ) ;
	mac_num ++ ;

	
}
//清除车间所有任有任务
void wplace :: clear ( ) 
{
	if ( en_work == true )
	{
		delete []doer ;
	}
	doer = new mac [ mac_num ] ;
	//还原一切为默认值,除mac_num
	is_work = false ;
	test = 0 ;
	MaxMac = 0 ;
	MinMac = 0 ;
	tmp_task = NULL ;
	is_optimize = false ;
	en_work = true ;
}
//最大效率机器与最小效率机器工作时间差，返回时设置MaxMac和MinMac
int wplace ::Max_Min ( )
{
	if ( en_work != true )
		return -1 ;
	MaxMac = 0 ;
	MinMac = 0 ;
	for ( int i = 0 ; i < mac_num ; i ++ )
	{
		if ( doer [ MaxMac ].all_time < doer [ i ].all_time  )
			MaxMac = i ;
		else if ( doer [ MinMac ].all_time > doer [ i ].all_time )
			MinMac = i ;
	}
	return ( doer [ MaxMac ].all_time - doer [ MinMac ].all_time ) ;
}
//初始化车间
wplace ::wplace ( )
{
	is_work = false ;
	test = 0 ;
	doer = NULL ;
	mac_num = 0 ;
	MaxMac = 0 ;
	MinMac = 0 ;
	tmp_task = NULL ;
	is_optimize = false ;
	en_work = false ;
}
wplace ::~wplace ( ) 
{
	if ( en_work == true )
	{
		delete []doer ;
	}
}
//初始有机器的车间
wplace ::wplace ( int num )
{
	test = 0 ;
	if ( num <= 0 )
		wplace ( ) ;
	else
	{
		//购入机器
		doer = new mac [ num ] ;
		mac_num = num ;
		MaxMac = 0 ;
		MinMac = 0 ;
		tmp_task = NULL ;
		is_optimize = false ;
		en_work = true ;
		total = 0 ;
		is_work = false ;
	}

}
//添加任务tmp至机器mac_id
void wplace ::add_task ( task tmp , int mac_id )
{
	if ( mac_id < 0 || mac_id >= mac_num || en_work == false )
		return ;
	total = tmp.time + total ;
	doer [ mac_id ].add_task ( tmp ) ;
}
//优化分配车间任务
void wplace ::optimize ( )
{
//	int i ;
	if ( en_work == false )
		return ;
	int MidTask ;
	//求得最高效率机器与最低效率机器之间任务时差
	int dt = Max_Min ( ) ;
	if ( dt <= 0 )
	{
		is_optimize = true ;
		return ;
	}

	MidTask = doer [ MaxMac ].get_midofd ( dt ) ;
	if ( MidTask > 0 )
	{
		doer [ MaxMac ].del_task ( MidTask ) ;
		doer [ MinMac ].add_task ( doer [ MaxMac ].tmp_reg ) ;
		return ;
	}
	
	if ( doer [ MaxMac ].get_midofd_twomac ( doer [ MinMac ] , dt ) != -1 ) 
	{
		doer [ MaxMac ].del_task ( doer [ MaxMac ].tmp_reg.time ) ;
		doer [ MinMac ].del_task ( doer [ MinMac ].tmp_reg.time ) ;
		doer [ MaxMac ].add_task ( doer [ MinMac ].tmp_reg ) ;
		doer [ MinMac ].add_task ( doer [ MaxMac ].tmp_reg ) ;
		return ;
	}
	if ( doer [ MaxMac ].get_midofd_twomac ( doer [ 0 ] , doer [ MaxMac ].all_time - doer [ 0 ].all_time  ) != -1 ) 
	{
		doer [ MaxMac ].del_task ( doer [ MaxMac ].tmp_reg.time ) ;
		doer [ 0 ].del_task ( doer [ 0 ].tmp_reg.time ) ;
		doer [ MaxMac ].add_task ( doer [ 0 ].tmp_reg ) ;
		doer [ 0 ].add_task ( doer [ MaxMac ].tmp_reg ) ;
		return ;
	}
	/*
	for ( i = 0 ; i < mac_num ; i ++ )
	{
		if ( i == MaxMac || i == 0 ) 
			continue ;
		if ( doer [ i ].get_midofd ( TwoMacTimeDif ( i , 0 ) ) > 0 )
		{
			doer [ i ].del_task ( 0 ) ;
			doer [ 0 ].add_task ( doer [ i ].tmp_reg ) ;
			return ;
		}
		else if (  doer [ 0 ].get_midofd ( TwoMacTimeDif ( 0 , i )) > 0 )
		{
			doer [ 0 ].del_task ( i ) ;
			doer [ i ].add_task ( doer [ 0 ].tmp_reg ) ;
			return ;
		}
		else if ( doer [ i ].get_midofd_twomac ( doer [ 0 ] , doer [ i ].all_time - doer [ 0 ].all_time  ) != -1 ) 
		{
			doer [ i ].del_task ( doer [ i ].tmp_reg.time ) ;
			doer [ 0 ].del_task ( doer [ 0 ].tmp_reg.time ) ;
			doer [ i ].add_task ( doer [ 0 ].tmp_reg ) ;
			doer [ 0 ].add_task ( doer [ i ].tmp_reg ) ;
			return ;
		}
		else if ( doer [ 0 ].get_midofd_twomac ( doer [ i ] , doer [ 0 ].all_time - doer [ i ].all_time  ) != -1 ) 
		{
			doer [ 0 ].del_task ( doer [ 0 ].tmp_reg.time ) ;
			doer [ i ].del_task ( doer [ i ].tmp_reg.time ) ;
			doer [ 0 ].add_task ( doer [ i ].tmp_reg ) ;
			doer [ i ].add_task ( doer [ 0 ].tmp_reg ) ;
			return ;
		}
	}
	*/
	is_optimize = true ;
}
//输出车间运作情况(这只在控制台模式有效)
void wplace ::show_plan ( )
{
	int i ;
	cout << "|----------------------------------|"<< endl ;
	cout << "/*********总体情况：**********/" << endl ;
	for ( i = 0 ; i < mac_num ; i ++ )
	{
		cout << "机器" << i << "总作业时间为:" << doer [ i ].all_time << endl ;
	}
	cout << "|-----------------------------|"<< endl ;
	cout << "/*****各机器具体运作情况:*****/" << endl ;
	for ( i = 0 ; i < mac_num ; i ++ )
	{
		cout << "机器" << i << "任务状况:" ;
		doer [ i ].show ( ) ;
	}
	cout << "|----------------------------------|"<< endl ;

}
//返回计划执行任务数最多的机器计划执行的任务数目
int wplace ::MostTaskMac ( )
{
	int max = 0 ;
	for ( int i = 0 ; i < mac_num ; i ++ )
	{
		if ( doer [ i ].task_num > doer [ max ].task_num )
			max = i ;
	}
	return doer [ max ].task_num  ;
}