public ScopeManager()
{
string key = DomainItem.CheckName(AppScopeNames.Legacy);
_dict.Locked(dict => dict.Add(key, new DomainItem()));
_defaultDomain = AppScopeNames.Legacy;
}
private void ReceiveTradeValuationResult(HandlerResponse pvRes)
{
var requestId = new Guid(pvRes.RequestId);
// ignore requests if we are not running
if (GetState() != BasicServerState.Running)
{
return;
}
_outstandingRequests.Locked(requests =>
{
InternalTradeRevalRequest request;
if (requests.TryGetValue(requestId, out request))
{
// exists
request.LatestResult = pvRes;
}
else
{
// not found
request = new InternalTradeRevalRequest(requestId, pvRes);
requests[requestId] = request;
}
});
// dispatch worker request
_workerEventQueue.Dispatch(null);
}
/// <summary>
/// The attach method.
/// </summary>
/// <param name="name"></param>
/// <param name="part"></param>
public void Attach(string name, IServerPart part)
{
if (part != null)
{
_attachedParts.Locked((attachedParts) => attachedParts[name] = part);
//Logger.LogDebug("ServerPart '{0}' attached.", name);
OnAttached(name, part);
}
//else
// Logger.LogDebug("ServerPart '{0}' not attached.", name);
}
public void Enqueue(IAsyncResult asyncOperation)
{
_queue.Locked(queue =>
{
queue.Enqueue(asyncOperation);
while (queue.Count > _maxQueueLength)
{
IAsyncResult ar = queue.Dequeue();
((AsyncResultNoResult)ar).EndInvoke();
}
});
}
public ProviderRuleSet ExportRules()
{
var list = new List <QRMarketDataMap>();
_rules.Locked(rules =>
{
foreach (MapRule rule in rules)
{
list.Add(new QRMarketDataMap
{
dictType = rule.DictType,
disabled = rule.Disabled,
priority = rule.Priority,
requestType = rule.RequestType,
sourceProvider = rule.SourceProvider,
targetProvider = rule.TargetProvider,
sourcePattern = rule.SearchValue,
outputValue = rule.OutputValue
});
}
});
return(new ProviderRuleSet {
provider = _provider, rules = list.ToArray()
});
}
protected override void OnStatsTimeoutReportDeltas()
{
base.OnStatsTimeoutReportDeltas();
int pendingInserts = 0;
int pendingDeletes = 0;
long completedOps = 0;
long dbExceptions = 0;
_state.Locked(state =>
{
pendingInserts = state.InsertQueue.Count;
pendingDeletes = state.DeleteQueue.Count;
dbExceptions = state.ExceptionCount;
completedOps = state.CompletedCount;
});
Logger.LogDebug("Enqueued operations : {0}", _inboundCallQueue.Length);
Logger.LogDebug("Pending insert ops : {0}", pendingInserts);
Logger.LogDebug("Pending delete ops : {0}", pendingDeletes);
Logger.LogDebug("Completed operations: {0}", completedOps);
Logger.LogDebug("Database exceptions : {0}", dbExceptions);
}
private void ReceivePortfolioValuationResult(ServerRequestStatus pvRes)
{
Guid requestId = new Guid(pvRes.RequestId);
_OutstandingRequests.Locked((requests) =>
{
InternalRequest request;
if (requests.TryGetValue(requestId, out request))
{
// exists
request.LatestResult = pvRes;
}
else
{
// not found
request = new InternalRequest(requestId, pvRes);
requests[requestId] = request;
}
});
// dispatch worker request
EnqueueWorkerRequest();
}
public void ProcessItems()
{
int count = Interlocked.Decrement(ref _queuedCalls);
// exit if there are more callbacks following us
if (count % 10000 == 0)
{
_loggerRef.Target.LogDebug("ProcessItems: Queued calls remaining: {0}", count);
}
if (count != 0)
{
return;
}
// start updating the display
treeNavigation.BeginUpdate();
ICoreItem item = null;
_queuedItems.Locked(queue =>
{
if (queue.Count > 0)
{
item = queue.Dequeue();
}
});
while (item != null)
{
// add item to navigation tree
TreeNode[] rootNodes = null;
switch (item.ItemKind)
{
case ItemKind.Object:
rootNodes = treeNavigation.Nodes.Find("Objects", false);
break;
case ItemKind.Debug:
rootNodes = treeNavigation.Nodes.Find("Debug", false);
break;
//case ItemKind.Signal:
// rootNodes = treeNavigation.Nodes.Find("Signals", false);
// break;
}
if (rootNodes != null)
{
TreeNode parentNode = rootNodes[0];
TreeNode thisNode = null;
string[] itemNameParts = item.Name.Split('.');
foreach (string itemNamePart in itemNameParts)
{
TreeNode[] nodes = parentNode.Nodes.Find(itemNamePart, false);
if (nodes.Length == 0)
{
// not found - add node at this level
thisNode = parentNode.Nodes.Insert(FindIndex(parentNode.Nodes, itemNamePart), itemNamePart);
thisNode.Name = itemNamePart;
}
else
{
// found
thisNode = nodes[0];
}
// next
parentNode = thisNode;
}
if (thisNode != null)
{
thisNode.Tag = item;
}
}
if (item.Name == _navDetailSubject)
{
DisplayItemInNavDetail(item);
}
item = null;
_queuedItems.Locked(queue =>
{
if (queue.Count > 0)
{
item = queue.Dequeue();
}
});
}
treeNavigation.EndUpdate();
}
internal void Enqueue(DispatcherItem item)
{
_Queue.Locked((queue) => queue.Enqueue(item));
ThreadPool.QueueUserWorkItem(AsyncProcessNode, null);
}
private void ProcessRequests(object notUsed)
{
try
{
// process rules and run handlers as required
BasicServerState state = this.GetState();
if (state != BasicServerState.Running)
{
return;
}
// subscription is ready and callback flood has stopped
List <InternalRequest> existingRequests = new List <InternalRequest>();
List <InternalRequest> enqueuedRequests = new List <InternalRequest>();
List <InternalRequest> cancelledRequests = new List <InternalRequest>();
var requestItems = _AssignedRequestsCache.Items;
var cancellationItems = _CancellationsCache.Items;
var responseItems = _WorkerResponseCache.Items;
_InternalRequests.Locked((internalRequests) =>
{
// - process responses
foreach (ICoreItem item in responseItems)
{
try
{
WorkerResponse response = (WorkerResponse)item.Data;
Guid requestId = Guid.Parse(response.RequestId);
InternalRequest internalRequest;
if (!internalRequests.TryGetValue(requestId, out internalRequest))
{
internalRequest = new InternalRequest(requestId);
}
internalRequest.Status = response.Status;
internalRequests[requestId] = internalRequest;
}
catch (Exception excp)
{
Logger.Log(excp);
}
}
// - process requests
foreach (ICoreItem item in requestItems)
{
try
{
AssignedWorkflowRequest request = (AssignedWorkflowRequest)item.Data;
Guid requestId = Guid.Parse(request.RequestId);
InternalRequest internalRequest;
if (!internalRequests.TryGetValue(requestId, out internalRequest))
{
internalRequest = new InternalRequest(requestId);
}
internalRequest.ExternalRequest = request;
internalRequests[requestId] = internalRequest;
}
catch (Exception excp)
{
Logger.Log(excp);
}
}
// - process cancellations
foreach (ICoreItem item in cancellationItems)
{
try
{
CancellationRequest cancellation = (CancellationRequest)item.Data;
Guid requestId = Guid.Parse(cancellation.RequestId);
InternalRequest internalRequest;
if (!internalRequests.TryGetValue(requestId, out internalRequest))
{
internalRequest = new InternalRequest(requestId);
}
internalRequest.Cancellation = cancellation;
internalRequests[requestId] = internalRequest;
}
catch (Exception excp)
{
Logger.Log(excp);
}
}
// determine requests to be launched or cancelled
foreach (InternalRequest internalRequest in internalRequests.Values)
{
if ((internalRequest.ExternalRequest != null) &&
((internalRequest.Status == RequestStatusEnum.Undefined) || (internalRequest.Status == RequestStatusEnum.Enqueued)))
{
// find requests to launch
if (internalRequest.Cancellation == null)
{
if (internalRequest.Status != RequestStatusEnum.Enqueued)
{
// new request
internalRequest.Status = RequestStatusEnum.Enqueued;
enqueuedRequests.Add(internalRequest);
}
existingRequests.Add(internalRequest);
}
else
{
// cancelled
internalRequest.Status = RequestStatusEnum.Cancelled;
cancelledRequests.Add(internalRequest);
}
}
}
});
// publish status for cancelled and enqueued requests
foreach (InternalRequest request in cancelledRequests)
{
PublishWorkerResponse(_IntClient.Target, request, HostInstance);
}
// now find handlers to launch
foreach (InternalRequest request in enqueuedRequests)
{
// publish enqueued status
PublishWorkerResponse(_IntClient.Target, request, HostInstance);
}
foreach (InternalRequest request in existingRequests)
{
// launch if handler available
int count = Interlocked.Decrement(ref _HandlersAvailable);
if (count >= 0)
{
Interlocked.Increment(ref _AvailabilityChangeCount);
Interlocked.Increment(ref _HandlersExecuting);
// publish launched status
request.Status = RequestStatusEnum.Launched;
PublishWorkerResponse(_IntClient.Target, request, HostInstance);
// launch
ThreadPool.QueueUserWorkItem(Launch, new LaunchPackage(_IntClient, request));
}
else
{
Interlocked.Increment(ref _HandlersAvailable);
}
}
// publish availability (throttled)
int changeCount = Interlocked.Exchange(ref _AvailabilityChangeCount, 0);
if ((changeCount > 0) || ((DateTimeOffset.Now - _AvailabilityLastPublished) > TimeSpan.FromSeconds(5)))
{
_IntClient.Target.SaveObject <WorkerAvailability>(new WorkerAvailability()
{
WorkerHostComputer = Environment.MachineName,
WorkerHostInstance = this.HostInstance,
AvailableNodeCount = Interlocked.Add(ref _HandlersAvailable, 0)
});
_AvailabilityLastPublished = DateTimeOffset.Now;
}
}
catch (Exception e)
{
Logger.Log(e);
}
}
public void ProcessItems()
{
int count = Interlocked.Decrement(ref _queuedCalls);
// exit if there are more callbacks following us
if (count % 10000 == 0)
{
_loggerRef.Target.LogDebug("ProcessItems: Queued calls remaining: {0}", count);
}
if (count != 0)
{
return;
}
ICoreItem item = null;
_queuedItems.Locked(queue =>
{
if (queue.Count > 0)
{
item = queue.Dequeue();
}
});
while (item != null)
{
if (item.Data is QuotedAssetSet)
{
var nameSpace = item.AppProps.GetValue <string>(EnvironmentProp.NameSpace);
var marketName = item.AppProps.GetValue <string>(CurveProp.MarketAndDate);
var curveType = item.AppProps.GetValue <string>(CurveProp.PricingStructureType);
var curveName = item.AppProps.GetValue <string>(CurveProp.CurveName);
var curveGenRequest = new OrdinaryCurveGenRequest
{
NameSpace = nameSpace,
BaseDate = DateTime.Now,
RequestId = Guid.NewGuid().ToString(),
RequesterId = new UserIdentity
{
Name = _clientRef.Target.ClientInfo.Name,
DisplayName = _clientRef.Target.ClientInfo.UserFullName
},
UseSavedMarketData = true,
ForceGenerateEODCurves = true,
CurveSelector = new[] { new CurveSelection
{
NameSpace = nameSpace,
MarketName = marketName,
CurveType = curveType,
CurveName = curveName
} }
};
IWorkContext context = new WorkContext(_loggerRef.Target, _clientRef.Target, "DEV");
using (var workflow = new WFGenerateOrdinaryCurve())
{
workflow.Initialise(context);
WorkflowOutput <HandlerResponse> output = workflow.Execute(curveGenRequest);
WorkflowHelper.ThrowErrors(output.Errors);
}
item = null;
_queuedItems.Locked(queue =>
{
if (queue.Count > 0)
{
item = queue.Dequeue();
}
});
}
}
}
/// <summary>
/// </summary>
public ICoreClient Create(string instanceName)
{
string cacheKey = null;
string env = null;
string servers = null;
string protocols = null;
bool debugRequests = false;
TimeSpan requestTimeout = TimeSpan.Zero;
TimeSpan offlineTimeout = TimeSpan.Zero;
CoreModeEnum coreMode = CoreModeEnum.Standard;
Assembly applAssembly = null;
bool useFallbackServers = true;
//bool cacheEnabled = false;
_factoryState.Locked(state =>
{
useFallbackServers = state.UseFallbackServers;
//cacheEnabled = state.CacheEnabled;
env = state.Env;
servers = state.Servers;
protocols = state.Protocols;
debugRequests = state.DebugRequests;
requestTimeout = state.RequestTimeout;
offlineTimeout = state.OfflineTimeout;
coreMode = state.CoreMode;
applAssembly = state.ApplAssembly;
cacheKey = $"[{env}][{(protocols ?? "").ToLower()}][{(servers ?? "").ToLower()}]";
if (state.SettingsCache.TryGetValue(cacheKey, out var cachedSettings))
{
env = cachedSettings.Env;
servers = $"{cachedSettings.ServerAddress.Host}:{cachedSettings.ServerAddress.Port}";
protocols = cachedSettings.ServerAddress.Protocol;
useFallbackServers = false;
debugRequests = cachedSettings.DebugRequests;
requestTimeout = cachedSettings.RequestTimeout;
offlineTimeout = cachedSettings.OfflineTimeout;
coreMode = cachedSettings.CoreMode;
applAssembly = cachedSettings.ApplAssembly;
//_Logger.LogDebug("Using cached settings: {0} --> {1}://{2}", cacheKey, scheme, servers);
}
});
ICoreClient client = new CoreClient(
_loggerRef, instanceName, env, servers, protocols, useFallbackServers, debugRequests,
requestTimeout, offlineTimeout, coreMode, applAssembly);
// save settings
_factoryState.Locked(state =>
{
state.SettingsCache[cacheKey] = new ClientSettings
{
Env = EnvHelper.EnvName(client.ClientInfo.ConfigEnv),
ServerAddress = client.ServerAddress,
DebugRequests = debugRequests,
RequestTimeout = requestTimeout,
OfflineTimeout = offlineTimeout,
CoreMode = coreMode,
ApplAssembly = applAssembly
};
});
return(client);
}
/// <summary>
/// Constructs a modifiable <see cref="NamedValueSet"/> by copying another.
/// </summary>
/// <param name="nvs">The NVS.</param>
public NamedValueSet(NamedValueSet nvs)
{
// constructs by cloning another
if (nvs != null)
{
_dict.Locked(dict =>
{
foreach (NamedValue nv in nvs.ToColl())
{
dict[nv.Name.ToLowerInvariant()] = nv;
}
});
}
}
public void ProcessItems()
{
int count = Interlocked.Decrement(ref _queuedCalls);
// exit if there are more callbacks following us
//if (count % 10000 == 0)
_loggerRef.Target.LogDebug("ProcessItems: Queued calls remaining: {0}", count);
if (count != 0)
{
return;
}
ICoreItem item = null;
_queuedItems.Locked(queue =>
{
if (queue.Count > 0)
{
item = queue.Dequeue();
}
});
while (item != null)
{
var qas = item.Data as QuotedAssetSet;
if (qas != null)
{
// 1. Get the property values that uniquely identify the curves to refresh.
// This is the process for the workflow request. Alternatively, a direct build of the curve can occur.
//
var nameSpace = item.AppProps.GetValue <string>(EnvironmentProp.NameSpace);
var market = item.AppProps.GetValue <string>(CurveProp.Market);//For real time use Market and not MarketAndDate
var curveType = item.AppProps.GetValue <string>(CurveProp.PricingStructureType);
var curveName = item.AppProps.GetValue <string>(CurveProp.CurveName);
var configIdentifier = FunctionProp.Configuration + ".PricingStructures." + market + "." + curveType + "." + curveName;
var identifier = FunctionProp.Market + "." + market + "." + curveType + "." + curveName;
List <ICoreItem> items = null;
// 2.Check if the dependent curves should be refreshed
//
if (chkBoxDependentCurves.Checked)
{
//Find all the QAS's where the ReferenceCurveName is equal to the curveType.curveName!
var requestProperties = new NamedValueSet();
requestProperties.Set(EnvironmentProp.NameSpace, NameSpace);
requestProperties.Set(CurveProp.Market, market);
requestProperties.Set(EnvironmentProp.Function, FunctionProp.Configuration);
requestProperties.Set(CurveProp.ReferenceCurveName, curveType + '.' + curveName);
IExpression queryExpr = Expr.BoolAND(requestProperties);
_loggerRef.Target.LogDebug("Dependent curve property request set at {0}", DateTime.Now.ToLongTimeString());
items = _cache.LoadItems <Market>(queryExpr);
}
// 3. If the build is a local build then use the curve engine.
//
if (!chkBoxWorkflow.Checked)
{
_loggerRef.Target.LogDebug("Request to build base curve {0} locally at : {1}", identifier,
DateTime.Now.ToLongTimeString());
var curve = CurveEngine.RefreshPricingStructureFromConfiguration(_loggerRef.Target, _cache, nameSpace, configIdentifier, identifier, qas, DateTime.Now, DateTime.Now);
_loggerRef.Target.LogDebug("Built the base curve {0} locally at : {1}", curve,
DateTime.Now.ToLongTimeString());
if (items != null)
{
foreach (var dataItem in items)
{
var spreadCurve = dataItem.Data as Market;
if (spreadCurve == null)
{
continue;
}
//var bootstrap = dataItem.AppProps.GetValue<bool>(CurveProp.BootStrap, false);
//if (!bootstrap) { dataItem.AppProps.Set(CurveProp.BootStrap, true); }
try
{
var curveId = spreadCurve.id;
if (String.IsNullOrEmpty(curveId))
{
curveId = spreadCurve.Items[0].id;
//use yieldCurve.id, CurveGen 1.X compatible
}
dataItem.AppProps.Set(CurveProp.BaseDate, DateTime.Now);
dataItem.AppProps.Set(CurveProp.BuildDateTime, DateTime.Now);
var marketData =
new Pair <PricingStructure, PricingStructureValuation>(spreadCurve.Items[0],
spreadCurve.Items1[0]);
var ps = PricingStructureFactory.Create(_loggerRef.Target, _cache, nameSpace, null, null,
marketData, dataItem.AppProps);
if (ps != null)
{
CurveEngine.SaveCurve(_cache, nameSpace, ps);
}
_loggerRef.Target.LogDebug("Built the spread curve {0} locally at : {1}",
curveId,
DateTime.Now.ToLongTimeString());
}
catch (Exception e)
{
_loggerRef.Target.LogDebug(e.ToString());
}
}
}
}
else
{
// 4. Set the parameters for the work request.
//
var curveGenRequest = new OrdinaryCurveGenRequest
{
NameSpace = nameSpace,
BaseDate = DateTime.Now,
RequestId = Guid.NewGuid().ToString(),
RequesterId = new UserIdentity
{
Name = _cache.ClientInfo.Name,
DisplayName = _cache.ClientInfo.UserFullName
//Name = _clientRef.Target.ClientInfo.Name,
//DisplayName = _clientRef.Target.ClientInfo.UserFullName
},
UseSavedMarketData = true,
ForceGenerateEODCurves = true
};
// 5. Set the base curve in the curve selection for the work request.
//
var curveSelector = new List <CurveSelection>
{
new CurveSelection
{
NameSpace = nameSpace,
MarketName = market,
CurveType = curveType,
CurveName = curveName
}
};
// 6.Include all other dependent curvenames i.e. spread curves.
//
if (items != null)
{
curveSelector.AddRange(from childCurve in items
let spreadCurveType =
childCurve.AppProps.GetValue <string>(
CurveProp.PricingStructureType)
let spreadCurveName =
childCurve.AppProps.GetValue <string>(CurveProp.CurveName)
select new CurveSelection
{
NameSpace = nameSpace,
MarketName = market,
CurveType = spreadCurveType,
CurveName = spreadCurveName
});
}
curveGenRequest.CurveSelector = curveSelector.ToArray();
// 7. Set the actual work request.
//
IWorkContext context = new WorkContext(_loggerRef.Target, _cache, "DEV");
//IWorkContext context = new WorkContext(_loggerRef.Target, _clientRef.Target, "DEV");
_loggerRef.Target.LogDebug("WorkContext set at {0}", DateTime.Now.ToLongTimeString());
using (var workflow = new WFGenerateOrdinaryCurve())
{
workflow.Initialise(context);
WorkflowOutput <HandlerResponse> output = workflow.Execute(curveGenRequest);
WorkflowHelper.ThrowErrors(output.Errors);
foreach (var error in output.Errors)
{
_loggerRef.Target.LogInfo("WorkFlow error: {0} at {1}", error.Message, DateTime.Now.ToLongTimeString());
}
}
_loggerRef.Target.LogDebug("WorkFlow executed at {0}", DateTime.Now.ToLongTimeString());
//item = null;
//_queuedItems.Locked(queue =>
// {
// if (queue.Count > 0)
// item = queue.Dequeue();
// });
}
}
}
}
public void TestObjectLockPerformance()
{
bool _IsSingleCore = (Environment.ProcessorCount == 1);
//---------------------------------------------------------------
{
object target = new object();
Stopwatch sw = new Stopwatch();
sw.Start();
int lockedCount = 0;
for (int i = 0; i < TestIterations; i++)
{
lock (target)
{
lockedCount++;
}
}
sw.Stop();
Debug.Print("BenchmarkC#LockPattern : {0} seconds, {1} locks/ms",
sw.Elapsed.TotalSeconds, lockedCount / sw.ElapsedMilliseconds);
}
//---------------------------------------------------------------
// ----------- this is the lowest overhead technique ------------
//---------------------------------------------------------------
{
Stopwatch sw = new Stopwatch();
sw.Start();
int lockedCount = 0;
int _Spinlock = 0;
for (int i = 0; i < TestIterations; i++)
{
while (Interlocked.CompareExchange(ref _Spinlock, 1, 0) != 0)
{
if (_IsSingleCore)
{
Thread.Sleep(0);
}
}
try
{
lockedCount++;
}
finally
{
Interlocked.Exchange(ref _Spinlock, 0);
}
}
sw.Stop();
Debug.Print("InlineInterlockedInt32 : {0} seconds, {1} locks/ms",
sw.Elapsed.TotalSeconds, lockedCount / sw.ElapsedMilliseconds);
}
//---------------------------------------------------------------
{
object target = new object();
Stopwatch sw = new Stopwatch();
sw.Start();
int lockedCount = 0;
for (int i = 0; i < TestIterations; i++)
{
Monitor.Enter(target);
try
{
lockedCount++;
}
finally
{
Monitor.Exit(target);
}
}
sw.Stop();
Debug.Print("SystemMonitorEnterExit : {0} seconds, {1} locks/ms",
sw.Elapsed.TotalSeconds, lockedCount / sw.ElapsedMilliseconds);
}
//---------------------------------------------------------------
{
object target = new object();
Stopwatch sw = new Stopwatch();
sw.Start();
int lockedCount = 0;
for (int i = 0; i < TestIterations; i++)
{
int spinCount = 0;
object lockedObject = null;
while ((lockedObject = Interlocked.Exchange <object>(ref target, null)) == null)
{
if (_IsSingleCore)
{
Thread.Sleep(0);
}
else
{
spinCount++;
if (spinCount % 4000 == 0)
{
Thread.Sleep(0);
}
}
}
try
{
lockedCount++;
}
finally
{
Interlocked.Exchange <object>(ref target, lockedObject);
}
}
sw.Stop();
Debug.Print("InlineInterlockedObject: {0} seconds, {1} locks/ms",
sw.Elapsed.TotalSeconds, lockedCount / sw.ElapsedMilliseconds);
}
//---------------------------------------------------------------
{
SpinLock spinlockFast = new SpinLock(false);
Stopwatch sw = new Stopwatch();
sw.Start();
int lockedCount = 0;
for (int i = 0; i < TestIterations; i++)
{
bool lockTaken = false;
while (!lockTaken)
{
spinlockFast.Enter(ref lockTaken);
try
{
if (lockTaken)
{
lockedCount++;
}
}
finally
{
if (lockTaken)
{
spinlockFast.Exit();
}
}
}
}
sw.Stop();
Debug.Print("Net4SpinlockPatternFast: {0} seconds, {1} locks/ms",
sw.Elapsed.TotalSeconds, lockedCount / sw.ElapsedMilliseconds);
}
//---------------------------------------------------------------
{
SpinLock spinlockSlow = new SpinLock(true);
Stopwatch sw = new Stopwatch();
sw.Start();
int lockedCount = 0;
for (int i = 0; i < TestIterations; i++)
{
bool lockTaken = false;
while (!lockTaken)
{
spinlockSlow.Enter(ref lockTaken);
try
{
if (lockTaken)
{
lockedCount++;
}
}
finally
{
if (lockTaken)
{
spinlockSlow.Exit();
}
}
}
}
sw.Stop();
Debug.Print("Net4SpinlockPatternSlow: {0} seconds, {1} locks/ms",
sw.Elapsed.TotalSeconds, lockedCount / sw.ElapsedMilliseconds);
}
//---------------------------------------------------------------
{
object target = new object();
Stopwatch sw = new Stopwatch();
sw.Start();
int lockedCount = 0;
for (int i = 0; i < TestIterations; i++)
{
object lockedObject = ObjectLock <object> .Enter(ref target);
try
{
lockedCount++;
}
finally
{
ObjectLock <object> .Leave(ref target, lockedObject);
}
}
sw.Stop();
Debug.Print("EnterLeaveCallsPattern : {0} seconds, {1} locks/ms",
sw.Elapsed.TotalSeconds, lockedCount / sw.ElapsedMilliseconds);
}
//---------------------------------------------------------------
{
object target = new object();
Stopwatch sw = new Stopwatch();
sw.Start();
int lockedCount = 0;
for (int i = 0; i < TestIterations; i++)
{
ObjectLock <object> .Protect(ref target, delegate(object lockedObject)
{
lockedCount++;
});
}
sw.Stop();
Debug.Print("LockedDelegatePattern : {0} seconds, {1} locks/ms",
sw.Elapsed.TotalSeconds, lockedCount / sw.ElapsedMilliseconds);
}
//---------------------------------------------------------------
{
object target = new object();
Guarded <object> wrapper = new Guarded <object>(target);
Stopwatch sw = new Stopwatch();
sw.Start();
int lockedCount = 0;
for (int i = 0; i < TestIterations; i++)
{
//int n = (i % TargetObjects);
wrapper.Locked((lockedObject) =>
{
lockedCount++;
});
}
sw.Stop();
Debug.Print("GuardedWrapperPattern : {0} seconds, {1} locks/ms",
sw.Elapsed.TotalSeconds, lockedCount / sw.ElapsedMilliseconds);
}
}
public void SetValue(Guid value)
{
_State.Locked((state) => state.Value = value);
}
private void ProcessRequests(object notUsed)
{
try
{
BasicServerState state = this.GetState();
if (state != BasicServerState.Running)
{
return;
}
List <InternalRequest> existingRequests = new List <InternalRequest>();
List <InternalRequest> receivedRequests = new List <InternalRequest>();
List <InternalRequest> cancelledRequests = new List <InternalRequest>();
//Dictionary<string, InternalAvailability> availableWorkers = new Dictionary<string, InternalAvailability>();
_State.Locked((managerState) =>
{
// - process responses
foreach (ICoreItem item in _ManagerResponseCache.Items)
{
try
{
ManagerResponse response = (ManagerResponse)item.Data;
Guid requestId = Guid.Parse(response.RequestId);
InternalRequest internalRequest;
if (!managerState.InternalRequests.TryGetValue(requestId, out internalRequest))
{
internalRequest = new InternalRequest(requestId);
}
internalRequest.Status = response.Status;
managerState.InternalRequests[requestId] = internalRequest;
}
catch (Exception excp)
{
Logger.Log(excp);
}
}
// - process requests
foreach (ICoreItem item in _UnassignedRequestsCache.Items)
{
try
{
UnassignedWorkflowRequest request = (UnassignedWorkflowRequest)item.Data;
Guid requestId = Guid.Parse(request.RequestId);
InternalRequest internalRequest;
if (!managerState.InternalRequests.TryGetValue(requestId, out internalRequest))
{
internalRequest = new InternalRequest(requestId);
}
internalRequest.ExternalRequest = request;
managerState.InternalRequests[requestId] = internalRequest;
}
catch (Exception excp)
{
Logger.Log(excp);
}
}
// - process cancellations
foreach (ICoreItem item in _CancellationsCache.Items)
{
try
{
CancellationRequest cancellation = (CancellationRequest)item.Data;
Guid requestId = Guid.Parse(cancellation.RequestId);
InternalRequest internalRequest;
if (!managerState.InternalRequests.TryGetValue(requestId, out internalRequest))
{
internalRequest = new InternalRequest(requestId);
}
internalRequest.Cancellation = cancellation;
managerState.InternalRequests[requestId] = internalRequest;
}
catch (Exception excp)
{
Logger.Log(excp);
}
}
// determine requests to be launched or cancelled
foreach (InternalRequest internalRequest in managerState.InternalRequests.Values)
{
if ((internalRequest.ExternalRequest != null) &&
((internalRequest.Status == RequestStatusEnum.Undefined) || (internalRequest.Status == RequestStatusEnum.Received)))
{
// find requests to launch
if (internalRequest.Cancellation == null)
{
if (internalRequest.Status != RequestStatusEnum.Received)
{
// new request
internalRequest.Status = RequestStatusEnum.Received;
receivedRequests.Add(internalRequest);
}
existingRequests.Add(internalRequest);
}
else
{
// cancelled
internalRequest.Status = RequestStatusEnum.Cancelled;
cancelledRequests.Add(internalRequest);
}
}
}
});
// publish cancelled requests
foreach (InternalRequest request in cancelledRequests)
{
PublishManagerResponse(_IntClient.Target, request);
}
// publish received status
foreach (InternalRequest request in receivedRequests)
{
PublishManagerResponse(_IntClient.Target, request);
}
// find available workers for received requests
//Logger.LogDebug("Assigning {0} requests ...", existingRequests.Count);
foreach (InternalRequest request in existingRequests)
{
//Logger.LogDebug("----- Request: {0}", request.RequestId);
WorkerAvailability chosenWorker = null;
int highestAvailability = 0;
foreach (var item in _WorkerAvailabilityCache.Items)
{
WorkerAvailability worker = (WorkerAvailability)item.Data;
//Logger.LogDebug("----- Worker: {0} ({1})", worker.PrivateKey, worker.AvailableNodeCount);
if (worker.AvailableNodeCount > highestAvailability)
{
highestAvailability = worker.AvailableNodeCount;
chosenWorker = worker;
}
}
// exit if no workers available
if (chosenWorker == null)
{
break;
}
Logger.LogDebug("Assigned request '{0}' to {1} ({2})", request.RequestId, chosenWorker.PrivateKey, chosenWorker.AvailableNodeCount);
chosenWorker.AvailableNodeCount = chosenWorker.AvailableNodeCount - 1;
// publish assigned status
request.Status = RequestStatusEnum.Assigned;
PublishManagerResponse(_IntClient.Target, request);
// reassign to worker
RequestBase.TransferToWorker(_IntClient.Target, request.ExternalRequest, chosenWorker.WorkerHostComputer, chosenWorker.WorkerHostInstance);
}
//Logger.LogDebug("Assigned.");
}
catch (Exception e)
{
Logger.Log(e);
}
}