c_shm.cpp

HP共享内存实现,只要将sql语句配置好,装载共享内存即可

/***********************************************************************
 * Module:  c_shm.cpp
 * Author:  Administrator
 * Modified: 2005年9月15日 9:18:09
 * Purpose: Implementation of the class c_shm
 * Comment: 共享内存基本类. 一个共享内存由多个内存块组成。获得共享内存时， 就可以获得多个共享内存块对象。 通过， 这么多个块对象对块中的数据进行操作。
 ***********************************************************************/

#include "c_shm_mem.h"
#include "c_shm.h"

////////////////////////////////////////////////////////////////////////
// Name:	c_shm::c_shm()
// Purpose:	构造函数
// Return:     
// Comment:	初始化c_info_info对象
////////////////////////////////////////////////////////////////////////
c_shm::c_shm()
{
	para.loadPara();
	p_share_info = new c_share_info();
	share_area_id = 0;
	//取得共享内存内需要加载的所有内存块信息，放入到vector中。
	loadShmInfo();
	v_share_area_name.clear();
}

////////////////////////////////////////////////////////////////////////
// Name:	c_shm::c_shm(int t_share_area_id)
// Purpose:	构造函数
// Parameters:
//	- t_share_area_id: 共享内存区ID
// Return:     
// Comment:	初始化c_info_info对象
////////////////////////////////////////////////////////////////////////
c_shm::c_shm( int t_share_area_id )
{
	para.loadPara();
	p_share_info = new c_share_info();
	share_area_id = t_share_area_id;
	//取得共享内存内需要加载的所有内存块信息，放入到vector中。
	loadShmInfo();
	v_share_area_name.clear();
}

////////////////////////////////////////////////////////////////////////
// Name:	c_shm::c_shm(const char* t_share_area_name)
// Purpose:	构造函数
// Parameters:
//	- t_share_area_name: 共享内存区名字
// Return:     
// Comment:	初始化c_info_info对象
////////////////////////////////////////////////////////////////////////
c_shm::c_shm( const char* t_share_area_name )
{
	para.loadPara();
	p_share_info = new c_share_info();
	if ( strcmp(t_share_area_name,"")== 0 )
		share_area_id = 0;
	else
	{
		share_area_id = p_share_info->getShareID(t_share_area_name);
		if( share_area_id == -1 )
			exit(1);
	}
	//取得共享内存内需要加载的所有内存块信息，放入到vector中。
	loadShmInfo();
	
}

////////////////////////////////////////////////////////////////////////
// Name:	c_shm::~c_shm()
// Purpose:	析构函数
// Return:     
// Comment:	删除c_shm_mem对象与c_share_info对象
////////////////////////////////////////////////////////////////////////
c_shm::~c_shm()
{
	for( int i = 0; i < v_shm_mem.size() ; i ++ )
	{
		if( v_shm_mem[i]->p_share_mem_info->application_kind == '0' )
		{
			delete v_shm_mem[i];
		}
		else if( v_shm_mem[i]->p_share_mem_info->application_kind == '1' )
		{
			c_shm_merge* p_temp = (c_shm_merge*)(v_shm_mem[i]);
			delete p_temp;
		}
		else
		{
			delete v_shm_mem[i];
		}
	}
	delete p_share_info;
}

////////////////////////////////////////////////////////////////////////
// Name:	c_shm::createshm()
// Purpose:	创建共享内存
// Return:  int 成功：0 失败：其它
// Comment:	计算共享内存区的大小，并创建。把各共享内存块的信息写入内存区中，并划好大小。
////////////////////////////////////////////////////////////////////////
int c_shm::createshm(void)
{	
	// TODO : implement
	int oflag = SHM_R|SHM_W|IPC_CREAT;


	//取得共享内存的大小
	size_t shmSize = getMemSize();
	
	//创建共享内存
	key_t shm_key;
	shm_key = ftok( para.getChar( "shm", "path_name"), share_area_id );

	shmId = shmget( shm_key, shmSize, oflag);
	theLog<<"共享内存Key:"<<shm_key<<",总大小"<shmSize<endi;
	
	c_shm_merge* p_shm_merge;

	if( shmId == -1)
	{
		cout<<"创建共享内存错误"<<endl;
		/*cout<<"创建共享内存错误"<<errno<<endl;
		if( errno == EINVAL )
			cout<<"EINVAL"<<endl;
		else if( errno == EACCES )
			cout<<"EACCES"<<endl;
		else if( errno == ENOENT )
			cout<<"ENOENT"<<endl;
		else if( errno == ENOMEM )
			cout<<"ENOMEM"<<endl;
		else if( errno == ENOSPC )
			cout<<"ENOSPC"<<endl;
		else if( errno == EEXIST )
			cout<<"标识已存在"<<endl;
		*/
		exit(1);	//ENOENT         
	}

	//往共享内存内放共享内存块的信息，并用head指针vector确定位置
	shm_area_head = (char*)shmat( shmId, NULL, 0 );
	int i, j;
	int point = 0;
	c_mutex p_mutex;
	int block_count;
	
	c_shm_mem_load_data* p_shm_mem_load;
	c_shm_merge* p_shm_mem_merge;
	c_shm_mem* p_shm_mem;
	
	//确定每个结构体的大小，不足16位的加够16位
	int size_share_mem_info = sizeof(SHARE_MEM_INFO);
	int add_size_share_mem_info;
	if( size_share_mem_info % 16 == 0 )
	{
		add_size_share_mem_info = size_share_mem_info;
	}
	else
	{
		add_size_share_mem_info = ( size_share_mem_info / 16 + 1 ) * 16 ;
	}
	int size_stshareinfo = sizeof( STSHAREINFO );
	int add_size_stshareinfo;
	if( size_stshareinfo % 16 == 0 )
	{
		add_size_stshareinfo = size_stshareinfo;
	}
	else
	{
		add_size_stshareinfo = ( size_stshareinfo / 16 + 1 ) * 16 ;
	}
	for( i = 0; i < v_share_mem_info.size(); i++)
	{
		switch(v_share_mem_info[i].application_kind)
		{
		case '0':
			p_shm_mem_load = new c_shm_mem_load_data();
			p_shm_mem_load->p_share_mem_info = (SHARE_MEM_INFO*)&(shm_area_head[ point ]);
			memcpy( p_shm_mem_load->p_share_mem_info, &(v_share_mem_info[i]), size_share_mem_info );

			v_shm_head.push_back ( p_shm_mem_load->p_share_mem_info );
			point += add_size_share_mem_info;
	
			//设置头信息
			p_shm_mem_load->p_stShareInfo = (STSHAREINFO*)&((( char * )shm_area_head)[ point ]);		
			point += add_size_stshareinfo;

			p_shm_mem_load->p_field_info = (MEM_FIELD*)&(shm_area_head[ point ]);
			point += 4000;

			p_shm_mem_load->p_stShareInfo->mem_area_no = v_share_mem_info[i].mem_area_no;
			p_shm_mem_load->p_stShareInfo->real_record_count = 0;
			p_shm_mem_load->p_stShareInfo->append_record_count = 0;

			p_shm_mem_load->head_point = (char*)&(shm_area_head[ point ]); 

			//设置可用标志
			p_shm_mem_load->p_stShareInfo->valid_flag = 1;

			//加锁			
			p_mutex._mutex = &(p_shm_mem_load->p_stShareInfo->append_lock);
			p_mutex.init();
			//;
			block_count = p_shm_mem_load->p_share_mem_info->mem_size / p_shm_mem_load->p_share_mem_info->block_size + 1 ;
			if( block_count > UPDATE_LOCK_COUNT )
				block_count = UPDATE_LOCK_COUNT;

			for( j = 0 ; j < block_count ; j ++ )
			{
				p_mutex._mutex = &(p_shm_mem_load->p_stShareInfo->update_lock[j]);
				p_mutex.init();
			}
			p_shm_mem_load->p_stShareInfo->block_count = block_count;
			p_shm_mem_load->p_share_mem_info->block_size = p_shm_mem_load->p_share_mem_info->mem_size/block_count+1;
			p_mutex._mutex = &(p_shm_mem_load->p_stShareInfo->record_count_lock);
			p_mutex.init();
			p_mutex._mutex = &(p_shm_mem_load->p_stShareInfo->append_key_lock);
			p_mutex.init();

			//////2005-11-23
			p_shm_mem_load->p_stShareInfo->addition_pos = 0;
			p_shm_mem_load->addition_point = &(p_shm_mem_load->head_point[p_shm_mem_load->p_share_mem_info->mem_size-p_shm_mem_load->p_share_mem_info->addition_size]);
			p_mutex._mutex = &(p_shm_mem_load->p_stShareInfo->addition_lock);
			p_mutex.init();

			delete p_shm_mem_load;
			break;
		case '1':
			p_shm_mem_merge = new c_shm_merge();
			p_shm_mem_merge->p_share_mem_info = (SHARE_MEM_INFO*)&(shm_area_head[ point ]);
			memcpy( p_shm_mem_merge->p_share_mem_info, &(v_share_mem_info[i]), sizeof(SHARE_MEM_INFO) );

			v_shm_head.push_back ( p_shm_mem_merge->p_share_mem_info );
			point += add_size_share_mem_info;
			
			//设置头信息
			p_shm_mem_merge->p_stShareInfo = (STSHAREINFO*)&((( char * )shm_area_head)[ point ]);		
			point += add_size_stshareinfo;

			p_shm_mem_merge->p_field_info = (MEM_FIELD*)&(shm_area_head[ point ]);
			point += 4000;

			p_shm_mem_merge->p_stShareInfo->mem_area_no = v_share_mem_info[i].mem_area_no;
			p_shm_mem_merge->p_stShareInfo->real_record_count = 0;
			p_shm_mem_merge->p_stShareInfo->append_record_count = 0;

			p_shm_mem_merge->head_point = (char*)&(shm_area_head[ point ]); 

			//设置可用标志
			p_shm_mem_merge->p_stShareInfo->valid_flag = 1;

			//加锁
			p_mutex._mutex = &(p_shm_mem_merge->p_stShareInfo->append_lock);
			p_mutex.init();
			//;
			block_count = p_shm_mem_merge->p_share_mem_info->mem_size / p_shm_mem_merge->p_share_mem_info->block_size + 1 ;
			if( block_count > UPDATE_LOCK_COUNT )
				block_count = UPDATE_LOCK_COUNT;

			for( j = 0 ; j < MAX_ITEM_COUNT ; j ++ )
			{
				p_mutex._mutex = &(p_shm_mem_merge->p_stShareInfo->update_lock[j]);
				p_mutex.init();
			}
			p_shm_mem_merge->p_stShareInfo->block_count = block_count;
			p_shm_mem_merge->p_share_mem_info->block_size = p_shm_mem_merge->p_share_mem_info->mem_size/block_count+1;
			p_mutex._mutex = &(p_shm_mem_merge->p_stShareInfo->record_count_lock);
			p_mutex.init();
			p_mutex._mutex = &(p_shm_mem_merge->p_stShareInfo->append_key_lock);
			p_mutex.init();

			p_shm_mem_merge->createItemShm();
			//调整块大小
			p_shm_mem_merge->p_share_mem_info->block_size = (p_shm_mem_merge->p_share_mem_info->mem_size - SHM_ITEM_SIZE*MAX_ITEM_COUNT)/block_count+1;

			strcpy(p_shm_mem_merge->backup_dir , para.getChar( "shm", "ShmBackupDir"));
			p_shm_mem_merge->max_backup_num = para.getInt( "shm", "MaxBackupNum" );
			delete p_shm_mem_merge;
			break;
		default:
			p_shm_mem = new c_shm_mem();
			p_shm_mem->p_share_mem_info = (SHARE_MEM_INFO*)&(shm_area_head[ point ]);
			memcpy( p_shm_mem->p_share_mem_info, &(v_share_mem_info[i]), sizeof(SHARE_MEM_INFO) );

			v_shm_head.push_back ( p_shm_mem->p_share_mem_info );
			point += add_size_share_mem_info;
			
			//设置头信息
			p_shm_mem->p_stShareInfo = (STSHAREINFO*)&((( char * )shm_area_head)[ point ]);		
			point += add_size_stshareinfo;

			p_shm_mem->p_field_info = (MEM_FIELD*)&(shm_area_head[ point ]);
			point += 4000;

			p_shm_mem->p_stShareInfo->mem_area_no = v_share_mem_info[i].mem_area_no;
			p_shm_mem->p_stShareInfo->real_record_count = 0;
			p_shm_mem->p_stShareInfo->append_record_count = 0;

			p_shm_mem->head_point = (char*)&(shm_area_head[ point ]); 

			//设置可用标志
			p_shm_mem->p_stShareInfo->valid_flag = 1;

			//加锁
			p_mutex._mutex = &(p_shm_mem->p_stShareInfo->append_lock);
			p_mutex.init();
			//;
			block_count = p_shm_mem->p_share_mem_info->mem_size / p_shm_mem->p_share_mem_info->block_size + 1 ;
			if( block_count > UPDATE_LOCK_COUNT )
				block_count = UPDATE_LOCK_COUNT;

			for( j = 0 ; j < block_count ; j ++ )
			{
				p_mutex._mutex = &(p_shm_mem->p_stShareInfo->update_lock[j]);
				p_mutex.init();
			}
			p_shm_mem->p_stShareInfo->block_count = block_count;
			p_shm_mem->p_share_mem_info->block_size = p_shm_mem->p_share_mem_info->mem_size/block_count+1;
			p_mutex._mutex = &(p_shm_mem->p_stShareInfo->record_count_lock);
			p_mutex.init();
			p_mutex._mutex = &(p_shm_mem->p_stShareInfo->append_key_lock);
			p_mutex.init();

			break;
		}
		if( v_share_mem_info[i].mem_size % 16 == 0 )
		{
			point += v_share_mem_info[i].mem_size;
		}
		else
		{
			point += (v_share_mem_info[i].mem_size / 16 + 1 ) * 16;
		}
	}

	shmctl( shmId, IPC_STAT, &shmBuf);	

	return 0;
}

////////////////////////////////////////////////////////////////////////
// Name:	c_shm::getshm()
// Purpose:	取得共享内存区，并加载各共享内存块的信息到c_shm_mem的vector中。
// Return:  int
////////////////////////////////////////////////////////////////////////
int c_shm::getshm(void)
{
   // TODO : implement
	int oflag = SHM_R|SHM_W;

	//取得共享内存的大小
	size_t shmSize = getMemSize();
	
	//获取共享内存
	key_t shm_key;
	shm_key = ftok( para.getChar( "shm", "path_name"), share_area_id );

	shmId = shmget( shm_key, shmSize, oflag);

	//获取失败
	if( shmId == -1)
	{
		theLog<<"获取共享内存"<<shm_key<<"|"<<share_area_id<<"|"<<para.getChar( "shm", "path_name")<<"失败"<<ende;
		exit(1);
	}
	
	shm_area_head = (char*)shmat(shmId, NULL, 0);
	
	//从共享内存中读取配置信息，并生成c_shm_mem的vector
	//SHARE_MEM_INFO* t_share_mem_info = (SHARE_MEM_INFO*)&(shm_area_head[0]);
	//cout<<"read mem size:"<<t_share_mem_info->mem_size<<endl;
	//v_shm_mem.clear();

	char* p = para.getChar( "shm", "stor_path_na" );
	char* pp = para.getChar( "shm", "ShmBackupDir") ;
	int dfe = para.getInt( "shm", "MaxBackupNum" );

	int point = 0;
	int i = 0;
	int add_count = 0;
	SHARE_MEM_INFO* t_share_mem_info;// = (SHARE_MEM_INFO*)&shm_area_head[point];
	
	int size_mem_field = sizeof( MEM_FIELD );
	c_mutex p_mutex;

	//确定每个结构体的大小，不足16位的加够16位
	int size_share_mem_info = sizeof(SHARE_MEM_INFO);
	int add_size_share_mem_info;
	if( size_share_mem_info % 16 == 0 )
	{
		add_size_share_mem_info = size_share_mem_info;
	}
	else
	{
		add_size_share_mem_info = ( size_share_mem_info / 16 + 1 ) * 16 ;
	}
	int size_stshareinfo = sizeof( STSHAREINFO );
	int add_size_stshareinfo;
	if( size_stshareinfo % 16 == 0 )
	{
		add_size_stshareinfo = size_stshareinfo;
	}
	else
	{
		add_size_stshareinfo = ( size_stshareinfo / 16 + 1 ) * 16 ;
	}
	
	while( ((point+add_count*4*16) < shmSize) && ( (t_share_mem_info = (SHARE_MEM_INFO*)&(shm_area_head[point])) != NULL) )
	{
		add_count ++;
		point += add_size_share_mem_info;
	
		STSHAREINFO* t_stshareinfo = (STSHAREINFO*)&(shm_area_head[ point ]);
		point += add_size_stshareinfo;

		MEM_FIELD* memField = (MEM_FIELD*)&(shm_area_head[ point ]);
		point += 4000;
	
		//test
		
		//vector <c_shm_mem *> v_shm_mem1;
		c_shm_mem_load_data* t_shm_load_data;
		c_shm_mem* t_shm_mem;
		c_shm_merge* t_shm_merge;
		switch( t_share_mem_info->application_kind )
		{
		case '0':
			//资料类，修改时，先删除原有记录，再添加一条新记录
			t_shm_load_data = new c_shm_mem_load_data();
			t_shm_load_data->p_share_mem_info = t_share_mem_info;
			t_shm_load_data->p_stShareInfo = t_stshareinfo;
			t_shm_load_data->p_field_info = memField;
			t_shm_load_data->head_point = &shm_area_head[ point];;

			//生成锁
			t_shm_load_data->append_mutex._mutex = &(t_stshareinfo->append_lock);
			t_shm_load_data->record_count_mutex._mutex = &(t_shm_load_data->p_stShareInfo->record_count_lock);
			t_shm_load_data->v_update_mutex.clear();
			for( i = 0 ; i < t_shm_load_data->p_stShareInfo->block_count ; i ++ )
			{
				c_mutex t_mutex;
				t_mutex._mutex = &(t_shm_load_data->p_stShareInfo->update_lock[i]);
				t_shm_load_data->v_update_mutex.push_back( t_mutex );
			}			
			t_shm_load_data->append_key_mutex._mutex = &(t_shm_load_data->p_stShareInfo->append_key_lock);

			//拷贝路径
			strcpy( t_shm_load_data->file_path, p );

			////////////////2005-11-23