public void TestGetFlowGraphInvalidArgumentWithNonNullParent()
{
IOperation parent = new BlockOperation(ImmutableArray <IOperation> .Empty, ImmutableArray <ILocalSymbol> .Empty,
semanticModel: null, syntax: null, isImplicit: false);
TestGetFlowGraphInvalidArgumentCore(argumentExceptionMessage: CodeAnalysisResources.NotARootOperation, parent);
}
public OriginationModel(BlockRpcEntity block, BlockOperation <BlockOriginationContent> transactionOperation, BlockOriginationContent originationContent)
{
BlockHash = block.hash;
BlockLevel = block.header.level;
OperationHash = transactionOperation.hash;
Timestamp = block.header.timestamp;
OriginationContent = originationContent;
}
public BlockInstruction(BlockOperation operation, object parameter)
{
this.operation = operation;
this.parameter = parameter;
}
private void TestGetFlowGraphInvalidArgumentCore(string argumentExceptionMessage, IOperation parent)
{
bool exceptionThrown = false;
try
{
IBlockOperation block = new BlockOperation(
ImmutableArray <IOperation> .Empty, ImmutableArray <ILocalSymbol> .Empty,
semanticModel: null, syntax: null, isImplicit: false);
block = Operation.SetParentOperation(block, parent);
_ = ControlFlowGraph.Create(block);
}
catch (ArgumentException ex)
{
Assert.Equal(new ArgumentException(argumentExceptionMessage, "body").Message, ex.Message);
exceptionThrown = true;
}
Assert.True(exceptionThrown);
exceptionThrown = false;
try
{
IFieldInitializerOperation initializer = new FieldInitializerOperation(
ImmutableArray <IFieldSymbol> .Empty, ImmutableArray <ILocalSymbol> .Empty,
value: null, semanticModel: null,
syntax: null, isImplicit: false);
initializer = Operation.SetParentOperation(initializer, parent);
_ = ControlFlowGraph.Create(initializer);
}
catch (ArgumentException ex)
{
Assert.Equal(new ArgumentException(argumentExceptionMessage, "initializer").Message, ex.Message);
exceptionThrown = true;
}
Assert.True(exceptionThrown);
exceptionThrown = false;
try
{
IPropertyInitializerOperation initializer = new PropertyInitializerOperation(
ImmutableArray <IPropertySymbol> .Empty, ImmutableArray <ILocalSymbol> .Empty,
value: null, semanticModel: null,
syntax: null, isImplicit: false);
initializer = Operation.SetParentOperation(initializer, parent);
_ = ControlFlowGraph.Create(initializer);
}
catch (ArgumentException ex)
{
Assert.Equal(new ArgumentException(argumentExceptionMessage, "initializer").Message, ex.Message);
exceptionThrown = true;
}
Assert.True(exceptionThrown);
exceptionThrown = false;
try
{
IParameterInitializerOperation initializer = new ParameterInitializerOperation(
parameter: null, locals: ImmutableArray <ILocalSymbol> .Empty,
value: null, semanticModel: null,
syntax: null, isImplicit: false);
initializer = Operation.SetParentOperation(initializer, parent);
_ = ControlFlowGraph.Create(initializer);
}
catch (ArgumentException ex)
{
Assert.Equal(new ArgumentException(argumentExceptionMessage, "initializer").Message, ex.Message);
exceptionThrown = true;
}
Assert.True(exceptionThrown);
exceptionThrown = false;
try
{
IConstructorBodyOperation constructorBody = new ConstructorBodyOperation(
ImmutableArray <ILocalSymbol> .Empty,
initializer: null,
blockBody: null,
expressionBody: null,
semanticModel: null,
syntax: null,
isImplicit: false);
constructorBody = Operation.SetParentOperation(constructorBody, parent);
_ = ControlFlowGraph.Create(constructorBody);
}
catch (ArgumentException ex)
{
Assert.Equal(new ArgumentException(argumentExceptionMessage, "constructorBody").Message, ex.Message);
exceptionThrown = true;
}
Assert.True(exceptionThrown);
exceptionThrown = false;
try
{
IMethodBodyOperation methodBody = new MethodBodyOperation(
blockBody: null,
expressionBody: null,
semanticModel: null,
syntax: null,
isImplicit: false);
methodBody = Operation.SetParentOperation(methodBody, parent);
_ = ControlFlowGraph.Create(methodBody);
}
catch (ArgumentException ex)
{
Assert.Equal(new ArgumentException(argumentExceptionMessage, "methodBody").Message, ex.Message);
exceptionThrown = true;
}
Assert.True(exceptionThrown);
exceptionThrown = false;
}
/// <summary>
/// Looks to see if the block is in the cache. if it is, it performs
/// the cache hit operation on the data. If the block was not in the cache
/// it pulls the block holder out of the cache so that no other thread can
/// access the block. It then performs the blocking read/write disk i/o
/// after giving up all locks. Finally it gets the locks again to insert
/// the new block back into the cache
/// </summary>
/// <param name="cacheHit">Operation to perform if the block is in cache (cannot block)</param>
/// <param name="chacheMiss">Operation to perform if the block is not in cache (can block)</param>
private int PerformBlockOperation(int blockNum,
BlockOperation cacheHit, BlockOperation chacheMiss)
{
BlockHolder bh = null;
bool success = false;
do
{
lock (m_cache)
{
bh = GetHolderForBlockNumInCache(blockNum);
if (bh == null)
{
// the block is not in cache
while (m_cache.Count == 0)
{
// condition wait on the cache until there is a block in
// the cache we can read into. This is a very rare case.
// It would only happen if more threads were waiting on
// the cache than there were spaces for blocks in the cache
}
// remove the oldest thing on the cache.
lock (m_diskQueue)
{
if (!m_diskQueue.Contains(blockNum))
{
bh = GetOldestCacheItem();
m_diskQueue.Add(blockNum);
}
else
{
// someone else is already fetching this block from disk.
// After we release the lock
}
}
}
else
{
// the block is in the cache, so just perform the operation,
// and update it's position to maintain LRU semantics
cacheHit(bh);
UpdateLastUsedTime(bh);
success = true;
}
}// unlock cache
if (!success)
{
if (bh == null)
{
// if we missed the cache (i.e. !success) and the holder is null
// it means another thread is fetching that block from disk.
lock (m_diskQueue)
{
while (m_diskQueue.Contains(blockNum))
{
// condition wait on m_diskQueue
}
}
// If we get here the block should be in the cache (at least for now)
// success is still false, so we'll loop in this method and hopefully
// get a cache hit, or else work on getting the block again.
}
else
{
// The holder is now isolated, so we can make all the blocking calls we want
chacheMiss(bh);
lock (m_cache)
{
lock (m_diskQueue)
{
AddMostRecentlyUsed(bh);
m_diskQueue.Remove(bh.BlockNum);
// broadcast on the condition variable associated with m_diskQueue
}
success = true;
}
}
}
} while (!success);
return(0);
}
public BlockInstruction(BlockOperation operation, object parameter)
{
this.operation = operation;
this.parameter = parameter;
}
