c_shm.cpp

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

			t_shm_load_data->addition_mutex._mutex = &(t_shm_load_data->p_stShareInfo->addition_lock);
			t_shm_load_data->addition_point = &(t_shm_load_data->head_point[t_share_mem_info->mem_size-t_share_mem_info->addition_size]);
			
			//////////////////
			v_shm_mem.push_back( t_shm_load_data );
			//delete t_shm_load_data;
			break;
		case '1':
			//实时合帐类，修改时，直接修改
			t_shm_merge = new c_shm_merge();

			t_shm_merge->p_share_mem_info = t_share_mem_info;
			t_shm_merge->p_stShareInfo = t_stshareinfo;
			t_shm_merge->p_field_info = memField;
			t_shm_merge->head_point = &shm_area_head[ point];;

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

			t_shm_merge->getItemShm();

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

			strcpy( t_shm_merge->backup_dir, para.getChar( "shm", "ShmBackupDir") );
			t_shm_merge->max_backup_num = para.getInt( "shm", "MaxBackupNum" );

			v_shm_mem.push_back( t_shm_merge );
			break;
		default:
			t_shm_mem = new c_shm_mem();
			t_shm_mem->p_share_mem_info = t_share_mem_info;
			t_shm_mem->p_stShareInfo = t_stshareinfo;
			t_shm_mem->p_field_info = memField;
			t_shm_mem->head_point = &shm_area_head[ point];;
			
			//生成锁
			t_shm_mem->append_mutex._mutex = &(t_shm_mem->p_stShareInfo->append_lock);
			t_shm_mem->record_count_mutex._mutex = &(t_shm_mem->p_stShareInfo->record_count_lock);
			t_shm_mem->v_update_mutex.clear();
			for( i = 0 ; i < t_shm_mem->p_stShareInfo->block_count ; i ++ )
			{
				c_mutex t_mutex;
				t_mutex._mutex = &(t_shm_mem->p_stShareInfo->update_lock[i]);
				t_shm_mem->v_update_mutex.push_back( t_mutex );
			}
			t_shm_mem->append_key_mutex._mutex = &(t_shm_mem->p_stShareInfo->append_key_lock);

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

			v_shm_mem.push_back( t_shm_mem );
			//delete t_shm_mem;
			break;
		}

		//取下一个内存块的信息		
		if( t_share_mem_info->mem_size % 16 == 0 )
		{
			point += t_share_mem_info->mem_size;
		}
		else
		{
			point += (t_share_mem_info->mem_size / 16 + 1 ) * 16;
		};
		//point += t_share_mem_info->mem_size;		
	}
	return 0;
}

////////////////////////////////////////////////////////////////////////
// Name:	c_shm::deleteshm()
// Purpose:	删除共享内存区.
// Return:  int
// Comment:	从内存中删除共享内存区
////////////////////////////////////////////////////////////////////////
int c_shm::deleteshm(void)
{
	/*
	// TODO : implement
	//检查是否所有的共享内存块已不可用，才可以删除。
	for( int i = 0 ; i < v_shm_mem.size() ; i ++ )
	{
		if( v_shm_mem[i].p_stShareInfo->valid_flag == 1 )
		{
			cout<<"第"<<i<<"块共享内存尚未卸载，不可删除共享内存。"<<endl;
			return 1;
		}
	}
	*/

	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];
		}
	}
	v_shm_mem.clear();

	if( shmdt( shm_area_head ) == -1)
    {
        theLog<<"卸载错误。"<<ende;
        exit(1);
    }

    shmctl( shmId, IPC_RMID, NULL );
	
	
	theLog<<"删除成功!"<<endi;
	return 0;
}

////////////////////////////////////////////////////////////////////////
// Name:	c_shm::get_shm_mem(int seq)
// Purpose:	根据共享内存块的序号获得共享内存块的指针
// Parameters:
// - seq	共享内存块的序号
// Return:	c_shm_mem*
// Comment:	根据顺序查找共享内存块，找到则返回指针，否则返回NULL。
////////////////////////////////////////////////////////////////////////
c_shm_mem* c_shm::get_shm_mem(int seq)
{
	if( seq >= v_shm_mem.size() )
	{
		theLog<<"没有第"<<seq<<"块共享内存"<<ende;
		return NULL;
	}
	else
	{
		//判断是否可用
		if( v_shm_mem[seq]->p_stShareInfo->valid_flag == 1 )
		{
			v_shm_mem[seq]->loadSQL();
			v_shm_mem[seq]->loadFieldInfo();
			v_shm_mem[seq]->buildSQLString();
			return v_shm_mem[seq];
		}
		else
		{
			theLog<<"共享内存块数据已被删除！"<<ende;
			return NULL;
		}
	}
}

////////////////////////////////////////////////////////////////////////
// Name:       c_shm::get_mem(const char* name)
// Purpose:		根据名字查找共享内存块
// Parameters:
// - name		共享内存块的名称
// Return:     c_shm_mem*
// Comment:		根据名字查找共享内存块，找到则返回指针，否则返回NULL。
////////////////////////////////////////////////////////////////////////

c_shm_mem* c_shm::get_mem(const char* name)
{
	// TODO : implement
	//printf("memsize:%d\n",v_shm_mem.size());
	for( int i = 0 ; i < v_shm_mem.size() ; i ++ )
	{
		//printf("%p\n", v_shm_mem[i]->p_share_mem_info );
		//cout<<"比较:"<<name<<"|"<<v_shm_mem[i]->p_share_mem_info->mem_name<<"|"<<endl;
		if( strcmp( name, v_shm_mem[i]->p_share_mem_info->mem_name ) == 0 )
		{
			//判断是否可用
			if( v_shm_mem[i]->p_stShareInfo->valid_flag == 1 )
			{
				v_shm_mem[i]->loadSQL();
				v_shm_mem[i]->loadFieldInfo();
				v_shm_mem[i]->buildSQLString();
				return v_shm_mem[i];
			}
			else
			{
				theLog<<"共享内存块数据已被删除！"<<ende;
				return NULL;
			}
		}
	}
	theLog<<"找不到"<<name<<"共享内存块!"<<endi;
	return NULL;
	
}

////////////////////////////////////////////////////////////////////////
// Name:	c_shm::getMemSize()
// Purpose:	计算共享内存区的大小
// Return:  size_t
// Comment:	计算所有共享内存块的大小，配置信息的大小之和
////////////////////////////////////////////////////////////////////////
size_t c_shm::getMemSize()
{
	int i;
	size_t temp = 0;
	size_t single_temp = 0;
	
	for( i = 0; i < v_share_mem_info.size(); i++ )
	{
		//cout<<"memsize:"<<v_share_mem_info[i].mem_size<<endl;
		single_temp = sizeof(SHARE_MEM_INFO) + sizeof(STSHAREINFO) + 4000 + v_share_mem_info[i].mem_size;
		single_temp = ( single_temp/16 + 4 ) * 16 ;
		temp += single_temp;
	}
	//return sizeof(SHARE_INFO)+  para.getInt( "shm", "max_acc_num")*sizeof(ACC_INFO);
	return temp;
	//return 10000;
}

////////////////////////////////////////////////////////////////////////
// Name:       c_shm::loadShmInfo()
// Purpose:		加载数据库中设置的共享内存区与共享内存块的信息
// Return:     void
////////////////////////////////////////////////////////////////////////
int c_shm::loadShmInfo()
{
	try
	{
		//加载内存信息
		p_share_info->loadAllInfo();
		////取得内存区个数
		//int memCount = p_share_info->getMemCountByShareAreaId( share_area_id );
		//加载内存区信息
		if( share_area_id != 0)
			p_share_info->getMemInfoByShareAreaId( share_area_id, v_share_mem_info );
		else
			v_share_mem_info = p_share_info->v_share_info;
	}
	catch( Exception & ex )
	{
		cout<<ex.what()<<endl;
		return 1;
	}
	return 0;
}

////////////////////////////////////////////////////////////////////////
// Name:       c_shm::writeToFile()
// Purpose:		把共享内存区内的数据写到文件
// Return:     int
////////////////////////////////////////////////////////////////////////
int c_shm::writeToFile()
{
	char* p = para.getChar( "shm", "path_name" );
	//cout<<"p:"<<p<<endl;
	char file_name[120], t_date[10];
	strcpy( file_name, p );
	strcat( file_name , "/shm_data_");
	get_date( t_date);
	strcat( file_name, t_date );
	strcat( file_name, ".dat" );

	FILE * fp;
	fp = fopen( file_name, "wb");
	if( fp == NULL )
	{
		printf("文件[%s]打开错误\n",  file_name );
		return -1;
	}

	int point = 0;
	int size_share_mem_info = sizeof( SHARE_MEM_INFO );
	int size_stshareinfo =  sizeof( STSHAREINFO );
	int size_mem_field = sizeof( MEM_FIELD );
	SHARE_MEM_INFO* t_share_mem_info;
	STSHAREINFO* t_stshareinfo;
	int j = 0;

	int mem_count = v_shm_mem.size();
	fwrite( &mem_count, sizeof( int ), 1, fp );

	for( int i = 0 ; i < mem_count ; i ++ )
	{
		//fwrite( shmInfo, sizeof(SHARE_INFO), 1, fp );
		t_share_mem_info = (SHARE_MEM_INFO*)&(shm_area_head[point]);
		point += size_share_mem_info;
		fwrite( t_share_mem_info, size_share_mem_info, 1, fp );

		t_stshareinfo = (STSHAREINFO*)&(shm_area_head[ point ]);
		point += size_stshareinfo;
		fwrite( t_stshareinfo, size_stshareinfo, 1, fp );

		MEM_FIELD* memField = (MEM_FIELD*)&(shm_area_head[ point ]);
		point += 3000;
		for( j = 0 ; j < t_share_mem_info->field_count ; j ++ )
		{
			fwrite( &memField[j], size_mem_field, 1, fp );
		}
		
		
		fwrite( &shm_area_head[point], t_stshareinfo->real_record_count * t_share_mem_info->element_size, 1, fp );
		
		point += t_share_mem_info->mem_size ;
	}
	
	fclose( fp );
	printf("文件[%s]建立成功\n", file_name );
	return 0;
}

////////////////////////////////////////////////////////////////////////
// Name:       c_shm::readFromFile( const char* fname )
// Purpose:		从文件中读出数据并写到共享内存区内
// Return:     int
////////////////////////////////////////////////////////////////////////
int c_shm::readFromFile( const char* fname )
{
	char* p = para.getChar( "shm", "path_name" );
	char file_name[120], t_date[10];
	strcpy( file_name, p );
	strcat( file_name, "/" );
	strcat( file_name , fname );

	FILE * fp;
	fp = fopen( file_name, "rb");
	if( fp == NULL )
	{
		printf("文件[%s]打开错误\n",  file_name );
		return -1;
	}

	int mem_count = 0;
	fread( &mem_count, sizeof(int), 1, fp );

	int point = 0;
	int size_share_mem_info = sizeof( SHARE_MEM_INFO );
	int size_stshareinfo =  sizeof( STSHAREINFO );
	int size_mem_field = sizeof( MEM_FIELD );
	SHARE_MEM_INFO* t_share_mem_info;
	STSHAREINFO* t_stshareinfo;
	int j, i;

	for( i = 0 ; i < mem_count ; i ++ )
	{
		t_share_mem_info = (SHARE_MEM_INFO*)&(shm_area_head[point]);
		point += size_share_mem_info;
		fread( t_share_mem_info, size_share_mem_info, 1, fp );

		t_stshareinfo = (STSHAREINFO*)&(shm_area_head[ point ]);
		point += size_stshareinfo;
		fread( t_stshareinfo, size_stshareinfo, 1, fp );

		MEM_FIELD* memField = (MEM_FIELD*)&(shm_area_head[ point ]);
		point += 3000;
		for( j = 0 ; j < t_share_mem_info->field_count ; j ++ )
		{
			fread( &memField[j], size_mem_field, 1, fp );
		}

		fread( &shm_area_head[point], t_stshareinfo->real_record_count * t_share_mem_info->element_size, 1, fp );
		
		point += t_share_mem_info->mem_size ;
	}

	fclose( fp );
	printf("文件[%s]导入成功\n", file_name );
	
	return 0;
}

bool c_shm::init( const char* shm_area_name )
{
	int i;
	for( i = 0 ; i < v_share_area_name.size() ; i ++ )
	{
		if( strcmp( v_share_area_name[i].share_area_name, shm_area_name ) == 0 )
			return true;
	}
	//没找到，要初始化
	p_share_info->share_area_id = 0;
	p_share_info->loadAllInfo();
	share_area_id = p_share_info->getShareID(shm_area_name);
	if( share_area_id == -1 )
	{
		theLog<<"没有这个名字的区号:"<<shm_area_name<<ende;
		return false;
	}
	
	loadShmInfo();
	getshm();
	
	return true;
}

int c_shm::getShmIDByName( const char* shm_area_name )
{
	para.loadPara();
	p_share_info ->share_area_id = 0;
	p_share_info->loadAllInfo();
	if ( strcmp(shm_area_name,"")== 0 )
	{
		//没有这个ID
		theLog<<"没有这个名字的区号:"<<shm_area_name<<ende;
		share_area_id = 0;
		return -1;
	}
	else
	{
		share_area_id = p_share_info->getShareID( shm_area_name );
		if( share_area_id == -1 )
		{
			theLog<<"没有这个名字的区号:"<<shm_area_name<<ende;
			share_area_id = 0;
			return -1;
		}
		else
		{
			return share_area_id;
		}
	}
}

/*c_shm_mem* c_shm::init( const char* mem_name )
{
	p_share_info->share_area_id = 0;
	p_share_info->loadAllInfo();	
	SHARE_MEM_INFO* tmp = p_share_info->getMemInfo( mem_name);
	if( tmp == NULL )
	{
		printf("不存在%s的共享内存\n", mem_name );fflush(stdout);
		return NULL;
	}
	share_area_id = tmp->share_area_id;
	loadShmInfo();
	getshm();
	
	return get_mem( mem_name );
}*/