The only thing missing from this is what helped me a ton, trying to understand negative integers (2's complement): The "sign" bit is not a true sign bit, like in floating point numbers; that would imply there's a positive and a negative 0. Mathematically, the "sign" bit is actually interpreted as -(2^n) instead of +(2^n), where n is the bit position. so 1000 in binary is -8 instead of +8. All the other bits' interpretation stays the same: 1011 is 1 + 2 + 0 + (-8) = -5
Treating the value of the sign bit as -(2^n) instead of +(2^n) is very clever! That's a great way of formalizing this in a very streamlined manner. Very cool 😎
always extremely well described. My brain hasn't formally tackled digital electronics in over 25 years but the quality of the descriptions is bringing it all back to the fore.
I've watched many people explain 2s compliment with varying levels of success. This video is now my go-to option if I ever find the need to explain it or just remind myself. Well done!!! 👌
Hot take, this is the best 2's complement lesson on the internet. This whole series is incredible o7. I'm just a hobbyist but still never knew how straightforward it is to implement subtraction in hardware, this whole series is keeping me in a state of bewildered awe at what is going on inside CPUs. One thing I'm having trouble with is seeing the register value led's...could a small piece of paper or cardboard be taped above them to keep them in shadow so they have better contrast for the camera? The manually added text next to them totally works though, thanks for doing all of that extra work.
Thank you so much for all the praise 😀🙌. Great idea about the LEDs... I could try with a red transparent film that blocks out other light, to make it easier to read. 👍
@@fabianschuiki Another idea for the leds that I've done is gone to a window tint shop and ask for a scrap of their lightest material. They gave me a huge piece that I cut up and clear-glued overtop of 4 digit 7 segment displays for my Arduino timer projects and they work great no matter the color of the leds. Still no need with the extra text you're adding so thanks again for all the effort you're putting into this series!
Thanks for your excellent series! It's perfectly complementary to Ben Eaters SAP-CPU. I already learned so much and can't wait to see the optimisations which makes it superscalar.
Thanks! I'm glad you're enjoying it. We should get around to the first superscalar bits soon. Need to finish the ALU and get some instruction decoding going. Then it's off to the out-of-order races 😃
I take issue with the description of "fake numbers", what is really happening is that we picked a way to represent negative numbers that exploit a quirk of binary math to simplify the handling of negative numbers and subtraction. There is no rule that says we must use the topmost bit a sign bit, we could use and external flag to do it, which would change the design a bit, but would still not be "fake" negative numbers, just a different way of representing them. Two's compliment is an ingenious way to achieve subtraction with the smallest amount of gates, but it is just a neat trick of how we choose to represent negative numbers in binary.
Yes, you're definitely correct. It's really down to assigning meaning to certain bit patterns, and picking that cleverly to make the most of pre-existing hardware. Nothing fake indeed. An interesting example of an external sign flag are standard floating point numbers, which store the sign bit separately from the actual mantissa. Also, the Apollo guidance computer had an interesting bit of one's complement arithmetic going on, which is pretty fun to see. 🙂
Modular arithmetic is most definitely _not_ a "neat trick." Seriously ask yourself whether or not it really is one the next time you try to read an analog clock. At the time of me writing this, it looks to be around -5:30 going counterclockwise, or 6:30 going clockwise. The only "neat trick" is using the left-most bit to indicate whether a number is positive or negative, even if it fails in 2 cases, which not coincidentally are the two cases that lie directly on the line of symmetry that gets reflected across when negating. 7 being -9 on the other hand is just a fact of the integers mod 16, because 7 ≡ -9 (mod 16), or "7 is congruent to -9, modulo 16".
That's arguably the best explanation and demonstration of 2's Compliment negative numbers that I've come across. Also, with this addition (or should that be subtraction 😂) are we now not Turin complete?
Thanks! 😀 There's still a bit of work ahead to make this Turing complete. It's lacking a form of conditional execution, like a branch, and some form of memory. (Although the registers technically qualify, but not quite.)
@@fabianschuiki of course, I forgot about the conditional jump. Still pondering how to implement that. There's still a spare input for the PC multiplexers. Maybe have it linked to the step input but with the step size determined by a flag. If it's set we move to the next instruction that contains the jump, it not it doubles the step size, effectively skipping the jump instruction.
That's an interesting approach! Pretty sure that would work. I was thinking about not taking the PC mode select bits directly from bits 1..0 of the instruction, but using a bit of logic to compute them. Regular instructions just leave them at 0, which results in regular stepping mode. Jumps set them to 1 or 2 for relative and absolute jumps. Conditional jumps / branches look at some register or flags, and set the PC mode select to 1 or 2 if the jump condition is true, or leave it at 0 otherwise. That would cause the PC to just step over the jump if the condition doesn't hold, and to jump otherwise.
@@fabianschuiki so basically set the PC select bits to do a standard rel/abs jump and have an additional "if then/else" bit somewhere in the instruction. If a flag is set then the PC select lines are passed through and we jump, otherwise we null them and step.
Yes exactly! And the decision whether to step or jump could be made by looking at a flag register, like in x86. That would allow the CPU to have instructions like branch-if-equal, branch-if-greater-than, etc. 🙂
