public MessageHub(IUserService userService, IMemoryAccess memory, IMessenger messenger, IGameService gameService) { _userService = userService; _memoryAccess = memory; _messenger = messenger; _gameService = gameService; }
public unsafe Tree([NotNull] Allocator alloc, [NotNull] IMemoryAccess mem) { _alloc = alloc; _mem = mem; NodeSize = NODE_HEAD_SIZE + sizeof(TElement); // Make the root node var res = _alloc.Alloc(NodeSize); if (!res.Success) { Valid = false; return; } // Set initial values Root = res.Value; var rootHead = new TreeNodeHead { FirstChildPtr = -1, NextSiblingPtr = -1, ParentPtr = -1 }; _mem.WriteC <TreeNodeHead, TElement>(Root, rootHead, default); Valid = true; }
/// <summary> /// Start a new allocator. /// This tracks memory usage, but does not do any physical work /// </summary> /// <param name="start">Start of space (bytes) available to the allocator. Some will be reserved for arena tracking</param> /// <param name="limit">Maximum memory before an out-of-memory condition is flagged (bytes)</param> /// <param name="memory">Access to real or simulated memory</param> public Allocator(long start, long limit, [NotNull] IMemoryAccess memory) { _limit = limit; _memory = memory; // with 64KB arenas (ushort) and 1GB of RAM, we get 16384 arenas. // recording only heads and refs would take 64KB of management space // recording heads, refs and back-step (an optimisation for very short-lived items) would use 96KB of management space. // This seems pretty reasonable. _arenaCount = (int)((_limit - _start) / ArenaSize); _currentArena = 0; // Allow space for arena tables, store adjusted base var sizeOfTables = sizeof(ushort) * _arenaCount; _headsPtr = start; _refCountsPtr = start + sizeOfTables; _start = start + (sizeOfTables * 2); // zero-out the tables var zptr = _headsPtr; while (zptr < _start) { _memory.Write <ushort>(zptr, 0); zptr += sizeof(ushort); } }
public static ushort PeekWord(this IMemoryAccess <ushort, byte> memory, ushort address) { ushort value = memory.Peek(address++); value += (ushort)(memory.Peek(address) << 8); return(value); }
public MemoryManagementUnit(IMemoryAccess <ushort, byte> rom, IMemoryAccess <ushort, byte> ram, IMemoryAccess <ushort, byte> mikey, IMemoryAccess <ushort, byte> suzy) { this.Ram = ram; this.Rom = rom; this.Suzy = suzy; this.Mikey = mikey; MAPCTL = new MemoryMapControl(); }
public SystemService(ICpuAccess cpuAccess, IMemoryAccess memoryAccess, IGpuAccess gpuAccess) { ArgumentMust.NotBeNull(() => cpuAccess); ArgumentMust.NotBeNull(() => memoryAccess); ArgumentMust.NotBeNull(() => gpuAccess); _cpuAccess = cpuAccess; _memoryAccess = memoryAccess; _gpuAccess = gpuAccess; }
/// <summary> /// A variable length array of variable elements. /// Create a new vector base in the first free section /// </summary> public Vector([NotNull] Allocator alloc, [NotNull] IMemoryAccess mem) { _alloc = alloc; _mem = mem; unsafe { ElementByteSize = sizeof(TElement); } // Work out how many elements can fit in an arena ChunkHeaderSize = PTR_SIZE; var spaceForElements = Allocator.ArenaSize - ChunkHeaderSize; // need pointer space ElemsPerChunk = (int)(spaceForElements / ElementByteSize); if (ElemsPerChunk <= 1) { IsValid = false; return; } if (ElemsPerChunk > TARGET_ELEMS_PER_CHUNK) { ElemsPerChunk = TARGET_ELEMS_PER_CHUNK; // no need to go crazy with small items. } ChunkBytes = (ushort)(ChunkHeaderSize + (ElemsPerChunk * ElementByteSize)); // Make a table, which can store a few chunks, and can have a next-chunk-table pointer // Each chunk can hold a few elements. _skipEntries = -1; _skipTable = -1; _endChunkPtr = -1; _baseChunkTable = -1; var res = NewChunk(); if (!res.Success) { IsValid = false; return; } _baseChunkTable = res.Value; _elementCount = 0; RebuildSkipTable(); // All done IsValid = true; }
public GeoAreaFinder(IMemoryAccess memoryAccess) { _memoryAccess = memoryAccess; }
/// <summary> /// Create a new hash map /// </summary> /// <param name="size">Initial size</param> /// <param name="alloc">Memory allocator</param> /// <param name="mem">Memory access</param> public TaggedHashMap(uint size, Allocator alloc, IMemoryAccess mem) { _alloc = alloc; _mem = mem; Resize((uint)NextPow2(size), false); }
public Messenger(IMemoryAccess cache, ISender sender, IUserNameValidator nameValidator) { _cache = cache; _sender = sender; _nameValidator = nameValidator; }
public GameController(IMemoryAccess memory, IGameService gameService) { _memoryAccess = memory; _gameService = gameService; }
public Cmos65SC02(IMemoryAccess <ushort, byte> memory, Clock clock) : base(memory, clock) { }
public GameService(IMemoryAccess memoryAccess, IMessenger messenger, IUserNameValidator nameValidator) { _memoryAccess = memoryAccess; _messenger = messenger; _nameValidator = nameValidator; }
public PageMemoryManager(IMemoryAccess MemoryAccess, int PageSize) { _memoryAccess = MemoryAccess; _pageSize = PageSize; _buffer = new byte[_pageSize]; }
public Nmos6502(IMemoryAccess <ushort, byte> memory, Clock clock) { SystemClock = clock; Memory = memory; }
public Sender(IMemoryAccess cache, IUserService userService) { _cache = cache; _userService = userService; }