private IEnumerable <SimpleWriteCommand> Enumerable() { WriteCommand current = this; while (current != null) { var compound = current as CompoundWrite; if (compound != null) { current = compound.TailCommand; yield return(compound.Head); } var simple = current as SimpleWriteCommand; if (simple != null) { current = null; yield return(simple); } } }
internal static WriteCommand MergeTwoAtomicOperations(WriteCommand command, Slice argument) { // truncate/resize the previous value to the size of the add int size = argument.Count; var tmp = PrepareValueForAtomicOperation(command.Value, size); switch (command.Type) { case Operation.AtomicAdd: { // do a littlee-endian ADD between the two buffers BufferAdd(tmp, 0, argument.Array, argument.Offset, size); break; } case Operation.AtomicBitAnd: { // do an AND between the two buffers BufferBitAnd(tmp, 0, argument.Array, argument.Offset, size); break; } case Operation.AtomicBitOr: { // do a OR between the two buffers BufferBitOr(tmp, 0, argument.Array, argument.Offset, size); break; } case Operation.AtomicBitXor: { // do a XOR between the two buffers BufferBitXor(tmp, 0, argument.Array, argument.Offset, size); break; } default: { // not supposed to happen throw new InvalidOperationException(); } } return(new WriteCommand(command.Type, command.Key, Slice.Create(tmp))); }
public void WriteCommandWithParamsTest() { // test WriteCommand with parameters with Guid as well var command = new WriteCommand("with_params.in"); Guid my_guid = new Guid("11A4801F-7977-4D3E-8D1E-6CA0BE52E604"); command.AddCommands("TestSystem", "TestCmd", new string[] { "Param0", "Param1", "Param2" }, new string[] { "Value0", "Value1", my_guid.ToString() }, true, 2); command.Save(); var cmnDocPath = Environment.GetFolderPath(Environment.SpecialFolder.CommonDocuments); var filePath = Path.Combine(cmnDocPath, "BpOmniaBridge", "temp_files", "with_params.in"); Assert.AreEqual(true, File.Exists(filePath)); var elements = XDocument.Load(filePath).Element("OmniaXB").Element("TestSystem").Element("TestCmd").Elements(); int num_params = 0; // test each parameter has the correct name and value // Important to test the GUID otherwise you get NACK from OMNIA foreach (XElement element in elements) { if (num_params == 2) { Assert.AreEqual("Param" + num_params, element.Name); Assert.AreEqual(new Guid(element.Value), my_guid); } else { Assert.AreEqual("Param" + num_params, element.Name); Assert.AreEqual("Value" + num_params, element.Value); } num_params += 1; } Assert.AreEqual(3, num_params); File.Delete(filePath); }
protected override void UpdateModuleCycle() { this.CycleCount++; { //Perform writing WriteCommand wCmd = Write_IFace.Get(); int no = wCmd.No % EntryCount; if (wCmd.Enabled) { Entries[no].Content = wCmd.Value; Entries[no].WriteAccessCount++; } PreviousWrite = wCmd; } { //Count reading ReadCommand rCmd = Read0_IFace.Get(); WriteCommand wCmd = Write_IFace.Get(); int no = rCmd.No % EntryCount; if (rCmd.Enabled && no != PreviousRead0.No && !(wCmd.Enabled && wCmd.No == no)) { Entries[no].ReadAccessCount++; } PreviousRead0 = rCmd; } { //Count reading ReadCommand rCmd = Read1_IFace.Get(); WriteCommand wCmd = Write_IFace.Get(); int no = rCmd.No % EntryCount; if (rCmd.Enabled && no != PreviousRead1.No && !(wCmd.Enabled && wCmd.No == no)) { Entries[no].ReadAccessCount++; } PreviousRead1 = rCmd; } base.UpdateModuleCycle(); }
public RawWriteOperation(RawWriteOperation other) { // Notes: May want to switch to MemberwiseClone, for now those this is fine m_Command = other.m_Command; }
public CompoundWrite(SimpleWriteCommand head, WriteCommand tailCommand) { _head = head; _tailCommand = tailCommand; }
public CompoundWrite Append(WriteCommand that) { return(that.Prepend(this)); }
private void Write8BitRegister(WriteCommand register, byte value) { byte[] buf = new byte[2]; buf[0] = (byte)register; buf[1] = value; WriteToDevice(buf); }
private PendingWrite CreatePendingBufferWrite(IActorRef commander, ByteString data, Tcp.Event ack, WriteCommand tail) { return(new PendingBufferWrite(this, SendArgs, Self, commander, data, ack, tail)); }
public override BuildPipelineCodes Convert(BuildDependencyInformation buildInfo, out BuildCommandSet output) { StartProgressBar("Generating Build Commands", buildInfo.assetLoadInfo.Count); Hash128 hash = CalculateInputHash(buildInfo); if (UseCache && BuildCache.TryLoadCachedResults(hash, out output)) { output = new BuildCommandSet(); EndProgressBar(); return(BuildPipelineCodes.SuccessCached); } var commands = new List <WriteCommand>(); foreach (var bundle in buildInfo.bundleToAssets) { var command = new WriteCommand(); var explicitAssets = new List <AssetLoadInfo>(); var assetBundleObjects = new List <SerializationInfo>(); var dependencies = new HashSet <string>(); foreach (var asset in bundle.Value) { var assetInfo = buildInfo.assetLoadInfo[asset]; explicitAssets.Add(assetInfo); if (!UpdateProgressBar(assetInfo.asset)) { output = new BuildCommandSet(); EndProgressBar(); return(BuildPipelineCodes.Canceled); } dependencies.UnionWith(buildInfo.assetToBundles[asset]); foreach (var includedObject in assetInfo.includedObjects) { if (!buildInfo.virtualAssets.Contains(asset) && buildInfo.objectToVirtualAsset.ContainsKey(includedObject)) { continue; } assetBundleObjects.Add(new SerializationInfo { serializationObject = includedObject, serializationIndex = SerializationIndexFromObjectIdentifier(includedObject) }); } foreach (var referencedObject in assetInfo.referencedObjects) { if (referencedObject.filePath == kUnityDefaultResourcePath) { continue; } if (buildInfo.objectToVirtualAsset.ContainsKey(referencedObject)) { continue; } if (buildInfo.assetLoadInfo.ContainsKey(referencedObject.guid)) { continue; } assetBundleObjects.Add(new SerializationInfo { serializationObject = referencedObject, serializationIndex = SerializationIndexFromObjectIdentifier(referencedObject) }); } BuildUsageTagGlobal globalUsage; if (buildInfo.sceneUsageTags.TryGetValue(asset, out globalUsage)) { command.sceneBundle = true; command.globalUsage |= globalUsage; } } dependencies.Remove(bundle.Key); assetBundleObjects.Sort(Compare); command.assetBundleName = bundle.Key; command.explicitAssets = explicitAssets; command.assetBundleDependencies = dependencies.OrderBy(x => x).ToList(); command.assetBundleObjects = assetBundleObjects; commands.Add(command); } output = new BuildCommandSet(); output.commands = commands; if (UseCache && !BuildCache.SaveCachedResults(hash, output)) { BuildLogger.LogWarning("Unable to cache CommandSetProcessor results."); } if (!EndProgressBar()) { return(BuildPipelineCodes.Canceled); } return(BuildPipelineCodes.Success); }
#pragma warning restore 649 /// <inheritdoc /> public ReturnCode Run() { Dictionary <string, WriteCommand> fileToCommand; Dictionary <string, HashSet <ObjectIdentifier> > forwardObjectDependencies; Dictionary <string, HashSet <string> > forwardFileDependencies; Dictionary <string, HashSet <GUID> > reverseAssetDependencies; // BuildReferenceMap details what objects exist in other bundles that objects in a source bundle depend upon (forward dependencies) // BuildUsageTagSet details the conditional data needed to be written by objects in a source bundle that is in used by objects in other bundles (reverse dependencies) using (m_Log.ScopedStep(LogLevel.Info, $"Temporary Map Creations")) { fileToCommand = m_WriteData.WriteOperations.ToDictionary(x => x.Command.internalName, x => x.Command); forwardObjectDependencies = new Dictionary <string, HashSet <ObjectIdentifier> >(); forwardFileDependencies = new Dictionary <string, HashSet <string> >(); reverseAssetDependencies = new Dictionary <string, HashSet <GUID> >(); foreach (var pair in m_WriteData.AssetToFiles) { GUID asset = pair.Key; List <string> files = pair.Value; // The includes for an asset live in the first file, references could live in any file forwardObjectDependencies.GetOrAdd(files[0], out HashSet <ObjectIdentifier> objectDependencies); forwardFileDependencies.GetOrAdd(files[0], out HashSet <string> fileDependencies); // Grab the list of object references for the asset or scene and add them to the forward dependencies hash set for this file (write command) if (m_DependencyData.AssetInfo.TryGetValue(asset, out AssetLoadInfo assetInfo)) { objectDependencies.UnionWith(assetInfo.referencedObjects); } if (m_DependencyData.SceneInfo.TryGetValue(asset, out SceneDependencyInfo sceneInfo)) { objectDependencies.UnionWith(sceneInfo.referencedObjects); } // Grab the list of file references for the asset or scene and add them to the forward dependencies hash set for this file (write command) // While doing so, also add the asset to the reverse dependencies hash set for all the other files it depends upon. // We already ensure BuildReferenceMap & BuildUsageTagSet contain the objects in this write command in GenerateBundleCommands. So skip over the first file (self) for (int i = 1; i < files.Count; i++) { fileDependencies.Add(files[i]); reverseAssetDependencies.GetOrAdd(files[i], out HashSet <GUID> reverseDependencies); reverseDependencies.Add(asset); } } } // Using the previously generated forward dependency maps, update the BuildReferenceMap per WriteCommand to contain just the references that we care about using (m_Log.ScopedStep(LogLevel.Info, $"Populate BuildReferenceMaps")) { foreach (var operation in m_WriteData.WriteOperations) { var internalName = operation.Command.internalName; BuildReferenceMap referenceMap = m_WriteData.FileToReferenceMap[internalName]; if (!forwardObjectDependencies.TryGetValue(internalName, out var objectDependencies)) { continue; // this bundle has no external dependencies } if (!forwardFileDependencies.TryGetValue(internalName, out var fileDependencies)) { continue; // this bundle has no external dependencies } foreach (string file in fileDependencies) { WriteCommand dependentCommand = fileToCommand[file]; foreach (var serializedObject in dependentCommand.serializeObjects) { // Only add objects we are referencing. This ensures that new/removed objects to files we depend upon will not cause a rebuild // of this file, unless are referencing the new/removed objects. if (!objectDependencies.Contains(serializedObject.serializationObject)) { continue; } referenceMap.AddMapping(file, serializedObject.serializationIndex, serializedObject.serializationObject); } } } } // Using the previously generate reverse dependency map, create the BuildUsageTagSet per WriteCommand to contain just the data that we care about using (m_Log.ScopedStep(LogLevel.Info, $"Populate BuildUsageTagSet")) { foreach (var operation in m_WriteData.WriteOperations) { var internalName = operation.Command.internalName; BuildUsageTagSet fileUsage = m_WriteData.FileToUsageSet[internalName]; if (reverseAssetDependencies.TryGetValue(internalName, out var assetDependencies)) { foreach (GUID asset in assetDependencies) { if (m_DependencyData.AssetUsage.TryGetValue(asset, out var assetUsage)) { fileUsage.UnionWith(assetUsage); } if (m_DependencyData.SceneUsage.TryGetValue(asset, out var sceneUsage)) { fileUsage.UnionWith(sceneUsage); } } } if (ReflectionExtensions.SupportsFilterToSubset) { fileUsage.FilterToSubset(m_WriteData.FileToObjects[internalName].ToArray()); } } } return(ReturnCode.Success); }
static async Task Run(Arguments arguments) { Log.Logger = new LoggerConfiguration() .Enrich.FromLogContext() .WriteTo.Console() .CreateLogger(); var serviceProvider = new ServiceCollection() .AddLogging(loggingBuilder => loggingBuilder.AddSerilog(dispose: true)) .BuildServiceProvider(); var loggerFactory = serviceProvider.GetService <ILoggerFactory>(); var isAdministrator = OperatingSystem.IsAdministrator(); if (!isAdministrator) { Console.WriteLine("Requires administrator rights!"); } var commandHelper = new CommandHelper(); var physicalDrives = (await GetPhysicalDrives(arguments)).ToList(); var cancellationTokenSource = new CancellationTokenSource(); switch (arguments.Command) { case Arguments.CommandEnum.List: var listCommand = new ListCommand(loggerFactory.CreateLogger <ListCommand>(), commandHelper, physicalDrives); listCommand.ListRead += (_, args) => { // // await Task.Run(() => // { // Console.WriteLine(JsonSerializer.Serialize(physicalDrivesList, JsonSerializerOptions)); // }); InfoPresenter.PresentInfo(args.MediaInfos); }; var listResult = await listCommand.Execute(cancellationTokenSource.Token); Console.WriteLine(listResult.IsSuccess ? "Done" : $"ERROR: Read failed, {listResult.Error}"); break; case Arguments.CommandEnum.Info: var infoCommand = new InfoCommand(loggerFactory.CreateLogger <InfoCommand>(), commandHelper, physicalDrives, arguments.SourcePath); infoCommand.DiskInfoRead += (_, args) => { InfoPresenter.PresentInfo(args.MediaInfo); }; var infoResult = await infoCommand.Execute(cancellationTokenSource.Token); Console.WriteLine(infoResult.IsSuccess ? "Done" : $"ERROR: Read failed, {infoResult.Error}"); break; case Arguments.CommandEnum.Read: Console.WriteLine("Reading physical drive to image file"); GenericPresenter.PresentPaths(arguments); var readCommand = new ReadCommand(loggerFactory.CreateLogger <ReadCommand>(), commandHelper, physicalDrives, arguments.SourcePath, arguments.DestinationPath, arguments.Size); readCommand.DataProcessed += (_, args) => { GenericPresenter.Present(args); }; var readResult = await readCommand.Execute(cancellationTokenSource.Token); Console.WriteLine(readResult.IsSuccess ? "Done" : $"ERROR: Read failed, {readResult.Error}"); break; case Arguments.CommandEnum.Convert: Console.WriteLine("Converting source image to destination image file"); GenericPresenter.PresentPaths(arguments); var convertCommand = new ConvertCommand(loggerFactory.CreateLogger <ConvertCommand>(), commandHelper, arguments.SourcePath, arguments.DestinationPath, arguments.Size); convertCommand.DataProcessed += (_, args) => { GenericPresenter.Present(args); }; var convertResult = await convertCommand.Execute(cancellationTokenSource.Token); Console.WriteLine( convertResult.IsSuccess ? "Done" : $"ERROR: Convert failed, {convertResult.Error}"); break; case Arguments.CommandEnum.Write: Console.WriteLine("Writing source image file to physical drive"); GenericPresenter.PresentPaths(arguments); var writeCommand = new WriteCommand(loggerFactory.CreateLogger <WriteCommand>(), commandHelper, physicalDrives, arguments.SourcePath, arguments.DestinationPath, arguments.Size); writeCommand.DataProcessed += (_, args) => { GenericPresenter.Present(args); }; var writeResult = await writeCommand.Execute(cancellationTokenSource.Token); Console.WriteLine(writeResult.IsSuccess ? "Done" : $"ERROR: Write failed, {writeResult.Error}"); break; case Arguments.CommandEnum.Verify: Console.WriteLine("Verifying source image to destination"); GenericPresenter.PresentPaths(arguments); var verifyCommand = new VerifyCommand(loggerFactory.CreateLogger <VerifyCommand>(), commandHelper, physicalDrives, arguments.SourcePath, arguments.DestinationPath, arguments.Size); verifyCommand.DataProcessed += (_, args) => { GenericPresenter.Present(args); }; var verifyResult = await verifyCommand.Execute(cancellationTokenSource.Token); Console.WriteLine(verifyResult.IsSuccess ? "Done" : $"ERROR: Verify failed, {verifyResult.Error}"); break; case Arguments.CommandEnum.Blank: Console.WriteLine("Creating blank image"); Console.WriteLine($"Path: {arguments.SourcePath}"); var blankCommand = new BlankCommand(loggerFactory.CreateLogger <BlankCommand>(), commandHelper, arguments.SourcePath, arguments.Size); var blankResult = await blankCommand.Execute(cancellationTokenSource.Token); Console.WriteLine(blankResult.IsSuccess ? "Done" : $"ERROR: Blank failed, {blankResult.Error}"); break; case Arguments.CommandEnum.Optimize: Console.WriteLine("Optimizing image file"); Console.WriteLine($"Path: {arguments.SourcePath}"); var optimizeCommand = new OptimizeCommand(loggerFactory.CreateLogger <OptimizeCommand>(), commandHelper, arguments.SourcePath); var optimizeResult = await optimizeCommand.Execute(cancellationTokenSource.Token); Console.WriteLine(optimizeResult.IsSuccess ? "Done" : $"ERROR: Optimize failed, {optimizeResult.Error}"); break; } }