https://www.shironekolabs.com/ Recent content on Shironeko Labs Hugo -- gohugo.io en-us Mon, 31 May 2021 15:33:42 +0900 https://www.shironekolabs.com/posts/superrt-source-release/ Mon, 31 May 2021 15:33:42 +0900 https://www.shironekolabs.com/posts/superrt-source-release/ It took a bit longer than I’d hoped to tidy things up, but the SuperRT source code is finally released. There’s a lot more detail in the readme file included with the code, but in broad strokes it’s probably mostly of academic interest rather than useful in any practical way - hopefully it will be of interest to anyone curious about the inner workings of the demo. https://www.shironekolabs.com/posts/efficient-approximate-square-roots-and-division-in-verilog/ Sat, 23 Jan 2021 11:51:27 +0900 https://www.shironekolabs.com/posts/efficient-approximate-square-roots-and-division-in-verilog/ SuperRT uses, for the most part, fairly simple maths operations - integer addition and multiplication - which are natively supported by Verilog (and can be offloaded to DSPs in some cases). There are, however, some places where it inevitably has to do more complex operations - notably divides and square roots (he hardware side avoids the need for any sine/cosine calculations by formatting the incoming data in such a way that the SNES CPU takes those on). https://www.shironekolabs.com/posts/the-superrt-tools/ Wed, 23 Dec 2020 19:33:23 +0900 https://www.shironekolabs.com/posts/the-superrt-tools/ Update 31th May 2021: The source code for SuperRT has now been released. One thing I learnt very quickly when I started looking at FPGA design was that debugging is hard. Simulation tools exist but from what I’ve seen they are slow, don’t replicate all the quirks of hardware, and for situations like this where interfacing to external devices is an integral part of the design don’t seem to be a good option - to be honest, I gave up pretty quickly on getting anything meaningful out of them and stuck to testing solely on the hardware itself (I fully expect that a large part of this is down to my not really understanding how they are supposed to be used, though - remember that this is my first FPGA project ever and weigh my opinions accordingly! https://www.shironekolabs.com/posts/superrt/ Sun, 13 Dec 2020 15:13:19 +0900 https://www.shironekolabs.com/posts/superrt/ Video links for this article: Short trailer Walkthrough and technical details Update 31th May 2021: The source code for SuperRT has now been released. I’m pleased to finally have some results to show for a project I’ve been working on in my spare time for the last year or so. The idea originated when I was trying to think of an interesting idea for a project to help me learn Verilog and FPGA design, and the notion of building a simple raytracer came to mind (partly inspired by a scarily smart friend of mine who is building his own GPU). https://www.shironekolabs.com/posts/the-evaluation-stack/ Wed, 25 Sep 2019 17:48:36 +0900 https://www.shironekolabs.com/posts/the-evaluation-stack/ A concept which took me a little while to get my head around the first time I encountered it in the CLR is that of the “evaluation stack”, so I thought I’d write a little bit to summarise how it works (or, well, how I think it works, which may be slightly different - let me know if I’ve got anything wrong!). In terms of how they execute code, the vast majority of CPUs are “register-based”, which is to say that instructions reference data stored in a fixed number of registers held within the chip itself. https://www.shironekolabs.com/posts/instruction-context/ Mon, 02 Sep 2019 18:42:32 -0700 https://www.shironekolabs.com/posts/instruction-context/ A key part of Catnip’s architecture is the use of internal microcode. As an intermediate step prior to execution, IL instructions are converted into this microcode, which is then what actually gets executed by the interpreter (or subsequently converted into native code). The primary reason for this is that IL instructions are heavily contextual - for example, the ADD instruction may be adding integers or floating point values in either 32 bit or 64 bit mode. https://www.shironekolabs.com/posts/concurrent-garbage-collection/ Wed, 31 Jul 2019 14:53:09 +0900 https://www.shironekolabs.com/posts/concurrent-garbage-collection/ In the previous post I looked a little bit at the fundamental principles of garbage collection, and now I’d like to talk a little about concurrent garbage collection and why it’s a much harder proposition. Up until now our assumption has been that whilst the GC is running the data in the heap is constant - this can either be because the application has been paused (and thus nothing is modifying it), or because some mechanism has been used to take a snapshot of the heap in a consistent state (we’ll talk a little about that later). https://www.shironekolabs.com/posts/garbage-collection-basics/ Sat, 01 Jun 2019 14:53:09 +0900 https://www.shironekolabs.com/posts/garbage-collection-basics/ This is the start of a semi-regular series of articles I’m hoping to write, time-permitting, looking at interesting things I’ve run into, discovered, or failed miserably to comprehend whilst working on Catnip. A lot of this is going to be a bit ad-hoc, so apologies in advance for any errors or omissions - criticism or corrections are both greatly appreciated at contact@shironekolabs.com! One of the more interesting concepts in writing a C# runtime, or for that matter managed languages in general, is that of garbage collection. https://www.shironekolabs.com/posts/introducing-catnip/ Fri, 22 Mar 2019 23:42:32 -0700 https://www.shironekolabs.com/posts/introducing-catnip/ Whilst I’m not quite in a position to share lots more details and/or code yet, I thought I’d write a little bit about a project I’ve been working on for some time now. It’s called “Catnip” (sorry, cat-related project names seem to happen a lot around me!), and it’s a new implementation of the Common Language Runtime - the foundation used by C# and other languages in what is often referred to as the “. https://www.shironekolabs.com/posts/the-catnip-prototype/ Fri, 22 Mar 2019 13:42:32 -0700 https://www.shironekolabs.com/posts/the-catnip-prototype/ So having talked a bit in my previous post about the rationale behind Catnip, I’d like to jump forward and introduce some results. Catnip is very much still a prototype, and I’d like to get more of the rough edges off before I actually release any code, but I’ve got an interesting little demo that shows off some of the key features at work. This is Catnip running a little “Wolfenstein 3D”-style demo written in pure C# on a Gameboy Advance Micro (which, for reference, has a 16Mhz CPU and 256Kb of RAM):