private RowAggregateData GetGroupAggregateData(string appName, AppResourceGroupInfo group, ulong totalProcessPrivateCommit)
{
Debug.WriteLine("GetGroupAggregateData: app: {0}, group: {1}", appName, group.InstanceId);
ulong commitLimit = 0;
ulong totalCommit = 0;
ulong privateCommit = 0;
ExecutionStateEx executionState = ExecutionStateEx.Unknown;
EnergyQuotaStateEx energyState = EnergyQuotaStateEx.Unknown;
int bgTaskCount = 0;
try
{
AppResourceGroupMemoryReport mReport = group.GetMemoryReport();
if (mReport != null)
{
commitLimit = mReport.CommitUsageLimit;
totalCommit = mReport.TotalCommitUsage;
privateCommit = mReport.PrivateCommitUsage;
}
}
catch (Exception ex)
{
Debug.WriteLine("GetMemoryReport: " + ex.ToString());
}
// The resource group Private Commit should always be the same (or almost the same) as the PDI Private Commit.
Debug.WriteLine("Private Commit: ResourceGroup={0:N0} bytes ~= Total PDI={1:N0} bytes", privateCommit, totalProcessPrivateCommit);
try
{
AppResourceGroupStateReport sReport = group.GetStateReport();
if (sReport != null)
{
executionState = (ExecutionStateEx)sReport.ExecutionState;
energyState = (EnergyQuotaStateEx)sReport.EnergyQuotaState;
}
}
catch (Exception ex)
{
Debug.WriteLine("GetStateReport: " + ex.ToString());
}
try
{
IList <AppResourceGroupBackgroundTaskReport> bgReports = group.GetBackgroundTaskReports();
if (bgReports != null)
{
bgTaskCount = bgReports.Count;
}
}
catch (Exception ex)
{
Debug.WriteLine("GetBackgroundTaskReports: " + ex.ToString());
}
RowAggregateData groupData = new RowAggregateData(
commitLimit, totalCommit, privateCommit, bgTaskCount, executionState, energyState);
return(groupData);
}
public async Task Start()
{
if (this.IsStarted())
{
return;
}
desiredExecutionState = ExecutionStateEx.Started; // REVIEW - have a single input/output
if (!CanStart)
{
return; // TODO: Error?
}
StartOnMarketAvailable = true;
// TODO:
//DesiredExecutionState = ExecutionStateEx.Started;
if (Account != null && Account.Started.Value)
{
//await Task.Run(async () => await _Start());
await _Start().ConfigureAwait(false);
}
else
{
ExecutionStateFlags |= ExecutionStateFlags.WaitingToStart;
}
}
public RowAggregateData(
ulong limit, ulong total, ulong priv, int bg, ExecutionStateEx exState, EnergyQuotaStateEx enState)
{
CommitLimit = limit;
TotalCommit = total;
PrivateCommit = priv;
BgTaskCount = bg;
ExecutionState = exState;
EnergyState = enState;
}
public void Update(
ulong limit, ulong total, ulong commit,
ExecutionStateEx exState, EnergyQuotaStateEx enState, int bgCount)
{
CommitLimit = limit;
TotalCommit = total;
PrivateCommit = commit;
ExecutionState = exState;
EnergyQuotaState = enState;
BackgroundTaskCount = bgCount;
}
private bool AddOrUpdateApp(
AppDiagnosticInfo app, RowAggregateData appData, ExecutionStateEx appExecutionState)
{
bool result = false;
string name = "(unknown)";
string appId = string.Empty;
if (app.AppInfo != null && app.AppInfo.DisplayInfo != null)
{
appId = app.AppInfo.AppUserModelId;
name = app.AppInfo.DisplayInfo.DisplayName;
}
// Check to see if this app is already in our list, and only add it if it wasn't already there.
bool isAppFound = false;
foreach (AppRowInfo existingRow in this)
{
if (appId == existingRow.Id)
{
isAppFound = true;
break;
}
}
// Don't add apps for resource groups that are not running.
// Otherwise, for one thing, trying to get the logo would throw.
if (!isAppFound && appExecutionState != ExecutionStateEx.NotRunning)
{
BitmapImage logo = GetLogoFromAppInfo(app);
// A new app has appeared, so we add it to the list.
AppRowInfo appRow = new AppRowInfo(
app,
appId, logo, name,
appData.CommitLimit, appData.TotalCommit, appData.PrivateCommit,
appData.ExecutionState, appData.EnergyState, appData.BgTaskCount);
Add(appRow);
result = true;
}
else
{
// For existing rows, we'll update the dynamic state.
IEnumerable <AppRowInfo> appRows = this.Where(r => r.Id == appId);
if (appRows != null && appRows.Count() > 0)
{
AppRowInfo existingApp = appRows.First();
existingApp.Update(
appData.CommitLimit, appData.TotalCommit, appData.PrivateCommit,
appData.ExecutionState, appData.EnergyState, appData.BgTaskCount);
}
}
return(result);
}
protected void SetState(ExecutionStateEx state)
{
var oldState = this.State;
this.State = state;
new MExecutionStateChanged()
{
Source = this, OldState = oldState, NewState = state
}.Publish();
OnPropertyChanged(nameof(this.State));
}
public async Task Stop()
{
if (this.IsStarted())
{
State = ExecutionStateEx.Stopping;
if (IsTradeApiEnabled)
{
await Task.Run(() => Stop_TradeApi()).ConfigureAwait(false);
}
State = ExecutionStateEx.Stopped;
}
}
public async Task StopAsync(CancellationToken cancellationToken = default)
{
if (this.IsStarted())
{
State = ExecutionStateEx.Stopping;
if (IsTradeApiEnabled)
{
await Task.Run(() => Stop_TradeApi()).ConfigureAwait(false);
}
State = ExecutionStateEx.Stopped;
}
}
public async Task Start()
{
State = ExecutionStateEx.Starting;
foreach (var workspace in App.GetComponents <TradingWorkspace>())
{
await StartWorkspace(workspace);
}
RunTask = runTask();
if (!RunTask.IsCompleted)
{
State = ExecutionStateEx.Started;
}
}
public async Task StartAsync(CancellationToken cancellationToken = default)
{
State = ExecutionStateEx.Starting;
#if TOPORT
foreach (var workspace in App.GetComponents <TradingWorkspace>())
{
await StartWorkspace(workspace);
}
#endif
RunTask = runTask();
if (!RunTask.IsCompleted)
{
State = ExecutionStateEx.Started;
}
}
public AppRowInfo(
AppDiagnosticInfo a,
string id,
BitmapImage logo, string name,
ulong limit, ulong totCommit, ulong prvCommit,
ExecutionStateEx exState, EnergyQuotaStateEx eqState, int taskCount)
{
Adi = a;
Id = id;
Logo = logo;
Name = name;
commitLimit = limit;
totalCommit = totCommit;
privateCommit = prvCommit;
executionState = exState;
energyQuotaState = eqState;
backgroundTaskCount = taskCount;
}
public async Task Start()
{
if (this.IsStarted())
{
return;
}
lock (connectLock)
{
if (this.IsStarted())
{
return;
}
State = ExecutionStateEx.Starting;
}
await OnStarting().ConfigureAwait(false);
RunTask = Run();
//RunTask = Task.Factory.StartNew(Run);
}
public bool Update()
{
bool result = false;
// If we don't lock the collection, there's a race where databinding could end up with
// additional spurious instances, especially if the polling interval is only 1-2 sec.
lock (lockObject)
{
// Get a list of running apps (filtered by permission level).
IAsyncOperation <IList <AppDiagnosticInfo> > infoOperation = AppDiagnosticInfo.RequestInfoAsync();
Task <IList <AppDiagnosticInfo> > infoTask = infoOperation.AsTask();
infoTask.Wait();
IList <AppDiagnosticInfo> runningApps = infoTask.Result;
// We don't recreate the list each time: instead, we remove dead rows and update existing ones,
// only adding new rows for new apps that appear. This is slow, but typically we'd only have a small
// number of UWP apps running (say 5-20), so it's not noticeable.
if (runningApps != null)
{
// First, remove from the list any apps that are no longer in memory.
RemoveDeadRows(runningApps);
// Find key data from the bottom-up (process and group level) for roll-up purposes.
foreach (AppDiagnosticInfo app in runningApps)
{
ulong appCommitLimit = 0;
ulong appTotalCommit = 0;
ulong appPrivateCommit = 0;
ExecutionStateEx appExecutionState = ExecutionStateEx.Unknown;
EnergyQuotaStateEx appEnergyState = EnergyQuotaStateEx.Unknown;
int appBgTaskCount = 0;
// Get the roll-up data from group and process level.
IList <AppResourceGroupInfo> groups = app.GetResourceGroups();
if (groups != null)
{
foreach (AppResourceGroupInfo group in groups)
{
Debug.WriteLine("app: {0}, group Id: {1}", app.AppInfo.DisplayInfo.DisplayName, group.InstanceId);
// Get the total private commit usage of all processes for this app.
ulong totalProcessPrivateCommit = 0;
IList <ProcessDiagnosticInfo> processes = group.GetProcessDiagnosticInfos();
if (processes != null)
{
foreach (ProcessDiagnosticInfo process in processes)
{
totalProcessPrivateCommit += GetProcessPrivateCommit(process);
}
}
// Accumulate the aggregated totals for all resource groups for this app.
// We pass down the private commit for all processes for this group for comparison only.
RowAggregateData groupData = GetGroupAggregateData(
app.AppInfo.DisplayInfo.DisplayName, group, totalProcessPrivateCommit);
appCommitLimit += groupData.CommitLimit;
appTotalCommit += groupData.TotalCommit;
appPrivateCommit += groupData.PrivateCommit;
appBgTaskCount += groupData.BgTaskCount;
if (appExecutionState != groupData.ExecutionState)
{
if (appExecutionState == ExecutionStateEx.Unknown)
{
appExecutionState = groupData.ExecutionState;
}
else
{
appExecutionState = ExecutionStateEx.Multiple;
}
}
if (appEnergyState != groupData.EnergyState)
{
if (appEnergyState == EnergyQuotaStateEx.Unknown)
{
appEnergyState = groupData.EnergyState;
}
else
{
appEnergyState = EnergyQuotaStateEx.Multiple;
}
}
}
}
RowAggregateData appData = new RowAggregateData(
appCommitLimit, appTotalCommit, appPrivateCommit, appBgTaskCount, appExecutionState, appEnergyState);
// Now add or update the rows.
bool isAppAdded = AddOrUpdateApp(app, appData, appExecutionState);
if (isAppAdded)
{
// If any row update resulted in adding an app, we set the return value to true.
result = true;
}
}
}
}
return(result);
}
