public Task <Kernel> ConnectKernelAsync(KernelInfo kernelInfo)
{
var proxy = new ProxyKernel(kernelInfo.LocalName, _defaultReceiver.CreateChildReceiver(), _defaultSender);
var _ = proxy.StartAsync();
return(Task.FromResult((Kernel)proxy));
}
public extern static int clGetKernelInfo(
IntPtr kernel,
KernelInfo param_name,
IntPtr param_value_size,
byte[] param_value,
out IntPtr param_value_size_ret
);
public async Task OnLoadAsync(Kernel kernel)
{
if (kernel is CompositeKernel root)
{
root.UseVSCodeCommands();
root.VisitSubkernels(k =>
{
switch (k)
{
case CSharpKernel csharpKernel:
csharpKernel.UseVSCodeHelpers();
break;
case FSharpKernel fsharpKernel:
fsharpKernel.UseVSCodeHelpers();
break;
case PowerShellKernel powerShellKernel:
powerShellKernel.UseVSCodeHelpers();
break;
}
});
var vscodeKernelInfo = new KernelInfo("vscode", new[] { "frontend" }, new Uri("kernel://vscode/vscode", UriKind.Absolute));
var jsKernelInfo = new KernelInfo("javascript", new[] { "js" }, new Uri("kernel://webview/javascript", UriKind.Absolute));
await root.Host.CreateProxyKernelOnDefaultConnectorAsync(vscodeKernelInfo);
var jsKernel = await root.Host.CreateProxyKernelOnDefaultConnectorAsync(jsKernelInfo);
jsKernel.UseValueSharing(new JavaScriptKernelValueDeclarer());
}
}
void Start()
{
blockNoiseInfo = initShader(blockNoiseShader, blockNoiseTexture, "WriteBlockNoise");
perlinNoiseInfo = initShader(perlinNoiseShader, perlinNoiseTexture, "WritePerlinNoise");
fbmNoiseInfo = initShader(fbmNoiseShader, fbmNoiseTexture, "WriteFBMNoise");
domainWarpInfo = initShader(domainWarpShader, domainWarpTexture, "WriteDomainWarp");
}
private static KernelInfo initShader(ComputeShader shader, RenderTexture targetTexture, string kernelName)
{
KernelInfo kernelInfo = new KernelInfo();
if (targetTexture.format != RenderTextureFormat.ARGB32)
{
Debug.LogError(targetTexture.name + "は書き込み可能なテクスチャではないようです。");
}
// ComputeShaderから書き込む用のテクスチャを最終出力テクスチャの形に合わせて生成
kernelInfo.tempTexture = new RenderTexture(targetTexture.width, targetTexture.height, 1, targetTexture.format);
kernelInfo.tempTexture.enableRandomWrite = true;
// ComputeShaderにテクスチャをセット
kernelInfo.kernelIndex = shader.FindKernel(kernelName);
shader.SetTexture(kernelInfo.kernelIndex, "textureBuffer", kernelInfo.tempTexture);
// テクスチャサイズのチェック
shader.GetKernelThreadGroupSizes(
kernelInfo.kernelIndex,
out kernelInfo.threadSizeX,
out kernelInfo.threadSizeY,
out kernelInfo.threadSizeZ
);
float threadGroupSizeX = (float)kernelInfo.tempTexture.width / kernelInfo.threadSizeX;
float threadGroupSizeY = (float)kernelInfo.tempTexture.height / kernelInfo.threadSizeY;
if (threadGroupSizeX % 1 != 0 || threadGroupSizeY % 1 != 0)
{
Debug.LogError(targetTexture.name + "はスレッドグループ数が整数にならないので、テクスチャサイズを変えてください。");
}
return(kernelInfo);
}
public override async Task <Kernel> ConnectKernelAsync(KernelInfo kernelInfo)
{
ProxyKernel?proxyKernel;
if (_receiver is not null)
{
proxyKernel = new ProxyKernel(kernelInfo.LocalName, _receiver.CreateChildReceiver(), _sender);
}
else
{
_clientStream = new NamedPipeClientStream(
".",
PipeName,
PipeDirection.InOut,
PipeOptions.Asynchronous, TokenImpersonationLevel.Impersonation);
await _clientStream.ConnectAsync();
_clientStream.ReadMode = PipeTransmissionMode.Message;
_receiver = new MultiplexingKernelCommandAndEventReceiver(new KernelCommandAndEventPipeStreamReceiver(_clientStream));
_sender = new KernelCommandAndEventPipeStreamSender(_clientStream);
proxyKernel = new ProxyKernel(kernelInfo.LocalName, _receiver, _sender);
}
var _ = proxyKernel.StartAsync();
return(proxyKernel);;
}
public async Task <Kernel> ConnectKernelAsync(KernelInfo kernelInfo)
{
// QUESTION: (ConnectKernelAsync) tests?
var hubConnection = new HubConnectionBuilder()
.WithUrl(HubUrl)
.Build();
await hubConnection.StartAsync();
await hubConnection.SendAsync("connect");
var receiver = new KernelCommandAndEventSignalRHubConnectionReceiver(hubConnection);
var sender = new KernelCommandAndEventSignalRHubConnectionSender(hubConnection);
var proxyKernel = new ProxyKernel(kernelInfo.LocalName, receiver, sender);
var _ = proxyKernel.StartAsync();
proxyKernel.RegisterForDisposal(receiver);
proxyKernel.RegisterForDisposal(async() =>
{
await hubConnection.DisposeAsync();
});
return(proxyKernel);
}
static List <KernelInfo> GetKernelDisplayInfo(ComputeShader cs)
{
var kernelInfo = new List <KernelInfo>();
var platformCount = ShaderUtil.GetComputeShaderPlatformCount(cs);
for (var i = 0; i < platformCount; ++i)
{
var platform = ShaderUtil.GetComputeShaderPlatformType(cs, i);
var kernelCount = ShaderUtil.GetComputeShaderPlatformKernelCount(cs, i);
for (var j = 0; j < kernelCount; ++j)
{
var kernelName = ShaderUtil.GetComputeShaderPlatformKernelName(cs, i, j);
var found = false;
foreach (var ki in kernelInfo)
{
if (ki.name == kernelName)
{
ki.platforms += ' ';
ki.platforms += platform.ToString();
found = true;
}
}
if (!found)
{
var ki = new KernelInfo();
ki.name = kernelName;
ki.platforms = platform.ToString();
kernelInfo.Add(ki);
}
}
}
return(kernelInfo);
}
public override Task <Kernel> ConnectKernelAsync(KernelInfo kernelInfo)
{
var kernel = new SQLiteKernel(
$"sql-{kernelInfo}",
ConnectionString);
return(Task.FromResult <Kernel>(kernel));
}
public override async Task <Kernel> ConnectKernelAsync(KernelInfo kernelInfo, KqlKernelConnector connector,
KernelInvocationContext context)
{
connector.PathToService = ResolvedToolsServicePath;
var kernel = await connector.ConnectKernelAsync(kernelInfo);
return(kernel);
}
/// <summary>
/// Loads an auto grouped kernel.
/// </summary>
protected override Kernel LoadAutoGroupedKernelInternal(
CompiledKernel kernel,
out KernelInfo kernelInfo)
{
var result = LoadKernel(kernel, WarpSize);
kernelInfo = new KernelInfo(WarpSize, NumThreads / WarpSize);
return(result);
}
/// <summary>
/// Constructs a new compiled kernel in PTX form.
/// </summary>
/// <param name="context">The associated context.</param>
/// <param name="entryPoint">The entry point.</param>
/// <param name="info">Detailed kernel information.</param>
/// <param name="ptxAssembly">The assembly code.</param>
internal PTXCompiledKernel(
Context context,
EntryPoint entryPoint,
KernelInfo info,
string ptxAssembly)
: base(context, entryPoint, info)
{
PTXAssembly = ptxAssembly;
}
/// <summary>
/// Constructs a new compiled kernel in OpenCL source form.
/// </summary>
/// <param name="context">The associated context.</param>
/// <param name="entryPoint">The entry point.</param>
/// <param name="info">Detailed kernel information.</param>
/// <param name="source">The source code.</param>
/// <param name="version">The OpenCL C version.</param>
public CLCompiledKernel(
Context context,
SeparateViewEntryPoint entryPoint,
KernelInfo info,
string source,
CLCVersion version)
: base(context, entryPoint, info)
{
Source = source;
CVersion = version;
}
public async Task OnLoadAsync(Kernel kernel)
{
var root = (CompositeKernel)kernel.RootKernel;
var vscodeKernelInfo = new KernelInfo("vscode", new[] { "frontend" }, new Uri("kernel://vscode/vscode", UriKind.Absolute));
var javascriptKernelInfo = new KernelInfo("javascript", new[] { "js" }, new Uri("kernel://webview/javascript", UriKind.Absolute));
await root.Host.CreateProxyKernelOnDefaultConnectorAsync(vscodeKernelInfo);
await root.Host.CreateProxyKernelOnDefaultConnectorAsync(javascriptKernelInfo);
}
private void ResetPosition(KernelInfo currnetKernel)
{
updatePositionsShader.SetTexture(initializeKernel.kernelIndex, "newPositions", initializeKernel.newPositions);
updatePositionsShader.Dispatch(
initializeKernel.kernelIndex,
initializeKernel.newPositions.width / (int)initializeKernel.threadSizeX,
initializeKernel.newPositions.height / (int)initializeKernel.threadSizeY,
1
);
Graphics.CopyTexture(initializeKernel.newPositions, currnetKernel.newPositions);
}
void Start()
{
initializeKernel = initShader(updatePositionsShader, currentPositions, "SetInitialPositions");
kernelInfos.Add(initShader(updatePositionsShader, currentPositions, "MoveByFBMNoise"));
kernelInfos.Add(initShader(updatePositionsShader, currentPositions, "MoveByCurlNoise"));
for (int i = 0; i < kernelInfos.Count; i++)
{
ResetPosition(kernelInfos[i]);
}
}
public override async Task <Kernel> ConnectKernelAsync(KernelInfo kernelInfo, MsSqlKernelConnector connector,
KernelInvocationContext context)
{
connector.PathToService = ResolvedToolsServicePath;
var kernel = await connector.ConnectKernelAsync(kernelInfo);
if (connector.CreateDbContext)
{
await InitializeDbContextAsync(kernelInfo.LocalName, connector, context);
}
return(kernel);
}
private static bool TryGetCommandLine(out KernelInfo kernelInfo, out string minerName, out string userWallet)
{
minerName = string.Empty;
userWallet = string.Empty;
kernelInfo = null;
try {
List <string> lines = new List <string>();
foreach (var item in _kernelInfoes)
{
lines = Windows.WMI.GetCommandLines(item.ProcessName);
if (lines.Count != 0)
{
if (string.IsNullOrEmpty(item.CommandLineKeyword) || lines.Any(a => a.IndexOf(item.CommandLineKeyword, StringComparison.OrdinalIgnoreCase) != -1))
{
kernelInfo = item;
break;
}
}
}
if (kernelInfo == null)
{
return(false);
}
string text = string.Join(" ", lines) + " ";
foreach (var regex in walRegexList)
{
var matches = regex.Matches(text);
if (matches.Count != 0)
{
userWallet = matches[matches.Count - 1].Groups[1].Value;
break;
}
}
foreach (var regex in workerRegexList)
{
var matches = regex.Matches(text);
if (matches.Count != 0)
{
minerName = matches[matches.Count - 1].Groups[1].Value;
break;
}
}
return(!string.IsNullOrEmpty(minerName) && !string.IsNullOrEmpty(userWallet));
}
catch (Exception e) {
Logger.ErrorDebugLine(e);
return(false);
}
}
/// <summary>
/// Loads an implicitly grouped kernel.
/// </summary>
protected override Kernel LoadImplicitlyGroupedKernelInternal(
CompiledKernel kernel,
int customGroupSize,
out KernelInfo kernelInfo)
{
if (customGroupSize < 0)
{
throw new ArgumentOutOfRangeException(nameof(customGroupSize));
}
kernelInfo = KernelInfo.CreateFrom(
kernel.Info,
customGroupSize,
null);
return(LoadKernel(kernel, customGroupSize));
}
private string GetStringInfo(KernelInfo param)
{
error = clGetKernelInfo(Handle, param, UIntPtr.Zero, IntPtr.Zero, out UIntPtr bufferSizeRet);
if (error != ErrorCode.Success)
{
return("Error: Can't read Kernel Info!");
}
byte[] buffer = new byte[bufferSizeRet.ToUInt64()];
GCHandle gcHandle = GCHandle.Alloc(buffer, GCHandleType.Pinned);
error = clGetKernelInfo(Handle, param, bufferSizeRet, gcHandle.AddrOfPinnedObject(), out _);
gcHandle.Free();
if (error != ErrorCode.Success)
{
return("Error: Can't read Kernel Info!");
}
char[] chars = Encoding.ASCII.GetChars(buffer, 0, buffer.Length - 1);
return(new string(chars));
}
public async Task <Kernel> ConnectKernelAsync(KernelInfo kernelInfo)
{
if (string.IsNullOrWhiteSpace(PathToService))
{
throw new InvalidOperationException($"{nameof(PathToService)} cannot be null or whitespace.");
}
var connectionDetails = await BuildConnectionDetailsAsync();
var sqlClient = new ToolsServiceClient(PathToService);
var kernel = new MsKqlKernel(
$"kql-{kernelInfo}",
connectionDetails,
sqlClient)
.UseValueSharing();
await kernel.ConnectAsync();
return(kernel);
}
public async Task <Kernel> ConnectKernelAsync(KernelInfo kernelInfo)
{
if (string.IsNullOrWhiteSpace(PathToService))
{
throw new InvalidOperationException($"{nameof(PathToService)} cannot be null or whitespace.");
}
var sqlClient = new ToolsServiceClient(PathToService, $"--parent-pid {Environment.ProcessId}");
var kernel = new MsSqlKernel(
$"sql-{kernelInfo}",
ConnectionString,
sqlClient)
.UseValueSharing();
kernel.RegisterForDisposal(sqlClient);
await kernel.ConnectAsync();
return(kernel);
}
private static KernelInfo initShader(ComputeShader shader, RenderTexture positionTexture, string kernelName)
{
KernelInfo kernelInfo = new KernelInfo();
if (positionTexture.format != RenderTextureFormat.ARGBFloat)
{
Debug.LogError(positionTexture.name + "は書き込み可能なテクスチャではないようです。");
}
// oldPosition用のテクスチャをinitialPositionに合わせて生成
kernelInfo.oldPositions = new RenderTexture(positionTexture.width, positionTexture.height, 1, positionTexture.format);
kernelInfo.oldPositions.enableRandomWrite = true;
Graphics.CopyTexture(positionTexture, kernelInfo.oldPositions);
// ComputeShaderにテクスチャをセット
kernelInfo.kernelIndex = shader.FindKernel(kernelName);
// テクスチャサイズのチェック
shader.GetKernelThreadGroupSizes(
kernelInfo.kernelIndex,
out kernelInfo.threadSizeX,
out kernelInfo.threadSizeY,
out kernelInfo.threadSizeZ
);
float threadGroupSizeX = (float)kernelInfo.oldPositions.width / kernelInfo.threadSizeX;
float threadGroupSizeY = (float)kernelInfo.oldPositions.height / kernelInfo.threadSizeY;
if (threadGroupSizeX % 1 != 0 || threadGroupSizeY % 1 != 0)
{
Debug.LogError(positionTexture.name + "はスレッドグループ数が整数にならないので、テクスチャサイズを変えてください。");
}
// newPosition用のテクスチャをinitialPositionに合わせて生成
kernelInfo.newPositions = new RenderTexture(positionTexture.width, positionTexture.height, 1, positionTexture.format);
kernelInfo.newPositions.enableRandomWrite = true;
Graphics.CopyTexture(positionTexture, kernelInfo.newPositions);
return(kernelInfo);
}
private static bool TryGetPosition(KernelInfo kernelInfo, string workerName, string ansiText, out int position)
{
position = 0;
if (ansiText.Contains("eth_submitLogin"))
{
int baseIndex = 0;
int workNameLen = 0;
switch (kernelInfo.Kernel)
{
case Kernel.Claymore:
baseIndex = 85;
workNameLen = "eth1.0".Length;
// 比isPhoenixMiner多一个空格
if (ansiText.Contains($": \"{workerName}\","))
{
workNameLen = workerName.Length;
}
break;
case Kernel.PhoenixMiner:
baseIndex = 114;
if (ansiText.Contains($":\"{workerName}\","))
{
workNameLen = workerName.Length;
}
else
{
workNameLen = "eth1.0".Length;
}
break;
default:
break;
}
position = baseIndex + workNameLen;
}
return(position != 0);
}
public async Task javascript_ProxyKernel_can_share_a_value_from_csharp()
{
using var kernel = new CompositeKernel
{
new CSharpKernel()
};
kernel.DefaultKernelName = "csharp";
using var remoteKernel = new FakeRemoteKernel();
var receiver = new MultiplexingKernelCommandAndEventReceiver(remoteKernel.Receiver);
using var host = new KernelHost(kernel, remoteKernel.Sender, receiver);
var _ = host.ConnectAsync();
var kernelInfo = new KernelInfo("javascript", null, new Uri("kernel://remote/js"));
var javascriptKernel = await host.CreateProxyKernelOnDefaultConnectorAsync(kernelInfo);
javascriptKernel.UseValueSharing(new JavaScriptKernelValueDeclarer());
await kernel.SubmitCodeAsync("var csharpVariable = 123;");
var submitCode = new SubmitCode(@"
#!javascript
#!share --from csharp csharpVariable");
await kernel.SendAsync(submitCode);
var remoteCommands = remoteKernel.Sender.Commands;
remoteCommands.Should()
.ContainSingle <SubmitCode>()
.Which
.Code
.Should()
.Be("csharpVariable = 123;");
}
public static Error clGetKernelInfo(OpenCLKernel kernel, KernelInfo param_name, IntPtr param_value_size, IntPtr param_value, out IntPtr param_value_size_ret)
{
if (param_name == KernelInfo.NumArgs)
{
Marshal.WriteIntPtr(param_value, new IntPtr(3));
param_value_size_ret = new IntPtr(IntPtr.Size);
}
else if (param_name == KernelInfo.FunctionName)
{
String name = "VectorAdd";
for (int i = 0; i < name.Length; i++)
{
Marshal.WriteByte(param_value, i, (byte)name[i]);
}
param_value_size_ret = new IntPtr(name.Length);
}
else
{
param_value_size_ret = default(IntPtr);
}
Console.WriteLine("Calling Error clGetKernelInfo(OpenCLKernel kernel, KernelInfo param_name, IntPtr param_value_size, IntPtr param_value, out IntPtr param_value_size_ret)");
return default(Error);
}
public abstract Task <Kernel> ConnectKernelAsync(KernelInfo kernelInfo,
TConnector connection,
KernelInvocationContext context);
internal extern static unsafe ErrorCode GetKernelInfo(IntPtr kernel, KernelInfo param_name, IntPtr param_value_size, IntPtr param_value, [Out] IntPtr *param_value_size_ret);
public static Error clGetKernelInfo(OpenCLKernel kernel, KernelInfo param_name, IntPtr param_value_size, IntPtr param_value, IntPtr param_value_size_ret)
{
Console.WriteLine("Calling Error clGetKernelInfo(OpenCLKernel kernel, KernelInfo param_name, IntPtr param_value_size, IntPtr param_value, IntPtr param_value_size_ret)");
return default(Error);
}
public KernelInfoProduced(
KernelInfo kernelInfo,
RequestKernelInfo command) : base(command)
{
KernelInfo = kernelInfo;
}
internal extern static unsafe int GetKernelInfo(IntPtr kernel, KernelInfo param_name, IntPtr param_value_size, IntPtr param_value, [OutAttribute] IntPtr *param_value_size_ret);
public static extern Error clGetKernelInfo(OpenCLKernel kernel, KernelInfo param_name, IntPtr param_value_size, IntPtr param_value, IntPtr param_value_size_ret);
public static InfoBuffer GetKernelInfo(Kernel kernel, KernelInfo paramName, out ErrorCode error)
{
return GetInfo(GetKernelInfo, kernel, paramName, out error);
}
public extern static int clGetKernelInfo ( IntPtr kernel, KernelInfo param_name, IntPtr param_value_size, byte[] param_value, out IntPtr param_value_size_ret );
public static InfoBuffer GetKernelInfo(Kernel kernel, KernelInfo paramName, out ErrorCode error)
{
return(GetInfo(GetKernelInfo, kernel, paramName, out error));
}
internal extern static unsafe int GetKernelInfo(IntPtr kernel, KernelInfo param_name, IntPtr param_value_size, IntPtr param_value, [OutAttribute] IntPtr* param_value_size_ret);
