lprocess.c

CBS（小区广播）程序实现手稿

//#include "lprocess.h"
#include "Include.h "

//---------------------------------------------------------
//	逻辑进程初始化

void init_pid()
{
    int i;

	process_head.suspend_max_count = MAX_SUSPEND_TIME/SCANNER_INTERVAL;
	process_head.busy_head = process_head.suspend_head =  -1;	
	process_head.free_head = 0 ;
	process_head.free_node = LPROCESS;
	
	memset(process_control,0,LPROCESS*sizeof(struct lprocess_control_t));
		
	for ( i = 0 ; i < LPROCESS; i ++)
	{
		process_control[i].flag =  PID_FREE; 
		process_control[i].prev = i - 1;
		process_control[i].next = i + 1;
	}
	process_control[LPROCESS-1].next = -1;	//next为-1表示结尾，prev为-1表示无前趋

	lprocess_mutex = CreateMutex(NULL,FALSE,NULL);

	//启动悬挂进程扫描例程
	set_suspend_scanner();
   
}


void set_suspend_scanner()
{
	HANDLE hThread;
	DWORD thread_id;
	//创建定时器扫描线程，定期（目前为10ms）唤醒，扫描定时器队列，查找到期的定时器
	hThread = CreateThread((LPSECURITY_ATTRIBUTES)NULL,0,(LPTHREAD_START_ROUTINE)scan_suspend,NULL,0,&thread_id);
}


//----------------------------------------------------------
//	创建一个进程
//	入口：创建者标识（功能块号、模块号）
//	返回值：进程的句柄
//----------------------------------------------------------
int alloc_a_pid(LPID_t pid)
{
	short process_id;
	if (process_head.free_node == 0 ) return -1;
	process_id = process_head.free_head;
	

	//从空闲队列中删除
	
	process_head.free_head = process_control[process_id].next;
	process_control[process_control[process_id].next].prev = -1;
	
	//置忙标识
	process_control[process_id].flag = PID_BUSY;
	//置创建者标识
	memcpy(&process_control[process_id].pid, &pid,sizeof(LPID_t));
	process_control[process_id].pid.process_id = process_id;
	//插入忙队列的头部
	process_control[process_id].next = process_head.busy_head;
	process_control[process_id].prev = -1;
	process_control[process_head.busy_head].prev = process_id;
	process_head.busy_head = process_id;
	
	process_head.free_node -- ;
	
	return process_id;		
}


//----------------------------------------------------------
//	释放一个进程
//	id    定时器内部编号
//	返回 >=0 表示成功，即返回实际释放的定时器句柄
//	返回 -1 表示失败
//----------------------------------------------------------
int free_a_pid(LPID_t  pid)
{
    int prev,next;
	int process_id;
	
	if ((process_id = pid.process_id) < 0 || process_id >= LPROCESS)
		return -1;
	if (process_control[process_id].flag != PID_BUSY )
		return -1;
/*	if (process_control[process_id].pid.function_id != pid.function_id
		|| process_control[process_id].pid.module_id != pid.module_id )
		return -1;
*/	

	prev = process_control[process_id].prev;
	next = process_control[process_id].next;
	//set flag as suspended
	process_control[process_id].flag = PID_SUSPEND;
	//free  from busy link
	if (prev == -1)   //first busy node
		process_head.busy_head = next;
	else
		process_control[prev].next = next;
	
	process_control[next].prev = prev;
	
	//insert into front of suspend link
	process_control[process_id].suspend_count 
		= process_head.suspend_max_count ;   //set suspend time count
	process_control[process_id].prev = -1;
	process_control[process_id].next = process_head.suspend_head;
	process_control[process_head.suspend_head].prev = process_id;
	process_head.suspend_head = process_id;
	
    return process_id;
}


//-----------------------------------------------------------------
//	悬挂队列扫描程序
//-----------------------------------------------------------------
void scan_suspend(void *dummy)
{
    int prev,cur,next;
 	
	while(1)
	{
		Sleep(10);
		WaitForSingleObject(lprocess_mutex,INFINITE); //无条件互斥
		cur = process_head.suspend_head ;
		while ( cur != -1 )
		{
			prev = process_control[cur].prev;
			next = process_control[cur].next;
			if (--process_control[cur].suspend_count <= 0 ) //suspend expires
			{
				//free from suspend link
				if (prev == -1)  //first node
					process_head.suspend_head = next;
				else
					process_control[prev].next = next;
				
				process_control[next].prev = prev;
				
				//insert into front of free link
				process_control[process_head.free_head].prev = cur;
				process_control[cur].next = process_head.free_head;
				process_control[cur].prev = -1;
				process_head.free_head = cur;
				memset(&process_control[cur].pid,0,sizeof(LPID_t));
				process_control[cur].flag = PID_FREE;
				process_head.free_node ++ ;
			}
			cur = next;
		}
		ReleaseMutex(lprocess_mutex);   //释放临界资源
	}	
}


int alloc_pid(char * c_pid)
{
	int process_id;
	LPID_t s_pid;
#ifdef  OPEN_WARNING
	unsigned char  cWarningDescription[WARNING_DESC_LEN];
#endif

	s_pid = *(LPID_t *) c_pid;

	WaitForSingleObject(lprocess_mutex,INFINITE); //申请临界资源
	process_id = alloc_a_pid(s_pid);
    /*Add for statistic--------*/
	if (process_id>=0)
	{
		s_RuntimeInfo.iProcessCount++;
	}
	/*-------------------------*/
	ReleaseMutex(lprocess_mutex); //释放临界资源
#ifdef DEBUG_PRINT_PID
            printf("Create a Pid=%d.\n\n",process_id); 
#endif


#ifdef  OPEN_WARNING
    if (process_id<0)
	{
    	/* 发送告警给OMP */
		memset(cWarningDescription,0,WARNING_DESC_LEN);
		sprintf(cWarningDescription,"进程不能分配");
		SendWarningToOmp(SOURCE_SHORTAGE,PID_USEUP,cWarningDescription);		
	}
#endif

	return process_id;
}

int free_pid(char * c_pid)
{
	int free_process_id;
	LPID_t s_pid;
	s_pid = *(LPID_t *) c_pid;

	WaitForSingleObject(lprocess_mutex,INFINITE);  //申请临界资源
	free_process_id = free_a_pid(s_pid);
    /*Add for statistic--------*/
	if (free_process_id>=0)
	{
		s_RuntimeInfo.iProcessCount--;
	}
	/*-------------------------*/
	ReleaseMutex(lprocess_mutex);  //释放临界资源
#ifdef DEBUG_PRINT_PID
            printf("Kill a Pid=%d.\n\n",s_pid.process_id); 
#endif
	return free_process_id;

}

int is_a_busy_pid(LPID_t pid)
{
	int process_id;
	if ((process_id = pid.process_id) < 0 || process_id >= LPROCESS)
		return -1;
	if (process_control[process_id].flag != PID_BUSY)
		return -1;
	if (memcmp(&pid.process_id,&process_control[process_id].pid.process_id,2)==0)
		return 0 ; //is busy
	else 
		return -1; //is not busy(free or suspend)
}

int is_busy_pid(char * c_pid)
{
	int result;
	LPID_t s_pid;
	s_pid = *(LPID_t *) c_pid;
	WaitForSingleObject(lprocess_mutex,INFINITE);  //无条件互斥
	result = is_a_busy_pid(s_pid);
	ReleaseMutex(lprocess_mutex);  //释放临界资源
	return result;
}