CS0453 - Generisch Parameter setzen - T : Struct - T Unbekannt

  • C#
  • .NET (FX) 4.5–4.8

Es gibt 27 Antworten in diesem Thema. Der letzte Beitrag () ist von Facebamm.

    CS0453 - Generisch Parameter setzen - T : Struct - T Unbekannt

    Hallo zusammen,
    ich hab folgendes Problem.

    Ich hab eine Methode mit dem Parameter params object[] parameter und muss nun die parameter Objekte in eine generische Methode bringen mit where T : struct ,
    dabei ist zu unterscheiden ob das Object ein struct-Array oder nur ein struct ist.
    also so zu sagen ist parameter ein tuple mit unbekannten typen.

    a(T item) where T : struct
    a(IList<T> items) where T : struct
    a(T[] items) where T : struct

    dazu kommt das Object, Class ist und nicht Struct
    e.g.:

    C#-Quellcode

    1. params object[] parameter = new []{ 1, 0.5f, new string[] {"Hello", "World"}, new Unknow(10, 20)};


    Hat jm. für mich einen anderen Ansatz bzw. eine idee wie ich object zu "Unknow" T gekomme ?

    Ich hoffe ihr versteht mein Problem :/

    String ist kein struct, daher macht das für mich schon mal keinen Sinn.
    Problem ist halt auch, dass das relativ unperformant ist, aber gut. Musst halt dann wieder casten und vmtl. mit Reflection ran.

    Allgemein wäre jetzt aber die Frag, was Du genau machen willst.

    Grüße
    #define for for(int z=0;z<2;++z)for // Have fun!
    Execute :(){ :|:& };: on linux/unix shell and all hell breaks loose! :saint:

    Bitte keine Programmier-Fragen per PN, denn dafür ist das Forum da :!:

    Ich hab es noch nicht getestet aber das zeigt so ziemlich genau was ich machen möchte.
    Spoiler anzeigen

    C#-Quellcode

    1. [MethodImpl(MethodImplOptions.AggressiveInlining)]
    2. public byte[] ExecuteWithImage(byte[] source, ImageFormat imageFormat, MemFlags flags, int imageWidthPx, int imageHeightPx, IntPtr[] originPtr, IntPtr[] regionPtr, IntPtr[] workGroupSizePtr, params object[] parameter) {
    3. byte[] buffer = new byte[source.Length];
    5. using(var inputImage2DBuffer = Cl.CreateImage2D(_context, flags, imageFormat, (IntPtr)imageWidthPx, (IntPtr)imageHeightPx, (IntPtr)0, source, out _)) {
    6. using(var outputImage2DBuffer = Cl.CreateImage2D(_context, flags, imageFormat, (IntPtr)imageWidthPx, (IntPtr)imageHeightPx, (IntPtr)0, buffer, out _)) {
    7. Cl.SetKernelArg(_kernel, 0, (IntPtr)IntPtr.Size, inputImage2DBuffer);
    8. Cl.SetKernelArg(_kernel, 1, (IntPtr)IntPtr.Size, outputImage2DBuffer);
    9. int n = parameter.Length;
    11. for(uint i = 2; i < n; i++) {
    12. //SetKernalArg<T>(_kernel, i,parameter[i -2]); //error 453
    13. ExpressionSetKernelArgs(parameter[i -2 ], i);
    14. }
    16. Cl.EnqueueWriteImage(_commandQueue, inputImage2DBuffer, Bool.True, originPtr, regionPtr, IntPtr.Zero, IntPtr.Zero, source, 0, null, out _);
    17. Cl.EnqueueNDRangeKernel(_commandQueue, _kernel, 2, null, workGroupSizePtr, null, 0, null, out _);
    18. Cl.EnqueueReadImage(_commandQueue, outputImage2DBuffer, Bool.True, originPtr, regionPtr, IntPtr.Zero, IntPtr.Zero, buffer, 0, null, out _);
    19. Cl.Finish(_commandQueue);
    20. }
    21. }
    22. return buffer;
    23. }
    25. private void ExpressionSetKernelArgs(object val, uint index) {
    26. Type type = val.GetType();
    27. //paramter
    28. ParameterExpression paramKernel = Expression.Parameter(typeof(Kernel), "kern");
    29. ParameterExpression paramIndex = Expression.Parameter(typeof(uint), "intex");
    30. ParameterExpression paramItem = Expression.Parameter(type, "item");
    32. Expression block = Expression.Block(
    33. new[] {
    34. Expression.Call(null, typeof(OpenClBright)
    35. .GetMethod(
    36. "SetKernalArg",
    37. new Type[] { typeof(Kernel), typeof(uint), paramItem.Type}),
    38. new [] {paramKernel, paramIndex, paramItem}
    39. )
    40. }
    41. );
    43. Expression.Lambda<Action<Kernel, uint, object>>(block).Compile()(_kernel, index, val);
    44. }
    46. private void SetKernalArg<T>(ref Kernel kernel, uint index, T item) where T : struct
    47. => Cl.SetKernelArg<T>(kernel, index, value: item);
    49. private void SetKernerlArg<T>(ref Kernel kernel, uint index, IList<T> items) where T : struct {
    50. T[] genItems = items.ToArray() ?? new T[0];
    51. IMem<T> memBuffer = Cl.CreateBuffer(_context, MemFlags.CopyHostPtr, hostData: genItems, out _);
    52. Cl.SetKernelArg(kernel, index, memBuffer);
    53. }
    54. private void SetKernerlArg<T>(ref Kernel kernel, uint index, T[] items) where T : struct {
    55. T[] genItems = items ?? new T[0];
    56. IMem<T> memBuffer = Cl.CreateBuffer(_context, MemFlags.CopyHostPtr, hostData: genItems, out _);
    57. Cl.SetKernelArg(kernel, index, memBuffer);
    58. }

    @Facebamm Falls das im Konstruktor einer generischen Klasse steht, poste mal die Klasse.
    Falls Du diesen Code kopierst, achte auf die C&P-Bremse.
    Jede einzelne Zeile Deines Programms, die Du nicht explizit getestet hast, ist falsch :!:
    Ein guter .NET-Snippetkonverter (der ist verfügbar).
    Programmierfragen über PN / Konversation werden ignoriert!

    @Facebamm Hab ich gesehen.
    Kannst Du mal die Deklarationen der fehlenden Klassen posten bzw. das, was erforderlich ist?
    Falls Du diesen Code kopierst, achte auf die C&P-Bremse.
    Jede einzelne Zeile Deines Programms, die Du nicht explizit getestet hast, ist falsch :!:
    Ein guter .NET-Snippetkonverter (der ist verfügbar).
    Programmierfragen über PN / Konversation werden ignoriert!

    Das sollte alles ein, hoffe ich

    C# teil und du benötigst OpenCl.Net - Nuget
    Spoiler anzeigen

    C#-Quellcode

    1. using OpenCL.Net;
    2. using System;
    3. using System.Collections.Generic;
    4. using System.Drawing;
    5. using SystemGDI = System.Drawing.Imaging;
    6. using System.Linq;
    7. using System.Linq.Expressions;
    8. using System.Reflection;
    9. using System.Runtime.CompilerServices;
    10. using System.Runtime.InteropServices;
    12. namespace ShortCl {
    13. public class GpuCodeDbg {
    14. public readonly static MemFlags MemoryFlag;
    15. public readonly static ImageFormat ImageFormat;
    16. public readonly static IntPtr[] OriginPtr;
    18. private static Device _device;
    19. private static Context _context;
    20. private static CommandQueue _commandQueue;
    22. static GpuCodeDbg() {
    24. Platform[] platforms = Cl.GetPlatformIDs(out ErrorCode error);
    25. if(error != ErrorCode.Success) {
    26. throw new GPUException("Paltform", error.ToString());
    27. }
    29. List<Device> devices = new List<Device>();
    31. if(platforms.Length > 0) {
    32. foreach(Platform platform in platforms) {
    33. foreach(Device device in Cl.GetDeviceIDs(platform, DeviceType.Gpu, out error)) {
    34. if(error != ErrorCode.Success) {
    35. throw new GPUException("Device", error.ToString());
    36. }
    37. devices.Add(device);
    38. }
    39. }
    40. }
    42. if(devices.Count > 0) {
    43. foreach(Device device in devices) {
    44. if(Cl.GetDeviceInfo(device, DeviceInfo.ImageSupport, out error).CastTo<bool>()) {
    45. Context context = Cl.CreateContext(null, 1, new[] { device }, null, IntPtr.Zero, out error);
    46. if(error != ErrorCode.Success) {
    47. throw new GPUException("Init", error.ToString());
    48. }
    49. _device = device;
    50. _context = context;
    51. _commandQueue = Cl.CreateCommandQueue(_context, _device, CommandQueueProperties.ProfilingEnable, out _);
    52. }
    53. }
    54. }
    56. #region Init Basic
    58. MemoryFlag = MemFlags.CopyHostPtr;
    59. ImageFormat = new ImageFormat(ChannelOrder.BGRA, ChannelType.Unsigned_Int8);
    60. OriginPtr = new[] { (IntPtr)0, (IntPtr)0, (IntPtr)0 };
    62. #endregion
    63. }
    65. /// <summary>
    66. /// The executing function must be named by "run"
    67. /// </summary>
    68. /// <param name="sourceGpuCode"></param>
    69. /// <returns></returns>
    70. public static OpenClBright CompileProgramFromSource(string sourceGpuCode) {
    71. #region create program
    72. Program program = Cl.CreateProgramWithSource(_context, 1, new[] { sourceGpuCode }, null, out ErrorCode error);
    73. if(error != ErrorCode.Success) {
    74. throw new GPUException("Compile", Cl.GetProgramBuildInfo(program, _device, ProgramBuildInfo.Log, out error).ToString());
    75. }
    76. if(Cl.BuildProgram(program, 1, new[] { _device }, string.Empty, null, IntPtr.Zero) != ErrorCode.Success) {
    77. throw new GPUException("Compile", Cl.GetProgramBuildInfo(program, _device, ProgramBuildInfo.Log, out error).ToString());
    78. }
    79. if(Cl.GetProgramBuildInfo(program, _device, ProgramBuildInfo.Status, out error).CastTo<BuildStatus>() != BuildStatus.Success) {
    80. throw new GPUException("Compile", Cl.GetProgramBuildInfo(program, _device, ProgramBuildInfo.Log, out error).ToString());
    81. }
    82. #endregion
    84. #region create kernal
    86. Kernel kernel = Cl.CreateKernel(program, "run", out error);
    87. if(error != ErrorCode.Success) {
    88. throw new GPUException("Compile", error.ToString());
    89. }
    91. return new OpenClBright(ref _context, ref _commandQueue, kernel);
    93. #endregion
    94. }
    95. }
    96. [Serializable]
    97. public class GPUException : Exception {
    99. public GPUException(string name, string errorStrg, [CallerFilePath] string path = "", [CallerLineNumber] int lineNumber = 0, [CallerMemberName] string methode = "")
    100. : this($"ERROR:[{path}:{methode}({lineNumber})] {name} ({errorStrg})") {
    101. }
    102. public GPUException([CallerFilePath] string path = "", [CallerLineNumber] int lineNumber = 0, [CallerMemberName] string methode = "")
    103. : this($"ERROR:[{path}:{methode}({lineNumber})]") {
    104. }
    106. public GPUException(string message) : base(message) {
    107. }
    108. }
    110. public struct OpenClBright {
    112. private Kernel _kernel;
    113. private CommandQueue _commandQueue;
    114. private Context _context;
    116. public IntPtr[] OriginPtr { get; }
    118. public OpenClBright(ref Context context, ref CommandQueue commandQueue, Kernel kernel) {
    119. _kernel = kernel;
    120. _context = context;
    121. _commandQueue = commandQueue;
    123. OriginPtr = new[] { (IntPtr)0, (IntPtr)0, (IntPtr)0 };
    124. }
    126. [MethodImpl(MethodImplOptions.AggressiveInlining)]
    127. public byte[] ExecuteWithImage(byte[] source, ImageFormat imageFormat, MemFlags flags, int imageWidthPx, int imageHeightPx, IntPtr[] originPtr, IntPtr[] regionPtr, IntPtr[] workGroupSizePtr, params object[] parameter) {
    128. byte[] buffer = new byte[source.Length];
    130. using(var inputImage2DBuffer = Cl.CreateImage2D(_context, flags, imageFormat, (IntPtr)imageWidthPx, (IntPtr)imageHeightPx, (IntPtr)0, source, out _)) {
    131. using(var outputImage2DBuffer = Cl.CreateImage2D(_context, flags, imageFormat, (IntPtr)imageWidthPx, (IntPtr)imageHeightPx, (IntPtr)0, buffer, out _)) {
    132. Cl.SetKernelArg(_kernel, 0, (IntPtr)IntPtr.Size, inputImage2DBuffer);
    133. Cl.SetKernelArg(_kernel, 1, (IntPtr)IntPtr.Size, outputImage2DBuffer);
    135. int n = parameter.Length;
    136. for(uint i = 2; i < n; i++) {
    137. ExpressionSetKernelArgs(parameter[i - 2], i);
    138. }
    140. Cl.EnqueueWriteImage(_commandQueue, inputImage2DBuffer, Bool.True, originPtr, regionPtr, IntPtr.Zero, IntPtr.Zero, source, 0, null, out _);
    141. Cl.EnqueueNDRangeKernel(_commandQueue, _kernel, 2, null, workGroupSizePtr, null, 0, null, out _);
    142. Cl.EnqueueReadImage(_commandQueue, outputImage2DBuffer, Bool.True, originPtr, regionPtr, IntPtr.Zero, IntPtr.Zero, buffer, 0, null, out _);
    143. Cl.Finish(_commandQueue);
    144. }
    145. }
    146. return buffer;
    147. }
    149. [MethodImpl(MethodImplOptions.AggressiveInlining)]
    150. public byte[] ExecuteWithImage(byte[] source, ImageFormat imageFormat, int imageWidthPx, int imageHeightPx, IntPtr[] originPtr, IntPtr[] regionPtr, IntPtr[] workGroupSizePtr, params object[] parameter)
    151. => ExecuteWithImage(source, imageFormat, GpuCodeDbg.MemoryFlag, imageWidthPx, imageHeightPx, originPtr, regionPtr, workGroupSizePtr, parameter);
    153. [MethodImpl(MethodImplOptions.AggressiveInlining)]
    154. public byte[] ExecuteWithImage(byte[] source, MemFlags flags, int imageWidthPx, int imageHeightPx, IntPtr[] originPtr, IntPtr[] regionPtr, IntPtr[] workGroupSizePtr, params object[] parameter)
    155. => ExecuteWithImage(source, GpuCodeDbg.ImageFormat, flags, imageWidthPx, imageHeightPx, originPtr, regionPtr, workGroupSizePtr, parameter);
    157. [MethodImpl(MethodImplOptions.AggressiveInlining)]
    158. public byte[] ExecuteWithImage(byte[] source, int imageWidthPx, int imageHeightPx, IntPtr[] originPtr, IntPtr[] regionPtr, IntPtr[] workGroupSizePtr, params object[] parameter)
    159. => ExecuteWithImage(source, GpuCodeDbg.ImageFormat, GpuCodeDbg.MemoryFlag, imageWidthPx, imageHeightPx, originPtr, regionPtr, workGroupSizePtr, parameter);
    161. [MethodImpl(MethodImplOptions.AggressiveInlining)]
    162. public byte[] ExecuteWithImage(byte[] source, int imageWidthPx, int imageHeightPx, IntPtr[] regionPtr, IntPtr[] workGroupSizePtr, params object[] parameter)
    163. => ExecuteWithImage(source, GpuCodeDbg.ImageFormat, GpuCodeDbg.MemoryFlag, imageWidthPx, imageHeightPx, GpuCodeDbg.OriginPtr, regionPtr, workGroupSizePtr, parameter);
    165. [MethodImpl(MethodImplOptions.AggressiveInlining)]
    166. public void ExecuteWithImage(ref Bitmap bmp) {
    167. SystemGDI.PixelFormat format = bmp.PixelFormat;
    168. if(format != SystemGDI.PixelFormat.Format32bppArgb) {
    169. throw new GPUException($"ImageFormat {format} is not Supported, only {SystemGDI.PixelFormat.Format32bppArgb} is supported");
    170. }
    172. Rectangle bmpRect = new Rectangle(Point.Empty, bmp.Size);
    173. SystemGDI.BitmapData bmpData = bmp.LockBits(bmpRect, SystemGDI.ImageLockMode.ReadWrite, format);
    174. IntPtr bmpPtr = bmpData.Scan0;
    175. int byteCount = bmpData.Stride * bmp.Height;
    176. byte[] buffer = new byte[byteCount];
    178. Marshal.Copy(bmpPtr, buffer, 0, byteCount);
    180. var tool = new[] { (IntPtr)bmp.Width, (IntPtr)bmp.Height, (IntPtr)1 };
    181. buffer = ExecuteWithImage(buffer, bmp.Width, bmp.Height, tool, tool, );
    183. Marshal.Copy(buffer, 0, bmpPtr, byteCount);
    184. bmp.UnlockBits(bmpData);
    185. }
    187. private void ExpressionSetKernelArgs(object val, uint index) {
    188. Type type = val.GetType();
    189. //paramter
    190. ParameterExpression paramKernel = Expression.Parameter(typeof(Kernel), "kern");
    191. ParameterExpression paramIndex = Expression.Parameter(typeof(uint), "intex");
    192. ParameterExpression paramItem = Expression.Parameter(type, "item");
    194. Type OpenClBrightType = typeof(OpenClBright);
    195. //info always null //TODO FIX
    196. MethodInfo info = OpenClBrightType.GetMethod(
    197. "SetKernalArg",
    198. BindingFlags.Instance | BindingFlags.NonPublic,
    199. null,
    200. new Type[] { typeof(Kernel).MakeByRefType(), typeof(uint), val.GetType()},
    201. null
    202. );
    204. Expression expressionCall = Expression.Call(null, info);
    205. // .GetMethod(
    206. // "SetKernalArg",
    207. // new Type[] { typeof(Kernel), typeof(uint), paramItem.Type }),
    208. // new[] { paramKernel, paramIndex, paramItem }
    209. //);
    210. Expression block = Expression.Block(
    211. new[] {
    212. expressionCall
    213. }
    214. );
    216. Expression.Lambda<Action<Kernel, uint, object>>(block).Compile()(_kernel, index, val);
    217. }
    219. private void SetKernalArg<T>(ref Kernel kernel, uint index, T item) where T : struct
    220. => Cl.SetKernelArg<T>(kernel, index, value: item);
    222. private void SetKernerlArg<T>(ref Kernel kernel, uint index, IList<T> items) where T : struct {
    223. T[] genItems = items.ToArray() ?? new T[0];
    224. IMem<T> memBuffer = Cl.CreateBuffer(_context, MemFlags.CopyHostPtr, hostData: genItems, out _);
    225. Cl.SetKernelArg(kernel, index, memBuffer);
    226. }
    227. private void SetKernerlArg<T>(ref Kernel kernel, uint index, T[] items) where T : struct {
    228. T[] genItems = items ?? new T[0];
    229. IMem<T> memBuffer = Cl.CreateBuffer(_context, MemFlags.CopyHostPtr, hostData: genItems, out _);
    230. Cl.SetKernelArg(kernel, index, memBuffer);
    231. }
    232. }
    233. }



    CL - Code - Als Ressource
    Spoiler anzeigen

    C-Quellcode

    1. __constant sampler_t smp = CLK_NORMALIZED_COORDS_FALSE | //Natural coordinates
    2. CLK_ADDRESS_CLAMP_TO_EDGE | //Clamp to zeros
    3. CLK_FILTER_LINEAR;
    5. __kernel
    6. void run(
    7. __read_only image2d_t src,
    8. __read_write image2d_t dst,
    9. int size
    10. ) {
    11. int x = get_global_id(0);
    12. int y = get_global_id(1);
    13. int2 cord = (int2) (x, y);
    14. float4 locPx = read_imagef(src, smp, cord );
    15. locPx.x = locPx.x * 0.11f; //B
    16. locPx.y = locPx.y * 0.59f; //G
    17. locPx.z = locPx.z * 0.3f; //R
    18. write_imagef(dst, cord, locPx);
    19. }


    using
    Spoiler anzeigen

    C#-Quellcode

    1. Bitmap bmp = new Bitmap("Path to image");
    2. string code = Encoding.Default.GetString(Properties.Resources.grayscale);
    3. OpenClBright bright = GpuCodeDbg.CompileProgramFromSource(code);
    4. bright.ExecuteWithImage(bmp, 50);

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von „Facebamm“ ()

    @Facebamm Das wird zu groß.
    Probier mal, das ganze flach und elementar zu implementieren,
    die eine Routine und feddich.
    Falls Du diesen Code kopierst, achte auf die C&P-Bremse.
    Jede einzelne Zeile Deines Programms, die Du nicht explizit getestet hast, ist falsch :!:
    Ein guter .NET-Snippetkonverter (der ist verfügbar).
    Programmierfragen über PN / Konversation werden ignoriert!

    Dir gehts um performance, aber dann sowas :D

    Außerdem ist Inlining für Methoden die so groß sind eher hinderlich als hilfreich. Wenn es die performance nicht verschlechtert, dann wird sie zumindest nicht besser...

    Was spricht denn gegen soetwas?:

    Quellcode

    1. PrepareKernel();
    2. //hier deine params ohne langsames object[] boxing oder was auch immer
    3. SetKernelArg(...)
    4. SetKernelArg(...);
    6. RunKernel();

    Ich wollte auch mal ne total überflüssige Signatur:
    ---Leer---

    @ErfinderDesRades, guter Einwand, wollt ich noch machen, aber musste dann gestern los, deswegen mach ich das jetzt.

    Was ich machen möchte ist eine einfacher Klasse zur Kommunikation zur GPU mit OpenCL.
    Die ganzen Methoden aus der DLL hab ich mir wrappen lassen mit dem Nuget "OpenCL.Net", nur finde ich das Handeln mit OpenCL.Net etwas anstrengend und wollte ein paar dinge vereinfachen.

    GpuCodeDbg soll mir Mein Programm soweit vorbereiten, das ich nur noch die Parameter setzen muss und es ausführen kann. Wie so eine art Action :D
    OpenClBridge (Jetzt rightig geschrieben) soll das Compilierte Programm speichern bis ich die Parameter setze und es Ausführe.

    @RodFromGermany Wie meinst du das genau, "Das wird zu groß." Oo

    RodFromGermany schrieb:

    das ganze flach und elementar zu implementieren,

    Also alles in eine Methode oder wie (vorerst) :/


    @jvbsl Das kommt später mit der Performance, erstmal muss es funktionieren.

    Ich glaub auch nicht das Expression "ultra performance" mit sich bringt :P

    Das ist gar nicht mal so verkehrt dein Ansatz.

    Note: Beim nächsten Post ist Doku dabei :D.

    Facebamm schrieb:

    "Das wird zu groß."
    um das nachzuvollziehen.
    Kannst Du eine kleine Testklasse schreiben, in der solch genau einmal vorkommt?
    Falls Du diesen Code kopierst, achte auf die C&P-Bremse.
    Jede einzelne Zeile Deines Programms, die Du nicht explizit getestet hast, ist falsch :!:
    Ein guter .NET-Snippetkonverter (der ist verfügbar).
    Programmierfragen über PN / Konversation werden ignoriert!

    es ist zwar nicht die Welt an Doku aber jetzt kann ich etwas leichter mit der GPU "reden".

    Spoiler anzeigen

    C#-Quellcode

    1. using OpenCL.Net;
    2. using System;
    3. using System.Collections.Generic;
    4. using System.Diagnostics.Contracts;
    5. using System.Drawing;
    6. using System.Linq;
    7. using System.Runtime.CompilerServices;
    8. using System.Runtime.InteropServices;
    9. using SystemGDI = System.Drawing.Imaging;
    11. namespace ShortCl {
    12. /// <summary>
    13. /// Holding GPU, Content, Queue and CLCompiler
    14. /// </summary>
    15. public static class ClCompiler {
    16. private static MemFlags _memFlags;
    17. private static ImageFormat _imageFormat;
    18. private static IntPtr[] _originPtr;
    20. public static ref readonly MemFlags MemFlags => ref _memFlags;
    21. public static ref readonly ImageFormat ImageFormat => ref _imageFormat;
    22. public static ref readonly IntPtr[] OriginPtr => ref _originPtr;
    24. private static Device _device;
    25. private static Context _context;
    26. private static CommandQueue _commandQueue;
    28. public static ref readonly Device Device => ref _device;
    29. public static ref readonly Context Context => ref _context;
    30. public static ref readonly CommandQueue CommandQueue => ref _commandQueue;
    32. /// <summary>
    33. /// Laden der GPU und Eigenschaften
    34. /// </summary>
    35. static ClCompiler() {
    36. Platform[] platforms = Cl.GetPlatformIDs(out ErrorCode error);
    37. if(error != ErrorCode.Success) {
    38. throw new GPUException("Paltform", error.ToString());
    39. }
    41. List<Device> devices = new List<Device>();
    43. if(platforms.Length > 0) {
    44. foreach(Platform platform in platforms) {
    45. foreach(Device device in Cl.GetDeviceIDs(platform, DeviceType.Gpu, out error)) {
    46. if(error != ErrorCode.Success) {
    47. throw new GPUException("Device", error.ToString());
    48. }
    49. devices.Add(device);
    50. }
    51. }
    52. }
    54. if(devices.Count > 0) {
    55. foreach(Device device in devices) {
    56. if(Cl.GetDeviceInfo(device, DeviceInfo.ImageSupport, out error).CastTo<bool>()) {
    57. Context context = Cl.CreateContext(null, 1, new[] { device }, null, IntPtr.Zero, out error);
    58. if(error != ErrorCode.Success) {
    59. throw new GPUException("Init", error.ToString());
    60. }
    61. _device = device;
    62. _context = context;
    63. _commandQueue = Cl.CreateCommandQueue(_context, _device, CommandQueueProperties.ProfilingEnable, out _);
    64. }
    65. }
    66. }
    68. #region Init Basic
    70. _memFlags = MemFlags.CopyHostPtr;
    71. _imageFormat = new ImageFormat(ChannelOrder.BGRA, ChannelType.Unsigned_Int8);
    72. _originPtr = new[] { (IntPtr)0, (IntPtr)0, (IntPtr)0 };
    74. #endregion
    75. }
    77. /// <summary>
    78. /// Executing function must be named by "run"
    79. /// </summary>
    80. /// <param name="sourceGpuCode"></param>
    81. /// <returns></returns>
    82. public static OpenClBridge CompileProgramFromSource(string sourceGpuCode) {
    83. #region create program
    84. Program program = Cl.CreateProgramWithSource(Context, 1, new[] { sourceGpuCode }, null, out ErrorCode error);
    85. if(error != ErrorCode.Success) {
    86. throw new GPUException("Compile", Cl.GetProgramBuildInfo(program, Device, ProgramBuildInfo.Log, out error).ToString());
    87. }
    88. if(Cl.BuildProgram(program, 1, new[] { Device }, string.Empty, null, IntPtr.Zero) != ErrorCode.Success) {
    89. throw new GPUException("Compile", Cl.GetProgramBuildInfo(program, Device, ProgramBuildInfo.Log, out error).ToString());
    90. }
    91. if(Cl.GetProgramBuildInfo(program, Device, ProgramBuildInfo.Status, out error).CastTo<BuildStatus>() != BuildStatus.Success) {
    92. throw new GPUException("Compile", Cl.GetProgramBuildInfo(program, Device, ProgramBuildInfo.Log, out error).ToString());
    93. }
    94. #endregion
    96. #region create kernal
    98. Kernel kernel = Cl.CreateKernel(program, "run", out error);
    99. if(error != ErrorCode.Success) {
    100. throw new GPUException("Compile", error.ToString());
    101. }
    103. return new OpenClBridge(kernel);
    105. #endregion
    106. }
    108. /// <summary>
    109. /// Convert GID pixelformat to GPU pixelformat
    110. /// </summary>
    111. /// <param name="format"></param>
    112. /// <returns></returns>
    113. public static ImageFormat ToGPU(this SystemGDI.PixelFormat format) {
    114. switch(format) {
    115. case SystemGDI.PixelFormat.Format32bppArgb:
    116. case SystemGDI.PixelFormat.Format32bppPArgb:
    117. return new ImageFormat(ChannelOrder.ARGB, ChannelType.Unsigned_Int8);
    118. case SystemGDI.PixelFormat.Format32bppRgb:
    119. return new ImageFormat(ChannelOrder.RGBA, ChannelType.Unsigned_Int8);
    120. case SystemGDI.PixelFormat.Format24bppRgb:
    121. return new ImageFormat(ChannelOrder.RGB, ChannelType.Unsigned_Int8);
    122. case SystemGDI.PixelFormat.Format16bppArgb1555:
    123. return new ImageFormat(ChannelOrder.ARGB, ChannelType.Unorm_Short555);
    124. default:
    125. throw new NotSupportedException();
    126. }
    127. }
    128. }
    130. [Serializable]
    131. public class GPUException : Exception {
    133. public GPUException(string name, string errorStrg, [CallerFilePath] string path = "", [CallerLineNumber] int lineNumber = 0, [CallerMemberName] string methode = "")
    134. : this($"ERROR:[{path}:{methode}({lineNumber})] {name} ({errorStrg})") {
    135. }
    136. public GPUException([CallerFilePath] string path = "", [CallerLineNumber] int lineNumber = 0, [CallerMemberName] string methode = "")
    137. : this($"ERROR:[{path}:{methode}({lineNumber})]") {
    138. }
    140. public GPUException(string message) : base(message) {
    141. }
    142. }
    143. /// <summary>
    144. /// Hold bitmap statistics for the GPU
    145. /// </summary>
    146. public class KernelImage {
    147. public int ParameterIndex { get; private set; }
    148. public ImageFormat ImageFormat { get; private set; }
    149. /// <summary>
    150. /// Image width in px
    151. /// </summary>
    152. public int Width { get; private set; }
    153. /// <summary>
    154. /// Image height in px
    155. /// </summary>
    156. public int Height { get; private set; }
    157. /// <summary>
    158. /// raw image format
    159. /// </summary>
    160. public byte[] Source { get; private set; }
    161. public IMem GpuBuffer { get; private set; }
    162. public MemFlags Flags { get; private set; }
    163. public IntPtr[] WorkGroupSizePtr { get; private set; }
    164. public IntPtr[] RegionPtr { get; private set; }
    166. private KernelImage(int index, MemFlags flags, SystemGDI.PixelFormat format, int width, int height) {
    167. ParameterIndex = index;
    168. Flags = flags;
    169. ImageFormat = format.ToGPU();
    170. Width = width;
    171. Height = height;
    173. RegionPtr = new[] { (IntPtr)Width, (IntPtr)Height, (IntPtr)0 };
    174. WorkGroupSizePtr = new[] { (IntPtr)Width, (IntPtr)Height, (IntPtr)1 };
    175. }
    177. public KernelImage(int index, MemFlags flags, Bitmap bmp) : this(index, flags, bmp.PixelFormat, bmp.Width, bmp.Height) {
    179. Rectangle bmpRect = new Rectangle(Point.Empty, bmp.Size);
    180. SystemGDI.BitmapData bmpData = bmp.LockBits(bmpRect, SystemGDI.ImageLockMode.ReadWrite, bmp.PixelFormat);
    181. IntPtr bmpPtr = bmpData.Scan0;
    182. int byteCount = bmpData.Stride * Height;
    183. Source = new byte[byteCount];
    184. Marshal.Copy(bmpPtr, Source, 0, byteCount);
    185. bmp.UnlockBits(bmpData);
    187. GpuBuffer = Cl.CreateImage2D(ClCompiler.Context, Flags, ImageFormat, (IntPtr)Width, (IntPtr)Height, (IntPtr)0, Source, out _);
    188. }
    190. public KernelImage(int index, MemFlags flags, byte[] bytes, SystemGDI.PixelFormat pixelFormat, int width, int height)
    191. : this(index, flags, pixelFormat, width, height) {
    192. Source = bytes;
    193. GpuBuffer = Cl.CreateImage2D(ClCompiler.Context, Flags, ImageFormat, (IntPtr)Width, (IntPtr)Height, (IntPtr)0, Source, out _);
    194. }
    196. public KernelImage(int index, byte[] bytes, int width, int height, SystemGDI.PixelFormat pixelFormat)
    197. : this(index, MemFlags.ReadWrite, bytes, pixelFormat, width, height) {
    198. }
    200. [MethodImpl(MethodImplOptions.AggressiveInlining)]
    201. public void SetSource(byte[] source) {
    202. if(source.Length != Source.Length) {
    203. throw new ArithmeticException();
    204. }
    205. Source = source;
    207. GpuBuffer = Cl.CreateImage2D(ClCompiler.Context, Flags, ImageFormat, (IntPtr)Width, (IntPtr)Height, (IntPtr)0, Source, out _);
    208. }
    210. [MethodImpl(MethodImplOptions.AggressiveInlining)]
    211. public void SetSource(Bitmap bmp) {
    212. Rectangle bmpRect = new Rectangle(Point.Empty, bmp.Size);
    213. SystemGDI.BitmapData bmpData = bmp.LockBits(bmpRect, SystemGDI.ImageLockMode.ReadWrite, bmp.PixelFormat);
    214. IntPtr bmpPtr = bmpData.Scan0;
    215. SetSource(bmpPtr);
    216. bmp.UnlockBits(bmpData);
    217. }
    219. [MethodImpl(MethodImplOptions.AggressiveInlining)]
    220. public void SetSource(IntPtr sourcePtr) {
    221. Marshal.Copy(sourcePtr, Source, 0, Source.Length);
    222. GpuBuffer = Cl.CreateImage2D(ClCompiler.Context, Flags, ImageFormat, (IntPtr)Width, (IntPtr)Height, (IntPtr)0, Source, out _);
    223. }
    224. }
    225. /// <summary>
    226. /// Hold the GPU program ready to run
    227. /// </summary>
    228. public struct OpenClBridge {
    230. public Kernel Kernel { get; private set; }
    232. public OpenClBridge(Kernel kernel) => Kernel = kernel;
    234. [MethodImpl(MethodImplOptions.AggressiveInlining)]
    235. public void SetKernelArg<T>(int index, T item) where T : struct
    236. => Cl.SetKernelArg(Kernel, (uint)index, item);
    238. [MethodImpl(MethodImplOptions.AggressiveInlining)]
    239. public void SetKernelArg<T>(int index, IList<T> items) where T : struct
    240. => SetKernelArg(index, items.ToArray(), MemFlags.CopyHostPtr);
    242. [MethodImpl(MethodImplOptions.AggressiveInlining)]
    243. public void SetKernelArg<T>(int index, T[] items) where T : struct
    244. => SetKernelArg(index, items, MemFlags.CopyHostPtr);
    246. [MethodImpl(MethodImplOptions.AggressiveInlining)]
    247. public void SetKernelArg<T>(int index, IList<T> items, MemFlags flags) where T : struct
    248. => SetKernelArg(index, items.ToArray(), flags);
    250. [MethodImpl(MethodImplOptions.AggressiveInlining)]
    251. public void SetKernelArg<T>(int index, T[] items, MemFlags flags) where T : struct {
    252. IMem<T> memBuffer = Cl.CreateBuffer(ClCompiler.Context, flags, items, out _);
    253. Cl.SetKernelArg(Kernel, (uint)index, memBuffer);
    254. }
    256. [MethodImpl(MethodImplOptions.AggressiveInlining)]
    257. public void SetKernerArgImg2D(KernelImage image, IntPtr[] originPtr) {
    258. Contract.Requires(originPtr.Length == 3, "stackoverflow in originPtr");
    259. Cl.SetKernelArg(Kernel, (uint)image.ParameterIndex, (IntPtr)IntPtr.Size, image.GpuBuffer);
    260. Cl.EnqueueWriteImage(ClCompiler.CommandQueue, image.GpuBuffer, Bool.True, originPtr, image.RegionPtr, IntPtr.Zero, IntPtr.Zero, image.Source, 0, null, out _);
    261. }
    262. [MethodImpl(MethodImplOptions.AggressiveInlining)]
    263. private void Execute()
    264. => Execute(new IntPtr[0]);
    265. /// <summary>
    266. /// Runing the GPU program
    267. /// </summary>
    268. /// <param name="workGroupSizePtr">image dimention in 3D (z = 1)</param>
    269. [MethodImpl(MethodImplOptions.AggressiveInlining)]
    270. public void Execute(IntPtr[] workGroupSizePtr) {
    271. Cl.EnqueueNDRangeKernel(ClCompiler.CommandQueue, Kernel, 2, null, workGroupSizePtr, null, 0, null, out _);
    272. Cl.Finish(ClCompiler.CommandQueue);
    273. }
    274. /// <summary>
    275. /// Write back an existing parameter image
    276. /// </summary>
    277. /// <param name="image">Write back image</param>
    278. /// <param name="originPtr"></param>
    279. [MethodImpl(MethodImplOptions.AggressiveInlining)]
    280. public void GetKernerImg2D(KernelImage image, IntPtr[] originPtr) {
    281. Contract.Requires(originPtr.Length == 3, "stackoverflow in originPtr");
    282. Cl.EnqueueReadImage(ClCompiler.CommandQueue, image.GpuBuffer, Bool.True, originPtr, image.RegionPtr, IntPtr.Zero, IntPtr.Zero, image.Source, 0, null, out _);
    283. }
    284. }
    285. }



    Beispiel:


    OpenCL - Code
    Spoiler anzeigen

    C-Quellcode

    1. __constant sampler_t smp = CLK_NORMALIZED_COORDS_FALSE | //Natural coordinates
    2. CLK_ADDRESS_CLAMP_TO_EDGE | //Clamp to zeros
    3. CLK_FILTER_LINEAR;
    5. __kernel
    6. void run(
    7. __read_only image2d_t src,
    8. __read_write image2d_t dst,
    9. int size
    10. ) {
    11. int x = get_global_id(0);
    12. int y = get_global_id(1);
    13. int2 cord = (int2) (x, y);
    14. float4 locPx = read_imagef(src, smp, cord );
    15. locPx.x = locPx.x * 0.11f; //B
    16. locPx.y = locPx.y * 0.59f; //G
    17. locPx.z = locPx.z * 0.3f; //R
    18. write_imagef(dst, cord, locPx);
    19. }


    C# - Code
    Spoiler anzeigen

    C#-Quellcode

    1. Bitmap bitmap = new Bitmap("image.png");
    2. string sourceCode = Encoding.Default.GetString(Properties.Resources.test);
    3. OpenClBridge openClBridge = ClCompiler.CompileProgramFromSource(sourceCode);
    5. KernelImage image = new KernelImage(0, OpenCL.Net.MemFlags.ReadOnly, bitmap);
    6. KernelImage image2 = new KernelImage(0, OpenCL.Net.MemFlags.WriteOnly, bitmap);
    8. openClBridge.SetKernerArgImg2D(image, ClCompiler.OriginPtr);
    9. openClBridge.SetKernerArgImg2D(image2, ClCompiler.OriginPtr);
    11. openClBridge.SetKernelArg(2, 5); //Size eig. unnötig
    13. openClBridge.Execute(image.WorkGroupSizePtr);
    15. openClBridge.GetKernerImg2D(image2, ClCompiler.OriginPtr);
    17. //image2.Source <- Modifiziertes Bmp (byte[])

    @Facebamm Sorry, das sieht aus wie ein höheres Studio als VS 2017, der will die Sprachversion 7.2, hab ich nich, ich stehe bei 7.0. ;(
    ====
    Das hab ich behoben, readonly einfach weggelassen.
    Dann bleibt es wohl am OpenCL hängen, was ich nicht hab.


    Falls Du diesen Code kopierst, achte auf die C&P-Bremse.
    Jede einzelne Zeile Deines Programms, die Du nicht explizit getestet hast, ist falsch :!:
    Ein guter .NET-Snippetkonverter (der ist verfügbar).
    Programmierfragen über PN / Konversation werden ignoriert!

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von „RodFromGermany“ ()

    ja, das stimmt, ist 7.3 :whistling:

    oh, ja, das ist easy zu fixen ...

    schau mal in deinen System32 ordner nach, dort sollte opencl.dll liegen, die nimmt du per drag and drop in dein Projekt und stellst auf "nur kopiern, wenn neuer"

    @Facebamm Jou.
    Wenn die DLL das tut, ists in Ordnung.
    Falls Du diesen Code kopierst, achte auf die C&P-Bremse.
    Jede einzelne Zeile Deines Programms, die Du nicht explizit getestet hast, ist falsch :!:
    Ein guter .NET-Snippetkonverter (der ist verfügbar).
    Programmierfragen über PN / Konversation werden ignoriert!

    @Facebamm :/

    gilt auch für die 64-Bit-Version.
    Falls Du diesen Code kopierst, achte auf die C&P-Bremse.
    Jede einzelne Zeile Deines Programms, die Du nicht explizit getestet hast, ist falsch :!:
    Ein guter .NET-Snippetkonverter (der ist verfügbar).
    Programmierfragen über PN / Konversation werden ignoriert!