static inline void GlueFreeBlocks(PPMdSubAllocatorVariantH *self)
{
if(self->LowUnit!=self->HighUnit) *self->LowUnit=0;
self->sentinel.next=self->sentinel.prev=PointerToOffset(self,&self->sentinel);
for(int i=0;i<N_INDEXES;i++)
{
while(self->FreeList[i].next)
{
struct PPMdMemoryBlockVariantH* p=(struct PPMdMemoryBlockVariantH *)RemoveNode(self,i);
InsertBlockAfter(self,p,&self->sentinel);
p->Stamp=0xFFFF;
p->NU=self->Index2Units[i];
}
}
for(struct PPMdMemoryBlockVariantH *p=OffsetToPointer(self,self->sentinel.next);
p!=&self->sentinel;p=OffsetToPointer(self,p->next))
{
for(;;)
{
struct PPMdMemoryBlockVariantH *p1=p+p->NU;
if(p1->Stamp!=0xFFFF) break;
if(p->NU+p1->NU>=0x10000) break;
RemoveBlock(self,p1);
p->NU+=p1->NU;
}
}
for(;;)
{
struct PPMdMemoryBlockVariantH *p=OffsetToPointer(self,self->sentinel.next);
if(p==&self->sentinel) break;
RemoveBlock(self,p);
int sz=p->NU;
while(sz>128)
{
InsertNode(self,p,N_INDEXES-1);
sz-=128;
p+=128;
}
int i=self->Units2Index[sz-1];
if(self->Index2Units[i]!=sz)
{
i--;
int k=sz-self->Index2Units[i];
InsertNode(self,p+(sz-k),k-1);
}
InsertNode(self,p,i);
}
}
void GoRegionBoard::MergeAdjacentAndAddBlock(SgPoint move,
SgBlackWhite capturedColor)
{
SgVector<SgPoint> nb;
for (GoNbIterator it(Board(), move); it; ++it)
if (Board().IsEmpty(*it))
nb.PushBack(*it);
SgVectorOf<GoBlock> captures;
PreviousBlocksAt(nb, capturedColor, &captures);
SG_ASSERT(captures.NonEmpty());
SgPointSet captured;
{for (SgVectorIteratorOf<GoBlock> it(captures); it; ++it)
captured |= (*it)->Stones();
}
SgVectorOf<GoRegion> adj;
const int size = Board().Size();
RegionsAt(captured.Border(size), capturedColor, &adj);
SG_ASSERT(adj.NonEmpty());
GoRegion* r = MergeAll(adj, captured, capturedColor);
SG_UNUSED(r);
for (SgVectorIteratorOf<GoBlock> it(captures); it; ++it)
RemoveBlock(*it, true, false);
// don't remove from regions; already gone.
}
void
block_cache::RemoveUnusedBlocks(int32_t maxAccessed, int32_t count)
{
TRACE(("block_cache: remove up to %ld unused blocks\n", count));
for (block_list::Iterator iterator = unused_blocks.GetIterator();
cached_block *block = iterator.Next();) {
if (maxAccessed < block->accessed)
continue;
TRACE((" remove block %Ld, accessed %ld times\n",
block->block_number, block->accessed));
// this can only happen if no transactions are used
if (block->is_dirty && !block->discard)
write_cached_block(this, block, false);
// remove block from lists
iterator.Remove();
RemoveBlock(block);
if (--count <= 0)
break;
}
}
/*! Discards the block from a transaction (this method must not be called
for blocks not part of a transaction).
*/
void
block_cache::DiscardBlock(cached_block* block)
{
if (block->parent_data != NULL && block->parent_data != block->current_data)
Free(block->parent_data);
block->parent_data = NULL;
if (block->original_data != NULL) {
Free(block->original_data);
block->original_data = NULL;
}
RemoveBlock(block);
}
// runs the deletion of the rows whenever a row is completed
// takes cares of the possibility of a split block
void BlockCollection::DoDeletion( BLOCK_PTR block, int x, int y )
{
m_logger.logTrace( "BlockCollection::DoDeletion( BLOCK_PTR block, int x, int y )" );
// this will point to the southern end of the split block
// if a split becomes necessary
BLOCK_PTR new_block = NULL;
// empty out the completed row
block->EmptyThisRow( y );
// if the block needs to be split in halves, then do so
if( block->IsSplitNeeded( y ) )
{
new_block = block->DoSplit( y );
AddSplitBlock( new_block, block );
}
if( block->IsEmpty() )
RemoveBlock( block );
}
void GoRegionBoard::UpdateBlock(int move, SgBlackWhite moveColor)
{
SgPoint anchor = Board().Anchor(move); // board is already up to date.
bool done = false;
const int size = Board().Size();
if (! Board().IsSingleStone(move)) // find old neighbor blocks
{
SgVectorOf<GoBlock> old;
for (GoNbIterator it(Board(), move); it; ++it)
{
if (IsColor(*it, moveColor))
old.Include(BlockAt(*it));
}
if (old.IsLength(1)) // append to single neighbor block
{
GoBlock* b = old.Front();
AppendStone(b, move);
done = true;
}
else // delete old, recompute
{
for (SgVectorIteratorOf<GoBlock> it(old); it; ++it)
RemoveBlock(*it, true, true);
}
}
if (! done) // create new block.
{
GoBlock* b = GenBlock(anchor, moveColor);
SgPointSet area(b->Stones().Border(size));
// link it to neighbor regions
SgVectorOf<GoRegion> regions;
RegionsAt(area, moveColor, ®ions);
for (SgVectorIteratorOf<GoRegion> it(regions); it; ++it)
(*it)->BlocksNonConst().PushBack(b);
}
}
bool MPEG_File::strip(int tags, bool freeMemory)
{
if( ReadOnly() )
{
wxLogDebug(wxT("MPEG::File::strip() - Cannot strip tags from a read only file."));
return false;
}
if((tags & MPEG_ID3v2) && m_hasId3v2)
{
if( !RemoveBlock(m_id3v2Location, m_id3v2OriginalSize) )
return false;
m_id3v2Location = -1;
m_id3v2OriginalSize = 0;
m_hasId3v2 = false;
if(freeMemory)
{
delete m_id3v2Tag;
m_id3v2Tag = NULL;
m_combinedTag->setID3v2Tag(NULL);
}
// v1 tag location has changed, update if it exists
if(m_id3v1Tag)
{
m_id3v1Location = findID3v1();
}
}
if((tags & MPEG_ID3v1) && m_hasId3v1)
{
Truncate(m_id3v1Location);
m_id3v1Location = -1;
m_hasId3v1 = false;
if(freeMemory)
{
delete m_id3v1Tag;
m_id3v1Tag = NULL;
m_combinedTag->setID3v1Tag(NULL);
}
}
if((tags & MPEG_APE) && m_hasApe)
{
if( !RemoveBlock(m_apeLocation, m_apeOriginalSize) )
return false;
m_apeLocation = -1;
m_hasApe = false;
if(m_hasId3v1)
{
if (m_id3v1Location > m_apeLocation)
m_id3v1Location -= m_apeOriginalSize;
}
if(freeMemory)
{
delete m_apeTag;
m_apeTag = NULL;
m_combinedTag->setAPETag(NULL);
}
}
return true;
}
cs_int32 cs_Tracker(void *ThreadData)
{
cs_int32 err;
cs_int32 size;
cs_int32 block,last,processed,block_count,count,i,mempool_attempt;
cs_char msg[CS_DCT_MAX_PATH];
cs_double start_time;
cs_int32 new_op_return_file;
cs_handle hRecvThread;
cs_uint32 idRecvThread;
cs_int32 restore_block;
cs_RecvThreadData *lpRecvThreadData;
err=CS_ERR_NOERROR;
g_State=NULL;
g_Log=NULL;
g_Connection=NULL;
g_Semaphore=NULL;;
hRecvThread=NULL;
lpRecvThreadData=NULL;
sprintf(msg,"mkdir %s%s",g_Args->m_DataDir,CS_DCT_FOLDER_NEW_TXOUTS);
__US_Shell(msg);
sprintf(msg,"mkdir %s%s",g_Args->m_DataDir,CS_DCT_FOLDER_SPENT_TXOUTS);
__US_Shell(msg);
sprintf(msg,"mkdir %s%s",g_Args->m_DataDir,CS_DCT_FOLDER_OP_RETURN);
__US_Shell(msg);
g_State=new cs_State;
g_State->m_TxOutAdd=new cs_Buffer;
g_State->m_TxOutAdd->Initialize(CS_DCT_CDB_KEY_SIZE,CS_DCT_CDB_KEY_SIZE+CS_DCT_CDB_VALUE_SIZE,0);
g_State->m_TxOutRemove=new cs_Buffer;
g_State->m_TxOutRemove->Initialize(CS_DCT_CDB_KEY_SIZE,CS_DCT_CDB_KEY_SIZE+CS_DCT_CDB_VALUE_SIZE,0);
g_State->m_MemPoolOpReturns=new cs_Buffer;
g_State->m_MemPoolOpReturns->Initialize(CS_DCT_HASH_BYTES,CS_DCT_HASH_BYTES+sizeof(cs_uint32),0);
g_State->m_MemPoolOpReturnsLast=new cs_Buffer;
g_State->m_MemPoolOpReturnsLast->Initialize(CS_DCT_HASH_BYTES,CS_DCT_HASH_BYTES+sizeof(cs_uint32),0);
g_State->m_MemoryPool=new cs_List;
g_State->m_TxAssetMatrix=new cs_Buffer;
g_State->m_TxAssetMatrix->Initialize(0,sizeof(CoinSparkAssetQty),0);
g_State->m_TxAssetList=new cs_Buffer;
g_State->m_TxAssetList->Initialize(CS_DCT_ASSET_ID_SIZE,CS_DCT_ASSET_ID_SIZE,0);
g_State->m_TxAssetTransfers=new cs_Buffer;
g_State->m_TxAssetTransfers->Initialize(0,sizeof(CoinSparkTransfer),0);
g_State->m_TxOutputSatoshis=new cs_Buffer;
g_State->m_TxOutputSatoshis->Initialize(0,sizeof(CoinSparkSatoshiQty),0);
g_State->m_TxOutputRegulars=new cs_Buffer;
g_State->m_TxOutputRegulars->Initialize(0,sizeof(bool),0);
g_State->m_AssetDB=(cs_Database*)ThreadData;
g_Log=cs_LogInitialize(g_Args->m_TrackerLogFile,-1,g_Args->m_TrackerLogFilter,g_Args->m_TrackerLogMode);
cs_LogShift(g_Log);
cs_LogMessage(g_Log,CS_LOG_SYSTEM,"C-0007","Tracker process, Starting...","");
g_Connection=new cs_Connection;
err=g_Connection->Connect(g_Args->m_BitcoinClientAddress,g_Args->m_BitcoinClientPort,-1,-1,0);
if(err)
{
cs_LogMessage(g_Log,CS_LOG_FATAL,"C-0009","Cannot connect to Bitcoin node","");
goto exitlbl;
}
g_Semaphore=__US_SemCreate();
if(g_Semaphore == NULL)
{
cs_LogMessage(g_Log,CS_LOG_FATAL,"C-0010","Cannot create semaphore","");
goto exitlbl;
}
g_ProcessMessage=0;
g_ErrorCode=0;
lpRecvThreadData=new cs_RecvThreadData;
lpRecvThreadData->m_StopFlag=0;
hRecvThread=__US_CreateThread(NULL,0,(void *)TrackerRecvLoop,(void *)(lpRecvThreadData),THREAD_SET_INFORMATION,&idRecvThread);//CREATE_SUSPENDED
if(hRecvThread == NULL)
{
cs_LogMessage(g_Log,CS_LOG_FATAL,"C-0011","Cannot create receiving thread","");
goto exitlbl;
}
g_Message=new cs_Message;
g_Message->Initialize(g_Args,-1);
cs_LogMessage(g_Log,CS_LOG_SYSTEM,"C-0012","Tracker process started","");
size=bitcoin_prepare_message_version(g_Message,0);
err=TrackerProcessAsyncMessage(1);
if(err)
{
cs_LogMessage(g_Log,CS_LOG_FATAL,"C-0013","Version exchange failed","");
goto exitlbl;
}
restore_block=CS_DCT_MEMPOOL_BLOCK;
while(restore_block>=-1)
{
ReadAssetState();
if(err)
{
cs_LogMessage(g_Log,CS_LOG_FATAL,"C-0008","Cannot initialize assetstate","");
goto errorlbl;
}
err=ReadBlockChain();
if(err)
{
cs_LogMessage(g_Log,CS_LOG_FATAL,"C-0014","Cannot initialize blockchain","");
goto errorlbl;
}
sprintf(msg,"%d",g_State->m_BlockChainHeight);
cs_LogMessage(g_Log,CS_LOG_REPORT,"C-0104","Blockchain height:",msg);
UpdateBlockChain();
block=GetRelevantBlockID(0);
processed=0;
new_op_return_file=1;
block_count=CS_DCT_BLOCKS_CHUNK;
cs_initMemPoolOpReturnsLast();
start_time=cs_TimeNow();
while((g_State->m_AssetDB->m_lpHandlerShMem[CS_OFF_DB_SHMEM_HEAD_SIGNAL] == 0) && (cs_TimeNow()-start_time<7200))
{
if(block<=g_State->m_BlockChainHeight)
{
err=RemoveBlock(1);
if(err)
{
sprintf(msg,"Error: %08X",err);
cs_LogMessage(g_Log,CS_LOG_FATAL,"C-0015","Cannot clear memory pool",msg);
goto errorlbl;
}
g_State->m_MemPoolOpReturnsLast->CopyFrom(g_State->m_MemPoolOpReturns);
g_State->m_MemPoolOpReturns->Clear();
new_op_return_file=1;
block=GetRelevantBlockID(0);
last=block+10000;
if(last>g_State->m_BlockChainHeight)
{
last=g_State->m_BlockChainHeight;
}
while(block<=last)
{
count=block_count;
if(count>g_State->m_BlockChainHeight-block+1)
{
count=g_State->m_BlockChainHeight-block+1;
}
err=ProcessBlock(block,count);
if(err)
{
sprintf(msg,"Error: %08X",err);
cs_LogMessage(g_Log,CS_LOG_FATAL,"C-0016","Error while processing block",msg);
goto errorlbl;
}
if(block>=CS_DCT_BLOCK_PURGE_DELAY)
{
for(i=0;i<count;i++)
{
err=PurgeBlock(block+i-CS_DCT_BLOCK_PURGE_DELAY);
if(err)
{
sprintf(msg,"Error: %08X",err);
cs_LogMessage(g_Log,CS_LOG_FATAL,"C-0017","Error while purging block",msg);
goto errorlbl;
}
}
}
if(block/10000 != (block+count)/10000)
{
err=RemoveBlock(1);
cs_BackUp(block+count);
goto exitlbl;
}
processed+=count;
block+=count;
if(g_State->m_AssetDB->m_lpHandlerShMem[CS_OFF_DB_SHMEM_HEAD_SIGNAL])
{
block=last+1;
}
}
}
else
{
__US_Sleep(5000);
}
if(g_State->m_AssetDB->m_lpHandlerShMem[CS_OFF_DB_SHMEM_HEAD_SIGNAL] == 0)
{
if(block>g_State->m_BlockChainHeight)
{
sprintf(msg,"Blockchain height: %d",g_State->m_BlockChainHeight);
cs_LogMessage(g_Log,CS_LOG_MINOR,"C-0056","Processing mempool",msg);
err=RemoveBlock(1);
if(err)
{
sprintf(msg,"Error: %08X",err);
cs_LogMessage(g_Log,CS_LOG_FATAL,"C-0018","Cannot clear memory pool",msg);
goto errorlbl;
}
for(mempool_attempt=0;mempool_attempt<1;mempool_attempt++)
{
err=ProcessMemPool(new_op_return_file);
new_op_return_file=0;
}
if(err)
{
sprintf(msg,"Error: %08X",err);
cs_LogMessage(g_Log,CS_LOG_FATAL,"C-0019","Error while processing mempool",msg);
// goto errorlbl;
err=RemoveBlock(1);
}
}
}
if(g_State->m_AssetDB->m_lpHandlerShMem[CS_OFF_DB_SHMEM_HEAD_SIGNAL] == 0)
{
size=-1;
while(size != g_State->m_BlockChainHeight)
{
size=g_State->m_BlockChainHeight;
UpdateBlockChain();
}
}
}
restore_block=-2;
errorlbl:
if(err == CS_ERR_TIMEOUT)
{
restore_block=-2;
}
if(restore_block>=0)
{
sprintf(msg,"%d",restore_block-1);
cs_LogMessage(g_Log,CS_LOG_REPORT,"C-0105","Trying to restore from height",msg);
err=cs_RestoreFromBackUp(&restore_block);
if(err)
{
sprintf(msg,"Error: %08X",err);
cs_LogMessage(g_Log,CS_LOG_FATAL,"C-0106","Cannot restore",msg);
goto exitlbl;
}
else
{
sprintf(msg,"%d",restore_block);
cs_LogMessage(g_Log,CS_LOG_REPORT,"C-0107","Restoring from height",msg);
}
}
else
{
restore_block=-2;
}
}
err=RemoveBlock(1);
exitlbl:
cs_LogMessage(g_Log,CS_LOG_SYSTEM,"C-0020","Tracker process, Exiting...","");
if(g_Connection)
{
g_Connection->Disconnect();
}
if(hRecvThread)
{
__US_WaitForSingleThread(hRecvThread, INFINITE);
hRecvThread=NULL;
idRecvThread=0;
}
if(g_Semaphore)
{
__US_SemDestroy(g_Semaphore);
g_Semaphore=NULL;
}
if(g_Connection)
{
delete g_Connection;
g_Connection=NULL;
}
if(g_Message)
{
delete g_Message;
g_Message=NULL;
}
if(lpRecvThreadData)
{
delete lpRecvThreadData;
}
if(g_State)
{
g_State->m_AssetDB=NULL;
delete g_State;
g_State=NULL;
}
cs_LogMessage(g_Log,CS_LOG_SYSTEM,"C-0021","Tracker process, Exited","");
cs_LogDestroy(g_Log);
g_Log=NULL;
return err;
}
void GoRegionBoard::OnUndoneMove()
// Called after a move has been undone. The board is guaranteed to be in
// a legal state.
{
//SG_ASSERT(false); // incremental code is incomplete, do not call
if (DEBUG_REGION_BOARD)
SgDebug() << "OnUndoneMove " << '\n';
const bool IS_UNDO = false;
SgVectorOf<GoRegion> changed;
for (int val = m_stack.PopEvent(); val != SG_NEXTMOVE;
val = m_stack.PopEvent())
{
switch (val)
{
case REGION_REMOVE:
{ GoRegion* r = static_cast<GoRegion*>(m_stack.PopPtr());
AddRegion(r, IS_UNDO);
changed.Insert(r);
}
break;
case REGION_ADD:
{ GoRegion* r = static_cast<GoRegion*>(m_stack.PopPtr());
RemoveRegion(r, IS_UNDO);
}
break;
case REGION_REMOVE_BLOCK:
{ GoBlock* b = static_cast<GoBlock*>(m_stack.PopPtr());
AddBlock(b, IS_UNDO);
for (int nu = m_stack.PopInt(); nu > 0; --nu)
{
GoRegion* r = static_cast<GoRegion*>(m_stack.PopPtr());
if (CHECK)
SG_ASSERT(! r->Blocks().Contains(b));
r->BlocksNonConst().PushBack(b);
changed.Insert(r);
}
}
break;
case REGION_ADD_BLOCK:
{ GoBlock* b = static_cast<GoBlock*>(m_stack.PopPtr());
RemoveBlock(b, IS_UNDO, true);
}
break;
case REGION_ADD_STONE:
{ GoRegion* r = static_cast<GoRegion*>(m_stack.PopPtr());
SgPoint p = m_stack.PopInt();
r->OnRemoveStone(p);
m_region[r->Color()][p] = r;
changed.Insert(r);
}
break;
case REGION_ADD_STONE_TO_BLOCK:
{ GoBlock* b = static_cast<GoBlock*>(m_stack.PopPtr());
SgPoint p = m_stack.PopInt();
b->RemoveStone(p);
m_block[p] = 0;
}
break;
default:
SG_ASSERT(false);
}
}
for (SgVectorIteratorOf<GoRegion> it(changed); it; ++it)
{
(*it)->ResetNonBlockFlags();
(*it)->ComputeBasicFlags();
}
if (HEAVYCHECK)
{
for (SgBWIterator it; it; ++it)
{
SgBlackWhite color(*it);
for (SgVectorIteratorOf<GoRegion> it(AllRegions(color)); it; ++it)
{
const GoRegion* r = *it;
SG_UNUSED(r);
SG_ASSERT(r->IsValid());
}
}
}
m_code = Board().GetHashCode();
if (HEAVYCHECK)
CheckConsistency();
}
