/// <summary> /// Initializes a new instance. /// </summary> /// <param name="counterExampleMetadata">The state vector layout expected by the counter example.</param> /// <param name="modelMetadata">The state vector layout expected by the model.</param> internal StateVectorMismatchException(StateVectorLayout counterExampleMetadata, StateVectorLayout modelMetadata) : base("Mismatch detected between the layout of the state vector as expected by the counter example and the " + "actual layout of the state vector used by the instantiated model.") { CounterExampleMetadata = counterExampleMetadata; ModelMetadata = modelMetadata; }
/// <summary> /// Deserializes a <see cref="SafetySharpRuntimeModel" /> from the <paramref name="reader" />. /// </summary> private unsafe SerializedRuntimeModel DeserializeModel(byte[] buffer, BinaryReader reader) { // Deserialize the object table var objectTable = DeserializeObjectTable(reader); // Deserialize the object identifiers of the model itself and the root formulas var model = (ModelBase)objectTable.GetObject(reader.ReadUInt16()); var formulas = new Formula[reader.ReadInt32()]; for (var i = 0; i < formulas.Length; ++i) { formulas[i] = (Formula)objectTable.GetObject(reader.ReadUInt16()); } // Copy the serialized initial state from the stream var stateVectorSize = reader.ReadInt32(); var serializedState = stackalloc byte[stateVectorSize]; for (var i = 0; i < stateVectorSize; ++i) { serializedState[i] = reader.ReadByte(); } // Deserialize the model's initial state OpenSerializationDelegate deserializer; lock (_syncObject) { if (StateVector == null) { StateVector = SerializationRegistry.Default.GetStateVectorLayout(model, objectTable, SerializationMode.Full); } if (_deserializer == null) { _deserializer = StateVector.CreateDeserializer(); } deserializer = _deserializer; } deserializer(objectTable, serializedState); // We instantiate the runtime type for each component and replace the original component // instance with the new runtime instance; we also replace all of the component's fault effects // with that instance and deserialize the initial state again. Afterwards, we have completely // replaced the original instance with its runtime instance, taking over all serialized data objectTable.SubstituteRuntimeInstances(); deserializer(objectTable, serializedState); // We substitute the dummy delegate objects with the actual instances obtained from the DelegateMetadata instances objectTable.SubstituteDelegates(); deserializer(objectTable, serializedState); // Return the serialized model data return(new SerializedRuntimeModel(model, buffer, objectTable, formulas)); }
/// <summary> /// Generates the <see cref="StateVectorLayout" /> for the <paramref name="objects" />. /// </summary> /// <param name="model">The model the state vector should be layouted for.</param> /// <param name="objects">The objects consisting of state values the state vector layout should be generated for.</param> /// <param name="mode">The serialization mode that should be used to generate the state vector layout.</param> internal StateVectorLayout GetStateVectorLayout(ModelBase model, ObjectTable objects, SerializationMode mode) { Requires.NotNull(model, nameof(model)); Requires.NotNull(objects, nameof(objects)); Requires.InRange(mode, nameof(mode)); var layout = new StateVectorLayout(); foreach (var slot in objects.SelectMany(obj => GetSerializer(obj).GetStateSlotMetadata(obj, objects.GetObjectIdentifier(obj), mode))) { layout.Add(slot); } layout.Compact(model, mode); return(layout); }
/// <summary> /// Serializes the <paramref name="model" />. /// </summary> private unsafe void SerializeModel(BinaryWriter writer, ModelBase model, Formula[] formulas) { // Collect all objects contained in the model var objectTable = CreateObjectTable(model, formulas); // Prepare the serialization of the model's initial state lock (_syncObject) { StateVector = SerializationRegistry.Default.GetStateVectorLayout(model, objectTable, SerializationMode.Full); _deserializer = null; } var stateVectorSize = StateVector.SizeInBytes; var serializer = StateVector.CreateSerializer(objectTable); // Serialize the object table SerializeObjectTable(objectTable, writer); // Serialize the object identifier of the model itself and the formulas writer.Write(objectTable.GetObjectIdentifier(model)); writer.Write(formulas.Length); foreach (var formula in formulas) { writer.Write(objectTable.GetObjectIdentifier(formula)); } // Serialize the initial state var serializedState = stackalloc byte[stateVectorSize]; serializer(serializedState); // Copy the serialized state to the stream writer.Write(stateVectorSize); for (var i = 0; i < stateVectorSize; ++i) { writer.Write(serializedState[i]); } }