mmiutilapi.c

是一个手机功能的模拟程序

				{
					pPrePMH->next = pPMH->next;
				}

				pPMH->next 	= NULL;
				pPMH->inuse	= MMI_MEMFREE_FLAG;

				pPMH->next 	= mmiPCBTbl[i].pFree;
				mmiPCBTbl[i].pFree	= pPMH;	
				mmiPCBTbl[i].aviableNum++;	
			}			 
		#endif //MMIMEM_UNBLKFREE		
		  
			if(mmiPCBTbl[i].aviableNum > 0)
			{
				*buf = (void*)((unsigned char*)mmiPCBTbl[i].pFree + PM_HEADER_LEN);
				pPMH = mmiPCBTbl[i].pFree;

			#if (MMIMEM_INFORMATION == 1)
				mmi_memInfo.cur_allocpart[i]++;
				if(mmi_memInfo.max_allocpart[i] < mmi_memInfo.cur_allocpart[i])
					mmi_memInfo.max_allocpart[i] = mmi_memInfo.cur_allocpart[i];
			#endif
			
			#if (MMIMEM_UNBLKFREE == 1)
				pPMH->inuse	= MMI_MEMINUSE_FLAG;
			#endif
			#if (MMIMEM_MONITOR == 1)
				pPMH->line	= line;
				memset(pPMH->caller, 0, MMIMEM_CALLER_LEN);
				ret = strlen(name);
				if(ret > (MMIMEM_CALLER_LEN - 1))				
					name = name + (ret - MMIMEM_CALLER_LEN +1);
				strcpy(pPMH->caller, name);
			#endif
				
				mmiPCBTbl[i].pFree 		= pPMH->next;
				pPMH->next				= mmiPCBTbl[i].pAllocated;
				mmiPCBTbl[i].pAllocated = pPMH;				
				mmiPCBTbl[i].aviableNum --;	
				error = EC_MMIMEM_OK;
				MMIMEMTRACE_MSG(("MI_mmimem_Alloc():find one in pool%d,add=%d", i, (UINT32)*buf));
				break;
			}			
			else
			/* the most fitable partition pool no free space, try the bigger partition */
			{
				MMIMEMTRACE_MSG(("MI_mmimem_Alloc():pool%d full, try pool%d", i, i+1));
				continue;
			}
		}
	}

	
	if(error != EC_MMIMEM_OK)	/* can't allocate from partition pools */
	{
		MMIMEMTRACE_MSG(("MI_mmimem_Alloc():all pool no parts, try dynmem,sz=%d", size));
		size = (size + sizeof(int) - 1) & (~(sizeof(int) - 1));		
		size += DM_HEADER_LEN;

	#if (MMIMEM_UNBLKFREE == 1)
		pDMH 	= mmiDynMemCB.pAllocated;
		pPreDMH = NULL;

		while(pDMH)
		{
			while(pDMH)
			{
				if(pDMH->inuse == MMI_MEMINUSE_FLAG)
				{
					pPreDMH	= pDMH;
					pDMH 	= pDMH->next;
				}
				else
				{
					break;
				}
			}

			if(pDMH != NULL)  //find a free block
			{
				if(pPreDMH == NULL)
				{
					mmiDynMemCB.pAllocated = pDMH->next;						
				}
				else
				{
					pPreDMH->next = pDMH->next;
				}			

			#ifndef _INNOVATION_EMULATOR_
				ret = NU_Deallocate_Memory((void*)pDMH);
				if(ret != NU_SUCCESS)
				{
					MMIMEMTRACE_MSG(("MI_mmimem_Free():dealloc to dynmem err,ret=%d",ret));
				}
			#else
				free((void*)pDMH);
			#endif

				//test next memory block
				if(pPreDMH == NULL)
				{
					pDMH = mmiDynMemCB.pAllocated;	
				}
				else
				{
					pDMH = pPreDMH->next;	
				}
			}			
		}
	#endif
			
	#ifndef _INNOVATION_EMULATOR_	
		ret = NU_Allocate_Memory(&mmimemPool, buf, size, 20);
		if(ret != NU_SUCCESS)
		{
			error = EC_MMIMEM_ERROR;
			MMIMEMTRACE_MSG(("MI_mmimem_Alloc():alloc dynmem failed,ret=%d", ret));
		}
		else
			error = EC_MMIMEM_OK;
	#else
		*buf = (void*)malloc(size);
		if(*buf == NULL)
			error = EC_MMIMEM_ERROR;
		else
			error = EC_MMIMEM_OK;
	#endif

		if(error == EC_MMIMEM_OK)
		{
			pDMH = (T_MMIMEM_DMHDR*)*buf;
			*buf = (unsigned char*)pDMH + DM_HEADER_LEN;
			pDMH->pDCB	= &mmiDynMemCB;
			pDMH->next	= mmiDynMemCB.pAllocated;			
			mmiDynMemCB.pAllocated = pDMH;
		#if (MMIMEM_UNBLKFREE == 1)
			pDMH->inuse = MMI_MEMINUSE_FLAG;
		#endif	

			pDMH->size	= size;

		#if (MMIMEM_INFORMATION == 1)
			totalAlloc += (pDMH->size / MMI_DYNMEM_BLKSZ + 1) * MMI_DYNMEM_BLKSZ;
		#endif
		
		#if (MMIMEM_MONITOR == 1)			
			pDMH->line	= line;
			ret = strlen(name);
			if(ret > (MMIMEM_CALLER_LEN - 1))				
				name = name + (ret - MMIMEM_CALLER_LEN +1);
			strcpy(pDMH->caller, name);
		#endif	
		}

	#if (MMIMEM_INFORMATION == 1)
		mmi_memInfo.cur_dyn_used = (totalAlloc * 100) / MMI_DYNMEM_POOL_SIZE;
		if(mmi_memInfo.cur_dyn_used > mmi_memInfo.max_dyn_used)
			mmi_memInfo.max_dyn_used = mmi_memInfo.cur_dyn_used;
	#endif
	}

#ifndef _INNOVATION_EMULATOR_
	ret = NU_Release_Semaphore(&mmimemSem);
	if(ret != NU_SUCCESS)
	{
		MMIMEMTRACE_MSG(("MI_mmimem_Alloc():relese sema err,ret=%d", ret));
	}	
#endif

	if(error != EC_MMIMEM_OK)
	{
		MI_mmimem_Dump();
	}
#if (MMIMEM_INFORMATION == 1)
	else
	{
		if(size > mmi_memInfo.max_allocsz)
			mmi_memInfo.max_allocsz = size;
	}
#endif	
	
	MMIMEMTRACE_MSG(("MI_mmimem_Alloc():allocated buf=%d", *buf));
	return error;
}

/***
 * Free a previously allocated memory block, if success return 0, 
 * otherwise return a negative number indicating the reason.
 */
#if (MMIMEM_MONITOR == 1)
#if (MMIMEM_UNBLKFREE == 1)
EXTERN_LCL int MI_mmimem_Free(void *buf, char* name, int line)
#else //MMIMEM_UNBLKFREE
EXTERN_LCL int MI_mmimem_Free(void *buf, unsigned int suspend, char* name, int line)
#endif 
#else  //MMIMEM_MONITOR
#if (MMIMEM_UNBLKFREE == 1)
EXTERN_LCL int MI_mmimem_Free(void *buf)
#else //MMIMEM_UNBLKFREE
EXTERN_LCL int MI_mmimem_Free(void *buf,  unsigned int suspend)
#endif
#endif 
{
	STATUS ret, error = EC_MMIMEM_ERROR;
	T_MMIMEM_PMHDR *pPMH, *pPrePMH;
	T_MMIMEM_PCB   *pPCB;
	T_MMIMEM_DMHDR *pDMH, *pPreDMH;
	T_MMIMEM_DCB   *pDCB;
#if (MMIMEM_MONITOR == 1)
	char *file;
#endif
	
#if (MMIMEM_MONITOR == 1)
  #ifndef _INNOVATION_EMULATOR_
	file = strrchr(name, '/');
  #else
  	file = strrchr(name, '\\');
  #endif

	if(file)
		file++;	
	MMIMEMTRACE_MSG(("MI_mmimem_Free():%d, %s, %d", (UINT32)buf, file, line));
#else
	MMIMEMTRACE_MSG(("MI_mmimem_Free():%d", (UINT32)buf));
#endif

	if(buf == NULL || (UINT32)buf%4 > 0)
	{
		MMIMEMTRACE_MSG(("MI_mmimem_Free():para err!"));
		return EC_MMIMEM_PTRERROR;
	}

#ifndef _INNOVATION_EMULATOR_
  #if (MMIMEM_UNBLKFREE == 0)
	ret = NU_Obtain_Semaphore(&mmimemSem, suspend);
	if(ret != NU_SUCCESS)
	{
		MMIMEMTRACE_MSG(("MI_mmimem_Free():obtain sema err,ret=%d", ret));
		return EC_MMIMEM_ERROR;
	}
  #endif	
#endif

	if((unsigned char*)buf > (unsigned char*)&mmiPartMem[0] && 
	   (unsigned char*)buf <  (unsigned char*)(&mmiPartMem[0] + MMI_PARTMEM_POOL_SIZE))
	{
		pPMH = (T_MMIMEM_PMHDR*)((unsigned char*)buf - PM_HEADER_LEN);
		pPCB = pPMH->pPCB;
		if(pPCB != NULL && pPCB->magicWord == MMI_PARTMEM_MAGICWORD 
		   && pPCB->totalNum != pPCB->aviableNum)
		{		
			if((void*)pPMH >= pPCB->pStartAddr && (unsigned char*)pPMH < ((unsigned char*)pPCB->pStartAddr + pPCB->poolSize))
			{
				error = EC_MMIMEM_OK;
				
			  #if (MMIMEM_UNBLKFREE == 0)
				if(pPCB->pAllocated == pPMH)
				{
					pPCB->pAllocated = pPMH->next;				
				}
				else
				{
					pPrePMH = pPCB->pAllocated;
					while(pPrePMH)
					{
						if(pPrePMH->next != pPMH)
							pPrePMH = pPrePMH->next;
						else
							break;
					}

					if(pPrePMH != NULL)
					{
						pPrePMH->next = pPMH->next;						
					}
					else
						error = EC_MMIMEM_ERROR;
				}

				if(error == EC_MMIMEM_OK)
				{
					pPMH->next 	= pPCB->pFree;
					pPCB->pFree	= pPMH;	
					pPCB->aviableNum++;
				}
			  #else	//MMIMEM_UNBLKFREE
				pPMH->inuse = MMI_MEMFREE_FLAG;
				
				#if (MMIMEM_INFORMATION == 1)
				mmi_memInfo.cur_allocpart[pPCB->idx]--;
				#endif
				
			  #endif //MMIMEM_UNBLKFREE
			}
		}
	}
#ifndef _INNOVATION_EMULATOR_
	else if((unsigned char*)buf >= (unsigned char*)&mmiDynMem[0] && 
	   		(unsigned char*)buf <  (unsigned char*)&mmiDynMem[0] + MMI_DYNMEM_POOL_SIZE)
#else
	else /* try dynamic memory space */
#endif	
	{
		pDMH = (T_MMIMEM_DMHDR*)((unsigned char*)buf - DM_HEADER_LEN);
		pDCB = pDMH->pDCB;
		if(pDCB != NULL && pDCB->magicWord == MMI_DYNMEM_MAGICWORD
		   && pDCB->pAllocated != NULL)
		{
			error = EC_MMIMEM_OK;
		  #if (MMIMEM_UNBLKFREE == 0)
			if(pDCB->pAllocated == pDMH)
			{
				pDCB->pAllocated = pDMH->next;				
			}
			else
			{
				pPreDMH = pDCB->pAllocated;
				while(pPreDMH)
				{
					if(pPreDMH->next != pDMH)
						pPreDMH = pPreDMH->next;
					else
						break;
				}

				if(pPreDMH != NULL)
				{
					pPreDMH->next = pDMH->next;						
				}
				else
					error = EC_MMIMEM_ERROR;					
			}

			if(error == EC_MMIMEM_OK)
			{
			#ifndef _INNOVATION_EMULATOR_
				ret = NU_Deallocate_Memory((void*)pDMH);
				if(ret != NU_SUCCESS)
				{
					MMIMEMTRACE_MSG(("MI_mmimem_Free():dealloc to dynmem err,ret=%d",ret));
				}
			#else
				free((void*)pDMH);
			#endif
			}
		  #else
			pDMH->inuse = MMI_MEMFREE_FLAG;
			#if (MMIMEM_INFORMATION == 1)
				totalAlloc -= (pDMH->size / MMI_DYNMEM_BLKSZ + 1) * MMI_DYNMEM_BLKSZ;				

				mmi_memInfo.cur_dyn_used = (totalAlloc * 100) / MMI_DYNMEM_POOL_SIZE;
				if(mmi_memInfo.cur_dyn_used > mmi_memInfo.max_dyn_used)
					mmi_memInfo.max_dyn_used = mmi_memInfo.cur_dyn_used;
			#endif

		  #endif //MMIMEM_UNBLKFREE
		}   
	}
#ifndef _INNOVATION_EMULATOR_
	else
	{
		error = EC_MMIMEM_NOTALLOC;
	}
#endif

#ifndef _INNOVATION_EMULATOR_
  #if (MMIMEM_UNBLKFREE == 0)
	ret = NU_Release_Semaphore(&mmimemSem);
	if(ret != NU_SUCCESS)
	{
		MMIMEMTRACE_MSG(("MI_mmimem_Alloc():relese sema err,ret=%d", ret));
	}
  #endif
#endif

	return  error;	
}	

#if (MMIMEM_INFORMATION == 1)
/* Get mmi memory usage information */
EXTERN_LCL void MI_mmimem_Info(T_MMIMEM_INFO *pInfo)
{
	memcpy((void*)pInfo, (void*)&mmi_memInfo, sizeof(T_MMIMEM_INFO));
}


void MI_Dump_mmimem_Info()
{
	int i = 0;
	MMIMEMTRACE_MSG(("****begin dump mmimem info"));
	MMIMEMTRACE_MSG(("min_reqsz:  		%d",mmi_memInfo.min_reqsz));
	MMIMEMTRACE_MSG(("max_reqsz: 		%d",mmi_memInfo.max_reqsz));
	MMIMEMTRACE_MSG(("max_allocsz: 	%d",mmi_memInfo.max_allocsz));
	for(i = 0; i< MMI_PARTMEM_POOL_NUM;i++)
		MMIMEMTRACE_MSG(("max_allocpart:%d, cur_allocpart:%d",mmi_memInfo.max_allocpart[i],mmi_memInfo.cur_allocpart[i]));	
	MMIMEMTRACE_MSG(("max_dyn_used: 	%d",mmi_memInfo.max_dyn_used));
	MMIMEMTRACE_MSG(("cur_dyn_used: 	%d",mmi_memInfo.cur_dyn_used));
	
	MMIMEMTRACE_MSG(("*****end dump mmimem info"));
}

#endif

void MI_mmimem_Dump(void)
{
	
}


#endif