void FileBasedSavingOfData()
{
var ml = new MLContext(seed: 1, conc: 1);
var src = new MultiFileSource(GetDataPath(TestDatasets.Sentiment.trainFilename));
var trainData = ml.Data.CreateTextLoader(TestDatasets.Sentiment.GetLoaderColumns(), hasHeader: true)
.Append(ml.Transforms.Text.FeaturizeText("SentimentText", "Features"))
.Fit(src).Read(src);
var path = DeleteOutputPath("i.idv");
using (var file = File.Create(path))
{
var saver = new BinarySaver(ml, new BinarySaver.Arguments());
using (var ch = ((IHostEnvironment)ml).Start("SaveData"))
DataSaverUtils.SaveDataView(ch, saver, trainData, file);
}
var trainer = ml.BinaryClassification.Trainers.StochasticDualCoordinateAscent(
new SdcaBinaryTrainer.Options {
NumThreads = 1
});
var loadedTrainData = new BinaryLoader(ml, new BinaryLoader.Arguments(), new MultiFileSource(path));
// Train.
var model = trainer.Fit(loadedTrainData);
}
private void MainWindow_OnLoaded(object sender, RoutedEventArgs e)
{
if (Environment.GetCommandLineArgs().Length != 1)
{
ILoader loader = new BinaryLoader();
Container container = null;
try
{
container = loader.Load(Environment.GetCommandLineArgs()[1]);
}
catch (Exception)
{
this.ShowMessageAsync("Impossible de lire le fichier selectionner",
Environment.GetCommandLineArgs()[1]);
}
if (container != null)
{
MainControl.Content = new GameModeSelection(container, this);
}
else
{
MainControl.Content = new Home(this);
}
}
else
{
MainControl.Content = new Home(this);
}
}
public void TestReadMapping()
{
string rawString = BinaryLoader.LoadString(prefab_mapping_path);
Dictionary <int, string> mapping = BinaryLoader.ParseMapping(rawString);
Assert.IsTrue(mapping.Count > 0);
}
public void TestDirectRead()
{
int[] ss = BinaryLoader.LoadDescriptions(map_desc_path);
int len = ss.Length;
for (int i = 0; i < len; ++i)
{
Assert.IsTrue(ss[i] >= 0);
}
Assert.AreEqual(999, ss[0]);
Assert.AreEqual(999, ss[1]);
Assert.AreEqual(2 + 999 * 999, len);
MapCellProto mcp0 = BinaryLoader.ParseCellProto(ss[2]);
Assert.AreEqual(0, mcp0.area);
Assert.AreEqual(3, mcp0.terrainType);
Assert.AreEqual(2, mcp0.terrainLevel);
MapCellProto mcp1 = BinaryLoader.ParseCellProto(ss[ss.Length - 1]);
Assert.AreEqual(3, mcp1.area);
Assert.AreEqual(1, mcp1.terrainType);
Assert.AreEqual(1, mcp1.terrainLevel);
}
/// <summary>
/// Loads and returns the loader and transforms from the specified repository reader.
/// </summary>
/// <param name="env">The host environment to use.</param>
/// <param name="rep">The repository reader.</param>
/// <param name="files">The data source to initialize the loader with.</param>
/// <param name="extractInnerPipe">Whether to extract the transforms and loader from the wrapped CompositeDataLoader.</param>
/// <returns>The created data view.</returns>
public static IDataView LoadPipeline(IHostEnvironment env, RepositoryReader rep, IMultiStreamSource files, bool extractInnerPipe = false)
{
// REVIEW: Should not duplicate loading loader/transforms code. This method should call LoadLoader.
Contracts.CheckValue(env, nameof(env));
env.CheckValue(rep, nameof(rep));
env.CheckValue(files, nameof(files));
var entry = rep.OpenEntryOrNull(SchemaEntryName);
if (entry != null)
{
var loader = new BinaryLoader(env, new BinaryLoader.Arguments(), entry.Stream);
ModelLoadContext.LoadModel <ITransformer, SignatureLoadModel>(env, out var transformerChain, rep, DirTransformerChain);
return(transformerChain.Transform(loader));
}
using (var ent = rep.OpenEntry(DirDataLoaderModel, ModelLoadContext.ModelStreamName))
{
ILegacyDataLoader loader;
env.Assert(ent.Stream.Position == 0);
ModelLoadContext.LoadModel <ILegacyDataLoader, SignatureLoadDataLoader>(env, out loader, rep, ent, DirDataLoaderModel, files);
IDataView result = loader;
if (extractInnerPipe)
{
var cdl = loader as LegacyCompositeDataLoader;
result = cdl == null ? loader : cdl.View;
}
return(result);
}
}
void New_FileBasedSavingOfData()
{
var dataPath = GetDataPath(SentimentDataPath);
var testDataPath = GetDataPath(SentimentTestPath);
using (var env = new TlcEnvironment(seed: 1, conc: 1))
{
// Pipeline.
var pipeline = new MyTextLoader(env, MakeSentimentTextLoaderArgs())
.Append(new MyTextTransform(env, MakeSentimentTextTransformArgs()));
var trainData = pipeline.Fit(new MultiFileSource(dataPath)).Read(new MultiFileSource(dataPath));
using (var file = env.CreateOutputFile("i.idv"))
trainData.SaveAsBinary(env, file.CreateWriteStream());
var trainer = new MySdca(env, new LinearClassificationTrainer.Arguments {
NumThreads = 1
}, "Features", "Label");
var loadedTrainData = new BinaryLoader(env, new BinaryLoader.Arguments(), new MultiFileSource("i.idv"));
// Train.
var model = trainer.Train(loadedTrainData);
DeleteOutputPath("i.idv");
}
}
void UpdatePatternData()
{
currentPatternData = BinaryLoader.LoadPatternData(currentSpellcard, currentSave);
//if the file does not exists:
if (currentPatternData == null)
{
currentPatternData = new PatternData();
currentPatternData.name = "Spellcard name";
}
for (int i = 0; i < previewParticleSystems.Length; i++)
{
var emission = previewParticleSystems[i].emission;
if (i < currentPatternData.particlePatterns.Count)
{
ParticleSystemScript.SetPSFromData(previewParticleSystems[i], currentPatternData.particlePatterns[i]);
emission.enabled = true;
}
else
{
emission.enabled = false;
}
}
spellcardName.text = currentPatternData.name;
}
void ICanSaveModel.Save(ModelSaveContext ctx)
{
if (!_allowSave)
{
throw _host.Except("Saving is not permitted.");
}
ctx.CheckAtModel();
ctx.SetVersionInfo(GetVersionInfo());
var dataPipe = _xf;
var transforms = new List <IDataTransform>();
while (dataPipe is IDataTransform xf)
{
// REVIEW: a malicious user could construct a loop in the Source chain, that would
// cause this method to iterate forever (and throw something when the list overflows). There's
// no way to insulate from ALL malicious behavior.
transforms.Add(xf);
dataPipe = xf.Source;
Contracts.AssertValue(dataPipe);
}
transforms.Reverse();
ctx.SaveSubModel("Loader", c => BinaryLoader.SaveInstance(_host, c, dataPipe.Schema));
ctx.Writer.Write(transforms.Count);
for (int i = 0; i < transforms.Count; i++)
{
var dirName = string.Format(TransformDirTemplate, i);
ctx.SaveModel(transforms[i], dirName);
}
}
private static IDataLoader LoadStopwords(IHostEnvironment env, IChannel ch, string dataFile,
IComponentFactory <IMultiStreamSource, IDataLoader> loader, ref string stopwordsCol)
{
Contracts.CheckValue(env, nameof(env));
env.CheckValue(ch, nameof(ch));
MultiFileSource fileSource = new MultiFileSource(dataFile);
IDataLoader dataLoader;
// First column using the file.
if (loader == null)
{
// Determine the default loader from the extension.
var ext = Path.GetExtension(dataFile);
bool isBinary = string.Equals(ext, ".idv", StringComparison.OrdinalIgnoreCase);
bool isTranspose = string.Equals(ext, ".tdv", StringComparison.OrdinalIgnoreCase);
if (isBinary || isTranspose)
{
ch.Assert(isBinary != isTranspose);
ch.CheckUserArg(!string.IsNullOrWhiteSpace(stopwordsCol), nameof(Arguments.StopwordsColumn),
"stopwordsColumn should be specified");
if (isBinary)
{
dataLoader = new BinaryLoader(env, new BinaryLoader.Arguments(), fileSource);
}
else
{
ch.Assert(isTranspose);
dataLoader = new TransposeLoader(env, new TransposeLoader.Arguments(), fileSource);
}
}
else
{
if (!string.IsNullOrWhiteSpace(stopwordsCol))
{
ch.Warning("{0} should not be specified when default loader is TextLoader. Ignoring stopwordsColumn={0}",
stopwordsCol);
}
dataLoader = TextLoader.Create(
env,
new TextLoader.Arguments()
{
Separator = "tab",
Column = new[]
{
new TextLoader.Column("Stopwords", DataKind.TX, 0)
}
},
fileSource);
stopwordsCol = "Stopwords";
}
ch.AssertNonEmpty(stopwordsCol);
}
else
{
dataLoader = loader.CreateComponent(env, fileSource);
}
return(dataLoader);
}
public void SetUp()
{
searchLog = new StringWriter();
mockTarget = Substitute.For <RemoteTarget>();
moduleReplacedHandler = Substitute.For <EventHandler <LldbModuleReplacedEventArgs> >();
mockModuleFileFinder = Substitute.For <IModuleFileFinder>();
mockModuleFileFinder.FindFileAsync(BINARY_FILENAME, UUID, false, searchLog)
.Returns(Task.FromResult(PATH_IN_STORE));
placeholderModule = Substitute.For <SbModule>();
placeholderModule.GetPlatformFileSpec().GetFilename().Returns(BINARY_FILENAME);
placeholderModule.GetUUIDString().Returns(UUID.ToString());
placeholderProperties =
new PlaceholderModuleProperties(MODULE_SLIDE, Substitute.For <SbFileSpec>());
mockModuleUtil = Substitute.For <ILldbModuleUtil>();
mockModuleUtil.IsPlaceholderModule(placeholderModule).Returns(true);
mockModuleUtil.GetPlaceholderProperties(Arg.Any <SbModule>(), Arg.Any <RemoteTarget>())
.ReturnsForAnyArgs(placeholderProperties);
mockModuleUtil.ApplyPlaceholderProperties(
Arg.Any <SbModule>(), Arg.Any <PlaceholderModuleProperties>(),
Arg.Any <RemoteTarget>())
.ReturnsForAnyArgs(true);
binaryLoader = new BinaryLoader(mockModuleUtil, mockModuleFileFinder,
mockTarget);
binaryLoader.LldbModuleReplaced += moduleReplacedHandler;
}
public static BaseLoaderElement CreateLoader(EnumResouceType type, string path)
{
BaseLoaderElement loader;
switch (type)
{
case EnumResouceType.CACHE_BINARY:
loader = new CacheBinaryLoader(path);
break;
case EnumResouceType.BINARY:
loader = new BinaryLoader(path);
break;
case EnumResouceType.REMOTE_BINARY:
loader = new RemoteBinaryLoader(path);
break;
case EnumResouceType.ASSETBUNDLE:
loader = new ABLoader(path);
break;
default:
loader = new BinaryLoader(path);
break;
}
return(loader);
}
/// <summary>
/// Save the data pipeline defined by dataPipe. If blankLoader is true or the root IDataView is not an IDataLoader,
/// this persists the root as a BinaryLoader having the same schema.
/// </summary>
public static void SaveDataPipe(IHostEnvironment env, RepositoryWriter repositoryWriter, IDataView dataPipe, bool blankLoader = false)
{
Contracts.CheckValue(env, nameof(env));
env.CheckValue(repositoryWriter, nameof(repositoryWriter));
env.CheckValue(dataPipe, nameof(dataPipe));
IDataView pipeStart;
var xfs = BacktrackPipe(dataPipe, out pipeStart);
Action <ModelSaveContext> saveAction;
if (!blankLoader && pipeStart is IDataLoader loader)
{
saveAction = loader.Save;
}
else
{
// The serialized pipe must start with a loader. If the original data view is not a loader,
// we replace it with a binary loader with the correct schema.
saveAction = ctx => BinaryLoader.SaveInstance(env, ctx, pipeStart.Schema);
}
using (var ctx = ModelFileUtils.GetDataModelSavingContext(repositoryWriter))
{
CompositeDataLoader.SavePipe(env, ctx, saveAction, xfs);
ctx.Done();
}
}
void FileBasedSavingOfData()
{
var dataPath = GetDataPath(SentimentDataPath);
var testDataPath = GetDataPath(SentimentTestPath);
using (var env = new LocalEnvironment(seed: 1, conc: 1))
{
// Pipeline
var loader = TextLoader.ReadFile(env, MakeSentimentTextLoaderArgs(), new MultiFileSource(dataPath));
var trans = TextTransform.Create(env, MakeSentimentTextTransformArgs(), loader);
var saver = new BinarySaver(env, new BinarySaver.Arguments());
using (var ch = env.Start("SaveData"))
using (var file = env.CreateOutputFile("i.idv"))
{
DataSaverUtils.SaveDataView(ch, saver, trans, file);
}
var binData = new BinaryLoader(env, new BinaryLoader.Arguments(), new MultiFileSource("i.idv"));
var trainRoles = new RoleMappedData(binData, label: "Label", feature: "Features");
var trainer = new LinearClassificationTrainer(env, new LinearClassificationTrainer.Arguments
{
NumThreads = 1
});
var predictor = trainer.Train(new Runtime.TrainContext(trainRoles));
DeleteOutputPath("i.idv");
}
}
public void Save(ModelSaveContext ctx)
{
_host.CheckValue(ctx, nameof(ctx));
ctx.CheckAtModel();
ctx.SetVersionInfo(GetVersionInfo());
var dataPipe = _xf;
var transforms = new List <IDataTransform>();
while (dataPipe is IDataTransform xf)
{
transforms.Add(xf);
dataPipe = xf.Source;
Contracts.AssertValue(dataPipe);
}
transforms.Reverse();
ctx.SaveSubModel("Loader", c => BinaryLoader.SaveInstance(_host, c, dataPipe.Schema));
ctx.Writer.Write(transforms.Count);
for (int i = 0; i < transforms.Count; i++)
{
var dirName = string.Format(TransformDirTemplate, i);
ctx.SaveModel(transforms[i], dirName);
}
}
public static TransposeLoader Create(IHostEnvironment env, ModelLoadContext ctx, IMultiStreamSource files)
{
Contracts.CheckValue(env, nameof(env));
IHost h = env.Register(LoadName);
h.CheckValue(ctx, nameof(ctx));
ctx.CheckAtModel(GetVersionInfo());
h.CheckValue(files, nameof(files));
return(h.Apply("Loading Model",
ch =>
{
if (files.Count == 0)
{
BinaryLoader schemaView = null;
// In the case where we have no input streams, but we have an input schema from
// the model repository, we still want to surface ourselves as being a binary loader
// with the existing schema. The loader "owns" this stream.
if (ctx.TryLoadBinaryStream("Schema.idv",
r => schemaView = new BinaryLoader(h, new BinaryLoader.Arguments(),
HybridMemoryStream.CreateCache(r.BaseStream), leaveOpen: false)))
{
h.AssertValue(schemaView);
h.CheckDecode(schemaView.GetRowCount() == 0);
// REVIEW: Do we want to be a bit more restrictive around uninterpretable columns?
return new TransposeLoader(h, ctx, schemaView);
}
h.Assert(schemaView == null);
// Fall through, allow the failure to be on OpenStream.
}
return new TransposeLoader(h, ctx, files);
}));
}
private void UseSaveButton_OnClick(object sender, RoutedEventArgs e)
{
ILoader loader = new BinaryLoader();
const string directorySaveName = "Save";
var fullSavePath = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location) + "\\" +
directorySaveName;
if (!Directory.Exists(fullSavePath))
{
Directory.CreateDirectory(fullSavePath);
}
var openFileDialog = new OpenFileDialog
{
Filter = loader.Filter(),
InitialDirectory = fullSavePath
};
if (openFileDialog.ShowDialog() != true)
{
return;
}
var container = loader.Load(openFileDialog.FileName);
_mainWindow.MainControl.Content = new Home(_mainWindow, container);
}
internal PredictionTransformerBase(IHost host, ModelLoadContext ctx)
{
Host = host;
ctx.LoadModel <TModel, SignatureLoadModel>(host, out TModel model, DirModel);
Model = model;
// *** Binary format ***
// model: prediction model.
// stream: empty data view that contains train schema.
// id of string: feature column.
// Clone the stream with the schema into memory.
var ms = new MemoryStream();
ctx.TryLoadBinaryStream(DirTransSchema, reader =>
{
reader.BaseStream.CopyTo(ms);
});
ms.Position = 0;
var loader = new BinaryLoader(host, new BinaryLoader.Arguments(), ms);
TrainSchema = loader.Schema;
FeatureColumn = ctx.LoadString();
if (!TrainSchema.TryGetColumnIndex(FeatureColumn, out int col))
{
throw Host.ExceptSchemaMismatch(nameof(FeatureColumn), RoleMappedSchema.ColumnRole.Feature.Value, FeatureColumn);
}
FeatureColumnType = TrainSchema.GetColumnType(col);
BindableMapper = ScoreUtils.GetSchemaBindableMapper(Host, model);
}
protected PredictionTransformerBase(IHost host, ModelLoadContext ctx)
{
Host = host;
// *** Binary format ***
// model: prediction model.
// stream: empty data view that contains train schema.
// id of string: feature column.
ctx.LoadModel <TModel, SignatureLoadModel>(host, out TModel model, DirModel);
Model = model;
// Clone the stream with the schema into memory.
var ms = new MemoryStream();
ctx.TryLoadBinaryStream(DirTransSchema, reader =>
{
reader.BaseStream.CopyTo(ms);
});
ms.Position = 0;
var loader = new BinaryLoader(host, new BinaryLoader.Arguments(), ms);
TrainSchema = loader.Schema;
}
public void SaveCurrentPattern()
{
if (currentPatternData == null)
{
return;
}
float duration = 0;
//compute the duration of the parttern:
foreach (var particleSystemData in currentPatternData.particlePatterns)
{
duration = Mathf.Max(duration, particleSystemData.startDelay + particleSystemData.duration);
}
duration = Mathf.Clamp(duration, .5f, 60);
currentPatternData.duration = duration / 2;
currentPatternData.cooldown = duration;
Debug.Log("duration = " + duration);
Debug.Log("saving " + currentPatternData.name);
BinaryLoader.SavePatternData(currentPatternData, currentSpellcard, currentSave);
UpdatePatternData();
}
private TermLookupTransform(IChannel ch, ModelLoadContext ctx, IHost host, IDataView input)
: base(host, ctx, input, TestIsText)
{
Host.AssertValue(ch);
// *** Binary format ***
// <base>
ch.AssertNonEmpty(Infos);
// Extra streams:
// DefaultMap.idv
byte[] rgb = null;
Action <BinaryReader> fn = r => rgb = ReadAllBytes(ch, r);
if (!ctx.TryLoadBinaryStream(DefaultMapName, fn))
{
throw ch.ExceptDecode();
}
_bytes = rgb;
// Process the bytes into the loader and map.
_ldr = GetLoader(Host, _bytes);
ValidateLoader(ch, _ldr);
_valueMap = Train(ch, _ldr);
SetMetadata();
}
/// <summary>
/// Gets the dataview corresponding to this sub-IDV entry. This will
/// lazily load the file, if it has not previously been requested. This
/// will return <c>null</c> if the offset is 0.
/// </summary>
public IDataView GetViewOrNull()
{
if (_view == null && _offset > 0)
{
Stream stream = _parent._file.Open(0);
stream.Seek(_offset, SeekOrigin.Begin);
Contracts.Check(stream.Position == _offset, "Unexpected position on substream");
SubsetStream ss = new SubsetStream(stream, _length);
var binArgs = new BinaryLoader.Arguments();
if (_parent._threads > 0)
{
binArgs.Threads = _parent._threads;
}
BinaryLoader loader = new BinaryLoader(Host,
binArgs, ss, leaveOpen: false);
var view = Interlocked.CompareExchange(ref _view, loader, null);
// If multiple threads have called this as it was being loaded,
// have ensure that this check only happens once.
if (view == loader)
{
VerifyView(view);
}
}
return(_view);
}
private PartitionedFileLoader(IHost host, ModelLoadContext ctx, IMultiStreamSource files)
{
Contracts.AssertValue(host);
_host = host;
_host.AssertValue(ctx);
_host.AssertValue(files);
// ** Binary format **
// int: tailing directory count
// Schema of the loader
// int[]: srcColumns
// byte[]: subloader
// model: file path spec
_tailingDirCount = ctx.Reader.ReadInt32();
// Load the schema
byte[] buffer = null;
if (!ctx.TryLoadBinaryStream(SchemaCtxName, r => buffer = r.ReadByteArray()))
{
throw _host.ExceptDecode();
}
BinaryLoader loader = null;
var strm = new MemoryStream(buffer, writable: false);
loader = new BinaryLoader(_host, new BinaryLoader.Arguments(), strm);
Schema = loader.Schema;
_srcDirIndex = ctx.Reader.ReadIntArray();
_subLoaderBytes = ctx.Reader.ReadByteArray();
ctx.LoadModel <IPartitionedPathParser, SignatureLoadModel>(_host, out _pathParser, FilePathSpecCtxName);
_files = files;
}
private void loadBinariesToolStripMenuItem_Click(object sender, EventArgs e)
{
BinaryLoader makeBinaries = new BinaryLoader();
this.Cursor = Cursors.WaitCursor;
makeBinaries.CreateDLLs();
this.Cursor = Cursors.Arrow;
}
private static void ValidateLoader(IExceptionContext ectx, BinaryLoader ldr)
{
if (ldr == null)
{
return;
}
ectx.CheckDecode(ldr.Schema.ColumnCount == 2);
ectx.CheckDecode(ldr.Schema.GetColumnType(0).IsText);
}
public void LoadBinary(string fileName, out ushort loadedAtAddress, ushort?forceLoadAddress = null)
{
BinaryLoader.Load(
Mem,
fileName,
out loadedAtAddress,
out int _,
forceLoadAddress);
}
public static CacheOutput CacheData(IHostEnvironment env, CacheInput input)
{
const string registrationName = "CreateCache";
Contracts.CheckValue(env, nameof(env));
var host = env.Register(registrationName);
host.CheckValue(input, nameof(input));
host.CheckValue(input.Data, nameof(input.Data));
IDataView data;
switch (input.Caching)
{
case CachingType.Memory:
data = new CacheDataView(env, input.Data, null);
break;
case CachingType.Disk:
var args = new BinarySaver.Arguments();
args.Compression = CompressionKind.Default;
args.Silent = true;
var saver = new BinarySaver(host, args);
var schema = input.Data.Schema;
var cols = new List <int>();
for (int i = 0; i < schema.ColumnCount; i++)
{
var type = schema.GetColumnType(i);
if (saver.IsColumnSavable(type))
{
cols.Add(i);
}
}
#pragma warning disable CS0618 // This ought to be addressed. See #1287.
// We are not disposing the fileHandle because we want it to stay around for the execution of the graph.
// It will be disposed when the environment is disposed.
var fileHandle = host.CreateTempFile();
#pragma warning restore CS0618
using (var stream = fileHandle.CreateWriteStream())
saver.SaveData(stream, input.Data, cols.ToArray());
data = new BinaryLoader(host, new BinaryLoader.Arguments(), fileHandle.OpenReadStream());
break;
default:
throw host.ExceptValue(nameof(input.Caching), $"Unrecognized caching option '{input.Caching}'");
}
return(new CacheOutput()
{
OutputData = data
});
}
/// <summary>
/// Read a data view from a Stream on a binary file using <see cref="BinaryLoader"/>.
/// </summary>
/// <param name="catalog">The catalog.</param>
/// <param name="stream">The stream to read from.</param>
public static IDataView ReadFromBinary(this DataOperations catalog, Stream stream)
{
Contracts.CheckValue(stream, nameof(stream));
var env = catalog.GetEnvironment();
var reader = new BinaryLoader(env, new BinaryLoader.Arguments(), stream);
return(reader);
}
public static DevImage ReadImage(BinaryLoader reader)
{
int width = reader.ReadInt16();
int height = reader.ReadInt16();
int bpp = reader.ReadInt16();
byte[] buffer = reader.ReadBytes(width * height * bpp);
return new DevImage(width, height, bpp, buffer);
}
/// <summary>
/// Read a data view from an <see cref="IMultiStreamSource"/> on a binary file using <see cref="BinaryLoader"/>.
/// </summary>
/// <param name="catalog">The catalog.</param>
/// <param name="fileSource">The file source to read from. This can be a <see cref="MultiFileSource"/>, for example.</param>
public static IDataView ReadFromBinary(this DataOperationsCatalog catalog, IMultiStreamSource fileSource)
{
Contracts.CheckValue(fileSource, nameof(fileSource));
var env = catalog.GetEnvironment();
var reader = new BinaryLoader(env, new BinaryLoader.Arguments(), fileSource);
return(reader);
}
/// <summary>
/// Read a data view from a binary file using <see cref="BinaryLoader"/>.
/// </summary>
/// <param name="catalog">The catalog.</param>
/// <param name="path">The path to the file to read from.</param>
public static IDataView ReadFromBinary(this DataOperationsCatalog catalog, string path)
{
Contracts.CheckNonEmpty(path, nameof(path));
var env = catalog.GetEnvironment();
var reader = new BinaryLoader(env, new BinaryLoader.Arguments(), path);
return(reader);
}
private Computer SetupEmulator(EmulatorConfig emulatorConfig)
{
Debug.WriteLine($"Loading 6502 machine code binary file.");
Debug.WriteLine($"{emulatorConfig.ProgramBinaryFile}");
if (!File.Exists(emulatorConfig.ProgramBinaryFile))
{
Debug.WriteLine($"File does not exist.");
throw new Exception($"Cannot find 6502 binary file: {emulatorConfig.ProgramBinaryFile}");
}
var enableBankSwitching = emulatorConfig.Memory.MemoryBanks.EnableMemoryBanks;
var mem = new Memory(enableBankSwitching: enableBankSwitching);
if (enableBankSwitching)
{
// Add additional memory banks for memory segment 1 (0x2000) and up (segment 0 cannot have multiple banks)
for (byte memorySegmentNumber = 1; memorySegmentNumber < mem.MemorySegments.Count; memorySegmentNumber++)
{
// By default each segment has one bank when Memory is created above.
// Thus we add the specified BanksPerSegment-1 new banks to each segment.
for (int i = 0; i < emulatorConfig.Memory.MemoryBanks.BanksPerSegment - 1; i++)
{
// Add additional memory banks for segment. Memory in those will be blank (0x00).
mem.AddMemorySegmentBank(memorySegmentNumber);
}
}
}
BinaryLoader.Load(
mem,
emulatorConfig.ProgramBinaryFile,
out ushort loadedAtAddress,
out int fileLength);
// Initialize emulator with CPU, memory, and execution parameters
var computerBuilder = new ComputerBuilder();
computerBuilder
.WithCPU()
.WithStartAddress(loadedAtAddress)
.WithMemory(mem)
.WithExecOptions(options =>
{
// Emulator will stop executing when a BRK instruction is reached.
options.ExecuteUntilInstruction = emulatorConfig.StopAtBRK?OpCodeId.BRK:null;
});
var computer = computerBuilder.Build();
return(computer);
}
