public static void Main()
{
Console.WriteLine("CUDAfy Example\nCollecting necessary resources...");
CudafyModes.Target = eGPUType.Cuda; // To use OpenCL, change this enum
CudafyModes.DeviceId = 0;
CudafyTranslator.Language = CudafyModes.Target == eGPUType.OpenCL ? eLanguage.OpenCL : eLanguage.Cuda;
//Check for available devices
if (CudafyHost.GetDeviceCount(CudafyModes.Target) == 0)
{
throw new System.ArgumentException("No suitable devices found.", "original");
}
//Init device
var gpu = CudafyHost.GetDevice(CudafyModes.Target, CudafyModes.DeviceId);
Console.WriteLine("Running example using {0}", gpu.GetDeviceProperties(false).Name);
//Load module for GPU
var km = CudafyTranslator.Cudafy();
gpu.LoadModule(km);
//Define local arrays
var a = new int[N];
var b = new int[N];
var c = new int[N];
// allocate the memory on the GPU
var dev_c = gpu.Allocate <int>(c);
// fill the arrays 'a' and 'b' on the CPU
for (var i = 0; i < N; i++)
{
a[i] = i;
b[i] = i * i;
}
// copy the arrays 'a' and 'b' to the GPU
var dev_a = gpu.CopyToDevice(a);
var dev_b = gpu.CopyToDevice(b);
gpu.Launch(1, N).add(dev_a, dev_b, dev_c);
// copy the array 'c' back from the GPU to the CPU
gpu.CopyFromDevice(dev_c, c);
// display the results
for (var i = 0; i < N; i++)
{
Console.WriteLine("{0} + {1} = {2}", a[i], b[i], c[i]);
}
// free the memory allocated on the GPU
gpu.FreeAll();
Console.WriteLine("Done!");
Console.ReadKey();
}
public static bool TestGpuDoublePrecision(int DeviceId)
{
if (DeviceId > CudafyHost.GetDeviceCount(eGPUType.OpenCL))
{
return(false);
}
try
{
CudafyModes.Target = eGPUType.OpenCL;
CudafyTranslator.Language = eLanguage.OpenCL;
CudafyModule km = CudafyTranslator.Cudafy();
GPGPU gpu = CudafyHost.GetDevice(eGPUType.OpenCL, DeviceId);
gpu.LoadModule(km);
double c;
double[] dev_c = gpu.Allocate <double>();
gpu.Launch().add_double(2.5d, 7.5d, dev_c);
gpu.CopyFromDevice(dev_c, out c);
gpu.Free(dev_c);
return(c == 10.0d);
}
catch
{ return(false); }
}
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 void Test_GetEmulatedDeviceCount()
{
if (CudafyModes.Target != eGPUType.Emulator)
{
Console.WriteLine("Only tests Emulator devices, so skip.");
return;
}
int cnt = CudafyHost.GetDeviceCount(eGPUType.Emulator);
Console.WriteLine("Emulated device count = {0}", cnt);
Assert.True(cnt > 0);
}
public void Test_GetCudaDeviceCount()
{
if (CudafyModes.Target != eGPUType.Cuda)
{
Console.WriteLine("Only tests CUDA devices, so skip.");
return;
}
int cnt = CudafyHost.GetDeviceCount(eGPUType.Cuda);
Console.WriteLine("Cuda device count = {0}", cnt);
Assert.True(cnt > 0);
}
static void Main(string[] args)
{
try
{
CudafyModes.DeviceId = 0;
CudafyModes.Architecture = CudafyHost.GetDevice(eGPUType.Cuda, CudafyModes.DeviceId).GetArchitecture(); //eArchitecture.sm_35; // *** Change this to the architecture of your target board ***
CudafyModes.Target = CompilerHelper.GetGPUType(CudafyModes.Architecture);
if (CudafyModes.Target != eGPUType.OpenCL)
{
CURANDTests.Basics();
}
StringTests st = new StringTests();
CudafyUnitTest.PerformAllTests(st);
BasicFunctionTests bft = new BasicFunctionTests();
CudafyUnitTest.PerformAllTests(bft);
GMathUnitTests gmu = new GMathUnitTests();
CudafyUnitTest.PerformAllTests(gmu);
MultithreadedTests mtt = new MultithreadedTests();
CudafyUnitTest.PerformAllTests(mtt);
CopyTests1D ct1d = new CopyTests1D();
CudafyUnitTest.PerformAllTests(ct1d);
GPGPUTests gput = new GPGPUTests();
CudafyUnitTest.PerformAllTests(gput);
if (CudafyHost.GetDeviceCount(CudafyModes.Target) > 1)
{
MultiGPUTests mgt = new MultiGPUTests();
CudafyUnitTest.PerformAllTests(mgt);
}
if (CudafyModes.Architecture == eArchitecture.sm_35)
{
Compute35Features c35f = new Compute35Features();
CudafyUnitTest.PerformAllTests(c35f);
}
Console.WriteLine("Done");
Console.ReadLine();
}
catch (Exception ex)
{
Console.WriteLine(ex.ToString());
Console.ReadLine();
}
}
public void Test_CreateOpenCLDevice()
{
if (CudafyModes.Target != eGPUType.OpenCL)
{
Console.WriteLine("Only tests OpenCL devices, so skip.");
return;
}
int cnt = CudafyHost.GetDeviceCount(eGPUType.OpenCL);
if (cnt > 0)
{
GPGPU gpu = CudafyHost.GetDevice(eGPUType.OpenCL, 0);
Assert.IsTrue(gpu is OpenCLDevice);
gpu = null;
}
}
public void Test_CreateCudaGPU()
{
if (CudafyModes.Target != eGPUType.Cuda)
{
Console.WriteLine("Only tests CUDA devices, so skip.");
return;
}
int cnt = CudafyHost.GetDeviceCount(eGPUType.Cuda);
if (cnt > 0)
{
GPGPU gpu = CudafyHost.GetDevice(eGPUType.Cuda, 0);
Assert.IsTrue(gpu is CudaGPU);
gpu = 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 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);
}
static void Main(string[] args)
{
String komen;
CudafyModes.Target = eGPUType.OpenCL;
CudafyModes.DeviceId = 0;
CudafyTranslator.Language = CudafyModes.Target == eGPUType.OpenCL ? eLanguage.OpenCL : eLanguage.Cuda;
try
{
int deviceCount = CudafyHost.GetDeviceCount(CudafyModes.Target);
if (deviceCount == 0)
{
Console.WriteLine("Tidak ada device ditemukan {0}", CudafyModes.Target);
}
else
{
Console.WriteLine("--------------Program Processing VGA ------------");
Console.WriteLine("-------------- C h r o n o M E Dev ------------");
GPGPU gpu = CudafyHost.GetDevice(CudafyModes.Target, CudafyModes.DeviceId);
Console.WriteLine("Radeon RX 570/580 Series");
Console.WriteLine("Code name: " + gpu.GetDeviceProperties(false).Name);
Console.WriteLine("Memori VGA: " + gpu.GetDeviceProperties(false).TotalMemory);
Console.WriteLine("Jumlah Pipeline " + gpu.GetDeviceProperties(false).MultiProcessorCount);
do
{
gpu_calculation.primaGPU();
//gpu_calculation.eksekusi();
//cpu_tes.eksekusi();
cpu_tes.prima();
Console.WriteLine("Done!");
Console.Write("Press q to quit > ");
komen = Console.ReadLine().ToString();
} while (komen != "q");
}
}
catch (Exception ex)
{
Console.WriteLine(ex);
}
}
public static bool InitGPU(PictureBox passedViewport)
{
viewport = passedViewport;
CudafyModes.Target = eGPUType.OpenCL; // To use OpenCL, change this enum
CudafyModes.DeviceId = 0;
CudafyTranslator.Language = CudafyModes.Target == eGPUType.OpenCL ? eLanguage.OpenCL : eLanguage.Cuda;
CudafyModule km = null;
try
{
int deviceCount = CudafyHost.GetDeviceCount(CudafyModes.Target);
if (deviceCount == 0)
{
Console.WriteLine("No suitable {0} devices found.", CudafyModes.Target);
return(false);
}
gpu = CudafyHost.GetDevice(CudafyModes.Target, CudafyModes.DeviceId);
Console.WriteLine("Device Name: {0}", gpu.GetDeviceProperties(false).Name);
var result = gpu.GetDeviceProperties(true); // diagnostic data
km = CudafyTranslator.Cudafy();
gpu.LoadModule(km);
}
catch (Exception ex)
{
Console.WriteLine(ex);
Console.WriteLine(km.SourceCode);
Debugger.Break();
return(false);
}
InitDevicePointers();
return(true);
}
public int Init()
{
this.m_km = CudafyTranslator.Cudafy();
CudafyModes.Target = eGPUType.Cuda;
var tgCount = CudafyHost.GetDeviceCount(CudafyModes.Target);
if (tgCount <= 0)
{
CudafyModes.Target = eGPUType.OpenCL;
tgCount = CudafyHost.GetDeviceCount(CudafyModes.Target);
}
if (tgCount <= 0)
{
CudafyModes.Target = eGPUType.Emulator;
tgCount = CudafyHost.GetDeviceCount(CudafyModes.Target);
}
if (tgCount <= 0)
{
throw new CtkCudafyCannotUseException("無法使用Cudafy");
}
for (int idx = 0; idx < tgCount; idx++)
{
try
{
this.m_gpu = CudafyHost.GetDevice(CudafyModes.Target, idx);
this.m_gpu.LoadModule(Km);
return(0);
}
catch (Cudafy.CudafyCompileException) { }
}
throw new Exception("Cudafy buidling fail.");
}
static void Main(string[] args)
{
// CudafyModes.Target = eGPUType.Cuda; // Jak chcesz obliczac na CUDA
CudafyModes.Target = eGPUType.OpenCL; // Jak chcesz obliczac na OpenCL
CudafyModes.DeviceId = 0;
CudafyTranslator.Language = CudafyModes.Target == eGPUType.OpenCL ? eLanguage.OpenCL : eLanguage.Cuda;
try
{
int deviceCount = CudafyHost.GetDeviceCount(CudafyModes.Target);
if (deviceCount == 0)
{
Console.WriteLine("No suitable {0} devices found.", CudafyModes.Target);
throw new Exception("No suitable devices found.");
}
GPGPU gpu = CudafyHost.GetDevice(CudafyModes.Target, CudafyModes.DeviceId);
Console.WriteLine("Running examples using {0}", gpu.GetDeviceProperties(false).Name);
int waitTime;
if (Int32.TryParse(args[0], out waitTime))
{
SQL.Execute(waitTime); // glowna funkcja
}
else
{
Console.WriteLine("Nie podano liczby całkowitej, program zostanie wyłączony...");
}
//SQL.Test(); // testowa funkcja
}
catch (Exception ex)
{
Console.WriteLine(ex);
}
Console.WriteLine("Done!");
Console.ReadKey();
}
private void InitializeGPUs()
{
eGPUType[] gpuTypes = new eGPUType[] { eGPUType.Cuda, eGPUType.OpenCL, eGPUType.Emulator };
eLanguage[] languages = new eLanguage[] { eLanguage.Cuda, eLanguage.OpenCL };
foreach (eGPUType gpuType in gpuTypes)
{
try
{
int numberOfAvailableDevices = CudafyHost.GetDeviceCount(gpuType);
for (int deviceNumber = 0; deviceNumber < numberOfAvailableDevices; deviceNumber++)
{
GPGPU gpgpu = CudafyHost.GetDevice(gpuType, deviceNumber);
GPGPUProperties gpgpuProperties = gpgpu.GetDeviceProperties(true);
CudafyModes.Target = gpuType;
foreach (eLanguage language in languages)
{
string cudaRandomFilename = Path.GetRandomFileName();
try
{
CudafyTranslator.Language = language;
CompileProperties compileProperties = CompilerHelper.Create(ePlatform.Auto, eArchitecture.Unknown, eCudafyCompileMode.Default, CudafyTranslator.WorkingDirectory, CudafyTranslator.GenerateDebug);
// Use a random filename to prevent conflict on default temp file when multithreading (unit tests)
compileProperties.InputFile = cudaRandomFilename;
// If this line fails with NCrunch/Unit tests, there probably is a new version of Cudafy.NET
// and it needs to be registered in the GAC like this: gacutil -i Cudafy.NET.dll
CudafyModule cudafyModule = CudafyTranslator.Cudafy(compileProperties, typeof(Primitives));
if (!gpgpu.IsModuleLoaded(cudafyModule.Name))
{
gpgpu.LoadModule(cudafyModule);
}
gpgpu.EnableMultithreading();
string gpuName = gpgpuProperties.Name.Trim() + " - " + gpuType.ToString() + " - " + language.ToString();
////this.gpgpus.Add(gpuName, gpgpu);
////this.gpgpuProperties.Add(gpuName, gpgpuProperties);
////this.gpuTypes.Add(gpuName, gpuType);
}
catch (CudafyCompileException)
{
// Language not supported
}
finally
{
File.Delete(cudaRandomFilename);
// ncrunch: no coverage start
}
}
}
}
catch (DllNotFoundException)
{
}
catch (InvalidOperationException)
{
// Language not supported
}
catch (Cloo.ComputeException)
{
// Language not supported
} // ncrunch: no coverage end
}
}
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;
}
}
}
static void Main(string[] args)
{
CudafyModes.Target = eGPUType.Cuda; // To use OpenCL, change this enum
CudafyModes.DeviceId = 0;
CudafyTranslator.Language = CudafyModes.Target == eGPUType.OpenCL ? eLanguage.OpenCL : eLanguage.Cuda;
Console.WriteLine("===================================\n Cudafy.Demo\n Hybrid DSP Systems\nCopyright © Hybrid DSP Systems 2011\n===================================");
Console.WriteLine("\n* Modern adaptation by dev.lepo.co\n");
try
{
int deviceCount = CudafyHost.GetDeviceCount(CudafyModes.Target);
if (deviceCount == 0)
{
Console.WriteLine("No suitable {0} devices found.", CudafyModes.Target);
goto theEnd;
}
GPGPU gpu = CudafyHost.GetDevice(CudafyModes.Target, CudafyModes.DeviceId);
Console.WriteLine("Running examples using {0}", gpu.GetDeviceProperties(false).Name);
// Chapter 3
Console.WriteLine("\r\nChapter 3");
Console.WriteLine("\r\nhello_world");
hello_world.Execute();
Console.WriteLine("\r\nsimple_kernel");
simple_kernel.Execute();
Console.WriteLine("\r\nsimple_kernel_params");
simple_kernel_params.Execute();
Console.WriteLine("\r\nenum_gpu");
enum_gpu.Execute();
// Chapter 4
Console.WriteLine("\r\nChapter 4");
Console.WriteLine("\r\nadd_loop_cpu");
add_loop_cpu.Execute();
Console.WriteLine("\r\nadd_loop_gpu");
add_loop_gpu.Execute();
Console.WriteLine("\r\nadd_loop_gpu_alt");
add_loop_gpu_alt.Execute();
Console.WriteLine("\r\nadd_loop_long");
add_loop_long.Execute();
Console.WriteLine("\r\njulia (cpu)");
new julia_gui(false).ShowDialog();
Console.WriteLine("\r\njulia (gpu)");
new julia_gui(true).ShowDialog();
// Chapter 5
Console.WriteLine("\r\nChapter 5");
Console.WriteLine("\r\nadd_loop_blocks");
add_loop_blocks.Execute();
Console.WriteLine("\r\nadd_loop_long_blocks");
add_loop_long_blocks.Execute();
Console.WriteLine("\r\nripple");
ripple r = new ripple();
r.Execute();
Console.WriteLine("\r\ndot");
dot.Execute();
// Chapter 6
Console.WriteLine("\r\nChapter 6");
Console.WriteLine("\r\nray (no constant memory) (OpenCL compatible as well as CUDA)");
new ray_gui(ray_gui.eRayVersion.OpenCL).ShowDialog();
Console.WriteLine("\r\nray (constant memory) (OpenCL compatible as well as CUDA)");
new ray_gui(ray_gui.eRayVersion.OpenCL_const).ShowDialog();
if (CudafyTranslator.Language == eLanguage.Cuda) // CUDA only
{
Console.WriteLine("\r\nray (no constant memory)");
new ray_gui(ray_gui.eRayVersion.CUDA).ShowDialog(); // no const
Console.WriteLine("\r\nray (constant memory)");
new ray_gui(ray_gui.eRayVersion.CUDA_const).ShowDialog(); // const
}
// Chapter 9
Console.WriteLine("\r\nChapter 9");
Console.WriteLine("\r\nhist_gpu_shmem_atomics");
hist_gpu_shmem_atomics.Execute();
// Chapter 10
Console.WriteLine("\r\nChapter 10");
Console.WriteLine("\r\nbasic_double_stream_correct");
basic_double_stream_correct.Execute();
Console.WriteLine("\r\ncopy_timed");
new copy_timed().Execute();
Console.WriteLine("Done!");
}
catch (Exception ex)
{
Console.WriteLine(ex);
}
theEnd:
Console.ReadKey();
}
static void Main(string[] args)
{
try
{
CudafyModes.DeviceId = 0;
GPGPU gpu = CudafyHost.GetDevice(eGPUType.Cuda, CudafyModes.DeviceId);
CudafyModes.Architecture = gpu.GetArchitecture(); //eArchitecture.sm_35; // *** Change this to the architecture of your target board ***
CudafyModes.Target = CompilerHelper.GetGPUType(CudafyModes.Architecture);
Console.WriteLine("{0}: Arch: {1}, Type: {2}, ID: {3}", gpu.GetDeviceProperties(false).Name, CudafyModes.Architecture, CudafyModes.Target, CudafyModes.DeviceId);
if (CudafyModes.Target == eGPUType.Cuda)
{
CURANDTests.Basics();
}
SIMDFunctionTests sft = new SIMDFunctionTests();
CudafyUnitTest.PerformAllTests(sft);
StringTests st = new StringTests();
CudafyUnitTest.PerformAllTests(st);
BasicFunctionTests bft = new BasicFunctionTests();
CudafyUnitTest.PerformAllTests(bft);
GMathUnitTests gmu = new GMathUnitTests();
CudafyUnitTest.PerformAllTests(gmu);
MultithreadedTests mtt = new MultithreadedTests();
CudafyUnitTest.PerformAllTests(mtt);
CopyTests1D ct1d = new CopyTests1D();
CudafyUnitTest.PerformAllTests(ct1d);
GPGPUTests gput = new GPGPUTests();
CudafyUnitTest.PerformAllTests(gput);
if (CudafyHost.GetDeviceCount(CudafyModes.Target) > 1)
{
MultiGPUTests mgt = new MultiGPUTests();
CudafyUnitTest.PerformAllTests(mgt);
}
if (CudafyModes.Architecture >= eArchitecture.sm_30 && CudafyModes.Target == eGPUType.Cuda)
{
WarpShuffleTests wst = new WarpShuffleTests();
CudafyUnitTest.PerformAllTests(wst);
}
if (CudafyModes.Architecture >= eArchitecture.sm_35 && CudafyModes.Target == eGPUType.Cuda)
{
Compute35Features c35f = new Compute35Features();
CudafyUnitTest.PerformAllTests(c35f);
}
Console.WriteLine("Done");
Console.ReadLine();
}
catch (Exception ex)
{
Console.WriteLine(ex.ToString());
Console.ReadLine();
}
}
public static IEnumerable <string> TestCUDASDK()
{
StringBuilder sb = new StringBuilder();
NvccCompilerOptions nvcc = null;
if (IntPtr.Size == 8)
{
nvcc = NvccCompilerOptions.Createx64();
}
else
{
nvcc = NvccCompilerOptions.Createx86();
}
yield return(string.Format("Platform={0}", nvcc.Platform));
yield return("Checking for CUDA SDK at " + nvcc.CompilerPath);
if (!nvcc.TryTest())
{
yield return("Could not locate CUDA Include directory.");
}
else
{
yield return(string.Format("CUDA SDK Version={0}", nvcc.Version));
yield return("Attempting to cudafy a kernel function.");
var mod = CudafyTranslator.Cudafy(nvcc.Platform, eArchitecture.sm_11, nvcc.Version, false, typeof(CUDACheck));
yield return("Successfully translated to CUDA C.");
yield return("Attempting to compile CUDA C code.");
string s = mod.Compile(eGPUCompiler.CudaNvcc, true);
yield return("Successfully compiled CUDA C into a module.");
if (CudafyHost.GetDeviceCount(eGPUType.Cuda) > 0)
{
yield return("Attempting to instantiate CUDA device object (GPGPU).");
var gpu = CudafyHost.GetDevice(eGPUType.Cuda, 0);
yield return("Successfully got CUDA device 0.");
yield return("Attempting to load module.");
gpu.LoadModule(mod);
yield return("Successfully loaded module.");
yield return("Attempting to transfer data to GPU.");
int[] a = new int[1024];
int[] b = new int[1024];
int[] c = new int[1024];
Random rand = new Random();
for (int i = 0; i < 1024; i++)
{
a[i] = rand.Next(16384);
b[i] = rand.Next(16384);
}
int[] dev_a = gpu.CopyToDevice(a);
int[] dev_b = gpu.CopyToDevice(b);
int[] dev_c = gpu.Allocate(c);
yield return("Successfully transferred data to GPU.");
yield return("Attempting to launch function on GPU.");
gpu.Launch(1, 1024).TestKernelFunction(dev_a, dev_b, dev_c);
yield return("Successfully launched function on GPU.");
yield return("Attempting to transfer results back from GPU.");
gpu.CopyFromDevice(dev_c, c);
yield return("Successfully transferred results from GPU.");
yield return("Testing results.");
int errors = 0;
for (int i = 0; i < 1024; i++)
{
if (a[i] + b[i] != c[i])
{
errors++;
}
}
if (errors == 0)
{
yield return("Successfully tested results.");
}
else
{
yield return("Test failed - results not as expected.");
}
yield return("Checking for math libraries (FFT, BLAS, SPARSE, RAND).");
var fft = GPGPUFFT.Create(gpu);
int version = fft.GetVersion();
if (version > 0)
{
yield return("Successfully detected.");
}
}
}
}
public static IEnumerable <string> TestOpenCL()
{
yield return("Attempting to cudafy a kernel function.");
//CudafyTranslator.Language = eLanguage.OpenCL;
var mod = CudafyTranslator.Cudafy(ePlatform.x64, eArchitecture.OpenCL, null, false, typeof(CUDACheck));
yield return("Successfully translated to OpenCL C.");
for (int id = 0; id < CudafyHost.GetDeviceCount(eGPUType.OpenCL); id++)
{
yield return("Attempting to instantiate OpenCL device object (GPGPU).");
var gpu = CudafyHost.GetDevice(eGPUType.OpenCL, id);
yield return(string.Format("Successfully got OpenCL device {0}.", id));
yield return("Name: " + gpu.GetDeviceProperties(false).Name);
yield return("Attempting to load module.");
gpu.LoadModule(mod);
yield return("Successfully loaded module.");
yield return("Attempting to transfer data to device.");
int[] a = new int[1024];
int[] b = new int[1024];
int[] c = new int[1024];
Random rand = new Random();
for (int i = 0; i < 1024; i++)
{
a[i] = rand.Next(16384);
b[i] = rand.Next(16384);
}
int[] dev_a = gpu.CopyToDevice(a);
int[] dev_b = gpu.CopyToDevice(b);
int[] dev_c = gpu.Allocate(c);
yield return("Successfully transferred data to device.");
yield return("Attempting to launch function on device.");
gpu.Launch(4, 256).TestKernelFunction(dev_a, dev_b, dev_c);
yield return("Successfully launched function on device.");
yield return("Attempting to transfer results back from device.");
gpu.CopyFromDevice(dev_c, c);
yield return("Successfully transferred results from device.");
yield return("Testing results.");
int errors = 0;
for (int i = 0; i < 1024; i++)
{
if (a[i] + b[i] != c[i])
{
errors++;
}
}
if (errors == 0)
{
yield return("Successfully tested results.\r\n\r\n");
}
else
{
yield return("Test failed - results not as expected.\r\n\r\n");
}
}
}