public void TestSetup()
{
manager = Substitute.For <IMemoryManager>();
manager.TryReserveBytes(Arg.Any <long>()).Returns(true);
buffer = new Buffer(InitialSize, MaximumSize, manager);
}
public void ChangeROM(IMemoryManager memoryManager, IROM rom)
{
this.rom = rom;
this.memoryManager = memoryManager;
LoadDataFromROM(memoryManager, rom);
}
private static int DoSnmp(Snmp snmp, SnmpTarget target, Pdu pdu,
OperType operType, ref TableReader.GetTableOptions tableOptions,
uint repeat, bool asyncSync, bool debug)
{
int ncalls = 0;
for (uint i = 0; i < repeat; i++)
{
using (IMemoryManager mgr = MemoryManager.GetMemoryManager())
{
bool show = (i % 1000) == 0;
if (show || debug)
{
PrintPdu(Console.Out, "Sending PDU to target " + target, pdu, debug);
}
Pdu resPdu = DoSnmp(snmp, target, pdu,
operType, ref tableOptions,
asyncSync, show, debug, ref ncalls);
if ((show || debug) && resPdu != null)
{
PrintPdu(Console.Out, "Received PDU:", resPdu, debug);
}
if (debug)
{
Console.WriteLine("Removing " + mgr.Count + " objects");
}
}
}
return(ncalls);
}
public static OpCode DecodeOpCode(IMemoryManager memory, ulong address, ExecutionMode mode)
{
int opCode = memory.Read <int>(address);
InstDescriptor inst;
OpCodeTable.MakeOp makeOp;
if (mode == ExecutionMode.Aarch64)
{
(inst, makeOp) = OpCodeTable.GetInstA64(opCode);
}
else
{
if (mode == ExecutionMode.Aarch32Arm)
{
(inst, makeOp) = OpCodeTable.GetInstA32(opCode);
}
else /* if (mode == ExecutionMode.Aarch32Thumb) */
{
(inst, makeOp) = OpCodeTable.GetInstT32(opCode);
}
}
if (makeOp != null)
{
return((OpCode)makeOp(inst, address, opCode));
}
else
{
return(new OpCode(inst, address, opCode));
}
}
public IntPtr Apply(IMemoryManager memory, IntPtr address)
{
switch (Type)
{
case LeaType.Byte:
return((IntPtr)memory.Read <byte>(address));
case LeaType.Word:
return((IntPtr)memory.Read <ushort>(address));
case LeaType.Dword:
return((IntPtr)memory.Read <uint>(address));
case LeaType.E8:
// 4 = <call instruction size> - <E8>
return(address + 4 + memory.Read <int>(address));
case LeaType.SimpleAddress:
return(address);
case LeaType.Cmp:
return(address + 5 + memory.Read <int>(address));
case LeaType.RelativePlus8:
return(address + 8 + memory.Read <int>(address));
default:
throw new InvalidDataException("Unknown " + nameof(LeaType));
}
}
public GuestLoginViewModel(IMemoryManager memoryManager = null)
{
Guest = new Guest();
eventFromServer = new EventModel();
_memoryManager = memoryManager ?? MemoryManager.GetInstance();
InitializeGuests();
}
public static string ReadHbAbiNextLoadPath(IMemoryManager memory, long position)
{
string fileName = null;
while (true)
{
long key = memory.ReadInt64(position);
if (key == 2)
{
long value0 = memory.ReadInt64(position + 0x08);
long value1 = memory.ReadInt64(position + 0x10);
fileName = MemoryHelper.ReadAsciiString(memory, value0, value1 - value0);
break;
}
else if (key == 0)
{
break;
}
position += 0x18;
}
return(fileName);
}
public static DbItemReference CreateNew(byte[] body, int transactionNumber, IMemoryManager memoryManager)
{
if (body == null)
{
throw new ArgumentNullException(nameof(body));
}
if (memoryManager == null)
{
throw new ArgumentNullException(nameof(memoryManager));
}
var bodyReference = memoryManager.Allocate(body);
var versionInfo = new VersionInfo
{
CreateChangeNumber = transactionNumber,
ExpireChangeNumber = -1,
VersionReference = bodyReference
};
byte[] versionInfoBytes;
using (var ms = new MemoryStream(VersionInfo.BytesLength))
{
versionInfo.Write(ms);
versionInfoBytes = ms.ToArray();
}
return(memoryManager.Allocate(versionInfoBytes));
}
public VersionedRecord(byte[] versionInfoBytes, IMemoryManager memoryManager, ISnapshotData snapshotData)
{
if (versionInfoBytes == null)
{
throw new ArgumentNullException(nameof(versionInfoBytes));
}
if (memoryManager == null)
{
throw new ArgumentNullException(nameof(memoryManager));
}
if (snapshotData == null)
{
throw new ArgumentNullException(nameof(snapshotData));
}
using (var ms = new MemoryStream(versionInfoBytes))
{
while (ms.Position < ms.Length)
{
_versions.Add(VersionInfo.Read(ms));
}
}
_memoryManager = memoryManager;
_snapshotData = snapshotData;
}
public IAudioRenderer(
Horizon system,
IMemoryManager memory,
IAalOutput audioOut,
AudioRendererParameter Params)
{
_updateEvent = new KEvent(system);
_memory = memory;
_audioOut = audioOut;
_params = Params;
_track = audioOut.OpenTrack(
AudioRendererConsts.HostSampleRate,
AudioRendererConsts.HostChannelsCount,
AudioCallback);
_memoryPools = CreateArray <MemoryPoolContext>(Params.EffectCount + Params.VoiceCount * 4);
_voices = CreateArray <VoiceContext>(Params.VoiceCount);
InitializeAudioOut();
_playState = PlayState.Stopped;
}
public void TestSetup()
{
memoryManager = Substitute.For <IMemoryManager>();
memoryManager.TryReserveBytes(Arg.Any <int>()).Returns(true);
underlyingWriter = new BinaryBufferWriter(4);
buffer = new Buffer(underlyingWriter, memoryManager);
}
public ZAbbreviations(ZHeader header, IMemoryManager manager)
{
var abbreviationsTable = manager.AsSpan(header.AbbreviationsTable).ToArray();
var dynamicMemory = manager.AsSpan(0, header.DynamicMemorySize);
var abbrevs = new List <string>();
var anyMoreEntries = true;
var abbrIdx = 0;
while (anyMoreEntries && abbrIdx < 96)
{
var addr = abbreviationsTable.GetUShort((ushort)(abbrIdx * 2));
anyMoreEntries = addr != 0;
if (anyMoreEntries)
{
var zStr = ZsciiString.Get(dynamicMemory.AsSpan((ushort)(addr * 2)), null, header);
abbrevs.Add(zStr);
abbrIdx++;
}
}
// for (int abbrIdx = 0; abbrIdx < 96 ; abbrIdx++)
// {
// var addr = abbreviationsTable.GetUShort((ushort) (abbrIdx * 2));
//
// if (addr == 0) break;
//
// var zStr = ZsciiString.Get(dynamicMemory.AsSpan((ushort)(addr * 2)), null);
// abbrevs.Add(zStr);
// }
Abbreviations = abbrevs.ToArray();
}
public MessageHandler(IProfilerCommunication profilerCommunication, IMarshalWrapper marshalWrapper, IMemoryManager memoryManager, IModuleLocator moduleLocator)
{
_profilerCommunication = profilerCommunication;
_marshalWrapper = marshalWrapper;
_memoryManager = memoryManager;
_moduleLocator = moduleLocator;
}
public HostAddEventViewModel(Host host, ObservableCollection <EventModel> events, IMemoryManager memoryManager = null)
{
_host = host;
_memoryManager = memoryManager ?? MemoryManager.GetInstance();
_events = events;
isErrorMessageEnabled = false;
}
public ZAttributes(IMemoryManager manager, ushort address, ZHeader header)
{
_address = address;
_manager = manager;
_header = header;
_attributesLength = AttributesLength(header);
}
protected virtual void CheckMemoryUsage()
{
if (_memoryManager == null ||
_crawlContext.IsCrawlHardStopRequested ||
_crawlContext.CrawlConfiguration.MaxMemoryUsageInMb < 1)
{
return;
}
var currentMemoryUsage = _memoryManager.GetCurrentUsageInMb();
_logger.LogDebug($"Current memory usage for site [{_crawlContext.RootUri}] is [{currentMemoryUsage}mb]");
if (currentMemoryUsage > _crawlContext.CrawlConfiguration.MaxMemoryUsageInMb)
{
_memoryManager.Dispose();
_memoryManager = null;
string message = $"Process is using [{currentMemoryUsage}mb] of memory which is above the max configured of [{_crawlContext.CrawlConfiguration.MaxMemoryUsageInMb}mb] for site [{_crawlContext.RootUri}]. This is configurable through the maxMemoryUsageInMb in app.conf or CrawlConfiguration.MaxMemoryUsageInMb.";
_crawlResult.ErrorException = new InsufficientMemoryException(message);
_logger.LogCritical("Memory exception", _crawlResult.ErrorException);
_crawlContext.IsCrawlHardStopRequested = true;
}
}
public ZObjectTree(ZHeader header,
IMemoryManager manager,
ZAbbreviations abbreviations)
{
_header = header;
var objectTableData = manager.AsSpan(header.ObjectTable);// memory.AsSpan(header.ObjectTable);
var(defaultProps, ptr) = GetDefaultProps(objectTableData);
DefaultProperties = defaultProps;
var lastObject = false;
ushort objNumber = 1;
_dict = new Dictionary <ushort, IZMachineObject>();
while (!lastObject && objNumber < 255)
{
// Objects end when the properties start!
ushort objectAddress = (ushort)(header.ObjectTable + ptr);
var min = _dict.Values.Any() ? _dict.Values.Min(v => v.PropertiesAddress) : ushort.MaxValue;
lastObject = objectAddress >= min;
if (!lastObject)
{
var zObj = new ZMachineObject(objNumber, objectAddress, header, manager, abbreviations, DefaultProperties);
_dict.Add(objNumber, zObj);
ptr += zObj.BytesRead;
objNumber++;
}
}
}
private StreamWriter _sw = new StreamWriter(new MemoryStream()); //@"d:\temp\gc-log.txt");
public AutoMemoryManager(AutoMemoryManagementContext autoMemoryManagementContext, IMemoryManager underlying)
{
_sw.BaseStream.SetLength(0);
_autoMemoryManagementContext = autoMemoryManagementContext;
_underlying = underlying;
_poolSize = _initialPoolSize;
_pool = underlying.Alloc(_initialPoolSize).value;
_defaultLayout = autoMemoryManagementContext.RuntimeGlobalAccessor.GetDefaultLayoutInfo();
_markBitFieldInfo = _defaultLayout.Fields[autoMemoryManagementContext.MarkBitFieldNumber];
_realBlockSizeFieldInfo = _defaultLayout.Fields[autoMemoryManagementContext.RealBlockSizeFieldNumber];
MMFreeBlockHeader *item = (MMFreeBlockHeader *)_pool;
item->next = MMFreeBlockHeader.ZeroPtr;
item->size = _poolSize - sizeof(MMFreeBlockHeader);
_freeBlocks = item;
_stats.currentAllocatedBlocksCount = 0;
_stats.currentAllocatedBytes = 0;
_stats.currentAllBlocksCount = 1;
_stats.currentAvailableBytes = _poolSize;
_stats.totalBlocksCreated = 1;
_stats.totalBlocksMerged = 0;
_stats.totalBlocksAllocated = 0;
_stats.totalBlocksFreed = 0;
}
/// <summary>
/// Creates a crawler instance with custom settings or implementation. Passing in null for all params is the equivalent of the empty constructor.
/// </summary>
/// <param name="threadManager">Distributes http requests over multiple threads</param>
/// <param name="scheduler">Decides what link should be crawled next</param>
/// <param name="pageRequester">Makes the raw http requests</param>
/// <param name="hyperLinkParser">Parses a crawled page for it's hyperlinks</param>
/// <param name="crawlDecisionMaker">Decides whether or not to crawl a page or that page's links</param>
/// <param name="crawlConfiguration">Configurable crawl values</param>
/// <param name="memoryManager">Checks the memory usage of the host process</param>
public WebCrawler(
CrawlConfiguration crawlConfiguration,
ICrawlDecisionMaker crawlDecisionMaker,
IThreadManager threadManager,
IScheduler scheduler,
IPageRequester pageRequester,
IHyperLinkParser hyperLinkParser,
IMemoryManager memoryManager)
{
_crawlContext = new CrawlContext();
_crawlContext.CrawlConfiguration = crawlConfiguration ?? GetCrawlConfigurationFromConfigFile();
CrawlBag = _crawlContext.CrawlBag;
_threadManager = threadManager ?? new TaskThreadManager(_crawlContext.CrawlConfiguration.MaxConcurrentThreads > 0 ? _crawlContext.CrawlConfiguration.MaxConcurrentThreads : Environment.ProcessorCount);
_scheduler = scheduler ?? new Scheduler(_crawlContext.CrawlConfiguration.IsUriRecrawlingEnabled, null, null);
_pageRequester = pageRequester ?? new PageRequester(_crawlContext.CrawlConfiguration);
_crawlDecisionMaker = crawlDecisionMaker ?? new CrawlDecisionMaker();
if (_crawlContext.CrawlConfiguration.MaxMemoryUsageInMb > 0 ||
_crawlContext.CrawlConfiguration.MinAvailableMemoryRequiredInMb > 0)
{
_memoryManager = memoryManager ?? new MemoryManager(new CachedMemoryMonitor(new GcMemoryMonitor(), _crawlContext.CrawlConfiguration.MaxMemoryUsageCacheTimeInSeconds));
}
_hyperLinkParser = hyperLinkParser ?? new HapHyperLinkParser(_crawlContext.CrawlConfiguration.IsRespectMetaRobotsNoFollowEnabled, _crawlContext.CrawlConfiguration.IsRespectAnchorRelNoFollowEnabled);
_crawlContext.Scheduler = _scheduler;
}
/// <summary>
/// Creates a crawler instance with custom settings or implementation. Passing in null for all params is the equivalent of the empty constructor.
/// </summary>
/// <param name="threadManager">Distributes http requests over multiple threads</param>
/// <param name="scheduler">Decides what link should be crawled next</param>
/// <param name="pageRequester">Makes the raw http requests</param>
/// <param name="htmlParser">Parses a crawled page for it's hyperlinks</param>
/// <param name="crawlDecisionMaker">Decides whether or not to crawl a page or that page's links</param>
/// <param name="crawlConfiguration">Configurable crawl values</param>
/// <param name="memoryManager">Checks the memory usage of the host process</param>
public WebCrawler(
CrawlConfiguration crawlConfiguration,
ICrawlDecisionMaker crawlDecisionMaker,
IThreadManager threadManager,
IScheduler scheduler,
IPageRequester pageRequester,
IHtmlParser htmlParser,
IMemoryManager memoryManager)
{
_crawlContext = new CrawlContext
{
CrawlConfiguration = crawlConfiguration ?? new CrawlConfiguration()
};
CrawlBag = _crawlContext.CrawlBag;
_threadManager = threadManager ?? new TaskThreadManager(_crawlContext.CrawlConfiguration.MaxConcurrentThreads > 0 ? _crawlContext.CrawlConfiguration.MaxConcurrentThreads : Environment.ProcessorCount);
_scheduler = scheduler ?? new Scheduler(_crawlContext.CrawlConfiguration.IsUriRecrawlingEnabled, null, null);
_pageRequester = pageRequester ?? new PageRequester(_crawlContext.CrawlConfiguration, new WebContentExtractor());
_crawlDecisionMaker = crawlDecisionMaker ?? new CrawlDecisionMaker();
if (_crawlContext.CrawlConfiguration.MaxMemoryUsageInMb > 0 ||
_crawlContext.CrawlConfiguration.MinAvailableMemoryRequiredInMb > 0)
{
_memoryManager = memoryManager ?? new MemoryManager(new CachedMemoryMonitor(new GcMemoryMonitor(), _crawlContext.CrawlConfiguration.MaxMemoryUsageCacheTimeInSeconds));
}
_htmlParser = htmlParser ?? new AngleSharpHyperlinkParser(_crawlContext.CrawlConfiguration, null);
_crawlContext.Scheduler = _scheduler;
}
protected virtual void CheckMemoryUsage()
{
if (_memoryManager == null ||
_crawlContext.IsCrawlHardStopRequested ||
_crawlContext.CrawlConfiguration.MaxMemoryUsageInMb < 1)
{
return;
}
int currentMemoryUsage = _memoryManager.GetCurrentUsageInMb();
if (_logger.IsDebugEnabled)
{
_logger.DebugFormat("Current memory usage for site [{0}] is [{1}mb]", _crawlContext.RootUri, currentMemoryUsage);
}
if (currentMemoryUsage > _crawlContext.CrawlConfiguration.MaxMemoryUsageInMb)
{
_memoryManager.Dispose();
_memoryManager = null;
string message = string.Format("Process is using [{0}mb] of memory which is above the max configured of [{1}mb] for site [{2}]. This is configurable through the maxMemoryUsageInMb in app.conf or CrawlConfiguration.MaxMemoryUsageInMb.", currentMemoryUsage, _crawlContext.CrawlConfiguration.MaxMemoryUsageInMb, _crawlContext.RootUri);
_crawlResult.ErrorException = new InsufficientMemoryException(message);
_logger.Fatal(_crawlResult.ErrorException);
_crawlContext.IsCrawlHardStopRequested = true;
}
}
/// <summary>
/// Creates a crawler instance with custom settings or implementation. Passing in null for all params is the equivalent of the empty constructor.
/// </summary>
/// <param name="threadManager">Distributes http requests over multiple threads</param>
/// <param name="scheduler">Decides what link should be crawled next</param>
/// <param name="httpRequester">Makes the raw http requests</param>
/// <param name="hyperLinkParser">Parses a crawled page for it's hyperlinks</param>
/// <param name="crawlDecisionMaker">Decides whether or not to crawl a page or that page's links</param>
/// <param name="crawlConfiguration">Configurable crawl values</param>
public WebCrawler(
CrawlConfiguration crawlConfiguration,
ICrawlDecisionMaker crawlDecisionMaker,
IThreadManager threadManager,
IScheduler scheduler,
IPageRequester httpRequester,
IHyperLinkParser hyperLinkParser,
IMemoryManager memoryManager)
{
_crawlContext = new CrawlContext();
_crawlContext.CrawlConfiguration = crawlConfiguration ?? GetCrawlConfigurationFromConfigFile() ?? new CrawlConfiguration();
CrawlBag = _crawlContext.CrawlBag;
_threadManager = threadManager ?? new ManualThreadManager(_crawlContext.CrawlConfiguration.MaxConcurrentThreads);
_scheduler = scheduler ?? new FifoScheduler(_crawlContext.CrawlConfiguration.IsUriRecrawlingEnabled);
_httpRequester = httpRequester ?? new PageRequester(_crawlContext.CrawlConfiguration);
_crawlDecisionMaker = crawlDecisionMaker ?? new CrawlDecisionMaker();
if (_crawlContext.CrawlConfiguration.MaxMemoryUsageInMb > 0 ||
_crawlContext.CrawlConfiguration.MinAvailableMemoryRequiredInMb > 0)
{
_memoryManager = memoryManager ?? new MemoryManager(new CachedMemoryMonitor(new GcMemoryMonitor(), _crawlContext.CrawlConfiguration.MaxMemoryUsageCacheTimeInSeconds));
}
_hyperLinkParser = hyperLinkParser ?? new HapHyperLinkParser();
_crawlContext.Scheduler = _scheduler;
}
public ArmEmitterContext(
IMemoryManager memory,
EntryTable <uint> countTable,
AddressTable <ulong> funcTable,
TranslatorStubs stubs,
ulong entryAddress,
bool highCq,
Aarch32Mode mode,
bool hasTtc)
{
Memory = memory;
CountTable = countTable;
FunctionTable = funcTable;
Stubs = stubs;
EntryAddress = entryAddress;
HighCq = highCq;
Mode = mode;
HasPtc = Ptc.State != PtcState.Disabled;
HasTtc = hasTtc;
_labels = new Dictionary <ulong, Operand>();
}
internal static TranslatedFunction Translate(IMemoryManager memory, JumpTable jumpTable, ulong address, ExecutionMode mode, bool highCq)
{
ArmEmitterContext context = new ArmEmitterContext(memory, jumpTable, address, highCq, Aarch32Mode.User);
Logger.StartPass(PassName.Decoding);
Block[] blocks = Decoder.Decode(memory, address, mode, highCq, singleBlock: false);
Logger.EndPass(PassName.Decoding);
PreparePool(highCq ? 1 : 0);
Logger.StartPass(PassName.Translation);
EmitSynchronization(context);
if (blocks[0].Address != address)
{
context.Branch(context.GetLabel(address));
}
ControlFlowGraph cfg = EmitAndGetCFG(context, blocks, out Range funcRange);
ulong funcSize = funcRange.End - funcRange.Start;
Logger.EndPass(PassName.Translation);
Logger.StartPass(PassName.RegisterUsage);
RegisterUsage.RunPass(cfg, mode);
Logger.EndPass(PassName.RegisterUsage);
OperandType[] argTypes = new OperandType[] { OperandType.I64 };
CompilerOptions options = highCq ? CompilerOptions.HighCq : CompilerOptions.None;
GuestFunction func;
if (Ptc.State == PtcState.Disabled)
{
func = Compiler.Compile <GuestFunction>(cfg, argTypes, OperandType.I64, options);
ResetPool(highCq ? 1 : 0);
}
else
{
using PtcInfo ptcInfo = new PtcInfo();
func = Compiler.Compile <GuestFunction>(cfg, argTypes, OperandType.I64, options, ptcInfo);
ResetPool(highCq ? 1 : 0);
Hash128 hash = Ptc.ComputeHash(memory, address, funcSize);
Ptc.WriteInfoCodeRelocUnwindInfo(address, funcSize, hash, highCq, ptcInfo);
}
return(new TranslatedFunction(func, funcSize, highCq));
}
private static void FillBlock(
IMemoryManager memory,
ExecutionMode mode,
Block block,
ulong limitAddress)
{
ulong address = block.Address;
OpCode opCode;
do
{
if (address >= limitAddress)
{
break;
}
opCode = DecodeOpCode(memory, address, mode);
block.OpCodes.Add(opCode);
address += (ulong)opCode.OpCodeSizeInBytes;
}while (!(IsBranch(opCode) || IsException(opCode)));
block.EndAddress = address;
}
public void Setup()
{
underlyingMemoryManager = Substitute.For <IMemoryManager>();
underlyingMemoryManager.TryReserveBytes(0).ReturnsForAnyArgs(true);
memoryManager = new MemoryManager(MaxSize, underlyingMemoryManager);
}
public void Setup()
{
memoryManager = Substitute.For <IMemoryManager>();
bufferPool = new BufferPool(memoryManager, InitialBufferSize, MaxRecordSize, MaxBufferSize);
memoryManager.TryReserveBytes(0).ReturnsForAnyArgs(true);
}
/// <summary>
/// Constructor that will maintain an objects property in zmemory
/// </summary>
/// <param name="manager"></param>
/// <param name="propAddress"></param>
/// <param name="header"></param>
public ZProperty(IMemoryManager manager, ushort propAddress, ZHeader header)
{
_manager = manager;
_header = header;
PropertyAddress = propAddress;
var ptr = propAddress;
var propByte = _manager.Get(PropertyAddress);
if (_header.Version > 3 && (byte)(propByte & Bits.Bit7) == Bits.Bit7)
{
Number = GetPropertyNumber(propByte);
Length = (ushort)(_manager.Get(++ptr) & 0x3F);
if (Length == 0)
{
Length = 64;
}
}
else
{
Number = GetPropertyNumber(propByte);
Length = GetPropertySize(propByte);
}
DataAddress = (ushort)(PropertyAddress + 1);
_data = _manager.AsSpan(DataAddress, 2);
BytesUsed = (ushort)(Length + 1);
}
public ThreadContext(State.ExecutionContext context, IMemoryManager memory, Translator translator)
{
Context = context;
Memory = memory;
Translator = translator;
ExclusiveAddress = ulong.MaxValue;
}
public NewHostViewModel(IMemoryManager memoryManager = null)
{
host = new Host();
dataHandler = new ServerDataHandler();
Com = new ServerCommunicator(dataHandler);
SuccesTxt = "";
_memoryManager = memoryManager ?? MemoryManager.GetInstance();
}
private void OpenROM(string file)
{
var newRomToEdit = new SimpleGBAROM();
textBox1.Text = Path.GetFileName(file);
newRomToEdit.OpenROM(file);
romToEdit = newRomToEdit;
memoryManager = new Lazy();
}
public static Block[] DecodeBasicBlock(IMemoryManager memory, ulong address, ExecutionMode mode)
{
Block block = new Block(address);
FillBlock(memory, mode, block, ulong.MaxValue);
return(new Block[] { block });
}
public override void OnSetup()
{
_key = (new Random().Next()).ToString();
_manager = new MemoryManager();
_manager.Initialise("Local", _key, Enumerable.Empty <string>());
_manager.AllocateMemoryBuffer(65536, 0);
Container.RegisterInstance(_manager);
}
public LazyReserver(int offset, int size, IROM rom, IMemoryManager manager)
{
this.offset = offset;
this.size = size;
this.rom = rom;
this.man = manager;
dataPointer = null;
}
public Z80Model(System.Windows.Forms.Form d, int size)
{
if (size == 128)
memoryManager = new Z80MemoryManager128K();
else
memoryManager = new Z80MemoryManager48KFlat();
portManager = new Z80PortManager();
videoRenderer = new VideoRenderer(d);
}
/// <summary>
/// Create an instance of the profiler manager
/// </summary>
/// <param name="communicationManager"></param>
/// <param name="persistance"></param>
/// <param name="memoryManager"></param>
/// <param name="commandLine"></param>
/// <param name="perfCounters"></param>
public ProfilerManager(ICommunicationManager communicationManager, IPersistance persistance,
IMemoryManager memoryManager, ICommandLine commandLine, IPerfCounters perfCounters)
{
_communicationManager = communicationManager;
_persistance = persistance;
_memoryManager = memoryManager;
_commandLine = commandLine;
_perfCounters = perfCounters;
}
public GeneralizedPointerTableEntry(IROM rom, IMemoryManager manager, FE6RawFormat rawFormat)
{
this.rom = rom;
this.manager = manager;
this.fromFE6Format = true;
MainPortraitOffset = GetPtr(rawFormat.MainPortraitPointer);
MiniPortraitOffset = GetPtr(rawFormat.MiniPortraitPointer);
PaletteOffset = GetPtr(rawFormat.PalettePointer);
MouthOffset = 0;
GenericOffset = 0;
MouthPosition = new Point(rawFormat.MouthXPosition, rawFormat.MouthYPosition);
EyePosition = Point.Empty;
EyeControl = EyeControl.Open;
}
public GeneralizedPointerTableEntry(IROM rom, IMemoryManager manager, FE78RawFormat rawFormat)
{
this.rom = rom;
this.manager = manager;
this.fromFE6Format = false;
MainPortraitOffset = GetPtr(rawFormat.MainPortraitPointer);
MiniPortraitOffset = GetPtr(rawFormat.MiniPortraitPointer);
PaletteOffset = GetPtr(rawFormat.PalettePointer);
MouthOffset = GetPtr(rawFormat.MouthPointer);
GenericOffset = GetPtr(rawFormat.GenericPointer);
MouthPosition = new Point(rawFormat.MouthXPosition, rawFormat.MouthYPosition);
EyePosition = new Point(rawFormat.EyeXPosition, rawFormat.EyeYPosition);
EyeControl = rawFormat.EyeControl;
}
/// <summary>
/// Initialise the bootstrapper
/// </summary>
/// <param name="filter">a series of filters</param>
/// <param name="commandLine">command line options needed by other components</param>
/// <param name="persistance">a persistence object</param>
public void Initialise(IFilter filter, ICommandLine commandLine, IPersistance persistance, IMemoryManager memoryManager)
{
_container.RegisterInstance(_logger);
_container.RegisterInstance(filter);
_container.RegisterInstance(commandLine);
_container.RegisterInstance(persistance);
_container.RegisterInstance(memoryManager);
_container.RegisterType<IInstrumentationModelBuilderFactory, InstrumentationModelBuilderFactory>();
_container.RegisterType<IProfilerManager, ProfilerManager>();
_container.RegisterType<IProfilerCommunication, ProfilerCommunication>();
_container.RegisterType<IMessageHandler, MessageHandler>();
_container.RegisterType<IMarshalWrapper, MarshalWrapper>();
_container.RegisterType<ITrackedMethodStrategy, TrackNUnitTestMethods>(typeof(TrackNUnitTestMethods).FullName);
_container.RegisterType<ITrackedMethodStrategy, TrackMSTestTestMethods>(typeof(TrackMSTestTestMethods).FullName);
}
public PoliteWebCrawler(
CrawlConfiguration crawlConfiguration,
ICrawlDecisionMaker crawlDecisionMaker,
IThreadManager threadManager,
IScheduler scheduler,
IPageRequester pageRequester,
IHyperLinkParser hyperLinkParser,
IMemoryManager memoryManager,
IDomainRateLimiter domainRateLimiter,
IRobotsDotTextFinder robotsDotTextFinder)
: base(crawlConfiguration, crawlDecisionMaker, threadManager, scheduler, pageRequester, hyperLinkParser, memoryManager)
{
_domainRateLimiter = domainRateLimiter ?? new DomainRateLimiter(_crawlContext.CrawlConfiguration.MinCrawlDelayPerDomainMilliSeconds);
_robotsDotTextFinder = robotsDotTextFinder ?? new RobotsDotTextFinder(new PageRequester(_crawlContext.CrawlConfiguration));
}
public void SetUp()
{
_filter = new Filter();
_filter.AddFilter("-[mscorlib]*");
_filter.AddFilter("-[System]*");
_filter.AddFilter("-[System.*]*");
_filter.AddFilter("-[Microsoft.VisualBasic]*");
_filter.AddFilter("+[OpenCover.Samples.*]*");
_commandLine = new Mock<ICommandLine>();
_logger = new Mock<ILog>();
var filePersistance = new BasePersistanceStub(_commandLine.Object, _logger.Object);
_persistance = filePersistance;
_manager = new MemoryManager();
}
public MultiProxyPoliteWebCrawler(
MultiProxyCrawlConfiguration crawlConfiguration,
ICrawlDecisionMaker crawlDecisionMaker,
IThreadManager threadManager,
IScheduler scheduler,
IPageRequester pageRequester,
IHyperLinkParser hyperLinkParser,
IMemoryManager memoryManager,
IMultiProxyDomainRateLimiter domainRateLimiter,
IRobotsDotTextFinder robotsDotTextFinder)
: base(crawlConfiguration, crawlDecisionMaker, threadManager, scheduler, pageRequester, hyperLinkParser, memoryManager)
{
if ((pageRequester as MultiProxyPageRequester) == null)
_pageRequester = new MultiProxyPageRequester(crawlConfiguration);
_domainRateLimiter = domainRateLimiter ?? new MultiProxyDomainRateLimiter(_crawlContext.CrawlConfiguration.MinCrawlDelayPerDomainMilliSeconds);
_robotsDotTextFinder = robotsDotTextFinder ?? new RobotsDotTextFinder(_pageRequester);
}
public PortraitIndexManager(IMemoryManager memoryManager, IROM rom, bool edited)
{
currentGame = GameEnumHelpers.GetGame(rom.GameCode);
var defaultInfo = defaultInfos[currentGame];
portraitDataPointerPointer = memoryManager.Reserve(defaultInfo.tablePointerOffset, 4);
int tableRawPtr = BitConverter.ToInt32(rom.ReadData(portraitDataPointerPointer), 0);
int tableEntryCount;
if (edited)
{
string data = rom.GetCustomData(portraitProperty);
if (data != null)
{
tableEntryCount = Convert.ToInt32(data);
}
else
{
//Let's just hope for the best...
tableEntryCount = defaultInfo.indexAmount;
rom.AddCustomData(portraitProperty, tableEntryCount.ToString());
}
}
else
{
tableEntryCount = defaultInfo.indexAmount;
rom.AddCustomData(portraitProperty, tableEntryCount.ToString());
}
portraitDataPointer =
memoryManager.Reserve(
Pointer.GetOffset(tableRawPtr + defaultInfo.IndexSize),
tableEntryCount);
entries = new List<GeneralizedPointerTableEntry>(tableEntryCount);
LoadDataFromROM(memoryManager, rom, defaultInfo.fe6format, tableEntryCount);
}
public ProfilerManager(IMessageHandler messageHandler, IPersistance persistance, IMemoryManager memoryManager)
{
_messageHandler = messageHandler;
_persistance = persistance;
_memoryManager = memoryManager;
}
private void LoadDataFromROM(IMemoryManager memoryManager, IROM rom, bool useFE6Format, int indexCount)
{
byte[] portraitData = rom.ReadData(portraitDataPointer);
unsafe
{
if (useFE6Format)
{
FE6RawFormat[] rawData = new FE6RawFormat[indexCount];
fixed (FE6RawFormat* ptr = rawData)
{
IntPtr ptr2 = (IntPtr)ptr;
Marshal.Copy(portraitData, 0, ptr2, portraitData.Length);
}
for (int i = 0; i < rawData.Length; i++)
{
entries.Add(new GeneralizedPointerTableEntry(
rom, memoryManager, rawData[i]));
}
}
else
{
FE78RawFormat[] rawData = new FE78RawFormat[indexCount];
fixed (FE78RawFormat* ptr = rawData)
{
IntPtr ptr2 = (IntPtr)ptr;
Marshal.Copy(portraitData, 0, ptr2, portraitData.Length);
}
for (int i = 0; i < rawData.Length; i++)
{
entries.Add(new GeneralizedPointerTableEntry(
rom, memoryManager, rawData[i]));
}
}
}
}
public void ChangeROM(IMemoryManager memoryManager, IROM rom)
{
throw new NotImplementedException();
}
private void LoadDataFromROM(IMemoryManager memoryManager, IROM rom)
{
int portraitPtrOffset;
int defaultIndexAmount;
bool FE6Format;
switch (game = GameEnumHelpers.GetGame(rom.GameCode))
{
case GameEnum.FE6Trans:
case GameEnum.FE6:
portraitPtrOffset = 0x007FD8;
defaultIndexAmount = 0xE6;
FE6Format = true;
break;
case GameEnum.FE7U:
portraitPtrOffset = 0x006B30;
defaultIndexAmount = 0xE4;
FE6Format = false;
break;
case GameEnum.FE8U:
portraitPtrOffset = 0x005524;
defaultIndexAmount = 0xAC;
FE6Format = false;
break;
//Unknown
case GameEnum.FE7J:
case GameEnum.FE8J:
case GameEnum.FE7E:
case GameEnum.FE8E:
default:
throw new Exception("Game not supported.");
}
portraitDataPointerPointer = memoryManager.Reserve(portraitPtrOffset, 4);
int tableRawPtr = BitConverter.ToInt32(rom.ReadData(portraitDataPointerPointer), 0);
int indexSize = Marshal.SizeOf(FE6Format ? typeof(FE6RawFormat) : typeof(FE78RawFormat));
portraitDataPointer =
memoryManager.Reserve(
Pointer.GetOffset(tableRawPtr + indexSize),
defaultIndexAmount * indexSize);
byte[] portraitData = rom.ReadData(portraitDataPointer);
portraitEntries.Clear();
unsafe
{
if (FE6Format)
{
FE6RawFormat[] rawData = new FE6RawFormat[defaultIndexAmount];
fixed (FE6RawFormat* ptr = rawData)
{
IntPtr ptr2 = (IntPtr)ptr;
Marshal.Copy(portraitData, 0, ptr2, portraitData.Length);
}
for (int i = 0; i < rawData.Length; i++)
{
portraitEntries.Add(new GeneralizedPointerTableEntry(
rom, memoryManager, rawData[i]));
}
}
else
{
FE78RawFormat[] rawData = new FE78RawFormat[defaultIndexAmount];
fixed (FE78RawFormat* ptr = rawData)
{
IntPtr ptr2 = (IntPtr)ptr;
Marshal.Copy(portraitData, 0, ptr2, portraitData.Length);
}
for (int i = 0; i < rawData.Length; i++)
{
portraitEntries.Add(new GeneralizedPointerTableEntry(
rom, memoryManager, rawData[i]));
}
}
}
CurrentIndex = 0;
form.MaxIndex = portraitEntries.Count - 1;
}
public ImageAltTextChecker(CrawlConfiguration crawlConfiguration, ICrawlDecisionMaker crawlDecisionMaker, IThreadManager threadManager, IScheduler scheduler, IPageRequester pageRequester, IHyperLinkParser hyperLinkParser, IMemoryManager memoryManager, IDomainRateLimiter domainRateLimiter, IRobotsDotTextFinder robotsDotTextFinder)
: base(crawlConfiguration, crawlDecisionMaker, threadManager, scheduler, pageRequester, hyperLinkParser, memoryManager, domainRateLimiter, robotsDotTextFinder)
{
}
/// <summary>
/// Creates a crawler instance with custom settings or implementation. Passing in null for all params is the equivalent of the empty constructor.
/// </summary>
/// <param name="threadManager">Distributes http requests over multiple threads</param>
/// <param name="scheduler">Decides what link should be crawled next</param>
/// <param name="pageRequester">Makes the raw http requests</param>
/// <param name="hyperLinkParser">Parses a crawled page for it's hyperlinks</param>
/// <param name="crawlDecisionMaker">Decides whether or not to crawl a page or that page's links</param>
/// <param name="crawlConfiguration">Configurable crawl values</param>
/// <param name="memoryManager">Checks the memory usage of the host process</param>
public WebCrawler(
CrawlConfiguration crawlConfiguration,
ICrawlDecisionMaker crawlDecisionMaker,
IThreadManager threadManager,
IScheduler scheduler,
IPageRequester pageRequester,
IHyperLinkParser hyperLinkParser,
IMemoryManager memoryManager)
{
_crawlContext = new CrawlContext();
_crawlContext.CrawlConfiguration = crawlConfiguration ?? GetCrawlConfigurationFromConfigFile();
CrawlBag = _crawlContext.CrawlBag;
_threadManager = threadManager ?? new TaskThreadManager(_crawlContext.CrawlConfiguration.MaxConcurrentThreads > 0 ? _crawlContext.CrawlConfiguration.MaxConcurrentThreads : Environment.ProcessorCount);
_scheduler = scheduler ?? new Scheduler(_crawlContext.CrawlConfiguration.IsUriRecrawlingEnabled, null, null);
_pageRequester = pageRequester ?? new PageRequester(_crawlContext.CrawlConfiguration);
_crawlDecisionMaker = crawlDecisionMaker ?? new CrawlDecisionMaker();
if (_crawlContext.CrawlConfiguration.MaxMemoryUsageInMb > 0
|| _crawlContext.CrawlConfiguration.MinAvailableMemoryRequiredInMb > 0)
_memoryManager = memoryManager ?? new MemoryManager(new CachedMemoryMonitor(new GcMemoryMonitor(), _crawlContext.CrawlConfiguration.MaxMemoryUsageCacheTimeInSeconds));
_hyperLinkParser = hyperLinkParser ?? new HapHyperLinkParser(_crawlContext.CrawlConfiguration.IsRespectMetaRobotsNoFollowEnabled, _crawlContext.CrawlConfiguration.IsRespectAnchorRelNoFollowEnabled, null, _crawlContext.CrawlConfiguration.IsRespectUrlNamedAnchorOrHashbangEnabled);
_crawlContext.Scheduler = _scheduler;
}
/// <summary>
/// Creates a crawler instance with custom settings or implementation. Passing in null for all params is the equivalent of the empty constructor.
/// </summary>
/// <param name="threadManager">Distributes http requests over multiple threads</param>
/// <param name="scheduler">Decides what link should be crawled next</param>
/// <param name="httpRequester">Makes the raw http requests</param>
/// <param name="hyperLinkParser">Parses a crawled page for it's hyperlinks</param>
/// <param name="crawlDecisionMaker">Decides whether or not to crawl a page or that page's links</param>
/// <param name="crawlConfiguration">Configurable crawl values</param>
public WebCrawler(
CrawlConfiguration crawlConfiguration,
ICrawlDecisionMaker crawlDecisionMaker,
IThreadManager threadManager,
IScheduler scheduler,
IPageRequester httpRequester,
IHyperLinkParser hyperLinkParser,
IMemoryManager memoryManager)
{
_crawlContext = new CrawlContext();
_crawlContext.CrawlConfiguration = crawlConfiguration ?? GetCrawlConfigurationFromConfigFile() ?? new CrawlConfiguration();
CrawlBag = _crawlContext.CrawlBag;
_threadManager = threadManager ?? new ManualThreadManager(_crawlContext.CrawlConfiguration.MaxConcurrentThreads);
_scheduler = scheduler ?? new FifoScheduler(_crawlContext.CrawlConfiguration.IsUriRecrawlingEnabled);
_httpRequester = httpRequester ?? new PageRequester(_crawlContext.CrawlConfiguration);
_crawlDecisionMaker = crawlDecisionMaker ?? new CrawlDecisionMaker();
if(_crawlContext.CrawlConfiguration.MaxMemoryUsageInMb > 0
|| _crawlContext.CrawlConfiguration.MinAvailableMemoryRequiredInMb > 0)
_memoryManager = memoryManager ?? new MemoryManager(new CachedMemoryMonitor(new GcMemoryMonitor(), _crawlContext.CrawlConfiguration.MaxMemoryUsageCacheTimeInSeconds));
_hyperLinkParser = hyperLinkParser ?? new HapHyperLinkParser();
_crawlContext.Scheduler = _scheduler;
}
protected virtual void CheckMemoryUsage()
{
if (_memoryManager == null
|| _crawlContext.IsCrawlHardStopRequested
|| _crawlContext.CrawlConfiguration.MaxMemoryUsageInMb < 1)
return;
int currentMemoryUsage = _memoryManager.GetCurrentUsageInMb();
if (_logger.IsDebugEnabled)
_logger.DebugFormat("Current memory usage for site [{0}] is [{1}mb]", _crawlContext.RootUri, currentMemoryUsage);
if (currentMemoryUsage > _crawlContext.CrawlConfiguration.MaxMemoryUsageInMb)
{
_memoryManager.Dispose();
_memoryManager = null;
string message = string.Format("Process is using [{0}mb] of memory which is above the max configured of [{1}mb] for site [{2}]. This is configurable through the maxMemoryUsageInMb in app.conf or CrawlConfiguration.MaxMemoryUsageInMb.", currentMemoryUsage, _crawlContext.CrawlConfiguration.MaxMemoryUsageInMb, _crawlContext.RootUri);
_crawlResult.ErrorException = new InsufficientMemoryException(message);
_logger.Fatal(_crawlResult.ErrorException);
_crawlContext.IsCrawlHardStopRequested = true;
}
}
