?? c_shm_merge.cpp
字號:
}
}
}
*/
//查找，找到，返回值，否則，返回NULL，二分法查找8個值
SHM_MERGE_LIST_ITEM* c_shm_merge_addition::find( const int begin_pos, const void * item_value )
{
return NULL;
}
//添加值，首先在空余的空間添加，如沒有空余的空間，則申請8個空間做為空余的空間，再添加
int c_shm_merge_addition::append( const int main_pos, const void* p_item, const void* p_fee )
{
//if( main_pos % MAX_LIST_COUNT != 0 )
// cout<<"error"<<main_pos<<endl;
int j, last_pos, get_comp_pos;
int last_main_pos = main_pos;
int begin_pos, end_pos, middle_pos, insert_pos;
long tmp_value1 = 0;
//將位置壓入
m_pos.clear();
m_pos.push_back(last_main_pos);
while( p_merge_list_item[last_main_pos].next_pos != -1 )
{
m_pos.push_back(p_merge_list_item[last_main_pos].next_pos);
last_main_pos = p_merge_list_item[last_main_pos].next_pos;
}
//從第一個節點開始比較
for( int i = 0; i < m_pos.size(); i++ )
{
int t = p_merge_list_item[ m_pos[i] ].acctFee[ p_merge_list_item[ m_pos[i] ].ele_count -1 ].key - *(int*)p_item ;
if( t == 0 )
{
memcpy( &tmp_value1, &(p_merge_list_item[ m_pos[i] ].acctFee[ p_merge_list_item[ m_pos[i] ].ele_count -1 ].fee), sizeof(long) );
tmp_value1 += *((long*)p_fee);
memcpy(&(p_merge_list_item[ m_pos[i] ].acctFee[ p_merge_list_item[ m_pos[i] ].ele_count -1 ].fee), &tmp_value1, sizeof(long) );
//p_merge_list_item[ m_pos[i] ].acctFee[ p_merge_list_item[ m_pos[i] ].ele_count -1 ].fee += *(long*)p_fee;
return 0;
}
else if( t > 0 )
{
break;
}
}
//找到插入塊 i
if( i == m_pos.size() ) //最后一塊
{
if( p_merge_list_item[ m_pos[i-1] ].ele_count < MAX_LIST_COUNT )
//直接插入到最后
{
memcpy(&(p_merge_list_item[ m_pos[i-1] ].acctFee[ p_merge_list_item[ m_pos[i-1] ].ele_count ].fee), p_fee, sizeof(long) );
memcpy(&(p_merge_list_item[ m_pos[i-1] ].acctFee[ p_merge_list_item[ m_pos[i-1] ].ele_count ].key), p_item, sizeof(int) );
p_merge_list_item[ m_pos[i-1] ].ele_count++;
return 0;
}
else //申請一個塊, 并將該元素放入
{
m_p_shm_merge->append_mutex.enterMutex();
if( p_merge_info->record_count >= m_p_shm_merge->max_addition_count )
{
cout<<"超出附加塊內存限制!"<<endl;
m_p_shm_merge->append_mutex.leaveMutex();
exit(1);
}
last_pos = p_merge_info->record_count;
p_merge_info->record_count ++;
m_p_shm_merge->append_mutex.leaveMutex();
p_merge_list_item[ m_pos[i-1] ].next_pos = last_pos;
memcpy(&(p_merge_list_item[last_pos].acctFee[0].key), p_item, sizeof(int) );
memcpy(&(p_merge_list_item[last_pos].acctFee[0].fee), p_fee, sizeof(long) );
p_merge_list_item[last_pos].ele_count = 1;
p_merge_list_item[last_pos].next_pos= -1;
return 0;
}
}
else //對應的塊號為m_pos[i], 在該塊中插入數據, 而且所有塊是滿
{
//在i中尋找插入位置
begin_pos = 0;
end_pos = p_merge_list_item[m_pos[i]].ele_count-2;
while( begin_pos <= end_pos )
{
middle_pos = begin_pos + (end_pos-begin_pos)/2;
int comp_value = p_merge_list_item[m_pos[i]].acctFee[middle_pos].key - *((int*)p_item);
if( comp_value == 0 )
{
//直接加
memcpy( &tmp_value1, &(p_merge_list_item[m_pos[i]].acctFee[middle_pos].fee), sizeof(long) );
tmp_value1 += *((long*)p_fee);
memcpy(&(p_merge_list_item[m_pos[i]].acctFee[middle_pos].fee), &tmp_value1, sizeof(long) );
return 0;
}
else if( comp_value > 0 )
{
end_pos = middle_pos - 1;
}
else
{
begin_pos = middle_pos + 1;
}
}
//printf("begin_pos:%d, %d\n",begin_pos, p_merge_list_item[ m_pos[m_pos.size()-1] ].ele_count);
if( p_merge_list_item[ m_pos[m_pos.size()-1] ].ele_count == MAX_LIST_COUNT ) //最后一個塊滿
{
m_p_shm_merge->append_mutex.enterMutex();
last_pos = p_merge_info->record_count;
p_merge_info->record_count ++;
if( p_merge_info->record_count >= m_p_shm_merge->max_addition_count )
{
cout<<"超出附加塊內存限制!"<<endl;
m_p_shm_merge->append_mutex.leaveMutex();
exit(1);
}
m_p_shm_merge->append_mutex.leaveMutex();
p_merge_list_item[ m_pos[m_pos.size()-1] ].next_pos = last_pos;
p_merge_list_item[ last_pos].ele_count = 0;
p_merge_list_item[ last_pos].next_pos = -1;
m_pos.push_back( last_pos );
}
if( m_pos.size() - 1 == i )
{
p_merge_list_item[ m_pos[i] ].ele_count++;
memmove( &p_merge_list_item[ m_pos[i] ].acctFee[begin_pos+1], &p_merge_list_item[m_pos[i]].acctFee[begin_pos], ( p_merge_list_item[ m_pos[i] ].ele_count - begin_pos-1 )*sizeof(ACCT_ITEM_FEE) );
//在begin_pos中插入新的元素
memcpy(&(p_merge_list_item[m_pos[i]].acctFee[begin_pos].key), p_item, sizeof(int) );
memcpy(&(p_merge_list_item[m_pos[i]].acctFee[begin_pos].fee), p_fee, sizeof(long) );
return 0;
}
//移動數據
//最后一個塊內的數據全部偏移一位
if( p_merge_list_item[ m_pos[m_pos.size() - 1]].ele_count != 0 )
{
memmove( &p_merge_list_item[ m_pos[m_pos.size() -1] ].acctFee[1], &p_merge_list_item[ m_pos[m_pos.size() - 1] ].acctFee[0], p_merge_list_item[ m_pos[m_pos.size() - 1]].ele_count*sizeof(ACCT_ITEM_FEE) );
}
p_merge_list_item[ m_pos[m_pos.size() - 1]].ele_count++;
for( j = m_pos.size() -2 ; j > i ; j-- )
{
//塊間偏移
memcpy( &p_merge_list_item[ m_pos[j+1] ].acctFee[0], &p_merge_list_item[ m_pos[j] ].acctFee[MAX_LIST_COUNT-1], sizeof(ACCT_ITEM_FEE) );
//塊內移動
memmove( &p_merge_list_item[ m_pos[j] ].acctFee[1], &p_merge_list_item[m_pos[j]].acctFee[0], (MAX_LIST_COUNT-1)*sizeof(ACCT_ITEM_FEE) );
}
//插入位置為begin_pos
memcpy( &p_merge_list_item[ m_pos[i+1] ].acctFee[0], &p_merge_list_item[ m_pos[i] ].acctFee[MAX_LIST_COUNT-1], sizeof(ACCT_ITEM_FEE) );
//塊內移動
memmove( &p_merge_list_item[ m_pos[i] ].acctFee[begin_pos+1], &p_merge_list_item[m_pos[i]].acctFee[begin_pos], ( MAX_LIST_COUNT-begin_pos-1 )*sizeof(ACCT_ITEM_FEE) );
//在begin_pos中插入新的元素
memcpy(&(p_merge_list_item[m_pos[i]].acctFee[begin_pos].key), p_item, sizeof(int) );
memcpy(&(p_merge_list_item[m_pos[i]].acctFee[begin_pos].fee), p_fee, sizeof(long) );
}
return 0;
}
/*
//添加值，首先在空余的空間添加，如沒有空余的空間，則申請8個空間做為空余的空間，再添加
int c_shm_merge_addition::append( const int main_pos, const void* p_item, const void* p_fee )
{
if( main_pos % MAX_LIST_COUNT != 0 )
cout<<"error"<<main_pos<<endl;
//cout<<"test :"<<main_pos+MAX_LIST_COUNT-1<<"|"<<p_merge_list_item[main_pos+MAX_LIST_COUNT-1].next_pos<<"|"<<endl;
SHM_MERGE_LIST_ITEM* p_find;
SHM_MERGE_LIST_ITEM shm_find;
shm_find.key = *(int*)p_item ;
int i, j, last_pos, get_comp_pos;
int last_main_pos = main_pos;
while(1)
{
p_find = (SHM_MERGE_LIST_ITEM*)bsearch(&shm_find, &p_merge_list_item[last_main_pos], p_merge_list_item[last_main_pos].ele_count, sizeof(SHM_MERGE_LIST_ITEM), listItemComp);
if( p_find != NULL )
{
//找到了。
//cout<<"find:"<<*(int*)p_item<<endl;
p_find->fee += *((int*)p_fee);
return 0;
}
else
{
//沒找到
//cout<<"not find:"<<*(int*)p_item<<endl;
if( p_merge_list_item[last_main_pos].ele_count == MAX_LIST_COUNT )
{
get_comp_pos = getPos( last_main_pos+MAX_LIST_COUNT-1 );
if( get_comp_pos == -1 )
{
//新開空間并插入
m_p_shm_merge->append_mutex.enterMutex();
last_pos = p_merge_info->record_count;
p_merge_info->record_count += MAX_LIST_COUNT;
m_p_shm_merge->append_mutex.leaveMutex();
p_merge_list_item[last_main_pos+MAX_LIST_COUNT-1].next_pos = last_pos;
//memcpy(p_merge_list_item[last_pos].key, (char*)p_item,MAX_ITEM_LENGTH);
p_merge_list_item[last_pos].key = *(int*)p_item;
p_merge_list_item[last_pos].fee = *((int*)p_fee);
p_merge_list_item[last_pos].ele_count = 1;
for( i = 0; i < MAX_LIST_COUNT; i ++ )
{
p_merge_list_item[last_pos+i].next_pos= -1;
}
return 0;
}
else
{
//找下一個小節
last_main_pos = get_comp_pos;
}
}
else
{
//新增一個節點
last_pos = last_main_pos + p_merge_list_item[last_main_pos].ele_count - 1 ;
p_merge_list_item[last_pos].next_pos = last_pos+1;
for( i = 0 ; i < p_merge_list_item[last_main_pos].ele_count ; i ++ )
{
if( listItemComp( &shm_find, &(p_merge_list_item[last_main_pos+i]) ) < 0 )
{
//插入
for( j = p_merge_list_item[last_main_pos].ele_count ; j > i ; j -- )
{
//memcpy( p_merge_list_item[last_main_pos+j].key, p_merge_list_item[last_main_pos+j-1].key, MAX_ITEM_LENGTH );
p_merge_list_item[last_main_pos+j].key = p_merge_list_item[last_main_pos+j-1].key;
p_merge_list_item[last_main_pos+j].fee = p_merge_list_item[last_main_pos+j-1].fee;
}
break;
}
}
//memcpy( p_merge_list_item[last_main_pos+i].key, p_item, MAX_ITEM_LENGTH);
p_merge_list_item[last_main_pos+i].key = *((int*)p_item) ;
p_merge_list_item[last_main_pos+i].fee = *((int*)p_fee);
p_merge_list_item[last_main_pos].ele_count ++;
return 0;
}
}
}
return 0;
}
*/
SHM_MERGE_LIST* c_shm_merge_item::binfind( const int begin_pos, const int end_pos, const SHM_MERGE_LIST* item )
{
return NULL;
}
//查找，找到，返回值，否則，返回NULL
SHM_MERGE_LIST* c_shm_merge_item::find( const void * p_main )
{
SHM_MERGE_LIST shm_find;
memcpy( shm_find.main, (char*)p_main, m_p_shm_merge->main_key_size );
//strcpy( shm_find.main, (char*) p_main);
//memcpy( shm_find.main, (char*)p_main, MAX_MAIN_LENGTH);
//for(int j=0; j<g_main_key.size(); j++ )
//{
// memcpy(&(shm_find.main[g_main_key[j].pos]), &(((char*)p_main)[g_main_key[j].pos]), g_main_key[j].size );
//}
if ( p_current != NULL )
{
if( itemComp( p_current, &shm_find ) == 0 )
return p_current;
//if( strcmp( p_current->main, (char*)p_main ) == 0 )
// return p_current;
}
SHM_MERGE_LIST* p = NULL;
if( p_merge_info->record_count > 0 )
{
p = (SHM_MERGE_LIST*)bsearch(&shm_find, p_merge_list, p_merge_info->record_count, sizeof(SHM_MERGE_LIST), itemComp);
}
if( p == NULL )
{
p_merge_info->unsort_find_count ++;
for( int i = 0 ; i < p_merge_info->add_record_count ; i ++ )
{
//if( strcmp( p_add_merge_list[i].main, (char*) p_main) == 0 )
if( itemComp( &p_add_merge_list[i], &shm_find ) == 0 )
{
p = &p_add_merge_list[i];
break;
}
}
}
p_current = p;
return p;
}
//添加值，首先在附加區添加，如果附加區的數量大于10000，則把附加區的數據添加到主區中，并排序
int c_shm_merge_item::append( const void* p_main, const void* p_item, const void* p_fee )
{
//在無序區添加
//append_main_mutex是鎖記錄數
//append_main_mutex.enterMutex();
//append_mutex是鎖附加區的記錄數
m_p_shm_merge->append_mutex.enterMutex();
int main_pos = m_p_shm_merge_addition->p_merge_info->record_count;
m_p_shm_merge_addition->p_merge_info->record_count ++;
int pos = p_merge_info->add_record_count;
p_merge_info->add_record_count ++;
m_p_shm_merge->append_mutex.leaveMutex();
//append_main_mutex.leaveMutex();
//strcpy(p_add_merge_list[pos].main, (char*) p_main );
memcpy( p_add_merge_list[pos].main, (char*)p_main, m_p_shm_merge->main_key_size );
p_add_merge_list[pos].item_pos = main_pos;
p_current = & (p_add_merge_list[pos]);
memcpy(&(m_p_shm_merge_addition->p_merge_list_item[main_pos].acctFee[0].key),p_item, sizeof(int) );
memcpy(&(m_p_shm_merge_addition->p_merge_list_item[main_pos].acctFee[0].fee), p_fee, sizeof(long) );
m_p_shm_merge_addition->p_merge_list_item[main_pos].ele_count = 1;
m_p_shm_merge_addition->p_merge_list_item[main_pos].next_pos = -1;
//排序無序區
//if( p_merge_info->add_record_count - p_merge_info->sort_count > 10 )
//{
// qsort(p_add_merge_list, p_merge_info->add_record_count, sizeof(SHM_MERGE_LIST), itemComp );
// p_merge_info->sort_count = p_merge_info->add_record_count;
//}
if ( p_merge_info->add_record_count >= MAX_ITEM_ADD_COUNT )
{
qSort();
}
return 0;
}
//更新值
int c_shm_merge_item::update( const int main_pos, const void* p_item, const void* p_fee )
{
return m_p_shm_merge_addition->append(main_pos, p_item, p_fee);
}
//排序
int c_shm_merge_item::qSort()
{
if( p_merge_info->add_record_count < 10 )
{
p_merge_info->unsort_find_count = 0;
return 0;
}
//把無序區的數據拷貝到有序區
memcpy( &p_merge_list[p_merge_info->record_count], &p_add_merge_list[0], (p_merge_info->add_record_count)*sizeof(SHM_MERGE_LIST) );
p_merge_info->record_count += p_merge_info->add_record_count;
p_merge_info->add_record_count = 0;
p_merge_info->unsort_find_count = 0;
//排序
qsort(p_merge_list, p_merge_info->record_count, sizeof(SHM_MERGE_LIST), itemComp );
return 0;
}
//添加數據，外部調用
int c_shm_merge_item::addRecord( const void* p_main, const void* p_item, const void* p_fee )
{
//cout<<"addrecord:"<<(char*)p_main<<"|"<<(char*)p_item<<"|"<<(char*)p_fee<<endl;
if( p_merge_info->unsort_find_count >= MAX_UNSORT_FINDED_COUNT )
{
qSort();
}
//在小塊中查找
SHM_MERGE_LIST* p_find_main = find( p_main );
if( p_find_main != NULL )
{
//找到號碼
//return update( p_find_main->item_pos, p_item, p_fee );
return m_p_shm_merge_addition->append(p_find_main->item_pos, p_item, p_fee);
}
else
{
//未找到號碼，在本塊中新增一個數據
return append( p_main, p_item, p_fee );
}
}
/////2006-01-18
//在共享內存塊中根據serv_id與counting_type_id查找到數據
////20060415 增加傳入counting_type_id為-1時，找出指定的serv_id的所有數據。
SHM_MERGE_LIST* c_shm_merge_item::findServID( const int serv_id, const int counting_type_id )
{
SHM_MERGE_LIST shm_find;
memset( serv_buff, 0, 30 );
sprintf(&serv_buff[0] ,"%10d", serv_id );
sprintf(&serv_buff[10?? 快捷鍵說明
復制代碼
Ctrl + C
搜索代碼
Ctrl + F
全屏模式
F11
切換主題
Ctrl + Shift + D
顯示快捷鍵
?
增大字號
Ctrl + =
減小字號
Ctrl + -