public static void Execute()
{
int i = 0;
foreach (GPGPUProperties prop in CudafyHost.GetDeviceProperties(CudafyModes.Target, false))
{
Console.WriteLine(" --- General Information for device {0} ---", i);
Console.WriteLine("Name: {0}", prop.Name);
Console.WriteLine("Platform Name: {0}", prop.PlatformName);
Console.WriteLine("Device Id: {0}", prop.DeviceId);
Console.WriteLine("Compute capability: {0}.{1}", prop.Capability.Major, prop.Capability.Minor);
Console.WriteLine("Clock rate: {0}", prop.ClockRate);
Console.WriteLine("Simulated: {0}", prop.IsSimulated);
Console.WriteLine();
Console.WriteLine(" --- Memory Information for device {0} ---", i);
Console.WriteLine("Total global mem: {0}", prop.TotalMemory);
Console.WriteLine("Total constant Mem: {0}", prop.TotalConstantMemory);
Console.WriteLine("Max mem pitch: {0}", prop.MemoryPitch);
Console.WriteLine("Texture Alignment: {0}", prop.TextureAlignment);
Console.WriteLine();
Console.WriteLine(" --- MP Information for device {0} ---", i);
Console.WriteLine("Shared mem per mp: {0}", prop.SharedMemoryPerBlock);
Console.WriteLine("Registers per mp: {0}", prop.RegistersPerBlock);
Console.WriteLine("Threads in warp: {0}", prop.WarpSize);
Console.WriteLine("Max threads per block: {0}", prop.MaxThreadsPerBlock);
Console.WriteLine("Max thread dimensions: ({0}, {1}, {2})", prop.MaxThreadsSize.x, prop.MaxThreadsSize.y, prop.MaxThreadsSize.z);
Console.WriteLine("Max grid dimensions: ({0}, {1}, {2})", prop.MaxGridSize.x, prop.MaxGridSize.y, prop.MaxGridSize.z);
Console.WriteLine();
i++;
}
}
private void PrintOutAviableDevices()
{
Console.WriteLine("Printing out avaiable devices...");
Console.WriteLine("For now this code will work only with Cuda devs...");
var numberOfCudaDevices = CudafyHost.GetDeviceCount(eGPUType.Cuda);
var numberOfOpenClDevices = CudafyHost.GetDeviceCount(eGPUType.OpenCL);
var numberOfEmulatorDevices = CudafyHost.GetDeviceCount(eGPUType.Emulator);
Console.WriteLine("{0} devices of type Cuda found", numberOfCudaDevices);
Console.WriteLine("{0} devices of type OpenCl found", numberOfOpenClDevices);
Console.WriteLine("{0} devices of type Emulator found", numberOfEmulatorDevices);
Console.WriteLine("Attempting to print out detailed info about Cuda devices..");
var cudaDevicesProperties = CudafyHost.GetDeviceProperties(eGPUType.Cuda);
if (cudaDevicesProperties.Count() != numberOfCudaDevices)
{
Console.WriteLine("Something is terribly off! Number of cuda devices differ from received properites");
}
foreach (var cudaDeviceProperties in cudaDevicesProperties)
{
Console.WriteLine(@"---");
PrintOutObjectPublicProperties(cudaDeviceProperties);
Console.WriteLine(@"---");
}
Console.WriteLine("Attempting to print out detailed info about openCl devices..");
var openClDevicesProperties = CudafyHost.GetDeviceProperties(eGPUType.OpenCL);
if (openClDevicesProperties.Count() != numberOfOpenClDevices)
{
Console.WriteLine("Something is terribly off! Number of openCl devices differ from received properites");
}
foreach (var openClDeviceProperties in openClDevicesProperties)
{
Console.WriteLine(@"---");
PrintOutObjectPublicProperties(openClDeviceProperties);
Console.WriteLine(@"---");
}
Console.WriteLine("Attempting to print out detailed info about emulator devices..");
var emulatorDevicesProperties = CudafyHost.GetDeviceProperties(eGPUType.Emulator);
if (emulatorDevicesProperties.Count() != numberOfEmulatorDevices)
{
Console.WriteLine("Something is terribly off! Number of emulator devices differ from received properites");
}
foreach (var emulatorDeviceProperties in emulatorDevicesProperties)
{
Console.WriteLine(@"---");
PrintOutObjectPublicProperties(emulatorDeviceProperties);
Console.WriteLine(@"---");
}
}
public static GPGPUProperties getProperties()
{
foreach (GPGPUProperties prop in CudafyHost.GetDeviceProperties(CudafyModes.Target))
{
gpgpuProperties = prop;
return(prop);
}
return(null);
}
public void Test_GetEmulatedDeviceProps()
{
if (CudafyModes.Target != eGPUType.Emulator)
{
Console.WriteLine("Only tests Emulator devices, so skip.");
return;
}
List <GPGPUProperties> props = CudafyHost.GetDeviceProperties(eGPUType.Emulator, false).ToList();
int cnt = CudafyHost.GetDeviceCount(eGPUType.Emulator);
Assert.AreEqual(cnt, props.Count);
Assert.AreEqual(0, props[0].DeviceId);
Assert.AreEqual(true, props[0].IsSimulated);
Assert.AreEqual(false, props[0].Integrated);
Assert.AreEqual(false, props[0].UseAdvanced);
Assert.IsTrue(props[0].MultiProcessorCount == 0);
}
public static int GetMaxThreadsPerBlock()
{
var cudaDevicesProperties = CudafyHost.GetDeviceProperties(eGPUType.Cuda);
var usedDeviceProperties = cudaDevicesProperties.ElementAt(ChosenDeviceId);
var cubeRoot = Convert.ToInt32(System.Math.Pow(usedDeviceProperties.MaxThreadsPerBlock, (1.0d / 3.0d)));
int i = 2;
for (i = 2; i <= usedDeviceProperties.WarpSize && i < cubeRoot; i = i * 2)
{
if (cubeRoot <= i)
{
return(i);
}
}
return(i / 2);
}
public void Test_GetCudaDeviceProps()
{
if (CudafyModes.Target != eGPUType.Cuda)
{
Console.WriteLine("Only testing CUDA devices, so skip.");
return;
}
List <GPGPUProperties> props = CudafyHost.GetDeviceProperties(eGPUType.Cuda, false).ToList();
int cnt = CudafyHost.GetDeviceCount(eGPUType.Cuda);
Assert.AreEqual(cnt, props.Count);
Assert.AreEqual(0, props[0].DeviceId);
Assert.AreEqual(false, props[0].IsSimulated);
Assert.AreEqual(false, props[0].Integrated);
Assert.AreEqual(false, props[0].UseAdvanced);
Assert.IsTrue(props[0].MultiProcessorCount == 0);
Assert.GreaterOrEqual(props[0].AsynchEngineCount, 1);
}
private static bool Init()
{
if (s_Gpu != null)
{
return(true);
}
try
{
var devices = CudafyHost.GetDeviceProperties(eGPUType.OpenCL).ToArray();
var device = devices.FirstOrDefault(d => d.Integrated && d.PlatformName.Contains("Intel(R)")); // use Intel iGPU if possible
if (device == null || IsInUseForVideoRendering(device))
{
// Fallback to CPU (prefer AMD Accelerated Parallel Processing first as it is faster)
const string cpuId = " CPU ";
device = devices.FirstOrDefault(d => d.Name.Contains(cpuId) && d.PlatformName.Contains("AMD"));
if (device == null)
{
// Settle for any CPU OpenCL device (most likely Intel OpenCL) as the last resort
device = devices.FirstOrDefault(d => d.Name.Contains(cpuId));
if (device == null)
{
throw new OpenClException("Error: CPU OpenCL drivers not installed");
}
}
}
var gpu = CudafyHost.GetDevice(eGPUType.OpenCL, device.DeviceId);
gpu.LoadAudioKernel(typeof(AudioKernels));
Player.Closed += PlayerOnClosed;
s_Gpu = gpu;
}
catch (Exception ex)
{
Trace.WriteLine(ex);
return(false);
}
return(true);
}
public GpuRenderer()
{
var availableOpenCLDevices = CudafyHost.GetDeviceProperties(eGPUType.OpenCL);
if (availableOpenCLDevices.Any() == false)
{
throw new Exception("No OpenCL devices found...");
}
var device = availableOpenCLDevices.First();
Module = CudafyTranslator.Cudafy(eArchitecture.OpenCL12);
var blockSide =
Enumerable
.Range(1, 15)
.Reverse()
.First(count => count * count <= device.MaxThreadsPerBlock);
BlockSize = new dim3(blockSide, blockSide);
// Initialize gpu and load the module (avoids reloading every time)
gpu = CudafyHost.GetDevice(eGPUType.OpenCL);
gpu.LoadModule(Module);
}
public Form GetForm()
{
string prefix = this.GetLocalizationPrefix();
var tab1 = DWSIM.UI.Shared.Common.GetDefaultContainer();
tab1.Tag = "Interface";
if (Application.Instance.Platform.IsMac)
{
tab1.CreateAndAddLabelRow("TouchBar");
tab1.CreateAndAddCheckBoxRow("Enable Custom TouchBar Buttons", Settings.EnableCustomTouchBar, (CheckBox sender, EventArgs obj) => { Settings.EnableCustomTouchBar = sender.Checked.Value; });
tab1.CreateAndAddDescriptionRow("Enables/disables custom TouchBar buttons on supported MacBook Pro models + macOS versions.");
}
tab1.CreateAndAddLabelRow("Renderer");
int currentrenderer = 0;
var renderers = new List <String>();
switch (GlobalSettings.Settings.RunningPlatform())
{
case Settings.Platform.Windows:
renderers.AddRange(Enum.GetNames(typeof(Settings.WindowsPlatformRenderer)));
currentrenderer = (int)Settings.WindowsRenderer;
break;
case Settings.Platform.Linux:
renderers.AddRange(Enum.GetNames(typeof(Settings.LinuxPlatformRenderer)));
currentrenderer = (int)Settings.LinuxRenderer;
break;
case Settings.Platform.Mac:
renderers.AddRange(Enum.GetNames(typeof(Settings.MacOSPlatformRenderer)));
currentrenderer = (int)Settings.MacOSRenderer;
break;
}
//tab1.CreateAndAddDropDownRow("Platform Renderer", renderers, currentrenderer, (sender, e) =>
//{
// switch (GlobalSettings.Settings.RunningPlatform())
// {
// case Settings.Platform.Windows:
// Settings.WindowsRenderer = (Settings.WindowsPlatformRenderer)sender.SelectedIndex;
// break;
// case Settings.Platform.Linux:
// Settings.LinuxRenderer = (Settings.LinuxPlatformRenderer)sender.SelectedIndex;
// break;
// case Settings.Platform.Mac:
// Settings.MacOSRenderer = (Settings.MacOSPlatformRenderer)sender.SelectedIndex;
// break;
// }
//});
//tab1.CreateAndAddDescriptionRow("This sets the GUI Renderer for the current platform. Recommended renderers for each platform are:\nWindows: WPF (Windows Presentation Foundation)\nLinux: GTK 2\nmacOS: MonoMac");
//tab1.CreateAndAddDescriptionRow("Changes to this setting will have effect upon application restart.");
//if (Settings.RunningPlatform() == Settings.Platform.Mac)
//{
// var check1 = tab1.CreateAndAddCheckBoxRow("Enable Dark Mode (macOS Mojave only)", Settings.DarkMode, (CheckBox sender, EventArgs obj) => { Settings.DarkMode = sender.Checked.Value; });
// check1.Enabled = false;
//}
tab1.CreateAndAddNumericEditorRow("Scaling Factor", Settings.UIScalingFactor, 0.2, 3.0, 2, (sender, e) => Settings.UIScalingFactor = sender.Value);
tab1.CreateAndAddDescriptionRow("Sets the Scaling Factor for controls (windows, panels, buttons, lists, etc). Useful on Linux when used in conjunction with Font Scaling on High DPI displays.");
tab1.CreateAndAddLabelRow("Flowsheet Designer");
tab1.CreateAndAddDropDownRow("Flowsheet Renderer", new List <string>()
{
"Software (CPU)", "Hardware (OpenGL)"
}, (int)Settings.FlowsheetRenderer, (sender, e) =>
{
Settings.FlowsheetRenderer = (Settings.SkiaCanvasRenderer)sender.SelectedIndex;
});
tab1.CreateAndAddCheckBoxRow("EnableAntiAliasing".Localize(prefix), Settings.DrawingAntiAlias, (CheckBox sender, EventArgs obj) => { Settings.DrawingAntiAlias = sender.Checked.Value; });
tab1.CreateAndAddDescriptionRow("Sets anti-aliasing (edge smoothing) for the Flowsheet Designer.");
tab1.CreateAndAddLabelRow("Editors");
var sizes = new[] { "6", "7", "8", "9", "10", "11", "12", "13", "14", "15", "16" };
if (Settings.EditorFontSize == -1)
{
Settings.EditorFontSize = (int)(new Eto.Drawing.Font(Eto.Drawing.SystemFont.Label).Size);
}
tab1.CreateAndAddDropDownRow("Font Size (Editor Labels/Descriptions)", sizes.ToList(), sizes.ToList().IndexOf(Settings.EditorFontSize.ToString()), (DropDown sender, EventArgs obj) => { Settings.EditorFontSize = int.Parse(sender.SelectedValue.ToString()); });
tab1.CreateAndAddDescriptionRow("Sets the Font Size for Editor labels and descriptions.");
tab1.CreateAndAddDropDownRow("Font Size (Text Reports)", sizes.ToList(), sizes.ToList().IndexOf(Settings.ResultsReportFontSize.ToString()), (DropDown sender, EventArgs obj) => { Settings.ResultsReportFontSize = int.Parse(sender.SelectedValue.ToString()); });
tab1.CreateAndAddDescriptionRow("Sets the Font Size for text reports.");
tab1.CreateAndAddCheckBoxRow("Fix Size of Input Controls", Settings.EditorTextBoxFixedSize, (CheckBox sender, EventArgs obj) => { Settings.EditorTextBoxFixedSize = sender.Checked.Value; });
tab1.CreateAndAddDescriptionRow("Fix the size of input textboxes and checkboxes on editors.");
tab1.CreateAndAddCheckBoxRow("View/Open Object Editor After Selection", Settings.EditOnSelect, (CheckBox sender, EventArgs obj) => { Settings.EditOnSelect = sender.Checked.Value; });
tab1.CreateAndAddDescriptionRow("Opens the object editor after selection on the flowsheet.");
tab1.CreateAndAddCheckBoxRow("Call Solver on Editor Property Update", Settings.CallSolverOnEditorPropertyChanged, (CheckBox sender, EventArgs obj) => { Settings.CallSolverOnEditorPropertyChanged = sender.Checked.Value; });
tab1.CreateAndAddDescriptionRow("Requests a flowsheet calculation after an object property is changed/updated on the editor.");
CheckBox chkInsp = null, chkCPUP = null;
var tab2a = DWSIM.UI.Shared.Common.GetDefaultContainer();
tab2a.Tag = "Inspector";
chkInsp = tab2a.CreateAndAddCheckBoxRow("Enable Inspector Reports", Settings.InspectorEnabled, (CheckBox sender, EventArgs obj) => {
Settings.InspectorEnabled = sender.Checked.GetValueOrDefault();
Settings.EnableParallelProcessing = !Settings.InspectorEnabled;
chkCPUP.Checked = !sender.Checked.GetValueOrDefault();
});
tab2a.CreateAndAddDescriptionRow("Enabling Inspector Reports will create model description and performance reports on-the-fly as the calculations are requested by the Flowsheet Solver. Use the Solution Inspector tool to view these reports.");
tab2a.CreateAndAddDescriptionRow("When the Inspector Reports feature is enabled and the Flowsheet Solver is called, the Parallel CPU Processing is automatically disabled. You must re-enable it manually and disable the Inspector to increase the calculation speed again.");
tab2a.CreateAndAddCheckBoxRow("Clear Previous Reports on new Flowsheet Calculation Request", Settings.ClearInspectorHistoryOnNewCalculationRequest, (CheckBox sender, EventArgs obj) => { Settings.ClearInspectorHistoryOnNewCalculationRequest = sender.Checked.GetValueOrDefault(); });
tab2a.CreateAndAddDescriptionRow("This will erase all previously stored reports when a new flowsheet calculation request is made by the user.");
var tab2 = DWSIM.UI.Shared.Common.GetDefaultContainer();
tab2.Tag = "Solver".Localize(prefix);
tab2.CreateAndAddTextBoxRow("N0", "Solver Timeout (s)", GlobalSettings.Settings.SolverTimeoutSeconds, (sender, e) =>
{
if (sender.Text.IsValidDouble())
{
GlobalSettings.Settings.SolverTimeoutSeconds = Convert.ToInt32(sender.Text);
}
});
tab2.CreateAndAddDescriptionRow("Set the solver's maximum calculation (waiting) time.");
chkCPUP = tab2.CreateAndAddCheckBoxRow("EnableCPUParallelProcessing".Localize(prefix), Settings.EnableParallelProcessing, (CheckBox sender, EventArgs obj) => {
Settings.EnableParallelProcessing = sender.Checked.GetValueOrDefault();
Settings.InspectorEnabled = !Settings.EnableParallelProcessing;
chkInsp.Checked = !sender.Checked.GetValueOrDefault();
});
tab2.CreateAndAddDescriptionRow("Enables utilization of all CPU cores during flowsheet calculations.");
tab2.CreateAndAddCheckBoxRow("EnableCPUSIMDAccel".Localize(prefix), Settings.UseSIMDExtensions, (CheckBox sender, EventArgs obj) => { Settings.UseSIMDExtensions = sender.Checked.GetValueOrDefault(); });
tab2.CreateAndAddDescriptionRow("Enables utilization of special CPU instructions for accelerated math calculations.");
tab2.CreateAndAddCheckBoxRow("BreakOnException".Localize(prefix), Settings.SolverBreakOnException, (CheckBox sender, EventArgs obj) => { Settings.SolverBreakOnException = sender.Checked.GetValueOrDefault(); });
tab2.CreateAndAddDescriptionRow("If activated, the solver won't calculate the rest of the flowsheet if an error occurs during the calculation of an intermediate block/object.");
tab2.CreateAndAddCheckBoxRow("EnableGPUAccel".Localize(prefix), Settings.EnableGPUProcessing, (CheckBox sender, EventArgs obj) => { Settings.EnableGPUProcessing = sender.Checked.Value; });
TextArea tbgpucaps = null;
var cbgpu = tab2.CreateAndAddDropDownRow("Computing Device", new List <string>(), 0, (sender, e) =>
{
if (!(sender.SelectedValue == null))
{
if (sender.SelectedValue.ToString().Contains("Emulator"))
{
Settings.CudafyTarget = (int)eGPUType.Emulator;
}
else if (sender.SelectedValue.ToString().Contains("CUDA"))
{
Settings.CudafyTarget = (int)eGPUType.Cuda;
}
else
{
Settings.CudafyTarget = (int)eGPUType.OpenCL;
}
Settings.CudafyTarget = Settings.CudafyTarget;
try
{
foreach (GPGPUProperties prop in CudafyHost.GetDeviceProperties((eGPUType)Settings.CudafyTarget, false))
{
if (sender.SelectedValue.ToString().Split('|')[1].Contains(prop.Name))
{
Settings.SelectedGPU = sender.SelectedValue.ToString();
Settings.CudafyDeviceID = prop.DeviceId;
Application.Instance.Invoke(() => GetCUDACaps(prop, tbgpucaps));
break;
}
}
}
catch (Exception)
{
}
if (loaded)
{
if (Settings.gpu != null)
{
Settings.gpu.Dispose();
}
Settings.gpu = null;
try
{
//set CUDA params
CudafyModes.Compiler = eGPUCompiler.All;
CudafyModes.Target = (eGPUType)Settings.CudafyTarget;
Cudafy.Translator.CudafyTranslator.GenerateDebug = false;
DWSIM.Thermodynamics.Calculator.InitComputeDevice();
Console.WriteLine("GPU initialized successfully: " + Settings.SelectedGPU + "(" + CudafyModes.Target.ToString() + ")");
}
catch (Exception ex)
{
Console.WriteLine("GPU initialization failed: " + ex.ToString());
var ex1 = ex;
while (ex1.InnerException != null)
{
Console.WriteLine("GPU initialization failed (IEX): " + ex1.InnerException.ToString());
if (ex1.InnerException is ReflectionTypeLoadException)
{
foreach (var tlex in ((ReflectionTypeLoadException)(ex1.InnerException)).LoaderExceptions)
{
Console.WriteLine("GPU initialization failed (TLEX): " + tlex.Message);
}
}
ex1 = ex1.InnerException;
}
}
}
}
});
tbgpucaps = tab2.CreateAndAddMultilineMonoSpaceTextBoxRow("", 200, true, null);
Task.Factory.StartNew(() =>
{
List <string> list = new List <string>();
try
{
CudafyModes.Target = eGPUType.Cuda;
foreach (GPGPUProperties prop in CudafyHost.GetDeviceProperties(CudafyModes.Target, false))
{
list.Add("CUDA | " + prop.Name + " (" + prop.DeviceId + ")");
}
}
catch (Exception)
{
}
try
{
CudafyModes.Target = eGPUType.OpenCL;
foreach (GPGPUProperties prop in CudafyHost.GetDeviceProperties(CudafyModes.Target, false))
{
list.Add("OpenCL | " + prop.Name + " (" + prop.DeviceId + ")");
}
}
catch (Exception)
{
}
return(list);
}).ContinueWith(t =>
{
foreach (var item in t.Result)
{
cbgpu.Items.Add(item);
}
CudafyModes.Target = (eGPUType)Settings.CudafyTarget;
if (Settings.SelectedGPU != "")
{
foreach (var s in cbgpu.Items)
{
if (s.Text == Settings.SelectedGPU)
{
cbgpu.SelectedValue = s;
break;
}
}
}
else
{
}
loaded = true;
}, TaskScheduler.FromCurrentSynchronizationContext());
var tab3 = DWSIM.UI.Shared.Common.GetDefaultContainer();
tab3.Tag = "UserComps".Localize(prefix);
tab3.CreateAndAddLabelRow("User-Defined Compound Datasets");
var list1 = tab3.CreateAndAddListBoxRow(200, GlobalSettings.Settings.UserDatabases.ToArray(), null);
tab3.CreateAndAddButtonRow("Add Dataset", null, (sender, e) =>
{
var dialog = new OpenFileDialog();
dialog.Title = "Select File".Localize();
dialog.Filters.Add(new FileFilter("Compound dataset files", new[] { ".xml", ".json" }));
dialog.MultiSelect = false;
dialog.CurrentFilterIndex = 0;
if (dialog.ShowDialog(null) == DialogResult.Ok)
{
if (!GlobalSettings.Settings.UserDatabases.Contains(dialog.FileName))
{
GlobalSettings.Settings.UserDatabases.Add(dialog.FileName);
list1.Items.Add(dialog.FileName);
}
}
});
tab3.CreateAndAddButtonRow("Remove selected", null, (sender, e) =>
{
GlobalSettings.Settings.UserDatabases.Remove(list1.SelectedValue.ToString());
list1.Items.RemoveAt(list1.SelectedIndex);
});
tab3.CreateAndAddLabelRow("User-Defined Interaction Parameter Datasets");
var list2 = tab3.CreateAndAddListBoxRow(200, GlobalSettings.Settings.UserInteractionsDatabases.ToArray(), null);
tab3.CreateAndAddButtonRow("Add Dataset", null, (sender, e) =>
{
var dialog = new OpenFileDialog();
dialog.Title = "Select File".Localize();
dialog.Filters.Add(new FileFilter("Interaction Parameter dataset files", new[] { ".xml" }));
dialog.MultiSelect = false;
dialog.CurrentFilterIndex = 0;
if (dialog.ShowDialog(null) == DialogResult.Ok)
{
if (!GlobalSettings.Settings.UserInteractionsDatabases.Contains(dialog.FileName))
{
GlobalSettings.Settings.UserInteractionsDatabases.Add(dialog.FileName);
list2.Items.Add(dialog.FileName);
}
}
});
tab3.CreateAndAddButtonRow("Remove selected", null, (sender, e) =>
{
GlobalSettings.Settings.UserInteractionsDatabases.Remove(list2.SelectedValue.ToString());
list2.Items.RemoveAt(list2.SelectedIndex);
});
var tab4 = DWSIM.UI.Shared.Common.GetDefaultContainer();
tab4.Tag = "Backup".Localize(prefix);
tab4.CreateAndAddLabelRow("BackupCopies".Localize(prefix));
tab4.CreateAndAddCheckBoxRow("EnableBackupCopies".Localize(prefix), Settings.EnableBackupCopies, (CheckBox sender, EventArgs obj) => { Settings.EnableBackupCopies = sender.Checked.Value; });
tab4.CreateAndAddEmptySpace();
tab4.CreateAndAddTextBoxRow("N0", "BackupInterval".Localize(prefix), Settings.BackupInterval, (TextBox sender, EventArgs obj) => { Settings.BackupInterval = sender.Text.IsValidDouble() ? (int)sender.Text.ToDouble() : Settings.BackupInterval; });
tab4.CreateAndAddEmptySpace();
tab4.CreateAndAddButtonRow("PurgeBackupFolder".Localize(prefix), null, (sender, e) =>
{
string backupdir = "";
if (GlobalSettings.Settings.RunningPlatform() == GlobalSettings.Settings.Platform.Mac)
{
backupdir = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.Personal), "Documents", "DWSIM Application Data", "Backup") + Path.DirectorySeparatorChar;
}
else
{
backupdir = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments), "DWSIM Application Data", "Backup") + Path.DirectorySeparatorChar;
}
var files = Directory.GetFiles(backupdir);
foreach (var file in files)
{
try
{
File.Delete(file);
}
catch { }
}
});
tab4.CreateAndAddEmptySpace();
var tab5 = DWSIM.UI.Shared.Common.GetDefaultContainer();
tab5.Tag = "Misc".Localize(prefix);
tab5.CreateAndAddLabelRow("Octave Settings");
tab5.CreateAndAddDescriptionRow("Setup the path for Octave binaries to enable integration with DWSIM.");
TextBox tbox = null;
tbox = tab5.CreateAndAddLabelAndTextBoxAndButtonRow("Binaries Path", GlobalSettings.Settings.OctavePath, "Search", null,
(sender, e) => GlobalSettings.Settings.OctavePath = sender.Text,
(sender, e) =>
{
var searchdialog = new SelectFolderDialog()
{
Title = "Search"
};
if (searchdialog.ShowDialog(tab5) == DialogResult.Ok)
{
tbox.Text = searchdialog.Directory;
}
});
tab5.CreateAndAddTextBoxRow("N0", "Calling Timeout (minutes)", GlobalSettings.Settings.OctaveTimeoutInMinutes, (sender, e) =>
{
if (sender.Text.IsValidDouble())
{
GlobalSettings.Settings.OctaveTimeoutInMinutes = sender.Text.ToDouble();
}
});
tab5.CreateAndAddLabelRow("Python Settings");
tab5.CreateAndAddDescriptionRow("Setup the path for Python binaries to enable integration with DWSIM.");
TextBox tbox2 = null;
tbox2 = tab5.CreateAndAddLabelAndTextBoxAndButtonRow("Binaries Path", GlobalSettings.Settings.PythonPath, "Search", null,
(sender, e) => GlobalSettings.Settings.PythonPath = sender.Text,
(sender, e) =>
{
var searchdialog = new SelectFolderDialog()
{
Title = "Search"
};
if (searchdialog.ShowDialog(tab5) == DialogResult.Ok)
{
tbox2.Text = searchdialog.Directory;
}
});
tab5.CreateAndAddTextBoxRow("N0", "Calling Timeout (minutes)", GlobalSettings.Settings.PythonTimeoutInMinutes, (sender, e) =>
{
if (sender.Text.IsValidDouble())
{
GlobalSettings.Settings.PythonTimeoutInMinutes = sender.Text.ToDouble();
}
});
var form = DWSIM.UI.Shared.Common.GetDefaultTabbedForm("Title".Localize(prefix), 700, 550, new[] { tab1, tab2, tab2a, tab3, tab4, tab5 });
form.Closed += (s, e) => {
try
{
DWSIM.GlobalSettings.Settings.SaveSettings("dwsim_newui.ini");
}
catch
{
}
};
return(form);
}
public static IEnumerable <string> EnumerateDevices(bool openCL = false)//out string info, out bool driverInstalled)
{
int count = 0;
string message = string.Empty;
string info = string.Empty;
IsDriverInstalled = true;
List <string> sb = new List <string>();
List <GPGPUProperties> deviceProps = new List <GPGPUProperties>();
bool failed = true;
try
{
count = openCL ? OpenCLDevice.GetDeviceCount() : CudaGPU.GetDeviceCount();
deviceProps = CudafyHost.GetDeviceProperties(openCL ? eGPUType.OpenCL : eGPUType.Cuda).ToList();
failed = false;
}
catch (DllNotFoundException dnfe)
{
sb.Add("Suitable driver not installed. " + dnfe.Message);
IsDriverInstalled = false;
}
catch (GASS.CUDA.CUDAException ex)
{
if (ex.Message == "ErrorNotInitialized")
{
sb.Add("Found 0 CUDA devices.");
}
else
{
sb.Add("CUDAException: " + ex.Message);
}
}
catch (Exception ex)
{
sb.Add("Error: " + ex.Message);
}
if (failed)
{
foreach (var s in sb)
{
yield return(s);
}
}
else
{
yield return(string.Format("Found {0} devices.\r\n", count));
foreach (var prop in deviceProps)
{
yield return("Name: " + prop.Name);
if (openCL)
{
yield return("OpenCL Version: " + prop.Capability.ToString());
}
else
{
yield return("Compute capability: " + prop.Capability.ToString());
}
if (!openCL && prop.Capability < new Version(1, 4))
{
yield return("Note: This device will not support default calls to Cudafy(). Use overloads to give specific value.");
}
yield return(string.Empty);
}
}
}
private void PopulateGPGPUComboBox()
{
gpus.Clear();
if (rdoCPU.Checked == true) // If CPU is Selected, disable GPGPU combo box and set TestType to CPU
{
cbGPGPU.Text = "Disabled";
cbGPGPU.Enabled = false;
TestType = "CPU";
}
if (rdoGPU.Checked == true) // If OpenCL is Selected:
{
cbGPGPU.Items.Clear(); // Clear GPGPU Selection box
multiGPU = false;
try
{
if (CudafyHost.GetDeviceCount(CudafyModes.Target = eGPUType.OpenCL) >= 1)
{
int gpuCount = 0;
foreach (GPGPUProperties prop in CudafyHost.GetDeviceProperties(CudafyModes.Target = eGPUType.OpenCL))
{
if (!prop.Name.Contains("CPU") && !prop.Name.Contains("Processor"))
{
gpuCount++;
}
}
if (gpuCount > 1)
{
cbGPGPU.Items.Add("Multi-GPU");
multiGPU = true;
cbGPGPU.SelectedIndex = 0;
lblPlatformDefault.Text = "Recommended Default Settings (Multi-GPU)";
}
foreach (GPGPUProperties prop in CudafyHost.GetDeviceProperties(CudafyModes.Target = eGPUType.OpenCL))
{
// Add all GPGPUs to combo box belonging to OpenCL
cbGPGPU.Items.Add(prop.Name.Trim() + " || OpenCL platform: " + prop.PlatformName.Trim());
if (multiGPU == false && (!prop.Name.Contains("CPU") && !prop.Name.Contains("Processor")))
{
cbGPGPU.SelectedIndex = cbGPGPU.Items.Count - 1;
lblPlatformDefault.Text = "Recommended Default Settings (" + prop.Name.Trim() + ")";
}
if (multiGPU == true && (!prop.Name.Contains("CPU") && !prop.Name.Contains("Processor")))
{
gpus.Add(prop.DeviceId);
}
gpuMem.Add(prop.TotalGlobalMem);
if (!prop.Name.Contains("CPU") && !prop.Name.Contains("Processor"))
{
if (maxGPUMem == 0 || prop.TotalGlobalMem < maxGPUMem)
{
maxGPUMem = prop.TotalGlobalMem;
}
}
//MessageBox.Show(maxGPUMem.ToString());
}
cbGPGPU.Enabled = true; // Enable combo box
}
else
{
cbGPGPU.Items.Add("No GPU detected on system");
cbGPGPU.SelectedIndex = cbGPGPU.Items.Count - 1;
lblPlatformDefault.Text = "Recommended Default Settings (CPU)";
cbGPGPU.Enabled = false;
rdoGPU.Enabled = false;
rdoCPU.Checked = true;
}
}
catch
{
cbGPGPU.Items.Add("Error populating GPUs on system");
cbGPGPU.SelectedIndex = cbGPGPU.Items.Count - 1;
lblPlatformDefault.Text = "Recommended Default Settings (CPU)";
cbGPGPU.Enabled = false;
rdoGPU.Enabled = false;
rdoCPU.Checked = true;
}
}
}