ShuriZma
/
BizHawk
mirror of https://github.com/TASEmulators/BizHawk.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

some waterbox cleanup+reorg

This commit is contained in:
nattthebear 2017-05-18 18:44:34 -04:00
parent 0efdd2405c
commit 8986ddb54b
8 changed files with 309 additions and 242 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
BizHawk.Emulation.Cores/BizHawk.Emulation.Cores.csproj
View File

@ -110,6 +110,9 @@
<SpecificVersion>False</SpecificVersion>
<HintPath>..\References\OpenTK.dll</HintPath>
</Reference>
<Reference Include="PeNet">
<HintPath>..\References\PeNet.dll</HintPath>
</Reference>
<Reference Include="System" />
<Reference Include="System.Core">
<RequiredTargetFramework>3.5</RequiredTargetFramework>
@ -208,7 +211,7 @@
<DependentUpon>C64.cs</DependentUpon>
</Compile>
<Compile Include="Computers\Commodore64\C64.ISettable.cs">
<DependentUpon>C64.cs</DependentUpon>
<DependentUpon>C64.cs</DependentUpon>
</Compile>
<Compile Include="Computers\Commodore64\C64.IStatable.cs">
<DependentUpon>C64.cs</DependentUpon>
@ -220,7 +223,7 @@
<Compile Include="Computers\Commodore64\C64.MotherboardInput.cs" />
<Compile Include="Computers\Commodore64\Cartridge\Mapper0001.cs" />
<Compile Include="Computers\Commodore64\Cartridge\Mapper0005.cs" />
<Compile Include="Computers\Commodore64\Cartridge\Mapper0008.cs" />
<Compile Include="Computers\Commodore64\Cartridge\Mapper0008.cs" />
<Compile Include="Computers\Commodore64\Cartridge\Mapper000A.cs" />
<Compile Include="Computers\Commodore64\Cartridge\Mapper000B.cs" />
<Compile Include="Computers\Commodore64\Cartridge\Mapper000F.cs" />
@ -1247,7 +1250,7 @@
<Compile Include="CPUs\Z80\Registers.cs" />
<Compile Include="CPUs\Z80\Tables.cs" />
<Compile Include="CPUs\Z80\Z80A.cs" />
<Compile Include="ElfRunner.cs" />
<Compile Include="Waterbox\ElfRunner.cs" />
<Compile Include="FileID.cs" />
<Compile Include="Consoles\PC Engine\MemoryMap.cs" />
<Compile Include="Consoles\PC Engine\MemoryMap.SF2.cs" />
@ -1269,7 +1272,8 @@
<Compile Include="Libretro\LibretroCoreSettings.cs" />
<Compile Include="Libretro\LibretroCore_Description.cs" />
<Compile Include="Libretro\LibretroCore_InputCallbacks.cs" />
<Compile Include="MemoryBlock.cs" />
<Compile Include="Waterbox\Heap.cs" />
<Compile Include="Waterbox\MemoryBlock.cs" />
<Compile Include="Properties\AssemblyInfo.cs" />
<Compile Include="Sound\CDAudio.cs" />
<Compile Include="Sound\HuC6280PSG.cs" />
@ -1281,6 +1285,8 @@
<Compile Include="Sound\VRC6Alt.cs" />
<Compile Include="Sound\YM2413.cs" />
<Compile Include="Sound\YM2612.cs" />
<Compile Include="Waterbox\Swappable.cs" />
<Compile Include="Waterbox\WaterboxUtils.cs" />
</ItemGroup>
<ItemGroup>
<Content Include="Consoles\Coleco\docs\CV-Sound.txt" />
@ -1346,4 +1352,4 @@
<Target Name="AfterBuild">
</Target>
-->
</Project>
</Project>

1
BizHawk.Emulation.Cores/Consoles/Sega/gpgx64/GPGX.cs
View File

@ -4,6 +4,7 @@ using System.Runtime.InteropServices;
using BizHawk.Common.BizInvoke;
using BizHawk.Emulation.Common;
using BizHawk.Emulation.Cores.Waterbox;
namespace BizHawk.Emulation.Cores.Consoles.Sega.gpgx64
{

248
BizHawk.Emulation.Cores/ElfRunner.cs → BizHawk.Emulation.Cores/Waterbox/ElfRunner.cs
View File

@ -13,9 +13,9 @@ using System.IO;
using System.Collections.Concurrent;
using System.Threading;
namespace BizHawk.Emulation.Cores
namespace BizHawk.Emulation.Cores.Waterbox
{
public sealed class ElfRunner : IImportResolver, IDisposable, IMonitor
public sealed class ElfRunner : Swappable, IImportResolver, IDisposable
{
// TODO: a lot of things only work with our elves and aren't fully generalized
@ -41,11 +41,6 @@ namespace BizHawk.Emulation.Cores
/// </summary>
private Heap _invisibleheap;
/// <summary>
/// _base.Start, or 0 if we were relocated and so don't need to be swapped
/// </summary>
private ulong _lockkey;
private long _loadoffset;
private Dictionary<string, SymbolEntry<long>> _symdict;
private List<SymbolEntry<long>> _symlist;
@ -55,11 +50,6 @@ namespace BizHawk.Emulation.Cores
/// </summary>
private List<IDisposable> _disposeList = new List<IDisposable>();
/// <summary>
/// everything to swap in for context switches
/// </summary>
private List<MemoryBlock> _memoryBlocks = new List<MemoryBlock>();
private ulong GetHeapStart(ulong prevend)
{
// if relocatable, we won't have constant pointers, so put the heap anywhere
@ -72,7 +62,7 @@ namespace BizHawk.Emulation.Cores
{
using (var fs = new FileStream(filename, FileMode.Open, FileAccess.Read))
{
_elfhash = Hash(fs);
_elfhash = WaterboxUtils.Hash(fs);
}
// todo: hack up this baby to take Streams
@ -87,12 +77,12 @@ namespace BizHawk.Emulation.Cores
{
_base = new MemoryBlock((ulong)(orig_end - orig_start));
_loadoffset = (long)_base.Start - orig_start;
_lockkey = 0;
Initialize(0);
}
else
{
_lockkey = (ulong)orig_start;
_base = new MemoryBlock(_lockkey, (ulong)(orig_end - orig_start));
Initialize((ulong)orig_start);
_base = new MemoryBlock((ulong)orig_start, (ulong)(orig_end - orig_start));
_loadoffset = 0;
Enter();
}
@ -100,7 +90,7 @@ namespace BizHawk.Emulation.Cores
try
{
_disposeList.Add(_base);
_memoryBlocks.Add(_base);
AddMemoryBlock(_base);
_base.Activate();
_base.Protect(_base.Start, _base.Size, MemoryBlock.Protection.RW);
@ -130,7 +120,7 @@ namespace BizHawk.Emulation.Cores
_heap.Memory.Activate();
end = _heap.Memory.End;
_disposeList.Add(_heap);
_memoryBlocks.Add(_heap.Memory);
AddMemoryBlock(_heap.Memory);
}
if (sealedheapsize > 0)
@ -139,7 +129,7 @@ namespace BizHawk.Emulation.Cores
_sealedheap.Memory.Activate();
end = _sealedheap.Memory.End;
_disposeList.Add(_sealedheap);
_memoryBlocks.Add(_sealedheap.Memory);
AddMemoryBlock(_sealedheap.Memory);
}
if (invisibleheapsize > 0)
@ -148,7 +138,7 @@ namespace BizHawk.Emulation.Cores
_invisibleheap.Memory.Activate();
end = _invisibleheap.Memory.End;
_disposeList.Add(_invisibleheap);
_memoryBlocks.Add(_invisibleheap.Memory);
AddMemoryBlock(_invisibleheap.Memory);
}
ConnectAllClibPatches();
@ -306,7 +296,7 @@ namespace BizHawk.Emulation.Cores
foreach (var d in _disposeList)
d.Dispose();
_disposeList.Clear();
_memoryBlocks.Clear();
PurgeMemoryBlocks();
_base = null;
_heap = null;
_sealedheap = null;
@ -425,67 +415,6 @@ namespace BizHawk.Emulation.Cores
}
}
/// <summary>
/// true if the IMonitor should be used for native calls
/// </summary>
public bool ShouldMonitor { get { return _lockkey != 0; } }
// any ElfRunner is assumed to conflict with any other ElfRunner at the same base address,
// but not any other starting address. so don't put them too close together!
private class LockInfo
{
public object Sync;
public ElfRunner Loaded;
}
private static readonly ConcurrentDictionary<ulong, LockInfo> LockInfos = new ConcurrentDictionary<ulong, LockInfo>();
static ElfRunner()
{
LockInfos.GetOrAdd(0, new LockInfo()); // any errant attempt to lock when ShouldMonitor == false will result in NRE
}
/// <summary>
/// acquire lock and swap this into memory
/// </summary>
public void Enter()
{
var li = LockInfos.GetOrAdd(_lockkey, new LockInfo { Sync = new object() });
Monitor.Enter(li.Sync);
if (li.Loaded != this)
{
if (li.Loaded != null)
li.Loaded.DeactivateInternal();
li.Loaded = null;
ActivateInternal();
li.Loaded = this;
}
}
/// <summary>
/// release lock
/// </summary>
public void Exit()
{
var li = LockInfos.GetOrAdd(_lockkey, new LockInfo { Sync = new object() });
Monitor.Exit(li.Sync);
}
private void DeactivateInternal()
{
Console.WriteLine("ElfRunner DeactivateInternal {0}", GetHashCode());
foreach (var m in _memoryBlocks)
m.Deactivate();
}
private void ActivateInternal()
{
Console.WriteLine("ElfRunner ActivateInternal {0}", GetHashCode());
foreach (var m in _memoryBlocks)
m.Activate();
}
#region state
const ulong MAGIC = 0xb00b1e5b00b1e569;
@ -533,7 +462,7 @@ namespace BizHawk.Emulation.Cores
if (sec.Size != len)
throw new InvalidOperationException("Unexpected section size for " + sec.Name);
var ms = _base.GetStream((ulong)(sec.LoadAddress + _loadoffset), (ulong)sec.Size, true);
CopySome(br.BaseStream, ms, len);
WaterboxUtils.CopySome(br.BaseStream, ms, len);
}
if (_heap != null) _heap.LoadStateBinary(br);
@ -555,33 +484,6 @@ namespace BizHawk.Emulation.Cores
#region utils
private static void CopySome(Stream src, Stream dst, long len)
{
var buff = new byte[4096];
while (len > 0)
{
int r = src.Read(buff, 0, (int)Math.Min(len, 4096));
dst.Write(buff, 0, r);
len -= r;
}
}
private static byte[] Hash(byte[] data)
{
using (var h = SHA1.Create())
{
return h.ComputeHash(data);
}
}
private static byte[] Hash(Stream s)
{
using (var h = SHA1.Create())
{
return h.ComputeHash(s);
}
}
private byte[] HashSection(ulong ptr, ulong len)
{
using (var h = SHA1.Create())
@ -591,132 +493,6 @@ namespace BizHawk.Emulation.Cores
}
}
/// <summary>
/// a simple grow-only fixed max size heap
/// </summary>
private sealed class Heap : IDisposable
{
public MemoryBlock Memory { get; private set; }
/// <summary>
/// name, used in identifying errors
/// </summary>
public string Name { get; private set; }
/// <summary>
/// total number of bytes used
/// </summary>
public ulong Used { get; private set; }
/// <summary>
/// true if the heap has been sealed, preventing further changes
/// </summary>
public bool Sealed { get; private set; }
private byte[] _hash;
public Heap(ulong start, ulong size, string name)
{
Memory = new MemoryBlock(start, size);
Used = 0;
Name = name;
}
private void EnsureAlignment(int align)
{
if (align > 1)
{
ulong newused = ((Used - 1) | (ulong)(align - 1)) + 1;
if (newused > Memory.Size)
{
throw new InvalidOperationException(string.Format("Failed to meet alignment {0} on heap {1}", align, Name));
}
Used = newused;
}
}
public ulong Allocate(ulong size, int align)
{
if (Sealed)
throw new InvalidOperationException(string.Format("Attempt made to allocate from sealed heap {0}", Name));
EnsureAlignment(align);
ulong newused = Used + size;
if (newused > Memory.Size)
{
throw new InvalidOperationException(string.Format("Failed to allocate {0} bytes from heap {1}", size, Name));
}
ulong ret = Memory.Start + Used;
Memory.Protect(ret, newused - Used, MemoryBlock.Protection.RW);
Used = newused;
Console.WriteLine("Allocated {0} bytes on {1}", size, Name);
return ret;
}
public void Seal()
{
if (!Sealed)
{
Memory.Protect(Memory.Start, Memory.Size, MemoryBlock.Protection.R);
_hash = Hash(Memory.GetStream(Memory.Start, Used, false));
Sealed = true;
}
else
{
throw new InvalidOperationException(string.Format("Attempt to reseal heap {0}", Name));
}
}
public void SaveStateBinary(BinaryWriter bw)
{
bw.Write(Name);
bw.Write(Used);
if (!Sealed)
{
var ms = Memory.GetStream(Memory.Start, Used, false);
ms.CopyTo(bw.BaseStream);
}
else
{
bw.Write(_hash);
}
}
public void LoadStateBinary(BinaryReader br)
{
var name = br.ReadString();
if (name != Name)
throw new InvalidOperationException(string.Format("Name did not match for heap {0}", Name));
var used = br.ReadUInt64();
if (used > Memory.Size)
throw new InvalidOperationException(string.Format("Heap {0} used {1} larger than available {2}", Name, used, Memory.Size));
if (!Sealed)
{
Memory.Protect(Memory.Start, Memory.Size, MemoryBlock.Protection.None);
Memory.Protect(Memory.Start, used, MemoryBlock.Protection.RW);
var ms = Memory.GetStream(Memory.Start, used, true);
CopySome(br.BaseStream, ms, (long)used);
Used = used;
}
else
{
var hash = br.ReadBytes(_hash.Length);
if (!hash.SequenceEqual(_hash))
{
throw new InvalidOperationException(string.Format("Hash did not match for heap {0}. Is this the same rom?"));
}
}
}
public void Dispose()
{
if (Memory != null)
{
Memory.Dispose();
Memory = null;
}
}
}
#endregion
}
}

134
BizHawk.Emulation.Cores/Waterbox/Heap.cs Normal file
View File

@ -0,0 +1,134 @@
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
namespace BizHawk.Emulation.Cores.Waterbox
{
/// <summary>
/// a simple grow-only fixed max size heap
/// </summary>
internal sealed class Heap : IDisposable
{
public MemoryBlock Memory { get; private set; }
/// <summary>
/// name, used in identifying errors
/// </summary>
public string Name { get; private set; }
/// <summary>
/// total number of bytes used
/// </summary>
public ulong Used { get; private set; }
/// <summary>
/// true if the heap has been sealed, preventing further changes
/// </summary>
public bool Sealed { get; private set; }
private byte[] _hash;
public Heap(ulong start, ulong size, string name)
{
Memory = new MemoryBlock(start, size);
Used = 0;
Name = name;
}
private void EnsureAlignment(int align)
{
if (align > 1)
{
ulong newused = ((Used - 1) | (ulong)(align - 1)) + 1;
if (newused > Memory.Size)
{
throw new InvalidOperationException(string.Format("Failed to meet alignment {0} on heap {1}", align, Name));
}
Used = newused;
}
}
public ulong Allocate(ulong size, int align)
{
if (Sealed)
throw new InvalidOperationException(string.Format("Attempt made to allocate from sealed heap {0}", Name));
EnsureAlignment(align);
ulong newused = Used + size;
if (newused > Memory.Size)
{
throw new InvalidOperationException(string.Format("Failed to allocate {0} bytes from heap {1}", size, Name));
}
ulong ret = Memory.Start + Used;
Memory.Protect(ret, newused - Used, MemoryBlock.Protection.RW);
Used = newused;
Console.WriteLine("Allocated {0} bytes on {1}", size, Name);
return ret;
}
public void Seal()
{
if (!Sealed)
{
Memory.Protect(Memory.Start, Memory.Size, MemoryBlock.Protection.R);
_hash = WaterboxUtils.Hash(Memory.GetStream(Memory.Start, Used, false));
Sealed = true;
}
else
{
throw new InvalidOperationException(string.Format("Attempt to reseal heap {0}", Name));
}
}
public void SaveStateBinary(BinaryWriter bw)
{
bw.Write(Name);
bw.Write(Used);
if (!Sealed)
{
var ms = Memory.GetStream(Memory.Start, Used, false);
ms.CopyTo(bw.BaseStream);
}
else
{
bw.Write(_hash);
}
}
public void LoadStateBinary(BinaryReader br)
{
var name = br.ReadString();
if (name != Name)
throw new InvalidOperationException(string.Format("Name did not match for heap {0}", Name));
var used = br.ReadUInt64();
if (used > Memory.Size)
throw new InvalidOperationException(string.Format("Heap {0} used {1} larger than available {2}", Name, used, Memory.Size));
if (!Sealed)
{
Memory.Protect(Memory.Start, Memory.Size, MemoryBlock.Protection.None);
Memory.Protect(Memory.Start, used, MemoryBlock.Protection.RW);
var ms = Memory.GetStream(Memory.Start, used, true);
WaterboxUtils.CopySome(br.BaseStream, ms, (long)used);
Used = used;
}
else
{
var hash = br.ReadBytes(_hash.Length);
if (!hash.SequenceEqual(_hash))
{
throw new InvalidOperationException(string.Format("Hash did not match for heap {0}. Is this the same rom?"));
}
}
}
public void Dispose()
{
if (Memory != null)
{
Memory.Dispose();
Memory = null;
}
}
}
}

2
BizHawk.Emulation.Cores/MemoryBlock.cs → BizHawk.Emulation.Cores/Waterbox/MemoryBlock.cs
View File

@ -5,7 +5,7 @@ using System.Text;
using System.Runtime.InteropServices;
using System.IO;
namespace BizHawk.Emulation.Cores
namespace BizHawk.Emulation.Cores.Waterbox
{
public static class Z
{

104
BizHawk.Emulation.Cores/Waterbox/Swappable.cs Normal file
View File

@ -0,0 +1,104 @@
using BizHawk.Common;
using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
namespace BizHawk.Emulation.Cores.Waterbox
{
/// <summary>
/// represents an object that can be swapped in and out of memory to compete with other objects in the same memory
/// not suited for general purpose stuff
/// </summary>
public abstract class Swappable : IMonitor
{
/// <summary>
/// start address, or 0 if we don't need to be swapped
/// </summary>
private ulong _lockkey = 0;
/// <summary>
/// everything to swap in for context switches
/// </summary>
private List<MemoryBlock> _memoryBlocks = new List<MemoryBlock>();
protected void AddMemoryBlock(MemoryBlock block)
{
_memoryBlocks.Add(block);
}
protected void PurgeMemoryBlocks()
{
_memoryBlocks = null;
}
protected void Initialize(ulong lockkey)
{
_lockkey = lockkey;
}
/// <summary>
/// true if the IMonitor should be used for native calls
/// </summary>
public bool ShouldMonitor { get { return _lockkey != 0; } }
// any Swappable is assumed to conflict with any other Swappable at the same base address,
// but not any other starting address. so don't put them too close together!
private class LockInfo
{
public object Sync;
public Swappable Loaded;
}
private static readonly ConcurrentDictionary<ulong, LockInfo> LockInfos = new ConcurrentDictionary<ulong, LockInfo>();
static Swappable()
{
LockInfos.GetOrAdd(0, new LockInfo()); // any errant attempt to lock when ShouldMonitor == false will result in NRE
}
/// <summary>
/// acquire lock and swap this into memory
/// </summary>
public void Enter()
{
var li = LockInfos.GetOrAdd(_lockkey, new LockInfo { Sync = new object() });
Monitor.Enter(li.Sync);
if (li.Loaded != this)
{
if (li.Loaded != null)
li.Loaded.DeactivateInternal();
li.Loaded = null;
ActivateInternal();
li.Loaded = this;
}
}
/// <summary>
/// release lock
/// </summary>
public void Exit()
{
var li = LockInfos.GetOrAdd(_lockkey, new LockInfo { Sync = new object() });
Monitor.Exit(li.Sync);
}
private void DeactivateInternal()
{
Console.WriteLine("Swappable DeactivateInternal {0}", GetHashCode());
foreach (var m in _memoryBlocks)
m.Deactivate();
}
private void ActivateInternal()
{
Console.WriteLine("Swappable ActivateInternal {0}", GetHashCode());
foreach (var m in _memoryBlocks)
m.Activate();
}
}
}

46
BizHawk.Emulation.Cores/Waterbox/WaterboxUtils.cs Normal file
View File

@ -0,0 +1,46 @@
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Security.Cryptography;
using System.Text;
namespace BizHawk.Emulation.Cores.Waterbox
{
public static class WaterboxUtils
{
/// <summary>
/// copy `len` bytes from `src` to `dest`
/// </summary>
/// <param name="src"></param>
/// <param name="dst"></param>
/// <param name="len"></param>
public static void CopySome(Stream src, Stream dst, long len)
{
var buff = new byte[4096];
while (len > 0)
{
int r = src.Read(buff, 0, (int)Math.Min(len, 4096));
dst.Write(buff, 0, r);
len -= r;
}
}
public static byte[] Hash(byte[] data)
{
using (var h = SHA1.Create())
{
return h.ComputeHash(data);
}
}
public static byte[] Hash(Stream s)
{
using (var h = SHA1.Create())
{
return h.ComputeHash(s);
}
}
}
}

BIN
References/PeNet.dll Normal file
View File

Binary file not shown.