public void BeginBatch() { Assert.IsTrue(currentChain == null, "Can not begin new batch write, when batch writing is started, Call EndBatch"); Assert.IsTrue(ThreadID <= BlockChainCount, "Thread ID must be smaller than BlockChainCount"); currentChain = BlockChains + ThreadID; currentBlock = currentChain->GetWritingBlock(allocator); }
public static Block *Allocate(Allocator allocator) { Block *pBlock = (Block *)UnsafeUtility.Malloc(BlockSize, 32, allocator); UnsafeUtility.MemClear(pBlock, BlockSize); return(pBlock); }
public Block *GetWritingBlock(Allocator allocator) { if (mCurrentWriteBlock == null) { if (mFirstBlock == null || mLastBlock == null) {//fresh start Assert.IsTrue(mFirstBlock == null || mLastBlock == null, "First/Last block has one missing while while other allocate!"); mCurrentWriteBlock = mFirstBlock = mLastBlock = Block.Allocate(allocator); mBlockAllocated++; } else { var curBlk = mFirstBlock; while (curBlk != null) { var nextBlk = curBlk->mNextBlock; if (nextBlk->mElementCount == 0) { mCurrentWriteBlock = curBlk; return(mCurrentWriteBlock); } Assert.IsFalse(nextBlk == mFirstBlock, "block loop!"); curBlk = nextBlk; } if (curBlk == null)//all block in use { mLastBlock->mNextBlock = curBlk = Block.Allocate(allocator); mCurrentWriteBlock = mLastBlock = curBlk; mBlockAllocated++; } } } return(mCurrentWriteBlock); }
public static unsafe void Print(Block *src, TextWriter dst) { dst.WriteLine($"Hash: {Hex(src->GetHash())}"); dst.WriteLine($"Previous: {Hex(src->GetPreviousHash())}"); if (src->len > 0) { dst.WriteLine($"Data: {Hex(src->GetData())}"); } int no = src->no; dst.WriteLine($"No: {no}"); var timestamp = src->timestamp; dst.WriteLine($"Timestamp: {(new System.DateTime(1970, 1, 1, 0, 0, 0, 0, System.DateTimeKind.Utc)).AddSeconds(timestamp).ToLocalTime()}"); var nonce = src->nonce; dst.WriteLine($"Nonce: {nonce}"); dst.WriteLine($"Verified: {Database.IsValidBlock(src, null)}"); if (Database.IsGenesis(src)) { dst.WriteLine($"Genesis: {true}"); } dst.WriteLine(); }
public static void GenerateResources(Map map) { Random seed = new Random(); Block *matrix = map.GetBlockMatrix(); int width = map.Width; int height = map.Height; /*gold*/ generateResource( Globals.RESOURCE_GOLD, matrix, width, height, 5, seed); /*stone*/ generateResource( Globals.RESOURCE_STONE, matrix, width, height, 5, seed); /*food*/ generateResource( Globals.RESOURCE_FOOD, matrix, width, height, 5, seed); }
public static unsafe byte[] CreateBlock(Block *src, bool unhash) { byte[] buf = new byte[1024]; Block tmp = *src; if (unhash) { byte *p = tmp.hash; for (int i = 0; i < 32; i++) { p[i] = 0; } } fixed(byte *p = buf) { byte *s = (byte *)&tmp; for (int i = 0; i < 1024; i++) { p[i] = s[i]; } } return(buf); }
public static unsafe void JSON(Block *src, TextWriter dst) { const string INDENT = "\t"; dst.WriteLine($"{{"); dst.WriteLine($"{INDENT}hash: \"{Hex(src->GetHash())}\","); dst.WriteLine($"{INDENT}previous: \"{Hex(src->GetPreviousHash())}\","); if (src->len > 0) { dst.WriteLine($"{INDENT}data: \"{Hex(src->GetData())}\","); } int no = src->no; dst.WriteLine($"{INDENT}no: {no},"); var timestamp = src->timestamp; dst.WriteLine($"{INDENT}timestamp: \"{(new System.DateTime(1970, 1, 1, 0, 0, 0, 0, System.DateTimeKind.Utc)).AddSeconds(timestamp).ToLocalTime()}\","); var nonce = src->nonce; dst.WriteLine($"{INDENT}nonce: \"{nonce}\","); dst.WriteLine($"}}"); }
private void updateConcreteMatrix() { Lock(); //has the concrete matrix not been allocated? if (p_ConcreteMatrix == (bool *)0) { p_ConcreteMatrix = (bool *)Marshal.AllocHGlobal( p_Width * p_Height); } //just populate the concerete matrix depending on //it's block counterpart having a resource state id (basically not -1) bool * ptr = p_ConcreteMatrix; bool * ptrEnd = ptr + (p_Width * p_Height); Block *blockPtr = p_Matrix; while (ptr != ptrEnd) { Block block = *blockPtr++; (*ptr++) = block.TypeID >= Globals.TERRAIN_END; } //clean up Unlock(); }
public Map(Game game, int width, int height) { p_Game = game; p_Width = width; p_Height = height; //allocate a block of memory to store the matrix p_Matrix = (Block *)Marshal.AllocHGlobal( (width * height) * sizeof(Block)); //initialize every block Block *ptr = p_Matrix; Block *ptrEnd = p_Matrix + (width * height); while (ptr != ptrEnd) { (*ptr).Selected = false; (*ptr).TypeID = 0; ptr++; } //generate resources generateMap(); updateConcreteMatrix(); pathfindBench(); }
public Block *Allocate(Block *oldBlock, int threadIndex) { Assert.IsTrue(threadIndex < BlockCount && threadIndex >= 0); Block *block = (Block *)UnsafeUtility.Malloc(AllocationSize, 16, Allocator); block->Next = null; if (oldBlock == null) { if (Blocks[threadIndex] == null) { Blocks[threadIndex] = block; } else { // Walk the linked list and append our new block to the end. // Otherwise, we leak memory. Block *head = Blocks[threadIndex]; while (head->Next != null) { head = head->Next; } head->Next = block; } } else { oldBlock->Next = block; } return(block); }
private static void generateResource(short type, Block *matrix, int width, int height, int maxCount, Random seed) { Block *ptr = matrix; Block *ptrEnd = matrix + (width * height); //iterate through every block while (ptr != ptrEnd) { Block *current = ptr++; //eligible for a resource? if ((*current).TypeID != Globals.TERRAIN_GRASS) { continue; } if (seed.Next(300) != 10) { continue; } /*1 in 100 chance of a resource*/ Block *nextBlock = current; int currentCount = 0; int currentMaxCount = seed.Next(0, maxCount); while (currentCount != currentMaxCount) { //out of bounds? if (nextBlock < matrix || nextBlock >= ptrEnd) { break; } //place this resource if ((*nextBlock).TypeID == Globals.TERRAIN_GRASS) { (*nextBlock).TypeID = type; } //go to the next resource int deltaX = 0; int deltaY = 0; while (deltaX == 0 && deltaY == 0) { deltaX = seed.Next(-1, 1); deltaY = seed.Next(-1, 1); //do not allow diagonals. if (deltaX != 0 && deltaY != 0) { deltaX = 0; deltaY = 0; } } nextBlock += (deltaY * width) + deltaX; currentCount++; } } }
public static unsafe bool IsGenesis(Block *src) { if (Compare(src->GetPreviousHash(), Genesis)) { return(true); } return(false); }
void StartNextBlock() { currentChain->mBlockUsed++; if (currentBlock->mNextBlock == null) { currentBlock->mNextBlock = Block.Allocate(allocator); currentChain->mBlockAllocated++; } currentBlock = currentBlock->mNextBlock; }
public void BeginForEachIndex(int foreachIndex) { BeginForEachIndexChecks(foreachIndex); m_ForeachIndex = foreachIndex; m_ElementCount = 0; m_NumberOfBlocks = 0; m_FirstBlock = m_CurrentBlock; m_FirstOffset = (int)(m_CurrentPtr - (byte *)m_CurrentBlock); }
public void BeginForEachIndex(int foreachIndex) { //@TODO: Check that no one writes to the same for each index multiple times... BeginForEachIndexChecks(foreachIndex); m_ForeachIndex = foreachIndex; m_ElementCount = 0; m_NumberOfBlocks = 0; m_FirstBlock = m_CurrentBlock; m_FirstOffset = (int)(m_CurrentPtr - (byte *)m_CurrentBlock); }
public void EndBatch() { Assert.IsTrue(currentChain != null, "Writing not started by calling BeginBatch, target batch is not defined"); if (currentBlock->mDataByteLen > 0) { currentChain->mBlockUsed++; } //currentChain->mLastBlock = currentBlock; currentChain = null; currentBlock = null; }
/// <summary> /// Expands the memory block of ptr to newSize /// </summary> /// <param name="ptr">The pointer to the memory block</param> /// <param name="newSize">The new size of the block</param> /// <returns>The memory block</returns> public static unsafe void *Expand(void *ptr, int newSize) { Block *block = getBlockFromPtr(ptr); int size = (block->Size < newSize) ? block->Size : newSize; void *newPtr = AlignedAlloc(4, newSize); Memory.Memcpy(newPtr, ptr, size); Free(ptr); return(newPtr); }
/// <summary> /// Gets the block from the pointer /// </summary> /// <param name="ptr">The pointer</param> /// <returns>The block</returns> private static unsafe Block *getBlockFromPtr(void *ptr) { Block *block = (Block *)((int)ptr - sizeof(Block)); #if HEAP_USE_MAGIC if (block->Magic != HEAP_MAGIC) { Panic.DoPanic("[HEAP] block->Magic != HEAP_MAGIC"); } #endif return(block); }
public int CompareTo(Sha1 other) { unsafe { fixed(Block *src = &_block) { Block *dst = &other._block; int cmp = ShaUtil.NativeMethods.MemCompare((byte *)src, (byte *)dst, ByteLength); return(cmp); } } }
public static void GenerateTerrain(Map map) { Block *matrix = map.GetBlockMatrix(); int width = map.Width; int height = map.Height; //define the noise generators for the terrain/resource Random seed = new Random(); PerlinNoise terrainNoise = new PerlinNoise(seed); //use perlin noise to generate terrain (check if //the heighmap for each pixel is within a range for a resource Block *ptr = matrix; Block *ptrEnd = matrix + (width * height); int x = 0, y = 0; while (ptr != ptrEnd) { Block *block = (ptr++); //get the heightmap value for this pixel //within a 1-100 scale double gen = terrainNoise.GetHeight(x, y, 50, 50); int value = (int)(Math.Abs(gen * 100)); //deturmine the terrain block short blockType = Globals.TERRAIN_GRASS; if (value < 15) { blockType = Globals.TERRAIN_WATER; (*block).Height = (byte)(value * 1.0f * 2); } else { blockType = Globals.TERRAIN_GRASS; } //set the block type (*block).TypeID = blockType; //update x/y x++; if (x == width) { x = 0; y++; } } }
/// <summary> /// Creates a block descriptor with given minimal size /// </summary> /// <param name="size">The minimal size</param> /// <returns>The block descriptor</returns> private static unsafe BlockDescriptor *createBlockDescriptor(int size) { #if HEAP_DEBUG_DESCRIPTOR Console.WriteLine("[HEAP] Creating a new block descriptor"); #endif // Add size of Block and BlockDescriptor size += sizeof(Block) + sizeof(BlockDescriptor); // Allocate descriptor size = getRequiredPageCount(size) * 0x1000; BlockDescriptor *descriptor = (BlockDescriptor *)Paging.AllocateVirtual(size); #if HEAP_DEBUG_DESCRIPTOR Console.Write("[HEAP] New descriptor is at 0x"); Console.WriteHex((int)descriptor); Console.Write(", physical: 0x"); Console.WriteHex((int)Paging.GetPhysicalFromVirtual(descriptor)); Console.Write('\n'); #endif if (descriptor == null) { Panic.DoPanic("descriptor == null"); } // Setup block Block *first = (Block *)((int)descriptor + sizeof(BlockDescriptor)); first->Prev = null; first->Next = null; first->Size = size - sizeof(BlockDescriptor); first->Used = false; first->Descriptor = descriptor; #if HEAP_USE_MAGIC first->Magic = HEAP_MAGIC; #endif // Setup descriptor descriptor->FreeSpace = size - sizeof(BlockDescriptor); descriptor->First = first; descriptor->FirstFree = first; descriptor->Next = null; #if HEAP_USE_MAGIC descriptor->Magic = HEAP_MAGIC; #endif return(descriptor); }
private void test() { Point st = Point.Empty; Point en = Point.Empty; bool[,] m = load("paths/maze.astar", out st, out en); //st = new Point(200, 0); //en = new Point(999, 999); //st = new Point(3, 0); //en = new Point(7, 9); for (int x = 0; x < 1000; x++) { for (int y = 0; y < 1000; y++) { Block *b = translateToPointer(x, y); (*b).TypeID = (short)(m[x, y] ? Globals.RESOURCE_WOOD : Globals.TERRAIN_GRASS); } } updateConcreteMatrix(); IPathfinderContext ctx = Pathfinder.ASCreateContext(p_Width, p_Height); while (true) { int time = Environment.TickCount; List <Point> path = Pathfinder.ASSearch( ctx, st, en, p_ConcreteMatrix); Console.WriteLine((Environment.TickCount - time) + "ms for " + path.Count + " items"); for (int c = 0; c < path.Count; c++) { Point p = path[c]; Block *bl = translateToPointer(p.X, p.Y); (*bl).Selected = true; } break; } }
public void BeginForEachIndex(int foreachIndex) { #if BLOCK_STREAM_DEBUG if (foreachIndex < m_MinIndex || foreachIndex > m_MaxIndex) { throw new ArgumentException($"Index {foreachIndex} is out of restricted IJobParallelFor range [{m_MinIndex}...{m_MaxIndex}] in BlockStream."); } Assert.IsTrue(foreachIndex >= 0 && foreachIndex < m_BlockStream->RangeCount); Assert.AreEqual(-1, m_ForeachIndex); Assert.AreEqual(0, m_BlockStream->Ranges[foreachIndex].Count); #endif m_ForeachIndex = foreachIndex; m_Count = 0; m_FirstBlock = m_CurrentBlock; m_FirstOffset = (int)(m_CurrentPtr - (byte *)m_CurrentBlock); }
static public short[] DecodeBlocks(Block *Blocks, int BlockCount) { var Data = new short[28 * BlockCount]; var Decoder = new Decoder(); int SamplesOffset = 0; for (int n = 0; n < BlockCount; n++) { if (Decoder.DecodeBlock(Blocks[n], Data, ref SamplesOffset)) { //Console.WriteLine("STOP: {0}/{1}", n, BlockCount); Data = Data.Slice(0, SamplesOffset); break; } } return(Data); }
public void AppendForEachIndex(int foreachIndex) { CheckAccess(); #if ENABLE_UNITY_COLLECTIONS_CHECKS if (foreachIndex < m_MinIndex || foreachIndex > m_MaxIndex) { throw new System.ArgumentException($"forEachIndex {foreachIndex} is not in the allowed range"); } #endif #if BLOCK_STREAM_DEBUG Assert.IsTrue(foreachIndex >= 0 && foreachIndex < m_BlockStream->RangeCount); Assert.AreEqual(-1, m_ForeachIndex); #endif m_ForeachIndex = foreachIndex; m_Count = m_BlockStream->Ranges[foreachIndex].Count; m_FirstOffset = m_BlockStream->Ranges[foreachIndex].Offset; m_FirstBlock = m_BlockStream->Ranges[foreachIndex].Block; if (m_Count > 0) { m_CurrentBlock = m_FirstBlock; while (m_CurrentBlock->Next != null) { m_CurrentBlock = m_CurrentBlock->Next; } m_CurrentPtr = (byte *)m_CurrentBlock + m_BlockStream->Ranges[foreachIndex].LastOffset; m_CurrentBlockEnd = (byte *)m_CurrentBlock + BlockStreamData.AllocationSize; } else { Block *allocatedBlock = m_BlockStream->Blocks[m_ThreadIndex]; if (allocatedBlock != null) { // This can happen if a job was generated for this work item but didn't produce any // contacts - the range will be empty, but a block will have been preemptively allocated m_FirstBlock = allocatedBlock; m_CurrentBlock = m_FirstBlock; m_CurrentPtr = m_CurrentBlock->Data; m_FirstOffset = (int)(m_CurrentPtr - (byte *)m_CurrentBlock); m_CurrentBlockEnd = (byte *)m_CurrentBlock + BlockStreamData.AllocationSize; } } }
public unsafe static Task GetBlocks(Microsoft.Owin.IOwinContext ctx) { Cors(ctx); var plain = new StringBuilder(); using (System.IO.TextWriter dst = new StringWriter(plain)) { Database.Map(App.FILE, (i) => { Block *block = (Block *)i; Utils.Print( block, dst); }); } return(OK(ctx, plain.ToString())); }
private void _Dispose() { if (m_Block == null) { return; } for (int i = 0; i != m_Block->BlockCount; i++) { Block *block = m_Block->Blocks[i]; while (block != null) { Block *next = block->Next; UnsafeUtility.Free(block, m_AllocatorLabel); block = next; } } UnsafeUtility.Free(m_Block, m_AllocatorLabel); m_Block = null; }
internal Writer(ref NativeStream stream) { m_BlockStream = stream.m_Block; m_ForeachIndex = int.MinValue; m_ElementCount = -1; m_CurrentBlock = null; m_CurrentBlockEnd = null; m_CurrentPtr = null; m_FirstBlock = null; m_NumberOfBlocks = 0; m_FirstOffset = 0; m_ThreadIndex = 0; #if ENABLE_UNITY_COLLECTIONS_CHECKS m_Safety = stream.m_Safety; m_Length = int.MaxValue; m_MinIndex = int.MinValue; m_MaxIndex = int.MinValue; m_PassByRefCheck = null; #endif }
private bool isCoastline(Block *ptr, Block *matrix, out Direction direction, int x, int y, int width, int height) { Block *ptrEnd = matrix + (width * height); //get adjacent blocks Block *top = ptr - width; Block *left = ptr - 1; Block *right = ptr + 1; Block *bottom = ptr + width; //check int typeID = Globals.TERRAIN_WATER; direction = Direction.NONE; if ((*ptr).TypeID == Globals.TERRAIN_WATER) { return(false); } if (y > 0 && (*top).TypeID == typeID) { direction |= Direction.NORTH; } if (x > 0 && (*left).TypeID == typeID) { direction |= Direction.WEST; } if (y < height && bottom < ptrEnd && (*bottom).TypeID == typeID) { direction |= Direction.SOUTH; } if (x < width && (*right).TypeID == typeID) { direction |= Direction.EAST; } return(direction != Direction.NONE); }
void Deallocate() { if (m_Block == null) { return; } for (int i = 0; i != m_Block->BlockCount; i++) { Block *block = m_Block->Blocks[i]; while (block != null) { Block *next = block->Next; UnsafeUtility.Free(block, m_AllocatorLabel); block = next; } } UnsafeUtility.Free(m_Block->Ranges, m_AllocatorLabel); UnsafeUtility.Free(m_Block, m_AllocatorLabel); m_Block = null; m_AllocatorLabel = Allocator.Invalid; }
public Decoder(Block* BlockPointer, int BlockTotalCount) { this.BlockPointer = BlockPointer; this.BlockTotalCount = BlockTotalCount; Reset(); }