//public BlitList<> DirtyKernelDatas; //public BlitList<> CreatedConnections; //public BlitList<> DeletedConnections; public GraphDiff(Allocator allocator) { CreatedNodes = new BlitList <ValidatedHandle>(0, allocator); DeletedNodes = new BlitList <DeletedTuple>(0, allocator); Commands = new BlitList <CommandTuple>(0, allocator); ResizedDataBuffers = new BlitList <BufferResizedTuple>(0, allocator); ResizedPortArrays = new BlitList <PortArrayResizedTuple>(0, allocator); MessagesArrivingAtDataPorts = new BlitList <DataPortMessageTuple>(0, allocator); }
/// <summary> /// Initializes this <see cref="NodeSet"/> in a mode that's compatible with running together with ECS, /// through the use of <see cref="ComponentNode"/>s. /// The <paramref name="hostSystem"/> and this instance are tied together from this point, and you must /// update this set using the <see cref="Update(JobHandle)"/> function. /// See also <seealso cref="NodeSet()"/>. /// </summary> /// <remarks> /// Any instantiated nodes with <see cref="IKernelPortDefinition"/>s containing ECS types will be added /// as dependencies to <paramref name="hostSystem"/>. /// </remarks> /// <exception cref="ArgumentNullException"> /// Thrown if the <paramref name="hostSystem"/> is null /// </exception> public NodeSet(JobComponentSystem hostSystem) : this() { if (hostSystem == null) { // In case of cascading constructors, an object can be partially constructed but still be // GC collected and finalized. Dispose(); throw new ArgumentNullException(nameof(hostSystem)); } HostSystem = hostSystem; m_ActiveComponentTypes = new BlitList <AtomicSafetyManager.ECSTypeAndSafety>(0, Allocator.Persistent); }
GenerateDataPortDeclarations(Type definitionType, Type kernelPortType) { // Offset from the start of the field of the data port to the pointer. A bit of a hack. const int k_PtrOffset = 0; var inputs = new BlitList <InputDeclaration>(0); var outputs = new BlitList <OutputDeclaration>(0); var outputBufferOffsets = new BlitList <BufferOffset>(0); try { var kernelPortValue = definitionType.GetField("s_KernelPorts", BindingFlags.FlattenHierarchy | BindingFlags.Static | BindingFlags.NonPublic)?.GetValue(null); foreach (var potentialPortFieldInfo in kernelPortType.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static)) { ValidateFieldOnKernelPort(potentialPortFieldInfo); var portType = potentialPortFieldInfo.FieldType; if (!portType.IsConstructedGenericType) { throw new InvalidNodeDefinitionException($"Simulation port definition contains disallowed field {portType}."); } // Acquire the assigned port number of this port declaration var assignedPortNumberField = portType.GetField("Port", BindingFlags.Instance | BindingFlags.NonPublic); var genericPortType = portType.GetGenericTypeDefinition(); var genericsForDeclaration = portType.GetGenericArguments(); bool isPortArray = genericPortType == typeof(PortArray <>); if (isPortArray) { // Extract the specifics of the port type inside the port array. portType = genericsForDeclaration[0]; if (!portType.IsConstructedGenericType) { throw new InvalidNodeDefinitionException($"Simulation port definition contains disallowed field {portType}."); } genericPortType = portType.GetGenericTypeDefinition(); genericsForDeclaration = portType.GetGenericArguments(); } if (genericsForDeclaration.Length < 2) { throw new InvalidNodeDefinitionException($"Simulation port definition contains disallowed type {portType}."); } var dataType = genericsForDeclaration[1]; ValidateDataPortType(potentialPortFieldInfo, dataType); var offsetOfWholePortDeclaration = UnsafeUtility.GetFieldOffset(potentialPortFieldInfo); var portValue = potentialPortFieldInfo.GetValue(kernelPortValue); if (genericPortType == typeof(DataInput <,>)) { if (UnsafeUtility.SizeOf(dataType) > k_MaxInputSize) { throw new InvalidNodeDefinitionException($"Node input data structure types cannot have a sizeof larger than {k_MaxInputSize}"); } inputs.Add( new InputDeclaration( new SimpleType(dataType), offsetOfWholePortDeclaration + k_PtrOffset, (InputPortID)assignedPortNumberField.GetValue(portValue), isPortArray ) ); } else if (genericPortType == typeof(DataOutput <,>)) { SimpleType type; if (IsBufferDefinition(dataType)) { // Compute the simple type of an element inside a buffer if possible type = new SimpleType(dataType.GetGenericArguments()[0]); outputBufferOffsets.Add(new BufferOffset(offsetOfWholePortDeclaration)); } else { // otherwise the entire value (breaks for aggregates) type = new SimpleType(dataType); foreach (var field in WalkTypeInstanceFields(dataType, BindingFlags.Public, IsBufferDefinition)) { outputBufferOffsets.Add(new BufferOffset(offsetOfWholePortDeclaration + UnsafeUtility.GetFieldOffset(field))); } } outputs.Add( new OutputDeclaration( type, offsetOfWholePortDeclaration + k_PtrOffset, (OutputPortID)assignedPortNumberField.GetValue(portValue) ) ); } else { throw new InvalidNodeDefinitionException($"Kernel port definition {kernelPortType} contains other types of fields than DataInput<> and DataOutput<> ({portType})"); } } } catch { inputs.Dispose(); outputs.Dispose(); outputBufferOffsets.Dispose(); throw; } return(inputs, outputs, outputBufferOffsets); }
public void Create() { Inputs = new BlitList <InputToECS>(0, Allocator.Persistent); Outputs = new BlitList <OutputFromECS>(0, Allocator.Persistent); JITPorts = new BlitList <JITPort>(0, Allocator.Persistent); }