private string GetSpecific(KernelConstantInfo kci) { StringBuilder sb = new StringBuilder(); if (kci != null) { sb.AppendLine("Declaration : " + kci.GetDeclaration()); } return sb.ToString(); }
private void lbConstants_SelectedIndexChanged(object sender, EventArgs e) { KernelConstantInfo item = lbConstants.SelectedItem as KernelConstantInfo; if (item != null) { string text = GetCommon(item as KernelMemberInfo); tbConstants.Text = text; text = GetSpecific(item); tbConstants.AppendText(text); } }
protected override void DoCopyToConstantMemoryAsync <T>(IntPtr hostArray, int hostOffset, Array devArray, int devOffset, int count, KernelConstantInfo ci, int streamId) { if (streamId >= 0 && !_streams.ContainsKey(streamId)) { _streams.Add(streamId, streamId); } int size = MSizeOf(typeof(T)); GCHandle handle = GCHandle.Alloc(devArray, GCHandleType.Pinned); IntPtr devArrayPtr = new IntPtr(handle.AddrOfPinnedObject().ToInt64() + (devOffset * size)); IntPtr hostArrayPtr = new IntPtr(hostArray.ToInt64() + (hostOffset * size)); CopyMemory(devArrayPtr, hostArrayPtr, (uint)(count * size)); }
/// <summary> /// Does the copy to constant memory. /// </summary> /// <typeparam name="T"></typeparam> /// <param name="hostArray">The host array.</param> /// <param name="hostOffset">The host offset.</param> /// <param name="devArray">The dev array.</param> /// <param name="devOffset">The dev offset.</param> /// <param name="count">The count.</param> /// <param name="ci">The ci.</param> protected override void DoCopyToConstantMemory <T>(Array hostArray, int hostOffset, Array devArray, int devOffset, int count, KernelConstantInfo ci) { Array.Copy(hostArray, hostOffset, devArray, devOffset, count); }
public static void AddConstant(KernelConstantInfo kci) { _constants.Add(kci); }
private static CudafyModule DoCudafy(CudafyModule cm, params Type[] types) { MemoryStream output = new MemoryStream(); var outputSw = new StreamWriter(output); MemoryStream structs = new MemoryStream(); var structsSw = new StreamWriter(structs); var structsPto = new PlainTextOutput(structsSw); MemoryStream declarations = new MemoryStream(); var declarationsSw = new StreamWriter(declarations); var declarationsPto = new PlainTextOutput(declarationsSw); MemoryStream code = new MemoryStream(); var codeSw = new StreamWriter(code); var codePto = new PlainTextOutput(codeSw); bool isDummy = false; eCudafyDummyBehaviour behaviour = eCudafyDummyBehaviour.Default; Dictionary <string, ModuleDefinition> modules = new Dictionary <string, ModuleDefinition>(); var compOpts = new DecompilationOptions { FullDecompilation = true }; CUDALanguage.Reset(); bool firstPass = true; if (cm == null) { cm = new CudafyModule();// #######!!! } else { firstPass = false; } // Test structs //foreach (var strct in types.Where(t => !t.IsClass)) // if (strct.GetCustomAttributes(typeof(CudafyAttribute), false).Length == 0) // throw new CudafyLanguageException(CudafyLanguageException.csCUDAFY_ATTRIBUTE_IS_MISSING_ON_X, strct.Name); IEnumerable <Type> typeList = GetWithNestedTypes(types); foreach (var type in typeList) { if (!modules.ContainsKey(type.Assembly.Location)) { modules.Add(type.Assembly.Location, ModuleDefinition.ReadModule(type.Assembly.Location)); } } // Additional loop to compile in order foreach (var requestedType in typeList) { foreach (var kvp in modules) { foreach (var td in kvp.Value.Types) { List <TypeDefinition> tdList = new List <TypeDefinition>(); tdList.Add(td); tdList.AddRange(td.NestedTypes); Type type = null; foreach (var t in tdList) { //type = typeList.Where(tt => tt.FullName.Replace("+", "") == t.FullName.Replace("/", "")).FirstOrDefault(); // Only select type if this matches the requested type (to ensure order is maintained). type = requestedType.FullName.Replace("+", "") == t.FullName.Replace("/", "") ? requestedType : null; if (type == null) { continue; } Debug.WriteLine(t.FullName); // Types var attr = t.GetCudafyType(out isDummy, out behaviour); if (attr != null) { _cl.DecompileType(t, structsPto, compOpts); if (firstPass) { cm.Types.Add(type.FullName.Replace("+", ""), new KernelTypeInfo(type, isDummy, behaviour));// #######!!! } } else if (t.Name == td.Name) { // Fields foreach (var fi in td.Fields) { attr = fi.GetCudafyType(out isDummy, out behaviour); if (attr != null) { VerifyMemberName(fi.Name); System.Reflection.FieldInfo fieldInfo = type.GetField(fi.Name, BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic); if (fieldInfo == null) { throw new CudafyLanguageException(CudafyLanguageException.csX_ARE_NOT_SUPPORTED, "Non-static fields"); } int[] dims = _cl.GetFieldInfoDimensions(fieldInfo); _cl.DecompileCUDAConstantField(fi, dims, codePto, compOpts); var kci = new KernelConstantInfo(fi.Name, fieldInfo, isDummy); if (firstPass) { cm.Constants.Add(fi.Name, kci);// #######!!! } CUDALanguage.AddConstant(kci); } } #warning TODO Only Global Methods can be called from host #warning TODO For OpenCL may need to do Methods once all Constants have been handled // Methods foreach (var med in td.Methods) { attr = med.GetCudafyType(out isDummy, out behaviour); if (attr != null) { if (!med.IsStatic) { throw new CudafyLanguageException(CudafyLanguageException.csX_ARE_NOT_SUPPORTED, "Non-static methods"); } _cl.DecompileMethodDeclaration(med, declarationsPto, new DecompilationOptions { FullDecompilation = false }); _cl.DecompileMethod(med, codePto, compOpts); MethodInfo mi = type.GetMethod(med.Name, BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic); if (mi == null) { continue; } VerifyMemberName(med.Name); eKernelMethodType kmt = eKernelMethodType.Device; kmt = GetKernelMethodType(attr, mi); if (firstPass) { cm.Functions.Add(med.Name, new KernelMethodInfo(type, mi, kmt, isDummy, behaviour, cm));// #######!!! } } } } } } } } codeSw.Flush(); if (CudafyTranslator.Language == eLanguage.OpenCL) { outputSw.WriteLine("#if defined(cl_khr_fp64)"); outputSw.WriteLine("#pragma OPENCL EXTENSION cl_khr_fp64: enable"); outputSw.WriteLine("#elif defined(cl_amd_fp64)"); outputSw.WriteLine("#pragma OPENCL EXTENSION cl_amd_fp64: enable"); outputSw.WriteLine("#endif"); } foreach (var oh in CUDALanguage.OptionalHeaders) { if (oh.Used && !oh.AsResource) { outputSw.WriteLine(oh.IncludeLine); } else if (oh.Used) { outputSw.WriteLine(GetResourceString(oh.IncludeLine)); } } foreach (var oh in CUDALanguage.OptionalFunctions) { if (oh.Used) { outputSw.WriteLine(oh.Code); } } declarationsSw.WriteLine(); declarationsSw.Flush(); structsSw.WriteLine(); structsSw.Flush(); foreach (var def in cm.GetDummyDefines()) { outputSw.WriteLine(def); } foreach (var inc in cm.GetDummyStructIncludes()) { outputSw.WriteLine(inc); } foreach (var inc in cm.GetDummyIncludes()) { outputSw.WriteLine(inc); } outputSw.Flush(); output.Write(structs.GetBuffer(), 0, (int)structs.Length); output.Write(declarations.GetBuffer(), 0, (int)declarations.Length); output.Write(code.GetBuffer(), 0, (int)code.Length); outputSw.Flush(); #if DEBUG using (FileStream fs = new FileStream("output.cu", FileMode.Create)) { fs.Write(output.GetBuffer(), 0, (int)output.Length); } #endif String s = Encoding.UTF8.GetString(output.GetBuffer(), 0, (int)output.Length); //cm.SourceCode = s;// #######!!! var scf = new SourceCodeFile(s, Language, _architecture); cm.AddSourceCodeFile(scf); return(cm); }
protected override void DoCopyToConstantMemoryAsync <T>(IntPtr hostArray, int hostOffset, Array devArray, int devOffset, int count, KernelConstantInfo ci, int streamId) { DoCopyToDeviceAsync <T>(hostArray, hostOffset, devArray, devOffset, count, streamId); }