tBOOL AddHash(DWHASH_TYPE *lpHash, tVOID *lpItem, tINT nInfo)
{
tINT nPos;
DWHASH_BLOCK_TYPE HashItem;
DWHASH_NEXT_TYPE NextItem;
nPos = lpHash->pHashCalFunc(lpItem);
if (nPos < 0) nPos *= -1;
if (nPos >= lpHash->nBucketCount) { // exception
nPos %= lpHash->nBucketCount;
}
memcpy(&HashItem, lpHash->lpBuf + nPos*sizeof(DWHASH_BLOCK_TYPE), sizeof(DWHASH_BLOCK_TYPE));
if (HashItem.nInfo == -1) { // 아무 것도 없다. good
HashItem.nInfo = nInfo;
HashItem.lpNextRec = NULL; // 여기에 해슁이 같으면 달리겠지..
memcpy(lpHash->lpBuf + nPos*sizeof(DWHASH_BLOCK_TYPE), &HashItem, sizeof(DWHASH_BLOCK_TYPE));
}
else { // collision 발생
if (HashItem.lpNextRec == NULL) { // 벌써 collision이 일어났군..
HashItem.lpNextRec = (RECORD *)malloc(sizeof(RECORD));
if (HashItem.lpNextRec == NULL) {
return FALSE;
}
if (AllocRecord(HashItem.lpNextRec, sizeof(DWHASH_NEXT_TYPE), 5, 5) == FALSE) {
return FALSE;
}
memcpy(lpHash->lpBuf + nPos*sizeof(DWHASH_BLOCK_TYPE), &HashItem, sizeof(DWHASH_BLOCK_TYPE)); // mem alloc 했으니.. update 해야지
}
NextItem.nInfo = nInfo;
AppendRecord(HashItem.lpNextRec, &NextItem);
lpHash->nCollision ++;
}
return TRUE;
}
tBOOL GetFindThDic(tCHAR *szStr, RECORD *lpRetRec)
{
THSTR_FORMAT ThStr;
tINT nPos, i;
STR_FORMAT Str;
if (bOpenIndexThDic == FALSE) return FALSE;
if (strlen(szStr) >= MAX_THSTR) return FALSE; // exception
strcpy(ThStr.szStr, szStr);
nPos = FindRecord(&RecThStr, &ThStr, TRUE, (CompProcP)CompRecThStr);
if (nPos == -1) return FALSE;
GetRecord(&RecThStr, nPos, &ThStr);
i = 0;
while (i < C_THSTR && ThStr.nStr[i] >= 0) {
GetRecord(&RecStr, ThStr.nStr[i], &Str);
AppendRecord(lpRetRec, &Str);
i ++ ;
}
return TRUE;
}
tVOID PutThPool(pthread_t ThreadId)
{
THPOOL_ITEMTYPE PoolItem;
LockMutexMan(&gMutexThPool, ID_MUTEX_POOL);
PoolItem.ThreadId = ThreadId;
gettimeofday(&(PoolItem.tv), NULL);
PoolItem.nSocketId = -1;
PoolItem.bActive = FALSE;
AppendRecord(&gTHPOOL, &PoolItem);
UnLockMutexMan(&gMutexThPool, ID_MUTEX_POOL);
}
int main(int argc, char const *argv[])
{
int n, c, Case = 1;
while(scanf("%d%d",&n,&c) && (n != 0 || c != 0))
{
printf("Case %d:\n",Case++);
struct student *p;
p = (STUDENT *)malloc(n * sizeof(STUDENT));
AppendRecord(p, pt, n);
Sort(pt, n, c);
free(p);
}
return 0;
}
tBOOL InsertThTime(pthread_t ThreadId, tINT nSocketId)
{
tBOOL bRetVal = TRUE;
#if defined(_USE_SAFETH)
tINT nItem;
SAFETH_FORMAT SafeItem;
time_t t = time(NULL); // 현재 시간..
tINT last_state;
if (!bStSafeTh) return TRUE;
//pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &last_state);
pthread_cleanup_push((tVOID *)pthread_mutex_unlock, (tVOID *)&gCheckTh);
pthread_mutex_lock(&gCheckTh);
// printf("I(%d) : M : Out\n", ThreadId);
memset(&SafeItem, 0, sizeof(SAFETH_FORMAT));
SafeItem.ThreadId = ThreadId;
SafeItem.nSocketId = nSocketId;
nItem = FindRecord(&RecordThTime, &SafeItem, FALSE, (CompProcP)Comp_ThreadId);
if (nItem == -1) { // 새로운 thread
t = time(NULL);
memcpy(&(SafeItem.s_time), &t, sizeof(time_t));
AppendRecord(&RecordThTime, &SafeItem);
}
else {
GetRecord(&RecordThTime, nItem, &SafeItem);
t = time(NULL);
memcpy(&(SafeItem.s_time), &t, sizeof(time_t));
SetRecord(&RecordThTime, nItem, &SafeItem);
//printf("EI(%d) : UM : In\n", ThreadId);
bRetVal = FALSE;
goto EndProc;
}
EndProc:;
//printf("I(%d) : UM : In\n", ThreadId);
//pthread_mutex_unlock(&gCheckTh);
pthread_cleanup_pop(1);
//printf("I(%d) : UM : Out\n", ThreadId);
//pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, &last_state);
#endif
return bRetVal;
}
void FileReader::run()
{
QStringList::iterator it;
for (it = filenames.begin(); it != filenames.end(); it++)
{
FileRecord *rec = new FileRecord();
QFileInfo f(*it);
if ((f.isFile()) && (!f.isSymLink()))
{
rec->setSize(f.size());
rec->setFileName(f.canonicalFilePath());
rec->setIsArchive(isFileArchive(*it));
parseFile((*it), *rec);
}
emit AppendRecord(*rec);
delete rec;
}
}
/*---------------------------------------------------------------------------------*/
void SplitRecordGroupRequests ( CCB_Header * h )
/*---------------------------------------------------------------------------------*/
{
switch ( h -> RequestCode )
{
case AppendRecordRequest:
AppendRecord ( h );
break;
case CollateFileRequest:
SplitCollateFileRequests ( h );
break;
case CopyRecordRequest:
CopyRecord ( h );
break;
default:
NotifyAndActAsProper ( ErrorRequestNotSupported );
break;
}
return;
}
int main()
{
int i ;
StLogFile stLog ;
StMemTable stMemTable1 ;
StMemTable stMemTable2 ;
StMemTable stMemTable3 ;
StSStableLevel stTableLevel ;
StSStableMem stTableMem ;
int iFileSize = 0 ;
int iRet ;
int iSplit = MAX_MERGE_CNT/3 ;
int iCr = CreateLogFile(LOG_FILE , &stLog);
if(iCr != 0){
printf("create file error:%d\n" , iCr);
return -1 ;
}
memtable_init(&stMemTable1 , compareFunc);
memtable_init(&stMemTable2 , compareFunc);
memtable_init(&stMemTable3 , compareFunc);
for(i = 0 ; i < MAX_MERGE_CNT ; ++i)
{
int iRand = rand()*rand();
char sKey[MAX_KEY_SIZE] ;
char sVal[2048];
//iRand = 1 ;
snprintf(sKey , sizeof(sKey)-1 , "%d_test_key_" , iRand );
snprintf(sVal , sizeof(sVal)-1 , "%d_ssssssssssssssssssssbbbbbbbbbbbbbbbbtest d_ssssssssssssssssssssbbbbbbbbbbbbbbbbtestd_ssssssssssssssssssssbbbbbbbbbbbbbbbbtestd_ssssssssssssssssssssbbbbbbbbbbbbbbbbtestd_ssssssssssssssssssssbbbbbbbbbbbbbbbbtestd_ssssssssssssssssssssbbbbbbbbbbbbbbbbtestd_ssssssssssssssssssssbbbbbbbbbbbbbbbbtestwhy so many sb in......................._val_%d" , iRand , i);
StLogNode stNode ;
stNode.sKey = sKey;
stNode.sVal = sVal;
stNode.uiKeySize = (unsigned int)strlen(stNode.sKey) + 1;
stNode.uiValSize = (unsigned int)strlen(stNode.sVal) + 1;
AppendRecord(&stLog , &stNode);
StValNode stValNode ;
stValNode.sKey = sKey ;
stValNode.uiKeySize = stNode.uiKeySize ;
stValNode.sVal = sVal ;
stValNode.uiValSize = stNode.uiValSize ;
if(i < iSplit)
{
memtable_set(&stMemTable1 , &stValNode);
if(i == iSplit/ 2)
printf("t1:%s\n" , stValNode.sKey);
}
else if(i >= iSplit && i < iSplit * 2)
{
memtable_set(&stMemTable2 , &stValNode);
if(i == iSplit + iSplit/2)
printf("t1:%s\n" , stValNode.sKey);
}
else
{
memtable_set(&stMemTable3 , &stValNode);
iFileSize += stValNode.uiKeySize + sizeof(int) * 3 + stValNode.uiKeySize + stValNode.uiValSize + sizeof(int) * 2 ;
if(i == iSplit*2 + iSplit/2)
printf("t1:%s\n" , stValNode.sKey);
}
}
iFileSize += sizeof(StSSTIndex);
printf("file size:%d\n" , iFileSize);
AppendLog(&stLog ,1);
DestroyFile(&stLog);
//dump file to sstable
StSStableLevel_Init(&stTableLevel) ;
iRet = SSTable_Dump0Level(&stTableLevel , &stMemTable3);
if(iRet == 0)
{
printf("dump sstable ok .\n");
}
else
{
printf("dump sstable error:%d .\n" , iRet);
}
iRet = SSTable_Load(&stTableMem , "sst_0_0.dat") ;
{
for(i = 0 ; i < stMemTable3.pList->iTotCnt ; ++i)
{
char *pIndexNode = stTableMem.pIndex[i];
StValNode *pValNode = memtable_find(&stMemTable3 ,pIndexNode+sizeof(int)) ;
if(pValNode == NULL)
{
printf("xxxxxxxxxxxxxxxxxxxxxxxxxxxx========%d key:%s\n" ,i, pIndexNode + sizeof(int));
return 0 ;
}
if(strcmp(pIndexNode + sizeof(int) , "-450124004_test_key_") == 0 )
{
printf("got it ....\n");
}
//if(i < 10 || i > stMemTable3.pList->iTotCnt -10)
{
unsigned int uiOffset = *((unsigned int*)(pIndexNode+sizeof(int) + pValNode->uiKeySize));
unsigned int uiNodeSize = *((unsigned int*)(pIndexNode+sizeof(int)*2 + pValNode->uiKeySize));
printf("%s %s offset:%d node size:%d\n" , pIndexNode + sizeof(int) , pValNode->sKey , uiOffset , uiNodeSize);
}
}
}
if(iRet == 0)
{
printf("load sstable file ok. index cnt:%d\n\n" , stTableMem.uiNodeNum);
}
else
{
printf("load sstable file error:%d.\n" , iRet );
return -1 ;
}
{
StValNode stNode ;
StValNode *pNode ;
stNode.sKey = stTableMem.pIndex[5]+sizeof(int);
stNode.uiKeySize = strlen(stNode.sKey) + 1;
//find in mem table 1
pNode = memtable_find(&stMemTable1 , stNode.sKey);
if(pNode != NULL)
{
printf("find in memtab1 key:[%s] val:[%s]\n" , pNode->sKey , pNode->sVal);
return 0 ;
}
printf("[%s]:can't find in memtab1 , start to find in memtable2.\n" , stNode.sKey);
//find in mem table 2
pNode = memtable_find(&stMemTable2 , stNode.sKey);
if(pNode != NULL)
{
printf("find in memtab2 key:[%s] val:[%s]\n" , pNode->sKey ,pNode->sVal);
return 0 ;
}
else
{
int iRet ;
void *pData = NULL ;
unsigned int uiNodeSize = 0 ;
printf("[%s]:can't find in memtab2 , start to find in sstable.\n" , stNode.sKey);
iRet = SSTable_Find(&stTableMem , stNode.sKey , stNode.uiKeySize , &pData , &uiNodeSize) ;
if(iRet == 0)
{
if(pData == NULL)
{
printf("can't find:[%s] \n" , stNode.sKey);
}
else
{
pData = (void *)((char *)pData + sizeof(int) + stNode.uiKeySize + sizeof(int));
printf("key:[%s] val:[%s]" , stNode.sKey , (char *)pData);
}
}
else
{
printf("find:[%s] error:%d\n" , stNode.sKey , iRet);
return -1;
}
}
}
return 0;
}
