public MyFourierBinder(MyWorkingNode owner, int inputSize, MyMemoryBlock<float> tempBlock) : base(owner, inputSize, tempBlock) { m_stream = new CudaStream(); m_fft = new CudaFFTPlan1D(inputSize, cufftType.R2C, 1); m_fft.SetStream(m_stream.Stream); m_ifft = new CudaFFTPlan1D(inputSize, cufftType.C2R, 1); m_ifft.SetStream(m_stream.Stream); m_mulkernel = MyKernelFactory.Instance.Kernel(owner.GPU, @"Common\CombineVectorsKernel", "MulComplexElementWise"); m_mulkernel.SetupExecution(inputSize + 1); m_involutionKernel = MyKernelFactory.Instance.Kernel(owner.GPU, @"Common\CombineVectorsKernel", "InvolveVector"); m_involutionKernel.SetupExecution(inputSize - 1); m_inversionKernel = MyKernelFactory.Instance.Kernel(owner.GPU, @"Transforms\InvertValuesKernel", "InvertLengthComplexKernel"); m_inversionKernel.SetupExecution(inputSize); m_dotKernel = MyKernelFactory.Instance.KernelProduct<float>(owner, owner.GPU, ProductMode.f_DotProduct_f); m_normalKernel = MyKernelFactory.Instance.Kernel(owner.GPU, @"Transforms\TransformKernels", "PolynomialFunctionKernel"); m_normalKernel.SetupExecution(inputSize); m_firstFFTOffset = 0; m_secondFFTOffset = (inputSize + 1) * 2; m_tempOffset = (inputSize + 1) * 4; Denominator = inputSize; }
/// <summary> /// Sets property of given task. Support Enums /// </summary> /// <param name="nodeId">Node ID</param> /// <param name="taskType">Task type</param> /// <param name="propName">Property name</param> /// <param name="value">New property value</param> public void Set(int nodeId, Type taskType, string propName, object value) { MyWorkingNode node = (Project.GetNodeById(nodeId) as MyWorkingNode); MyTask task = GetTaskByType(node, taskType); SetProperty(task, propName, value); }
// Check the dashboard for expected properties. private static void CheckDashboard(MyProject project) { Dashboard dashboard = project.Dashboard; var property1 = CheckDashboardProperty(project, dashboard, 338, "PerformTask", "SimilarityOperator"); var property2 = CheckDashboardProperty(project, dashboard, 331, "PerformTask", "SimilarityOperator"); CheckDashboardProperty(project, dashboard, 451, "ShareWeightsTask", "SourceNodeName"); MyWorkingNode nodeGroup = project.Network.GetChildNodeById(359) as MyWorkingNode; var property4 = dashboard.Get(nodeGroup, "InputBranches"); Assert.NotNull(property4); // Check the grouped dashboard for expected properties. GroupDashboard groupedDashboard = project.GroupedDashboard; var group = groupedDashboard.Get("f6af17f3-82b0-42b6-89b0-a4eaf6432316"); Assert.NotNull(@group); Assert.True(@group.GroupedProperties.Contains(property1)); Assert.True(@group.GroupedProperties.Contains(property2)); }
private void RefreshNode(MyWorkingNode node) { node.Updated(); propertyGrid.Refresh(); m_mainForm.InvalidateGraphLayouts(); }
public MyFourierBinder(MyWorkingNode owner, int inputSize, MyMemoryBlock <float> tempBlock) : base(owner, inputSize, tempBlock) { m_fft = new CudaFFTPlan1D(inputSize, cufftType.R2C, 1); m_ifft = new CudaFFTPlan1D(inputSize, cufftType.C2R, 1); m_mulkernel = MyKernelFactory.Instance.Kernel(owner.GPU, @"Common\CombineVectorsKernel", "MulComplexElementWise"); m_mulkernel.SetupExecution(inputSize + 1); m_involutionKernel = MyKernelFactory.Instance.Kernel(owner.GPU, @"Common\CombineVectorsKernel", "InvolveVector"); m_involutionKernel.SetupExecution(inputSize - 1); m_inversionKernel = MyKernelFactory.Instance.Kernel(owner.GPU, @"Transforms\InvertValuesKernel", "InvertLengthComplexKernel"); m_inversionKernel.SetupExecution(inputSize); m_dotKernel = MyReductionFactory.Kernel(owner.GPU, MyReductionFactory.Mode.f_DotProduct_f); m_normalKernel = MyKernelFactory.Instance.Kernel(owner.GPU, @"Transforms\TransformKernels", "PolynomialFunctionKernel"); m_normalKernel.SetupExecution(inputSize); m_firstFFTOffset = 0; m_secondFFTOffset = (inputSize + 1) * 2; m_tempOffset = (inputSize + 1) * 4; Denominator = inputSize; }
/// <summary> /// Merge tasks directly below the Target node into the nodes in this level of the execution tree. /// This adds the signal values but mostly is used for custom execution plans. /// </summary> /// <param name="profilingInfo">The target's </param> /// <returns></returns> private static Dictionary <IMyExecutable, TimeSpan> GetProfilingInfoWithTasks(IDictionary <IMyExecutable, TimeSpan> profilingInfo) { var profilingInfoWithTasks = new Dictionary <IMyExecutable, TimeSpan>(); foreach (KeyValuePair <IMyExecutable, TimeSpan> profiling in profilingInfo) { var task = profiling.Key as MyTask; if (task != null) { // Tasks belong to a node, their time should be added to the node's. MyWorkingNode node = task.GenericOwner; if (profilingInfoWithTasks.ContainsKey(node.ExecutionBlock)) { profilingInfoWithTasks[node.ExecutionBlock] = profilingInfoWithTasks[node.ExecutionBlock].Add(profiling.Value); } else { profilingInfoWithTasks[node.ExecutionBlock] = profiling.Value; } } else { profilingInfoWithTasks[profiling.Key] = profiling.Value; } } return(profilingInfoWithTasks); }
private List <IMyExecutable> GetTasks(MyWorkingNode node) { List <IMyExecutable> tasks = new List <IMyExecutable>(); foreach (string taskName in node.GetInfo().KnownTasks.Keys) { MyTask task = node.GetTaskByPropertyName(taskName); tasks.Add(task); } MyNodeGroup nodeGroup = node as MyNodeGroup; if (nodeGroup != null) { foreach (MyNode childNode in nodeGroup.Children) { MyWorkingNode childWorkingNode = childNode as MyWorkingNode; if (childWorkingNode != null) { tasks.AddRange(GetTasks(childWorkingNode)); } } } return(tasks); }
public VectorOps(MyWorkingNode caller, VectorOperation operations, MyMemoryBlock<float> tempBlock) { m_caller = caller; m_operations = operations; m_temp = tempBlock; MatOperation mat_ops = MatOperation.None; if (m_operations.HasFlag(VectorOperation.Rotate)) { Debug.Assert(tempBlock.Count >= 4, "Temporary memory block has to be large at least 4 items when using Rotate operation"); mat_ops |= MatOperation.Multiplication; } if (m_operations.HasFlag(VectorOperation.Angle)) mat_ops |= MatOperation.DotProd; if (m_operations.HasFlag(VectorOperation.DirectedAngle)) { mat_ops |= MatOperation.Multiplication | MatOperation.DotProd; m_operations |= VectorOperation.Angle | VectorOperation.Rotate; } m_matOperation = new MyMatrixAutoOps(caller, mat_ops); }
private static string ResolveFilePath(MyAbstractMemoryBlock memoryBlock, string globalDataFolder) { string fileName = GetTempStorage(memoryBlock.Owner.Owner) + "\\" + GetNodeFolder(memoryBlock.Owner) + "\\" + GetFileName(memoryBlock); if (!File.Exists(fileName)) { MyWorkingNode node = memoryBlock.Owner as MyWorkingNode; if (!string.IsNullOrEmpty(node.DataFolder)) { fileName = node.DataFolder; } else if (!string.IsNullOrEmpty(globalDataFolder)) { fileName = globalDataFolder + "\\" + GetNodeFolder(memoryBlock.Owner); } else { throw new FileNotFoundException( "File not found in temporal folder and no data folder defined: " + fileName); } fileName += "\\" + GetFileName(memoryBlock); } if (!File.Exists(fileName)) { throw new FileNotFoundException("Memory block file not found: " + fileName); } return(fileName); }
public VectorOps(MyWorkingNode caller, VectorOperation operations, MyMemoryBlock <float> tempBlock) { m_caller = caller; m_operations = operations; m_temp = tempBlock; MatOperation mat_ops = MatOperation.None; if (m_operations.HasFlag(VectorOperation.Rotate)) { Debug.Assert(tempBlock.Count >= 4, "Temporary memory block has to be large at least 4 items when using Rotate operation"); mat_ops |= MatOperation.Multiplication; } if (m_operations.HasFlag(VectorOperation.Angle)) { mat_ops |= MatOperation.DotProd; } if (m_operations.HasFlag(VectorOperation.DirectedAngle)) { mat_ops |= MatOperation.Multiplication | MatOperation.DotProd; m_operations |= VectorOperation.Angle | VectorOperation.Rotate; } m_matOperation = new MyMatrixAutoOps(caller, mat_ops); }
public MyPermutationBinder(MyWorkingNode owner, int inputSize, MyMemoryBlock<float> tempBlock) : base(owner, inputSize, tempBlock) { m_PermKernel = MyKernelFactory.Instance.Kernel(owner.GPU, @"Common\CombineVectorsKernel", "CombineVectorsKernel"); m_PermKernel.SetupExecution(inputSize); m_binaryPermKernel = MyKernelFactory.Instance.Kernel(owner.GPU, @"Common\CombineVectorsKernel", "CombineTwoVectorsKernel"); m_binaryPermKernel.SetupExecution(inputSize); }
public MyPermutationBinder(MyWorkingNode owner, int inputSize, MyMemoryBlock <float> tempBlock) : base(owner, inputSize, tempBlock) { m_stream = new CudaStream(); m_binaryPermKernel = MyKernelFactory.Instance.Kernel(owner.GPU, @"Common\CombineVectorsKernel", "CombineTwoVectorsKernel"); m_binaryPermKernel.SetupExecution(inputSize); }
private void CollectNodeAndTaskIdentifiers() { CSharpCodeProvider codeProvider = new CSharpCodeProvider(); m_nodeVariables = new Dictionary <string, int>(); m_taskVariables = new Dictionary <string, Tuple <int, string> >(); m_codeGenerationLog = new List <string>(); m_codeGenerationLog.Add("Script generator:"); Iterate(true, false, node => { string nodeIdentifier = node.Name; nodeIdentifier = nodeIdentifier.Replace(' ', '_'); if (!codeProvider.IsValidIdentifier(nodeIdentifier) || m_nodeVariables.ContainsKey(nodeIdentifier)) { string newIdentifier = "Node_" + node.Id; m_codeGenerationLog.Add("\"" + nodeIdentifier + "\" is invalid name for identifier (or it exists already). \"" + newIdentifier + "\" generated instead."); nodeIdentifier = newIdentifier; } m_nodeVariables[nodeIdentifier] = node.Id; MyWorkingNode wNode = node as MyWorkingNode; if (wNode != null) { foreach (string taskName in node.GetInfo().KnownTasks.Keys) { string taskIdentifier = nodeIdentifier + "_" + taskName; if (!codeProvider.IsValidIdentifier(taskIdentifier) || m_nodeVariables.ContainsKey(taskIdentifier)) { m_codeGenerationLog.Add("\"" + nodeIdentifier + "\" is invalid name for identifier (or it exists already). No task variable generated."); } else { m_taskVariables[taskIdentifier] = new Tuple <int, string>(wNode.Id, taskName); } } } }); m_nameExpressions = String.Empty; if (m_nodeVariables.Any()) { m_nameExpressions = m_nodeVariables.Keys.Aggregate((a, b) => a + " " + b); } if (m_taskVariables.Any()) { m_nameExpressions += " " + m_taskVariables.Keys.Aggregate((a, b) => a + " " + b); } }
public MyMatrixKernelOps(MyWorkingNode callee, MatOperation operations, MyMemoryBlock <float> A, MyMemoryBlock <float> B = null) { OpersKerlsDictionary = new Dictionary <MatOperation, MyCudaKernel>(); this.callee = callee; if ((operations & MatOperation.Log) > 0) { OpersKerlsDictionary.Add(MatOperation.Log, MyKernelFactory.Instance.Kernel(callee.GPU, @"Vision\Matrix", "LogKernel_naive")); } if ((operations & MatOperation.Exp) > 0) { OpersKerlsDictionary.Add(MatOperation.Exp, MyKernelFactory.Instance.Kernel(callee.GPU, @"Vision\Matrix", "ExpKernel_naive")); } if ((operations & MatOperation.Round) > 0) { OpersKerlsDictionary.Add(MatOperation.Round, MyKernelFactory.Instance.Kernel(callee.GPU, @"Vision\Matrix", "RoundKernel_naive")); } if ((operations & MatOperation.Floor) > 0) { OpersKerlsDictionary.Add(MatOperation.Floor, MyKernelFactory.Instance.Kernel(callee.GPU, @"Vision\Matrix", "FloorKernel_naive")); } if ((operations & MatOperation.Ceil) > 0) { OpersKerlsDictionary.Add(MatOperation.Ceil, MyKernelFactory.Instance.Kernel(callee.GPU, @"Vision\Matrix", "CeilKernel_naive")); } if ((operations & MatOperation.Abs) > 0) { OpersKerlsDictionary.Add(MatOperation.Abs, MyKernelFactory.Instance.Kernel(callee.GPU, @"Vision\Matrix", "AbsKernel_naive")); } if ((operations & MatOperation.GetCol) > 0) { OpersKerlsDictionary.Add(MatOperation.GetCol, MyKernelFactory.Instance.Kernel(callee.GPU, @"Vision\Matrix", "Matrix_getCol_FloatId_naive")); } if ((operations & MatOperation.GetRow) > 0) { OpersKerlsDictionary.Add(MatOperation.GetRow, MyKernelFactory.Instance.Kernel(callee.GPU, @"Vision\Matrix", "Matrix_getRow_FloatId_naive")); } if ((operations & MatOperation.MultiplElemntWise) > 0) { OpersKerlsDictionary.Add(MatOperation.MultiplElemntWise, MyKernelFactory.Instance.Kernel(callee.GPU, @"Vision\Matrix", "Matrix_MultiplElementWise_naive")); } if ((operations & MatOperation.Addition) > 0) { OpersKerlsDictionary.Add(MatOperation.Addition, MyKernelFactory.Instance.Kernel(callee.GPU, @"Vision\Matrix", "Matrix_Addition_naive")); } if ((operations & MatOperation.Substraction) > 0) { OpersKerlsDictionary.Add(MatOperation.Substraction, MyKernelFactory.Instance.Kernel(callee.GPU, @"Vision\Matrix", "Matrix_Substraction_naive")); } if (operations > 0 && OpersKerlsDictionary.Count == 0) { MyLog.Writer.WriteLine(MyLogLevel.ERROR, "Trying to init kernel MatrixOps for undefined MatOperation"); } }
public MyMatrixKernelOps(MyWorkingNode callee, MatOperation operations, MyMemoryBlock<float> A, MyMemoryBlock<float> B = null) { OpersKerlsDictionary = new Dictionary<MatOperation, MyCudaKernel>(); this.callee = callee; if ((operations & MatOperation.Log) > 0) { OpersKerlsDictionary.Add(MatOperation.Log, MyKernelFactory.Instance.Kernel(callee.GPU, @"Vision\Matrix", "LogKernel_naive")); } if ((operations & MatOperation.Exp) > 0) { OpersKerlsDictionary.Add(MatOperation.Exp, MyKernelFactory.Instance.Kernel(callee.GPU, @"Vision\Matrix", "ExpKernel_naive")); } if ((operations & MatOperation.Round) > 0) { OpersKerlsDictionary.Add(MatOperation.Round, MyKernelFactory.Instance.Kernel(callee.GPU, @"Vision\Matrix", "RoundKernel_naive")); } if ((operations & MatOperation.Floor) > 0) { OpersKerlsDictionary.Add(MatOperation.Floor, MyKernelFactory.Instance.Kernel(callee.GPU, @"Vision\Matrix", "FloorKernel_naive")); } if ((operations & MatOperation.Ceil) > 0) { OpersKerlsDictionary.Add(MatOperation.Ceil, MyKernelFactory.Instance.Kernel(callee.GPU, @"Vision\Matrix", "CeilKernel_naive")); } if ((operations & MatOperation.Abs) > 0) { OpersKerlsDictionary.Add(MatOperation.Abs, MyKernelFactory.Instance.Kernel(callee.GPU, @"Vision\Matrix", "AbsKernel_naive")); } if ((operations & MatOperation.GetCol) > 0) { OpersKerlsDictionary.Add(MatOperation.GetCol, MyKernelFactory.Instance.Kernel(callee.GPU, @"Vision\Matrix", "Matrix_getCol_FloatId_naive")); } if ((operations & MatOperation.GetRow) > 0) { OpersKerlsDictionary.Add(MatOperation.GetRow, MyKernelFactory.Instance.Kernel(callee.GPU, @"Vision\Matrix", "Matrix_getRow_FloatId_naive")); } if ((operations & MatOperation.MultiplElemntWise) > 0) { OpersKerlsDictionary.Add(MatOperation.MultiplElemntWise, MyKernelFactory.Instance.Kernel(callee.GPU, @"Vision\Matrix", "Matrix_MultiplElementWise_naive")); } if ((operations & MatOperation.Addition) > 0) { OpersKerlsDictionary.Add(MatOperation.Addition, MyKernelFactory.Instance.Kernel(callee.GPU, @"Vision\Matrix", "Matrix_Addition_naive")); } if ((operations & MatOperation.Substraction) > 0) { OpersKerlsDictionary.Add(MatOperation.Substraction, MyKernelFactory.Instance.Kernel(callee.GPU, @"Vision\Matrix", "Matrix_Substraction_naive")); } if (operations > 0 && OpersKerlsDictionary.Count == 0) { MyLog.Writer.WriteLine(MyLogLevel.ERROR, "Trying to init kernel MatrixOps for undefined MatOperation"); } }
/// <summary> /// Return task of given type from given node /// </summary> /// <param name="node">Node</param> /// <param name="type">Type of task</param> /// <returns>Task</returns> protected MyTask GetTaskByType(MyWorkingNode node, Type type) { foreach (PropertyInfo taskPropInfo in node.GetInfo().TaskOrder) { MyTask task = node.GetTaskByPropertyName(taskPropInfo.Name); if (task.GetType().ToString() == type.ToString()) { return(task); } } return(null); }
private void loadNodeDataButton_Click(object sender, EventArgs e) { MyWorkingNode node = Target as MyWorkingNode; if (node == null) { return; } node.LoadOnStart = loadNodeDataButton.Checked; RefreshNode(node); }
public MyMatrixAutoOps(MyWorkingNode callee, MatOperation operations, MyMemoryBlock <float> A = null) { if ((MyMatrixKernelOps.AvailableOperations() & operations) > 0) { MatKerlOps = new MyMatrixKernelOps(callee, operations); } if ((MyMatrixCublasOps.AvailableOperations() & operations) > 0) { MatCublOps = new MyMatrixCublasOps(callee); } if ((MyMatrixCPUOps.AvailableOperations() & operations) > 0) { MatCPUOps = new MyMatrixCPUOps(callee); } }
public MyMatrixAutoOps(MyWorkingNode callee, MatOperation operations, MyMemoryBlock<float> A = null) { if ((MyMatrixKernelOps.AvailableOperations() & operations) > 0) { MatKerlOps = new MyMatrixKernelOps(callee, operations); } if ((MyMatrixCublasOps.AvailableOperations() & operations) > 0) { MatCublOps = new MyMatrixCublasOps(callee); } if ((MyMatrixCPUOps.AvailableOperations() & operations) > 0) { MatCPUOps = new MyMatrixCPUOps(callee); } }
public override void RestoreTargetFromIdentifier(MyProject project) { if (TargetIdentifier != null) { string[] split = TargetIdentifier.Split('#'); if (split.Length == 2) { MyWorkingNode node = (MyWorkingNode)project.GetNodeById(int.Parse(split[0])); if (node != null) { Target = MyMemoryManager.Instance.GetMemoryBlockByName(node, split[1]); } } } }
public void CreateAndShowObserverView(MyWorkingNode node, Type observerType) { try { MyAbstractObserver observer = (MyAbstractObserver)Activator.CreateInstance(observerType); observer.GenericTarget = node; ObserverForm newView = new ObserverForm(this, observer, node); ObserverViews.Add(newView); newView.Show(dockPanel, DockState.Float); } catch (Exception e) { MyLog.ERROR.WriteLine("Error creating observer: " + e.Message); } }
private void SaveBlocks(List <MyWorkingNode> nodeList) { MyMemoryBlockSerializer serializer = new MyMemoryBlockSerializer(); for (int j = 0; j < nodeList.Count; j++) { MyWorkingNode node = nodeList[j]; if (SaveAllNodesData || node.SaveOnStop) { foreach (MyAbstractMemoryBlock mb in MyMemoryManager.Instance.GetBlocks(node)) { if (mb.Persistable) { serializer.SaveBlock(mb); } } } } }
private void LoadBlocks(List <MyWorkingNode> nodeList) { MyMemoryBlockSerializer serializer = new MyMemoryBlockSerializer(); for (int j = 0; j < nodeList.Count; j++) { MyWorkingNode node = nodeList[j]; if (LoadAllNodesData || node.LoadOnStart) { foreach (MyAbstractMemoryBlock mb in MyMemoryManager.Instance.GetBlocks(node)) { if (mb.Persistable) { serializer.LoadBlock(mb, GlobalDataFolder); } } } } }
private void saveDataNodeButton_Click(object sender, EventArgs e) { /* * if (folderBrowserDialog.ShowDialog(this) == DialogResult.OK) * { * MyMemoryManager.Instance.LoadBlocks(Target as MyNode, true, folderBrowserDialog.SelectedPath, false); * MyLog.INFO.WriteLine("Memory blocks of '" + (Target as MyNode).Name + "' were loaded from '" + folderBrowserDialog.SelectedPath + "'."); * } */ MyWorkingNode node = Target as MyWorkingNode; if (node == null) { return; } node.SaveOnStop = saveNodeDataButton.Checked; RefreshNode(node); }
private string GenerateVariablesCode() { StringBuilder defs = new StringBuilder(); StringBuilder init = new StringBuilder(); init.AppendLine("public static void __InitGeneratedVariables(MyCSharpNodeGroup owner) { "); if (GenerateVariables) { foreach (string nodeIdentifier in m_nodeVariables.Keys) { MyNode node = GetChildNodeById(m_nodeVariables[nodeIdentifier]); string nodeTypeName = node.GetType().FullName.Replace('+', '.'); if (node != null) { defs.AppendLine("static " + nodeTypeName + " " + nodeIdentifier + ";"); init.AppendLine(nodeIdentifier + " = (" + nodeTypeName + ")owner.GetChildNodeById(" + node.Id + ");"); } } foreach (string taskIdentifier in m_taskVariables.Keys) { MyWorkingNode wNode = (MyWorkingNode)GetChildNodeById(m_taskVariables[taskIdentifier].Item1); MyTask task = wNode.GetTaskByPropertyName(m_taskVariables[taskIdentifier].Item2); if (task != null) { string taskTypeName = task.GetType().FullName.Replace('+', '.'); defs.AppendLine("static " + taskTypeName + " " + taskIdentifier + ";"); init.AppendLine(taskIdentifier + " = (" + taskTypeName + ")((MyWorkingNode)owner.GetChildNodeById(" + wNode.Id + ")).GetTaskByPropertyName(\"" + m_taskVariables[taskIdentifier].Item2 + "\");"); } } } init.AppendLine("}"); return(defs.ToString() + init.ToString()); }
public MyDistanceOps(MyWorkingNode caller, DistanceOperation operations, MyMemoryBlock <float> tempBlock = null) { m_caller = caller; m_operations = operations; m_temp = tempBlock; if (operations.HasFlag(DistanceOperation.DotProd)) { m_dotKernel = MyKernelFactory.Instance.KernelProduct <float>(caller, caller.GPU, ProductMode.f_DotProduct_f); } if (operations.HasFlag(DistanceOperation.CosDist)) { m_cosKernel = MyKernelFactory.Instance.KernelProduct <float>(caller, caller.GPU, ProductMode.f_Cosine_f); } if (operations.HasFlag(DistanceOperation.EuclidDist) || operations.HasFlag(DistanceOperation.EuclidDistSquared)) { // EuclidDist computes EuclidDistSquared first, so keep them together: m_operations |= DistanceOperation.EuclidDist | DistanceOperation.EuclidDistSquared; m_dotKernel = MyKernelFactory.Instance.KernelProduct <float>(caller, caller.GPU, ProductMode.f_DotProduct_f); } if (operations.HasFlag(DistanceOperation.HammingDist)) { m_reduceSumKernel = MyKernelFactory.Instance.KernelReduction <float>(caller, caller.GPU, ReductionMode.f_Sum_f); } if (operations.HasFlag(DistanceOperation.HammingSim)) { m_reduceSumKernel = MyKernelFactory.Instance.KernelReduction <float>(caller, caller.GPU, ReductionMode.f_Sum_f); } if (operations.HasFlag(DistanceOperation.EuclidDist) || operations.HasFlag(DistanceOperation.EuclidDistSquared) || operations.HasFlag(DistanceOperation.HammingDist) || operations.HasFlag(DistanceOperation.HammingSim)) { m_combineVecsKernel = MyKernelFactory.Instance.Kernel(m_caller.GPU, @"Common\CombineVectorsKernel", "CombineTwoVectorsKernel"); } }
public MyDistanceOps(MyWorkingNode caller, DistanceOperation operations, MyMemoryBlock<float> tempBlock = null) { m_caller = caller; m_operations = operations; m_temp = tempBlock; if (operations.HasFlag(DistanceOperation.DotProd)) { m_dotKernel = MyKernelFactory.Instance.KernelProduct<float>(caller, caller.GPU, ProductMode.f_DotProduct_f); } if (operations.HasFlag(DistanceOperation.CosDist)) { m_cosKernel = MyKernelFactory.Instance.KernelProduct<float>(caller, caller.GPU, ProductMode.f_Cosine_f); } if (operations.HasFlag(DistanceOperation.EuclidDist) || operations.HasFlag(DistanceOperation.EuclidDistSquared)) { // EuclidDist computes EuclidDistSquared first, so keep them together: m_operations |= DistanceOperation.EuclidDist | DistanceOperation.EuclidDistSquared; m_dotKernel = MyKernelFactory.Instance.KernelProduct<float>(caller, caller.GPU, ProductMode.f_DotProduct_f); } if (operations.HasFlag(DistanceOperation.HammingDist)) { m_reduceSumKernel = MyKernelFactory.Instance.KernelReduction<float>(caller, caller.GPU, ReductionMode.f_Sum_f); } if (operations.HasFlag(DistanceOperation.HammingSim)) { m_reduceSumKernel = MyKernelFactory.Instance.KernelReduction<float>(caller, caller.GPU, ReductionMode.f_Sum_f); } if (operations.HasFlag(DistanceOperation.EuclidDist) || operations.HasFlag(DistanceOperation.EuclidDistSquared) || operations.HasFlag(DistanceOperation.HammingDist) || operations.HasFlag(DistanceOperation.HammingSim)) { m_combineVecsKernel = MyKernelFactory.Instance.Kernel(m_caller.GPU, @"Common\CombineVectorsKernel", "CombineTwoVectorsKernel"); } }
private void ExtractPartitioningFromExecutionPlan() { HashSet <MyWorkingNode>[] indexTable = new HashSet <MyWorkingNode> [ExecutionPlan.Length]; NodePartitioning = new List <MyWorkingNode> [ExecutionPlan.Length]; MyExecutionBlock.IteratorAction extractNodesAction = delegate(IMyExecutable executable) { if (executable is MyTask) { MyWorkingNode taskOwner = (executable as MyTask).GenericOwner; indexTable[taskOwner.GPU].Add(taskOwner); } }; for (int i = 0; i < ExecutionPlan.Length; i++) { indexTable[i] = new HashSet <MyWorkingNode>(); ExecutionPlan[i].InitStepPlan.Iterate(true, extractNodesAction); ExecutionPlan[i].StandardStepPlan.Iterate(true, extractNodesAction); NodePartitioning[i] = new List <MyWorkingNode>(indexTable[i]); } }
public void CreateAndShowObserverView(MyWorkingNode node, Type observerType) { try { MyAbstractObserver observer = (MyAbstractObserver)Activator.CreateInstance(observerType); observer.GenericTarget = node; ObserverForm newView = new ObserverForm(this, observer, node); ObserverViews.Add(newView); newView.Show(dockPanel, DockState.Float); ProjectStateChanged("Node observer added"); } catch (Exception e) { MyLog.ERROR.WriteLine("Error creating observer: " + e.Message); } }
public MySymbolBinderBase(MyWorkingNode owner, int inputSize, MyMemoryBlock<float> tempBlock) { m_inputSize = inputSize; m_tempBlock = tempBlock; m_owner = owner; }
/// <summary> /// Return task of given type from given node /// </summary> /// <param name="node">Node</param> /// <param name="type">Type of task</param> /// <returns>Task</returns> protected MyTask GetTaskByType(MyWorkingNode node, Type type) { foreach (PropertyInfo taskPropInfo in node.GetInfo().TaskOrder) { MyTask task = node.GetTaskByPropertyName(taskPropInfo.Name); if (task.GetType().ToString() == type.ToString()) return task; } return null; }
public void RemoveNode(MyWorkingNode node) { m_removedNodes.Add(node); }
//private CudaBlas cublas = null; public MyMatrixCublasOps(MyWorkingNode callee, MatOperation operation = 0, MyMemoryBlock <float> A = null, MyMemoryBlock <float> tmp = null) { // cublas = new CudaBlas(); this.callee = callee; }
private MyExecutionBlock CreateNodeExecutionPlan(MyWorkingNode node, bool initPhase) { List<IMyExecutable> defaultPlanContent = new List<IMyExecutable>(); if (!initPhase && PlanSignalTasks) { defaultPlanContent.Add(new MyIncomingSignalTask(node)); } foreach (string taskName in node.GetInfo().KnownTasks.Keys) { MyTask task = node.GetTaskByPropertyName(taskName); if (task != null && initPhase && task.OneShot || !initPhase && !task.OneShot) { defaultPlanContent.Add(task); } } if (node is MyNodeGroup) { IEnumerable<MyNode> children = (node as MyNodeGroup).Children.OrderBy(x => x.TopologicalOrder); foreach (MyNode childNode in children) { if (childNode is MyWorkingNode) { defaultPlanContent.Add(CreateNodeExecutionPlan(childNode as MyWorkingNode, initPhase)); } } } if (!initPhase && PlanSignalTasks) { defaultPlanContent.Add(new MyOutgoingSignalTask(node)); } MyExecutionBlock defaultPlan = new MyExecutionBlock(defaultPlanContent.ToArray()); defaultPlan.Name = node.Name; MyExecutionBlock resultPlan = defaultPlan; if (node is IMyCustomExecutionPlanner) { if (initPhase) { resultPlan = (node as IMyCustomExecutionPlanner).CreateCustomInitPhasePlan(defaultPlan); } else { resultPlan = (node as IMyCustomExecutionPlanner).CreateCustomExecutionPlan(defaultPlan); } resultPlan.Name = defaultPlan.Name; } if (node is MyNodeGroup) { resultPlan.Name += " (group)"; } return resultPlan; }
private MyTask GetCurrentTask(MyWorkingNode node) => node.GetTaskByPropertyName(m_taskPropInfo.Name);
public MyXORBinder(MyWorkingNode owner, int inputSize) : base(owner, inputSize, null) { m_XORKernel = MyKernelFactory.Instance.Kernel(owner.GPU, @"Common\CombineVectorsKernel", "CombineTwoVectorsKernel"); m_XORKernel.SetupExecution(inputSize); }
public override CUdeviceptr GetDevicePtr(MyWorkingNode callee, int offset) { return(GetDevicePtr(callee.GPU, offset)); }
//private CudaBlas cublas = null; public MyMatrixCublasOps(MyWorkingNode callee, MatOperation operation = 0, MyMemoryBlock<float> A = null, MyMemoryBlock<float> tmp = null) { // cublas = new CudaBlas(); this.callee = callee; }
public MyExecutionBlock CreateNodeExecutionPlan(MyWorkingNode node, bool initPhase) { List<IMyExecutable> defaultPlanContent = new List<IMyExecutable>(); if (!initPhase && PlanSignalTasks) { defaultPlanContent.Add(new MyIncomingSignalTask(node)); } foreach (string taskName in node.GetInfo().KnownTasks.Keys) { MyTask task = node.GetTaskByPropertyName(taskName); if (task != null && !task.DesignTime && (initPhase && task.OneShot || !initPhase && !task.OneShot)) { defaultPlanContent.Add(task); } } MyNodeGroup nodeGroup = node as MyNodeGroup; if (nodeGroup != null) { IEnumerable<MyNode> children = nodeGroup.Children.OrderBy(x => x.TopologicalOrder); foreach (MyNode childNode in children) { MyWorkingNode childWorkingNode = childNode as MyWorkingNode; if (childWorkingNode != null) { defaultPlanContent.Add(CreateNodeExecutionPlan(childWorkingNode, initPhase)); } } } if (!initPhase && PlanSignalTasks) { defaultPlanContent.Add(new MyOutgoingSignalTask(node)); } MyExecutionBlock defaultPlan = new MyExecutionBlock(defaultPlanContent.ToArray()); defaultPlan.Name = node.Name; MyExecutionBlock resultPlan = defaultPlan; IMyCustomExecutionPlanner executionPlannerNode = node as IMyCustomExecutionPlanner; if (executionPlannerNode != null) { if (initPhase) { resultPlan = executionPlannerNode.CreateCustomInitPhasePlan(defaultPlan); } else { resultPlan = executionPlannerNode.CreateCustomExecutionPlan(defaultPlan); } resultPlan.Name = defaultPlan.Name; } if (resultPlan.Name == null) resultPlan.Name = node.GetType().Name; if (node is MyNodeGroup) { resultPlan.Name += " (group)"; } // TODO(HonzaS): Rethink this. It's only used in profiling results. node.ExecutionBlock = resultPlan; return resultPlan; }
public void AddNode(MyWorkingNode node) { m_addedNodes.Add(node); }
private List<IMyExecutable> GetTasks(MyWorkingNode node) { List<IMyExecutable> tasks = new List<IMyExecutable>(); foreach (string taskName in node.GetInfo().KnownTasks.Keys) { MyTask task = node.GetTaskByPropertyName(taskName); tasks.Add(task); } MyNodeGroup nodeGroup = node as MyNodeGroup; if (nodeGroup != null) { foreach (MyNode childNode in nodeGroup.Children) { MyWorkingNode childWorkingNode = childNode as MyWorkingNode; if (childWorkingNode != null) { tasks.AddRange(GetTasks(childWorkingNode)); } } } return tasks; }
public override void Restore(MyProject project) { string[] idSplit = PropertyId.Split(new[] { SerializationIdSeparator }, StringSplitOptions.RemoveEmptyEntries); MyNode node = FindNode(project, idSplit[0]); WorkingNode = node as MyWorkingNode; if (Node == null) throw new SerializationException(string.Format("Node id {0} was found but doesn't contain tasks", node.Id)); string taskGroupName = idSplit[1]; TaskGroup taskGroup; if (!WorkingNode.TaskGroups.TryGetValue(taskGroupName, out taskGroup)) throw new SerializationException(string.Format("Task group {0} not found", taskGroupName)); TaskGroup = taskGroup; }
public MyStackingOps(MyWorkingNode caller, MyStackingOperation operations, bool forceInputChecking = false) { m_caller = caller; m_operations = operations; m_forceInputChecking = forceInputChecking; }
public override CudaDeviceVariable <T> GetDevice(MyWorkingNode callee) { return(GetDevice(callee.GPU)); }
public static void CheckControlSize(MyValidator validator, MyAbstractMemoryBlock controls, MyWorkingNode sender) { validator.AssertError(controls != null, sender, "Controls are not connected"); if (controls != null) { int neededControls = NrOfControls; int providedControls = controls.Count; validator.AssertError(providedControls >= neededControls, sender, String.Format("Wrong number of actions. With current control mode ({0}) you have to provide at least {1} controls. Provide the correct number of controls or change the control mode.", Mode, neededControls)); validator.AssertWarning(providedControls != neededControls, sender, String.Format("With current control mode ({0}) you should provide {1} controls but you provided {2} controls. Make sure that this is what you want and you have correct control mode chosen.", Mode, neededControls, providedControls)); } }
public MyMatrixCPUOps(MyWorkingNode callee = null, MatOperation operation = 0, MyMemoryBlock <float> A = null, MyMemoryBlock <float> tmp = null) { }
public MyMatrixCPUOps(MyWorkingNode callee=null, MatOperation operation = 0, MyMemoryBlock<float> A = null, MyMemoryBlock<float> tmp = null) { }