private static ConversionResult?GenereteKernel(ConversionState state, ConversionResult arg, Identifier receiverBufferIdentifier, MethodStruct methodStruct)
{
// generate kernel for argument if needed
if (arg.KernelDetails != null)
{
if (methodStruct.Func != null)
{
arg = ConversionHelper.GenerateKernelExecution(state, arg, null);
}
else
{
return(ConversionHelper.GenerateKernelExecution(state, arg, receiverBufferIdentifier));
}
}
Debug.Assert(arg.KernelDetails == null);
ConversionResult?result = null;
if (methodStruct.Func != null)
{
result = methodStruct.Func(state, arg, methodStruct, receiverBufferIdentifier);
}
if (!result.HasValue)
{
return(null);
}
return(ConversionHelper.GenerateKernelExecution(state, result.Value, receiverBufferIdentifier, arg.HasComplexIndexer));
}
public async Task SetProcessToStarted_Extracting(ConversionEvent conversionEvent)
{
_logger.LogInformation("Logging that I'm in SetProcessToStarted_Extracting");
// _telemetry.TrackEvent("SetProcessToStarted_Extracting");
var conversionProcess = new ConversionProcess();
conversionProcess.ConversionStates = new List <ConversionState>();
conversionProcess.ProcessStartTimeUtc = DateTime.UtcNow;
conversionProcess.PolicyNumber = conversionEvent.PolicyNumber;
conversionProcess.CorrelationId = conversionEvent.CorrelationId;
var currentState = new ConversionState()
{
StateName = "ConversionStarted", DateTimeOfStateChangeUtc = DateTime.UtcNow, DurationInMillisecondsBetweenLastStateAndThisState = 0
};
conversionProcess.MostRecentState = currentState;
conversionProcess.ConversionStates.Add(currentState);
await cosmosDatabase.CreateConversionProcess(conversionProcess);
//Sending this to policy so they can start. In the real world the mainframe starts the process
// await _messageSender.SendAsync(conversionEvent, MessagingConfiguration.StartOverallProcessCommand);
// _logger.LogWarning("Start sent for overallprocess {PolicyNumber}", conversionEvent.PolicyNumber);
}
private void btn_Pause_Click(object sender, EventArgs e)
{
if (this.currentState != ConversionState.Paused)
{
foreach (VideoConvertTask vt in Tasks)
{
if (vt.IsStarted() && !vt.IsPaused)
{
vt.Pause();
}
}
currentState = ConversionState.Paused;
this.btn_Pause.Text = "Resume";
}
else
{
foreach (VideoConvertTask vt in Tasks)
{
if (vt.IsPaused)
{
vt.Resume();
}
}
currentState = ConversionState.Paused;
this.btn_Pause.Text = "Pause";
}
RefreshButtomState();
}
void CleanupConversion()
{
m_JournalingUnityLogger.Unhook();
s_ComponentsCache.Clear();
m_ConversionState = ConversionState.NotConverting;
m_BeginConvertingRefCount = 0;
}
private void btn_Start_Click(object sender, EventArgs e)
{
//Update all settings before conversion
UpdateHardwareAcceleration();
StartTasks();
currentState = ConversionState.Started;
}
private void btn_Stop_Click(object sender, EventArgs e)
{
foreach (VideoConvertTask vt in Tasks)
{
if (vt.IsStarted())
{
vt.Stop();
}
currentState = ConversionState.Completed;
}
}
internal void ConversionStateChanged(ConversionState newState)
{
this.ConversionState = newState;
var e = StateChanged;
if (e != null)
{
e(this, new ConversionStateChangedEventArgs(newState));
}
}
internal void ConversionStateChanged(ConversionState newState)
{
this.ConversionState = newState;
var e = StateChanged;
if (e != null)
{
e(this, new ConversionStateChangedEventArgs(newState));
}
}
private ConversionStatus DefaultSuccessCheck(ConversionState state, string swfFilePath)
{
if (state == ConversionState.Converted)
{
if (!File.Exists(swfFilePath))
{
var failed = new ConversionStatus(ConversionState.ConversionFailed, "Output file doesn't exist");
_logger.LogError(failed.Message);
return(failed);
}
}
return(new ConversionStatus(state));
}
public static ConversionResult ConvertEval(ConversionState state, ConversionResult arg, MethodStruct methodStruct, Identifier receiveBufferIdentifier)
{
String completeExpression = string.Format("{0}({1})", methodStruct.Name, arg.CompleteExpression);
return(new ConversionResult(
arg.KernelDetails,
arg.AccessExpression,
arg.Type,
arg.SizeIdentifier,
arg.KernelArguments,
arg.WaitHandles,
completeExpression
));
}
public void BeginConversion()
{
if (ConversionState == ConversionState.Converting)
{
throw new InvalidOperationException("Cannot BeginConversion after conversion has started (call EndConversion first)");
}
++m_BeginConvertingRefCount;
if (ConversionState == ConversionState.NotConverting)
{
m_ConversionState = ConversionState.Discovering;
m_JournalingUnityLogger.Hook();
}
}
private ConversionStatus DefaultMultiPageSuccessCheck(ConversionState state, string swfPageFileNamePattern, int numberOfPages)
{
if (state == ConversionState.Converted)
{
foreach (var outputSwfFileName in GetOutputSwfFileNames(swfPageFileNamePattern, numberOfPages))
{
if (!File.Exists(outputSwfFileName))
{
var status = new ConversionStatus(ConversionState.ConversionFailedPaged);
status.Message = $"At least one output page is missing: " + outputSwfFileName;
_logger.LogError(status.Message);
return(status);
}
}
}
return(new ConversionStatus(state));
}
public void CreatePrimaryEntities()
{
if (ConversionState != ConversionState.Discovering)
{
throw new InvalidOperationException("Unexpected conversion state transition");
}
m_ConversionState = ConversionState.Converting;
#if DETAIL_MARKERS
using (m_CreatePrimaryEntities.Auto())
#endif
{
Entities.WithIncludeAll().ForEach((Transform transform) =>
{
CreatePrimaryEntity(transform.gameObject);
});
//@TODO: inherited classes should probably be supported by queries, so we can delete this loop
Entities.WithIncludeAll().ForEach((RectTransform transform) =>
{
CreatePrimaryEntity(transform.gameObject);
});
//@TODO: [slow] implement this using new inherited query feature so we can do
// `Entities.WithAll<Asset>().ForEach((UnityObject asset) => ...)`
Entities.WithAll <Asset>().ForEach(entity =>
{
using (var types = EntityManager.GetComponentTypes(entity))
{
var derivedType = types.FirstOrDefault(t => typeof(UnityObject).IsAssignableFrom(t.GetManagedType()));
if (derivedType.TypeIndex == 0)
{
throw new Exception("Expected to find a UnityEngine.Object-derived component type in this entity");
}
var asset = EntityManager.GetComponentObject <UnityObject>(entity, derivedType);
CreatePrimaryEntity(asset);
}
});
}
}
public static ConversionResult ConvertDummy(ConversionState state, ConversionResult arg, MethodStruct methodStruct, Identifier receiveBufferIdentifier)
{
Dictionary <String, KernelArgumentDetails> arguments = arg.KernelArguments;
String kernelSource = ComputeKernelTemplates.ElementWiseCopy;
kernelSource = kernelSource.Replace("{type}", arg.Type.ScalarType.OpenCLTypeName);
kernelSource = kernelSource.Replace("{expression}", arg.AccessExpression);
List <Identifier> waitHandles = arg.WaitHandles;
String completeExpression = string.Format("{0}({1})", methodStruct.Name, arg.CompleteExpression);
return(new ConversionResult(
arg.KernelDetails,
arg.AccessExpression,
arg.Type,
arg.SizeIdentifier,
arguments,
new List <Identifier>(),
completeExpression
));
}
public async Task <IActionResult> Run(
[HttpTrigger(AuthorizationLevel.Anonymous, "get", "post", Route = null)] HttpRequest req,
ILogger log)
{
string name = req.Query["name"];
string requestBody = await new StreamReader(req.Body).ReadToEndAsync();
dynamic data = JsonConvert.DeserializeObject(requestBody);
name = name ?? data?.name;
var cp = new ConversionProcess();
cp.CorrelationId = Guid.NewGuid().ToString();
cp.PolicyNumber = name;
cp.ProcessStartTimeUtc = DateTime.UtcNow;
cp.ConversionStates = new List <ConversionState>();
var currentState = new ConversionState()
{
StateName = "ConversionStarted", DateTimeOfStateChangeUtc = DateTime.UtcNow, DurationInMillisecondsBetweenLastStateAndThisState = 0
};
cp.MostRecentState = currentState;
cp.ConversionStates.Add(currentState);
var container = this.cosmos.GetContainer(this.dbSettings.DatabaseName, "FlowEvents");
ItemResponse <ConversionProcess> conversionProcessResponse = await container.CreateItemAsync <ConversionProcess>(cp);
log.LogInformation("C# HTTP trigger function processed a request.");
string responseMessage = string.IsNullOrEmpty(name)
? "This HTTP triggered function executed successfully. Pass a name in the query string or in the request body for a personalized response."
: $"Hello, {name}. This HTTP triggered function executed successfully.";
return(new OkObjectResult(responseMessage));
}
public static Expression ConvertExpression(EXPRESSION expression, TYPE type)
{
ConversionState state = new ConversionState();
ConversionResult conversionResult;
if (ExpressionConverter.Convert(state, expression, true).TryGetValue(out conversionResult))
{
Expression node = null;
if (expression is CALL)
{
// call can be directly converted
node = expression.convert() as MethodCall;
}
else if (expression is INSTANCE)
{
// if the result should be data, return plain indetifier
if (type is ARRAY_TYPE)
{
return(expression.name);
}
// otherwise don't convert single instance
node = null;
}
else
{
// everything else convert with empty convert function
node = MethodConverter.Convert(
state,
conversionResult,
new MethodConverter.MethodStruct {
Type = type,
}
);
}
return(node);
}
return(null);
}
public ConversionStatus(ConversionState state, string message = null)
{
State = state;
Message = message;
}
public static ConversionResult ConvertPPS(ConversionState state, ConversionResult arg, MethodStruct methodStruct, Identifier receiveBufferIdentifier)
{
#region // 1st stage
// store new size in variable
Int32 kernelIndex = state.GetNextKernelIndex();
// get problem global size
Identifier kernelSizeIdentifier = Identifier.For(String.Format("_kernel{0}Size", kernelIndex));
ConversionHelper.GenerateKernelSizeArrayField(state, kernelSizeIdentifier);
state.Constructor.Body.Statements.Add(
NodeHelper.GetAssignmentStatementForNewSizeArray(kernelSizeIdentifier, arg.Type.Rank)
);
for (Int32 index = 0; index < arg.Type.Rank; index++)
{
state.Constructor.Body.Statements.Add(
NodeHelper.GetAssignmentStatementForIndices(kernelSizeIdentifier, index, arg.SizeIdentifier, index)
);
}
Dictionary <String, KernelArgumentDetails> arguments = arg.KernelArguments;
String kernelSource = ComputeKernelTemplates.pps1;
kernelSource = kernelSource.Replace("{type}", arg.Type.ScalarType.OpenCLTypeName);
kernelSource = kernelSource.Replace("{expression}", arg.AccessExpression);
kernelSource = kernelSource.Replace("{operation}", methodStruct.Operation);
kernelSource = kernelSource.Replace("{identity}", methodStruct.Identity);
List <Identifier> waitHandles = arg.WaitHandles;
Func <List <Identifier>, Expression, Identifier> generate = (buffers, kernelExpression) => {
Identifier kernelIdentifier = Identifier.For("_kernel" + kernelIndex.ToString());
// get kernel
ConversionHelper.GenerateGetKernelForProgram(state, kernelIdentifier, kernelExpression);
Identifier globalSizeIdent = Identifier.For("globalSize");
state.CodeletMethod.Body.Statements.Add(new VariableDeclaration {
Name = globalSizeIdent,
Type = SystemTypes.UInt64.GetArrayType(1),
Initializer = new ConstructArray {
ElementType = SystemTypes.UInt64,
Rank = 1,
Operands = new ExpressionList(Literal.Int32One),
Initializers = new ExpressionList(new Literal(2048 /* FIXME */, SystemTypes.UInt64))
}
});
Expression localSize = new ConstructArray {
ElementType = SystemTypes.UInt64,
Rank = 1,
Operands = new ExpressionList(Literal.Int32One),
Initializers = new ExpressionList(new Literal(64 /* FIXME */, SystemTypes.UInt64))
};
// localSize is 64 elements
Expression localSizeMem = new BinaryExpression {
NodeType = NodeType.Mul,
Operand1 = new Literal(64 /* FIXME */, SystemTypes.UInt64),
Operand2 = new Literal(arg.Type.ScalarType.ByteSize, SystemTypes.UInt64)
};
// set kernel arguments
Int32 index = 0;
ConversionHelper.GenerateKernelSetValueArgument(state, kernelIdentifier, index++, NodeHelper.GetSizeMultiplicationClosure(kernelSizeIdentifier, arg.Type.Rank));
ConversionHelper.GenerateKernelSetLocalArgument(state, kernelIdentifier, index++, localSizeMem);
foreach (var buffer in buffers)
{
ConversionHelper.GenerateKernelSetGlobalArgument(state, kernelIdentifier, index, buffer);
index += 1;
}
Identifier kernelPredecessorsIdentifier = Identifier.For(String.Format("kernel{0}predecessors", kernelIndex));
ConversionHelper.GenerateKernelPredecessors(state, kernelPredecessorsIdentifier, waitHandles);
Identifier waitHandleIdentifier = Identifier.For("_eventObject" + kernelIndex.ToString());
ConversionHelper.GenerateEventObjectAndStartKernel(state, waitHandleIdentifier, kernelIdentifier, globalSizeIdent, localSize, kernelPredecessorsIdentifier);
ConversionHelper.GenerateFlushCommandQueue(state);
return(waitHandleIdentifier);
};
String completeExpression = string.Format("{0}({1})", methodStruct.Name, arg.CompleteExpression);
ConversionResult firstStage = new ConversionResult(
new KernelDetails(kernelSource, generate),
"value",
arg.Type,
kernelSizeIdentifier,
arguments,
new List <Identifier>(),
completeExpression
);
arg = ConversionHelper.GenerateKernelExecution(state, firstStage, null);
#endregion
#region // 2nd stage
// store new size in variable
kernelIndex = state.GetNextKernelIndex();
kernelSizeIdentifier = Identifier.For(String.Format("_kernel{0}Size", kernelIndex));
// get problem global size
ConversionHelper.GenerateKernelSizeArrayField(state, kernelSizeIdentifier);
state.Constructor.Body.Statements.Add(
NodeHelper.GetAssignmentStatementForNewSizeArray(kernelSizeIdentifier, 1)
);
state.Constructor.Body.Statements.Add(new AssignmentStatement {
Target = NodeHelper.GetConstantIndexerForExpression(kernelSizeIdentifier, 0),
Source = new BinaryExpression {
NodeType = NodeType.Div,
Operand1 = new Literal(2048 /* FIXME */, SystemTypes.UInt64),
Operand2 = new Literal(64 /* FIXME */, SystemTypes.UInt64)
}
});
arguments = arg.KernelArguments;
kernelSource = ComputeKernelTemplates.pps2;
kernelSource = kernelSource.Replace("{type}", arg.Type.ScalarType.OpenCLTypeName);
kernelSource = kernelSource.Replace("{expression}", arg.AccessExpression);
kernelSource = kernelSource.Replace("{operation}", methodStruct.Operation);
kernelSource = kernelSource.Replace("{identity}", methodStruct.Identity);
waitHandles = arg.WaitHandles;
generate = (buffers, kernelExpression) => {
Identifier kernelIdentifier = Identifier.For("_kernel" + kernelIndex.ToString());
// get kernel
ConversionHelper.GenerateGetKernelForProgram(state, kernelIdentifier, kernelExpression);
// set kernel arguments
Int32 index = 0;
ConversionHelper.GenerateKernelSetValueArgument(state, kernelIdentifier, index++, NodeHelper.GetConstantIndexerForExpression(kernelSizeIdentifier, 0));
//ConversionHelper.GenerateKernelSetLocalArgument(state, kernelIdentifier, index++, localSize);
foreach (var buffer in buffers)
{
ConversionHelper.GenerateKernelSetGlobalArgument(state, kernelIdentifier, index, buffer);
index += 1;
}
Identifier kernelPredecessorsIdentifier = Identifier.For(String.Format("kernel{0}predecessors", kernelIndex));
ConversionHelper.GenerateKernelPredecessors(state, kernelPredecessorsIdentifier, waitHandles);
Identifier waitHandleIdentifier = Identifier.For("_eventObject" + kernelIndex.ToString());
ConversionHelper.GenerateEventObjectAndStartKernel(state, waitHandleIdentifier, kernelIdentifier, kernelSizeIdentifier, Literal.Null, kernelPredecessorsIdentifier);
ConversionHelper.GenerateFlushCommandQueue(state);
return(waitHandleIdentifier);
};
completeExpression = string.Format("{0}({1})", methodStruct.Name, arg.CompleteExpression);
return(new ConversionResult(
new KernelDetails(kernelSource, generate),
"value",
arg.Type,
kernelSizeIdentifier,
arguments,
new List <Identifier>(),
completeExpression
));
#endregion
}
public static ConversionResult ConvertApply(ConversionState state, ConversionResult arg, MethodStruct methodStruct, Identifier receiveBufferIdentifier)
{
if (arg.HasComplexIndexer)
{
#region // argument has a complex indexer
// store new size in variable
Int32 kernelIndex = state.GetNextKernelIndex();
Identifier kernelSizeIdentifier = Identifier.For(String.Format("_kernel{0}Size", kernelIndex));
// get problem global size
ConversionHelper.GenerateKernelSizeArrayField(state, kernelSizeIdentifier);
state.Constructor.Body.Statements.Add(
NodeHelper.GetAssignmentStatementForNewSizeArray(kernelSizeIdentifier, 1)
);
if (arg.Type.Rank == 2)
{
state.Constructor.Body.Statements.Add(new AssignmentStatement {
Target = NodeHelper.GetConstantIndexerForExpression(kernelSizeIdentifier, 0),
Source = new BinaryExpression {
NodeType = NodeType.Mul,
Operand1 = NodeHelper.GetConstantIndexerForExpression(arg.SizeIdentifier, 0),
Operand2 = NodeHelper.GetConstantIndexerForExpression(arg.SizeIdentifier, 1)
}
});
}
else
{
state.Constructor.Body.Statements.Add(new AssignmentStatement {
Target = NodeHelper.GetConstantIndexerForExpression(kernelSizeIdentifier, 0),
Source = NodeHelper.GetConstantIndexerForExpression(arg.SizeIdentifier, 0)
});
}
Dictionary <String, KernelArgumentDetails> arguments = arg.KernelArguments;
String kernelSource = ComputeKernelTemplates.apply_indexer;
kernelSource = kernelSource.Replace("{type}", arg.Type.ScalarType.OpenCLTypeName);
kernelSource = kernelSource.Replace("{expression}", arg.AccessExpression);
kernelSource = kernelSource.Replace("{operation}", methodStruct.Operation);
List <Identifier> waitHandles = arg.WaitHandles;
Identifier kernelGlobalRangeIdentifier = Identifier.For(String.Format("kernel{0}GlobalRange", kernelIndex));
Func <List <Identifier>, Expression, Identifier> generate = (buffers, kernelExpression) => {
Identifier kernelIdentifier = Identifier.For("_kernel" + kernelIndex.ToString());
state.CodeletMethod.Body.Statements.Add(new VariableDeclaration {
Name = kernelGlobalRangeIdentifier,
Type = SystemTypes.UInt64.GetArrayType(1),
Initializer = new ConstructArray {
ElementType = SystemTypes.UInt64,
Rank = 1,
Operands = new ExpressionList(
Literal.Int32Two
)
}
});
ConversionHelper.GenerateSizeFromBufferIdentifier(state, state.CodeletMethod, String.Format("_buffer{0}", arg.ArgumentIndex), kernelGlobalRangeIdentifier);
// get kernel
ConversionHelper.GenerateGetKernelForProgram(state, kernelIdentifier, kernelExpression);
// set kernel arguments
Int32 index = 0;
ConversionHelper.GenerateKernelSetValueArgument(state, kernelIdentifier, index++, NodeHelper.GetConstantIndexerForExpression(kernelSizeIdentifier, 0));
foreach (var buffer in buffers)
{
ConversionHelper.GenerateKernelSetGlobalArgument(state, kernelIdentifier, index, buffer);
index += 1;
#region Complex Indexer
if (arg.HasComplexIndexer)
{
ConversionHelper.GenerateKernelSetValueArgument(state, kernelIdentifier, index, Identifier.For(String.Format("_{0}n", buffer.Name)));
index++;
for (int dimension = 0; dimension < 2 /* FIXME */; dimension++)
{
ConversionHelper.GenerateKernelSetValueArgument(state, kernelIdentifier, index, Identifier.For(String.Format("_{0}from{1}", buffer.Name, dimension)));
index++;
ConversionHelper.GenerateKernelSetValueArgument(state, kernelIdentifier, index, Identifier.For(String.Format("_{0}by{1}", buffer.Name, dimension)));
index++;
}
}
#endregion
}
Identifier kernelPredecessorsIdentifier = Identifier.For(String.Format("kernel{0}predecessors", kernelIndex));
ConversionHelper.GenerateKernelPredecessors(state, kernelPredecessorsIdentifier, waitHandles);
Identifier waitHandleIdentifier = Identifier.For("_eventObject" + kernelIndex.ToString());
ConversionHelper.GenerateEventObjectAndStartKernel(state, waitHandleIdentifier, kernelIdentifier, kernelGlobalRangeIdentifier, Literal.Null, kernelPredecessorsIdentifier);
ConversionHelper.GenerateFlushCommandQueue(state);
return(waitHandleIdentifier);
};
String completeExpression = string.Format("{0}({1})", methodStruct.Name, arg.CompleteExpression);
return(new ConversionResult(
new KernelDetails(kernelSource, generate),
"value",
arg.Type,
kernelGlobalRangeIdentifier,
arguments,
new List <Identifier>(),
completeExpression
));
#endregion
}
else
{
// store new size in variable
Int32 kernelIndex = state.GetNextKernelIndex();
Identifier kernelSizeIdentifier = Identifier.For(String.Format("_kernel{0}Size", kernelIndex));
// get problem global size
ConversionHelper.GenerateKernelSizeArrayField(state, kernelSizeIdentifier);
state.Constructor.Body.Statements.Add(
NodeHelper.GetAssignmentStatementForNewSizeArray(kernelSizeIdentifier, 1)
);
if (arg.Type.Rank == 2)
{
state.Constructor.Body.Statements.Add(new AssignmentStatement {
Target = NodeHelper.GetConstantIndexerForExpression(kernelSizeIdentifier, 0),
Source = new BinaryExpression {
NodeType = NodeType.Mul,
Operand1 = NodeHelper.GetConstantIndexerForExpression(arg.SizeIdentifier, 0),
Operand2 = NodeHelper.GetConstantIndexerForExpression(arg.SizeIdentifier, 1)
}
});
}
else
{
state.Constructor.Body.Statements.Add(new AssignmentStatement {
Target = NodeHelper.GetConstantIndexerForExpression(kernelSizeIdentifier, 0),
Source = NodeHelper.GetConstantIndexerForExpression(arg.SizeIdentifier, 0)
});
}
Dictionary <String, KernelArgumentDetails> arguments = arg.KernelArguments;
String kernelSource = methodStruct.KernelSource;
kernelSource = kernelSource.Replace("{type}", arg.Type.ScalarType.OpenCLTypeName);
kernelSource = kernelSource.Replace("{expression}", arg.AccessExpression);
kernelSource = kernelSource.Replace("{operation}", methodStruct.Operation);
List <Identifier> waitHandles = arg.WaitHandles;
Func <List <Identifier>, Expression, Identifier> generate = (buffers, kernelExpression) => {
Identifier kernelIdentifier = Identifier.For("_kernel" + kernelIndex.ToString());
// get kernel
ConversionHelper.GenerateGetKernelForProgram(state, kernelIdentifier, kernelExpression);
// set kernel arguments
Int32 index = 0;
ConversionHelper.GenerateKernelSetValueArgument(state, kernelIdentifier, index++, NodeHelper.GetConstantIndexerForExpression(kernelSizeIdentifier, 0));
//ConversionHelper.GenerateKernelSetLocalArgument(state, kernelIdentifier, index++, localSize);
foreach (var buffer in buffers)
{
ConversionHelper.GenerateKernelSetGlobalArgument(state, kernelIdentifier, index, buffer);
index += 1;
}
Identifier kernelPredecessorsIdentifier = Identifier.For(String.Format("kernel{0}predecessors", kernelIndex));
ConversionHelper.GenerateKernelPredecessors(state, kernelPredecessorsIdentifier, waitHandles);
Identifier waitHandleIdentifier = Identifier.For("_eventObject" + kernelIndex.ToString());
ConversionHelper.GenerateEventObjectAndStartKernel(state, waitHandleIdentifier, kernelIdentifier, kernelSizeIdentifier, Literal.Null, kernelPredecessorsIdentifier);
ConversionHelper.GenerateFlushCommandQueue(state);
return(waitHandleIdentifier);
};
String completeExpression = string.Format("{0}({1})", methodStruct.Name, arg.CompleteExpression);
return(new ConversionResult(
new KernelDetails(kernelSource, generate),
"value",
arg.Type,
kernelSizeIdentifier,
arguments,
new List <Identifier>(),
completeExpression
));
}
}
public ConversionStateChangedEventArgs(ConversionState newState)
{
this.NewState = newState;
}
public static Expression Convert(ConversionState state, ConversionResult expressionResult, MethodStruct methodStruct)
{
#region // result will be stored in a temporary value
bool complexIndexer;
ComputeType receiverComputeType;
if (methodStruct.Type is ARRAY_TYPE)
{
// result is array
ComputeType.FromType(methodStruct.Type).TryGetValue(out receiverComputeType);
}
else
{
// result is scalar
receiverComputeType = new ComputeType(ComputeScalarType.Single, 1);
}
Identifier receiverIdentifier = Identifier.For("ret");
Expression[] indices = ConversionHelper.GetExpressionsFromIndexer(null, ref receiverComputeType, out complexIndexer);
complexIndexer |= expressionResult.HasComplexIndexer;
#endregion
List <ConversionHelper.Argument> sortedArguments = ConversionHelper.ExtractArguments(state, false);
List <ConversionHelper.Argument> scalarArguments = ConversionHelper.ExtractArguments(state, true);
//ExpressionArgument receiverArgument;
//ConversionHelper.ProcessReceiver(state, expressionResult, receiverIdentifier, receiverComputeType, indices, null, ref sortedArguments, complexIndexer, out receiverArgument);
#region // add the temporary variable as a receiver
ExpressionArgument receiverArgument = new ExpressionArgument(sortedArguments.Count, indices, null, -1);
sortedArguments.Add(new ConversionHelper.Argument {
Index = receiverArgument.Index,
Name = receiverIdentifier.ToString(),
Indexers = receiverArgument.Indexers,
IsRead = false,
IsWritten = true,
IsCall = receiverArgument.IsCall,
CallRank = receiverArgument.CallRank,
});
Identifier receiverDataIdentifier = Identifier.For("data" + receiverArgument.Index);
if (!expressionResult.HasComplexIndexer)
{
// allocate receiver (1D array with size 1 for scalar result, matrix (vector) in other cases)
ExpressionList ctorExpr = new ExpressionList();
for (int index = 0; index < receiverComputeType.Rank; index++)
{
ctorExpr.Add(NodeHelper.GetConstantIndexerForExpression(expressionResult.SizeIdentifier, index));
}
state.Constructor.Body.Statements.Add(
new AssignmentStatement {
Target = new AddressDereference {
Address = receiverDataIdentifier,
Type = STANDARD.Data,
},
Source = new Construct {
Constructor = new MemberBinding {
BoundMember = STANDARD.Data.GetConstructor(SystemTypes.Array),
},
Operands = new ExpressionList(
new ConstructArray {
ElementType = expressionResult.Type.ScalarType.TypeNode,
Rank = (methodStruct.Type is ARRAY_TYPE) ? receiverComputeType.Rank : 1,
Operands = (methodStruct.Type is ARRAY_TYPE) ? ctorExpr : new ExpressionList(Literal.Int32One),
}
),
}
}
);
}
else
{
state.Constructor.Body.Statements.Add(new Block {
Statements = ConversionHelper.GenerateIndexedSize(expressionResult, receiverComputeType, receiverDataIdentifier, state.GetNextTempSizeIdentifier())
});
}
#endregion
#region // generate kernel
ConversionResult?result = GenereteKernel(state, expressionResult, Identifier.For("buffer" + receiverArgument.Index.ToString()), methodStruct);
ConversionResult finalConversionResult;
if (result.HasValue)
{
finalConversionResult = result.Value;
}
else
{
return(null);
}
#endregion
#region // generate delegates
DelegateNode getOpenCLTimeDelegateType;
DelegateNode startOpenCLDelegateType;
ConversionHelper.GenerateOpenCLDelegates(state, out getOpenCLTimeDelegateType, out startOpenCLDelegateType);
#endregion
#region // generate get time method
ConversionHelper.GenerateTimeMethod(state);
#endregion
#region // generate the codelets
Identifier codeletsIdentifier;
ConversionHelper.GenerateCodelets(state, getOpenCLTimeDelegateType, startOpenCLDelegateType, out codeletsIdentifier);
#endregion
#region // process all arguments - add them to parameters and data uses
ExpressionList ctorArgs = new ExpressionList();
ExpressionList callArgs = new ExpressionList();
ParameterList callParams = new ParameterList();
List <TypeNode> typeList = new List <TypeNode>();
Identifier dataUsesIdentifier;
ConversionHelper.ProcessArguments(state, sortedArguments, scalarArguments, complexIndexer, startOpenCLDelegateType, out dataUsesIdentifier, ref callParams, ref callArgs, ref state.Constructor.Parameters, ref ctorArgs, ref typeList);
#endregion
ConversionHelper.GenerateSubmitCodelet(state, codeletsIdentifier, dataUsesIdentifier);
ConversionHelper.FinishOperation(state, finalConversionResult);
Class actualOperationClass = CONTEXT._operationRegistry.RegisterOperation(finalConversionResult.CompleteExpression, state.Class);
#region // create method 'call'
Identifier callIdentifier = Identifier.For("call");
Method callMethod = actualOperationClass.GetMethod(callIdentifier, typeList.ToArray());
Expression returnExp;
if (methodStruct.Type is ARRAY_TYPE)
{
returnExp = receiverIdentifier;
}
else
{
returnExp = new BinaryExpression {
NodeType = NodeType.Castclass,
Operand2 = new MemberBinding {
BoundMember = expressionResult.Type.ScalarType.TypeNode.GetArrayType(1)
},
Operand1 = new MethodCall {
Callee = new MemberBinding {
TargetObject = receiverIdentifier,
BoundMember = STANDARD.Data.GetMethod(Identifier.For("GetHostArray")),
},
}
};
}
if (methodStruct.Type is ARRAY_TYPE)
{
}
else
{
returnExp = NodeHelper.GetConstantIndexerForExpression(returnExp, 0);
if (methodStruct.Type is BOOLEAN_TYPE)
{
// if it was a boolean operation invert the value (1 is false in OpenCL kernel)
returnExp = new BinaryExpression {
NodeType = NodeType.Eq,
Operand1 = returnExp,
Operand2 = Literal.Int32Zero
};
}
}
if (callMethod == null)
{
actualOperationClass.Members.Add(new Method {
DeclaringType = state.Class,
Flags = MethodFlags.Static,
ReturnType = (methodStruct.Type is ARRAY_TYPE) ? STANDARD.Data : methodStruct.Type.convert() as TypeNode /*receiverComputeType.ScalarType.TypeNode*/,
Parameters = callParams,
Name = callIdentifier,
Body = new Block {
Statements = new StatementList(
new VariableDeclaration {
Name = receiverIdentifier,
Type = STANDARD.Data,
},
new ExpressionStatement(new Construct {
Constructor = new MemberBinding {
BoundMember = actualOperationClass.GetConstructors()[0],
},
Operands = ctorArgs,
}),
new Return(returnExp)
)
}
});
}
#endregion
#region // return call to 'call'
return(new MethodCall {
Operands = callArgs,
Callee = new MemberBinding(null, actualOperationClass.GetMethod(callIdentifier, typeList.ToArray())),
Type = expressionResult.Type.ScalarType.TypeNode,
});
#endregion
}
internal void ConversionStateChanged(ConversionState newState)
{
ConversionState = newState;
StateChanged?.Invoke(this, new ConversionStateChangedEventArgs(newState));
}
public static Statement Convert(ConversionState state, ConversionResult expressionResult, Identifier receiverIdentifier, ComputeType receiverComputeType, INDEXER indexer)
{
bool complexIndexer;
ComputeType computeType = receiverComputeType;
Expression[] indices = ConversionHelper.GetExpressionsFromIndexer(indexer, ref receiverComputeType, out complexIndexer);
// create empty indices if there is a complex indexer
if (indices == null && complexIndexer)
{
receiverComputeType = computeType;
indices = new Expression[computeType.Rank];
}
if (indices == null || (receiverComputeType != expressionResult.Type && !complexIndexer))
{
return(null);
}
// if the right expression has a complex indexer, we need it too
complexIndexer |= expressionResult.HasComplexIndexer;
List <ConversionHelper.Argument> sortedArguments = ConversionHelper.ExtractArguments(state, false);
List <ConversionHelper.Argument> scalarArguments = ConversionHelper.ExtractArguments(state, true);
ExpressionArgument receiverArgument;
ConversionHelper.ProcessReceiver(state, expressionResult, receiverIdentifier, receiverComputeType, indices, indexer, ref sortedArguments, complexIndexer, out receiverArgument);
ConversionResult finalConversionResult = ConversionHelper.GenerateKernelExecution(state, expressionResult, Identifier.For("buffer" + receiverArgument.Index.ToString()), complexIndexer);
// generate delegates
DelegateNode getOpenCLTimeDelegateType;
DelegateNode startOpenCLDelegateType;
ConversionHelper.GenerateOpenCLDelegates(state, out getOpenCLTimeDelegateType, out startOpenCLDelegateType);
// generate get time method
ConversionHelper.GenerateTimeMethod(state);
// generate the codelets
Identifier codeletsIdentifier;
ConversionHelper.GenerateCodelets(state, getOpenCLTimeDelegateType, startOpenCLDelegateType, out codeletsIdentifier);
// process arguments
Identifier dataUsesIdentifier;
ExpressionList constructArguments = new ExpressionList();
ConversionHelper.ProcessArguments(state, sortedArguments, scalarArguments, complexIndexer, startOpenCLDelegateType, out dataUsesIdentifier, ref state.Constructor.Parameters, ref constructArguments);
ConversionHelper.GenerateSubmitCodelet(state, codeletsIdentifier, dataUsesIdentifier);
ConversionHelper.FinishOperation(state, finalConversionResult);
String completeExpression = string.Format("{0} = {1}", ConversionHelper.FormatIdentifierExpression(receiverComputeType, indices, receiverArgument.Index, complexIndexer), finalConversionResult.CompleteExpression);
Class actualOperationClass = CONTEXT._operationRegistry.RegisterOperation(completeExpression, state.Class);
return(new ExpressionStatement {
Expression = new Construct {
Constructor = new MemberBinding {
BoundMember = actualOperationClass.GetConstructors()[0],
},
Operands = constructArguments,
}
});
}
public ConversionStateChangedEventArgs(ConversionState newState)
{
this.NewState = newState;
}
