public static void CleanUpFunctionProcesses()
{
Processes?.ForEach(process =>
{
var processName = process.ProcessName;
if (!process.HasExited)
{
process.Kill();
}
});
Processes?.Clear();
}
public static void CleanUpFunctionProcesses()
{
Processes?.ForEach(process =>
{
//process.WaitForExit()
var processName = process.ProcessName;
if (!process.HasExited)
{
process.Kill();
}
//foreach (var process1 in Process.GetProcessesByName(processName))
//{
// process1.Kill();
//}
});
Processes?.Clear();
}
/// <summary>,
/// Refresh the processes.
/// </summary>
private void OnRefresh()
{
Processes.Clear();
Processes.AddRange(Process.GetProcesses()
.Where(x =>
{
var isNotEmpty = !string.IsNullOrWhiteSpace(x.MainWindowTitle);
try
{
var hasFFXIMain = (from ProcessModule m in x.Modules where m.ModuleName.ToLower() == "ffximain.dll" select m).FirstOrDefault() != null;
return(isNotEmpty && hasFFXIMain);
}
catch
{
return(false);
}
return(isNotEmpty);
})
.ToList());
}
public void SimulateProcesses()
{
if (Processes.Count <= 0)
{
return;
}
// If Time unit smaller than or equal 0
if (TimeUnit <= 0)
{
// Use FSFC(First Come First Served) Algorithm
var Fcfs = new CPU_FCFS_Algorithm(Processes);
Fcfs.SimulateProcesses();
TerminatedProcesses = Fcfs.TerminatedProcesses;
// and return here
return;
}
var currentTime = 0;
point:
var PQueue = Processes.Where(a => a.ArrivalTime <= currentTime).OrderBy(a => a.ArrivalTime).ToList();
if (PQueue.Count == 0)
{
var process = new OSASProcess();
process.Id = -1;
process.StartTime = currentTime;
process.BurstTime += (Processes.OrderBy(a => a.ArrivalTime).FirstOrDefault().ArrivalTime - currentTime);
process.FinishTime = process.StartTime + process.BurstTime;
process.RemainingTime = 0;
currentTime = process.FinishTime;
TerminatedProcesses.Add(process);
goto point;
}
while (PQueue.Count > 0)
{
var p = PQueue.FirstOrDefault();
if (p.RemainingTime > TimeUnit)
{
PQueue.Remove(p);
p.StartTime = currentTime;
p.RemainingTime -= TimeUnit;
currentTime += TimeUnit;
var pro = new OSASProcess(p)
{
FinishTime = currentTime,
WaitTime = p.StartTime - LastFinishOrArrival(TerminatedProcesses, p)
};
TerminatedProcesses.Add(pro);
Processes.Remove(p);
PQueue.AddRange(Processes.Where(a => a.ArrivalTime <= currentTime &&
!PQueue.Exists(b => b.Id.Equals(a.Id)) &&
a.Id != p.Id).OrderBy(a => a.ArrivalTime));
PQueue.Add(p);
}
else
{
PQueue.Remove(p);
p.StartTime = currentTime;
currentTime += p.RemainingTime;
p.RemainingTime = 0;
p.WaitTime = p.StartTime - LastFinishOrArrival(TerminatedProcesses, p);
p.FinishTime = currentTime;
p.TurnAroundTime = p.FinishTime - p.ArrivalTime;
TerminatedProcesses.Add(p);
Processes.Remove(p);
PQueue.AddRange(Processes.Where(a => a.ArrivalTime <= currentTime &&
!PQueue.Exists(b => b.Id.Equals(a.Id)))
.OrderBy(a => a.ArrivalTime));
}
if (PQueue.Count == 0 && Processes.Count > 0)
{
var process = new OSASProcess();
process.Id = -1;
process.StartTime = currentTime;
process.BurstTime += (Processes.OrderBy(a => a.ArrivalTime).FirstOrDefault().ArrivalTime - currentTime);
process.FinishTime = process.StartTime + process.BurstTime;
process.RemainingTime = 0;
currentTime = process.FinishTime;
TerminatedProcesses.Add(process);
PQueue.AddRange(Processes.Where(a => a.ArrivalTime <= currentTime &&
!PQueue.Exists(b => b.Id.Equals(a.Id)))
.OrderBy(a => a.ArrivalTime));
}
}
Processes.Clear();
CalculatedSuccessfully = true;
}
public void Clear()
{
Processes.Clear();
Counters = null;
}
public Task Refresh()
{
Processes.Clear();
return(Task.Factory.StartNew(UpdateProcesses));
}
/// <summary>
/// Initializes a new instance of the ManageProcessViewModel class.
/// </summary>
public ManageProcessViewModel(IProcessManager processManager, DialogHandler dialogHandler)
{
_processManager = processManager;
_dialogHandler = dialogHandler;
Messenger.Default.Register <UpdateMessage>(this, message =>
{
switch (message.UpdateType)
{
case UpdateType.NewProcessCreated:
var processes = Processes.ToList();
var currentProcess = (Process)message.Parameter;
currentProcess.Start = currentProcess.Start.ToLocalTime();
currentProcess.End = currentProcess.End.ToLocalTime();
processes.Add(currentProcess);
DispatcherHelper.CheckBeginInvokeOnUI(() => Processes = new ObservableCollection <Process>(processes.OrderByDescending(p => p.Start)));
break;
}
});
LoadedCommand = new RelayCommand(async() =>
{
try
{
Mouse.SetCursor(Cursors.Arrow);
SetGridSettings();
if (_loadedFirst && _processManager != null)
{
_loadedFirst = false;
await _dialogHandler.ShowProgress(null, async() =>
{
DispatcherHelper.CheckBeginInvokeOnUI(() => Processes.Clear());
Log.Info(LogMessages.ManageProcessLoadProcesses);
var response = await _processManager.GetProcessesAsync(true);
if (ResponseValidator.Validate(response, false))
{
DispatcherHelper.CheckBeginInvokeOnUI(() =>
{
if (response.ResponseObject.Any())
{
var ordered = response.ResponseObject.OrderByDescending(p => p.Start);
Processes = new ObservableCollection <Process>(ordered.Select(p =>
{
p.Start = p.Start.ToLocalTime();
p.End = p.End.ToLocalTime();
return(p);
}));
RaisePropertyChanged("Processes");
}
});
}
});
}
}
catch (Exception exception)
{
Messenger.Default.Send(exception);
}
});
RefreshProcessCommand = new RelayCommand <string>(async id =>
{
try
{
var processResponse = await _processManager.GetProcessAsync(id);
if (ResponseValidator.Validate(processResponse, false))
{
var selectedItem = Processes.FirstOrDefault(p => p.Id == id);
if (selectedItem != null)
{
Processes[Processes.IndexOf(selectedItem)] = processResponse.ResponseObject;
Processes = new ObservableCollection <Process>(Processes);
}
}
}
catch (Exception exception)
{
Messenger.Default.Send(exception);
}
});
CancelProcessCommand = new RelayCommand <Process>(async process =>
{
try
{
var processResponse = await _processManager.CancelProcessAsync(process.Id);
if (ResponseValidator.Validate(processResponse, false))
{
var selectedItem = Processes.FirstOrDefault(p => p.Id == process.Id);
if (selectedItem != null)
{
selectedItem.Status = ProcessStatusEnum.Cancelled;
Processes = new ObservableCollection <Process>(Processes);
}
}
}
catch (Exception exception)
{
Messenger.Default.Send(exception);
}
});
ShowProcessDetailsCommand = new RelayCommand <Process>(async process =>
{
if (process == null)
{
return;
}
var context = new CommonDialogViewModel
{
Header = "Process details",
Buttons = ButtonsEnum.Ok,
Content = new JContent(process)
};
var view = new CommonDialog {
DataContext = context
};
await _dialogHandler.Show(view);
});
}
void Clear(object parameter)
{
Processes.Clear();
}
/// <summary>
/// Vide les propriétés de navigation.
/// </summary>
protected virtual void ClearNavigationProperties()
{
Childs.Clear();
Parent = null;
Processes.Clear();
}
