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; } }