Insane Redstone Computer v4.0 Breakdown!! 😱

Hey guys leggo Massa 99er again with another video today and today we are back in the redstone computer version 4.0 world here as you guys can probably see a lot of you guys have seen this but yeah I am back in this world today and you might be asking why and the reason

Is is that I am going to be doing a video breaking down and explaining how this big mess and contraption of redstone actually works how it operates and everything just like I did with the redstone computer 3.0 video that I did previously so yeah without further ado let’s get

Started alright so the rights the computer for when I shares a lot of similarities with the redstone computer 3.0 but also has a lot of differences and that sort of thing and this video will be structured in a similar way compared to the redstone computer 3.0

Breakdown video that I did and if you guys haven’t seen that yet I would recommend you guys going to check that out because I explain a lot of the fundamental concepts and how the general computer model works that I use and I’ll be explaining that briefly in this video

As well but the right some computer 3.0 video covers a lot of that stuff as well so just like in the 3.0 breakdown video we will first start off with explaining everything on this UI panel and how it all works and all that stuff alright so

First we want to start off with the computer power controls and these three are also present in the Wrights 10 computer 4.0 and they basically function the same as a redstone computer 3.0 the on button essentially initializes the computer prepares it for code execution and then it also allows the clock pulse

Signal to propagate down to the cores that are enabled which I’ll talk about in a second and the core clock runs down this way I’m pretty sure right here and then it gets distributed to the different cores to initialize them and when you sleep the computer that basically just disables the the pulse

From updating the cores and then when you turn off the computer it resets all of the registers it turns off the computer officially and then also runs these settings here which I will explain in second for the software speed control here or it is a speed control in general

It works similarly to the writes and computer 3.0 except that instead of levers levers leaders we have sort of a button system here and I demoed this in my right so if you’re a 4.0 video so I’m not going to show it to you here you can

Go check that out if you haven’t seen it yeah and also in this computer this instruction set which I will go into more depth later that this computer has supports software speed control where the right stone computer 3.0 does not support that and to enable that functionality to flip the switch and

Basically what that will do is that it will start the computer or start the cores with the speed that you have selected here but you no longer have control over changing that unless you turn the computer off and then you flip the switch off and then you change the

Speed so once you flip the speed a hands overall speed control to the instruction set and the program itself and the change of speed you will have to do it through there all right so the core enabling panel here this is a pretty self-explanatory these are just e

Flip-flops and you just push the buttons to enable or disable the course and also we have the RNG toggle here and this works in the same way that the right stick you could do 3.0 is random number generator work let’s see Q let’s follow this wire down here essentially what it

Does is that it if we run all the way down here as you can see when the random number generator on it starts basically giving out random pulses and whenever the computer requests a random number generator signal or a number from the random number generator these pistons will extend enabling these signals to

Propagate through the master output bus which is which I will explain in a second but that is also covered in the write some computer 3.0 video now I know I’m referencing the other video a lot and that’s because there are a lot of similarities at both of these computers

Had like I mentioned earlier so here we have the computer input panel and this works a bit differently compared to the register on computer 3.0 in that computer you had levers and in this computer here is more of a memory system so you push one of the buttons to toggle it but you

Can’t untangle it and if the inputs essentially turn off when the computer requests any sort of computer input signal so if a program asks if computer input 1 is toggled it’ll reset after that check is done regardless of if it’s on or not and then 3 set that you can

Just press the off button like that and while we’re on that topic of user input here is our other user input panel and these are also just T flip-flops and then this connects back to the computer so you can send user input into the program which is essential all right so

On this side we have our 4 computer indicators so these are indicators that are controlled by the program and we also have our shift overflow and shift under flow lamps here and basically the shift overflow light will turn on when one of the L use or arithmetic logic

Units does a computation that exceeds the 8-bit limit which is 255 and then the shift underflow light will turn on when the ALU does a calculation that makes the answer go below zero since both of those cases this computer cannot really support that over here is the I

Guess peripheral control panel it’s not really the official name for it but these are just some options to clear stuff and reset things and as you can see here we have the reset ramonn shutdown and the reset displays on shutdown now displays includes everything on this big iron panel here I

Guess so the the screen the decimal display and the raw binary display as well and then also we have here the clear decimal display register the clear raw binary display register and then clear the display so if you just want to clear like a component of this instead

Of clearing the entire thing when the computer is turned off you can do that by pressing one of these buttons here and you can do that manually and so that just about covers all of the buttons and stuff down here but if we move up here we have the core

I guess line of code instruction info panels here and essentially what these are is that it indicates or tells the user what line of code each core is currently on if it is enabled so if we go ahead and like you know we have our checker board program turned on here I’m

Gonna turn that off because it might be lagging now if we turn the computer on and core one is enabled this this will update with the line of code so as you can see we have line 1 of code and then this should update to line 2 there we go line 2

And then line 3 so this basically gives the user visual on what line of code the computer is on without running down to the core itself and checking and maybe yeah and the computer turns off and that was the checker board program which is demoed in the redstone computer 4.0

Showcase video all right so now that we have gotten the user input panel here out of the way on how that all works and everything we’re not going to move into the breakdown of the data flow in this computer and how that works and I might

Sound like a broken record at this point but it is similar to the redstone computer 3.0 fundamentally so let’s go ahead and take a look so you’ll go ahead and go down to core 1 which I’m pretty sure this is core 1 right here and the data flow starts with the program memory

Here and essentially what happens is that when the computer turns on the first line of code gets loaded into the program memory registers which are this which is this really long green portion here and essentially what happens is that the each instruction or what each I

Guess line of code if you will not the computer has to execute will be loaded through here and once it is saved into these registers it moves on and gets decoded since all of the information for each instruction is encode or else it would be essentially impossible to have every single option

In here it would be way too impractical but everything here gets decoded and then let’s see here and I will break down that in a second and then once that happens the data and the in the opcode the operation code for the instruction is sent to the ALU so that the opcode

Which I’m going to call it is decoded in this decoder right here and that signal is sent to the cores ALU which is let me see here everything in orange right here for each core so this is for core one and then for core two and for core 30 of

Core four and these ALU support the same operations for the ALU that the writes on computer 3.0 does so we have add subtract not this is inverting nom and then left and bit shift right and once that is computed or once the instruction is finished the output will

Be pushed on to what is called the master output bus which is right here it’s just great bus and this runs down the entire computer all the way through here and essentially all of the outputs are pushed onto this bus from every single peripheral component even the ALU

And everything all merged into this bus so we have a random number generator here we have the outputs from each of the cores that are on here we have all sorts of things and where this ultimately ends up is if we follow it down here it goes all the way down to

The memory so this is the RAM here this says 31 bytes of dual read memory compared to 15 I am pretty sure of the right stone computer 3.0 and yes so once that output goes to the RAM it is usually saved here and then in the next instruction more data is usually read

From the this Ram and since I mentioned this is dual reading memory we have our read a up here and our read B so if you wanted to add two numbers you would load up number one here and then number two there and then let’s see here yeah so those inputs

Are those numbers I guess then travel around back up to the AL use again to be input so it’s basically a big loop that goes from the the RAM to the ALU to the master output bus and then back down to the RAM again and that is all controlled and how

That data moves in everything and how to manipulate that data is controlled by the instruction set which is right here which is all of this stuff that gets decoded each time the computer pulses a signal and I will break this down really quickly here so this component here is

The go-to I guess go to sections so basically each line of code has the next line of code programmed into it or a condition to determine which line of code to go to and just the lines of code to go to next are stored here so if the

Condition is true or if if a condition is true it’s in one of these and then if it’s a false if it’s in another one excuse me I can’t I can’t really talk them which I haven’t recorded in a while but and then this gets sent to a decoder

Here which basically reads that specific line of code and then we have the condition decoder here so let’s say you wanted to jump to a certain line of code if a certain condition was true you would put that condition here and there are a bunch of different conditions

Which are all listed in these signs here I will just go through all of them so some of them are at least most of them actually are arithmetic conditions that are from the ALU and then the last four here we have the computer inputs and then we have if the random number

Generator is on or not and then we have the this is what’s called the immediate input in the instruction set and essentially this is where you can send data through the program straight to the ALU so if you took a number i was stored

A ram and you wanted to add like five to it then you would put that five that constant in here to do that and then we have the ram control here so this is essentially what addresses so what essentially spaces in memory to read and

Write from which is put here and then we have our opcode operation code for the instruction so this basically tells the computer what do you want to do in this instruction so we have adds subtract not all of the ALU operations and we have some IO stuff and new with the register

Computer 4.0 is GPU stuff or GPU opcodes rather so we have GPU reset GPU drop point GPU erase point GPU granular and I will get into all of those later when we talk about the GPU on the screen I should rather just call it a plotter because there’s no real graphics

Processing here but that’s what it’s referred to in the instruction set and then here we have some these are just options this is just to essentially select options for certain opcode so for an example if we had the IO IO output instruction you would put or and here

You would encode what specific device are peripheral to output to so if you wanted to output to the decimal display up there you would first of all select IO output as your opcode and then you would specify that you want the decimal display by putting that it’s correct

Value in here and this is the cache control as I mentioned in the rights to computer 4.0 video this computer has a caching system for extra memory and faster memory and I will talk about that later as well and then over here we have more caching stuff that’s just this is

For caching the specific addresses that you want to use and that sort of thing so that is essentially a breakdown of the data flow in the computer and a little bit of a breakdown of the instruction set here for the redstone computer 4.0 all right so now that I have explained

The data flow I’m going to go ahead and break down how each one of these core is wired and how it works and each one of the four cores is essentially identical in functionality and everything so let’s go ahead and start at the input of the core so just like the redstone computer

3.0 there’s an input a Dan input B and the signals from or the data from RAM then I was talking about earlier when you read data from RAM it travels up these buses and it stopped essentially right here and as you see it won’t travel forward unless these Pistons are

Retracted which happens whenever we have any ALU opcode selected and once the data is allowed to go flow through into the ALU it goes through the ALU I guess master bus I think that’s what I called it in the right so computer 3.0 video it’s essentially the same concept the

Data runs through the entirety of the ALU and in this case it’s more compact so it runs all the way through here and then it branches off into different components of the ALU to manipulate that data on so on the left here we have the

ALU and not the ALU excuse me the adder and the subtractor I what is it in this iteration of the Redstone computer the two’s complement that is necessary to do subtraction is integrated into this ALU or I keep saying ALU adder sorry and this is also proper anguishes I’m gonna

I’m gonna say it’s Engrish yeah proper Engrish is adder here big props to him because I in my opinion this is one of the best adders out there and so that is the adder and the subtracter and then on let’s see here we have the not opcode to

Invert the signals right here just branches off and goes up here we have the bit shifting left then right I a circuit on this side on the left here and then we have the binary comparator at the very end which essentially compares the two inputs and

Sees which one is greater which one is smaller or if they’re equal and that sort of thing oh yeah with the binary compared to as well all of the signals that are sent here essentially the a equals zero B equals zero the greater than or less than and the equals to all

Of that is sent to the ALU conditional register which is right here and essentially every instruction this will update with the correct status of the numbers that are being manipulated so if I wanted to add five and seven this register would update while that that calculation is being performed the

Reduce register would update with the fact that 7 is greater than 5 and that a is not equal to zero B is not equal to 0 there is no shift overflow or yeah there’s no shift overflow and all that sort of stuff so all of those flags

Essentially are stored here and then the outputs of that essentially converge in the conditional decoder or the conditional section of the instruction set which I discussed a few minutes ago and that essentially determines whether the condition is true or not so if we want the test for a shift overflow we

Would need to this is basically a NAND gate here and both of these need to be turned off for this line to turn on which essentially means that the condition is true and for this for both of these to turn off you need to have you need to be testing for the condition

And the condition needs to be true and this condition true data comes from this ALU conditional register as well as for the computer inputs the computer inputs themselves then this just connects back up to the user input panel oh also oops I forgot one more we have the GPU point

Encoder here I will explain this when we talk about the GPU and the screen but that is also here and all of those the results from all of those calculations merge onto this gray bus that you see here I guess is the ALU output bus and this all merges to the

ALU output register which is right here and essentially what happens is that when when the data is let through it essentially computes through all devices at the same time and what happens is that based on the opcode that you’ve selected in the instruction set it will choose which output to use from the

Peripheral if that made any sense so all the data would basically be added it would be bit shifted it would be inverted it would be compared against it would be encoded in everything it would do all of that at the same time and then let’s say we wanted to do a bit shift

Left it would select the bit shift left output from the bit shifting circuit to push on to the output bus here and then that output would be saved to this register and then once it is saved there that output is pushed back on to the master output bus which runs right here

And as I explained a few minutes ago it’ll run all the way down back into memory so that is essentially how the ALU works for each core here but what the redstone computer 4.0 there is an extra component to each ALU that was not present in the right some computer 3.0

And that is the inclusion of a cache all right yeah so the rest of computer 4.0 has a cache on it and I’m pretty sure it is I think it’s four bytes of readwrite memory yes of dual read dual write memory so that is right here and let me give you a

Perspective of where the cash is so let’s go out here so this is the ALU right here this orange part here and then the gray and the orange up here is the cache so the cache essentially sits right on top of the ALU and the cache is

Deeply integrated with the ALU as well and the cache controls as I mentioned from the instructions to earlier this green these green wires here from the instruction set is essentially control if you want to save data to the cache if you want to read from it if you want to manipulate

It all that sort of thing and essentially the cache is like additional memory but the key advantage is two things rather one it is in theory faster than RAM because the cache the memory literally sits right next to the ALU compared to the memory running down

A long bus all the way down at the very physical bottom of the computer as vertical space is pretty important here and the second benefit of having a cache is that it is isolated memory so if you were running multiple cores at the same time and each core needed its individual

Memory you would use the cache because each cache is contained within its own core and you cannot share the data in cache with other cores unless you route it through Ram because the Ram is the shared memory and then you could consider the cache as individual core

Memory yeah and then you won’t have to route it through the master output bus and everything like that all right yeah so since the cache is deeply integrated with the ALU here it has to be able to basically manipulate data and always possible and a few examples of that are

When we have the data sent through from the inputs you can save it to the cache immediately and that is on this Lane I guess Lane this these watt buses up here you can save the inputs to cache you can save the outputs to cache so if we see

Here there’s also another bus that runs vertically here to the outputs of the cache to be able to write to it and then you can as with the memory or not the memory the RAM to be more specific is a dual read as well so

We can read two values at the same time to enable faster computations and yeah that’s basically it and one thing is that this memory here is solid state compared to the RAM being I guess mechanical can I say mechanical essentially the dual read Ram of the not

Delivery I’m getting all my terms mixed up I’m sorry they dual read cache the cache is in each core don’t have any Pistons in them at least the actual physical I guess the each bit of memory but in the RAM it does and that may introduce some instability with high speed signals with

Zero tic pulses and that kind of thing but yeah that is essentially the cache it is it was intended to be a very versatile and nice addition to the redstone computer to enable more efficient programming and processing of data and that sort of thing so once let’s say once your computation is

Complete from the ALU the data travels down into the master output bus and let’s say you want to go ahead and output it to one displays or that kind of thing so how would that work so essentially all of the data from all cores comes up to around here

And then it gets split off into the different possible outputs that we can use so let’s see here I’m pretty sure this is where right here or what am I trying to say there are different outputs so you can output to the parallel output port which essentially

Is like a it’s a USB port but it’s parallel which essentially means that you have all eight signals instead of just one so here’s a parallel output port you can output your data to that and then you can connect this to like some sort of other device that you’ve

Created like over here or something and you can also output it to the the decimal display and the raw binary display and that is through here I’m pretty sure these two registers so the master output bus connects to these two registers and the right line on these registers is

Controlled by the opcode we talked about earlier which is right up here io output opcode and then once you’ve selected the specific display in the options section here it will basically enable the right on that register to allow the data to go through to that and we also have the

Master output bus connecting to the GPU or the plotter and I will explain this later as well but this is where the the specific coordinate data goes compared to the I guess mass image data if you will and that is about it for peripherals and that sort of thing we

Also have the parallel input port which is connected to the master output bus as well because data that let’s say for example you had a encoder or something and that would connect to this like some sort of device you would want that data to be saved somewhere and that is how it

Is done so once the data is sent through here you can save that to memory and then manipulate it to your liking alright so now that I have broken down most of the computer that essentially a lot of those things that I just described we’re pretty similar compared

To the rights to computer 3.0 except the cache which I described a little earlier that is new on the rest of peter 4.0 but if you’ve seen the rights to computer 3.0 break down video you can see that a lot of the fundamental concepts and the model a computer model essentially of

This computer is pretty similar in fact to the writes no computer 3.0 it is just more upgraded and it’s faster and more efficient and that kind of thing but now I want to talk about the big elephant in the room here the new the most obvious new additions to the computer and that

Is the GPU plotters the display thing here and in the red some computer 3.0 I was not able to include a plotter because I essentially didn’t have enough space and everything I don’t plan for that kind of thing but in this computer I made sure that I was able to get this in

And I did and I want to explain how this whole thing works alright so to start off we are going to go ahead and head back to the opcode decoder of each core or at least four core one here as an example and as I mentioned earlier we

Have four specific op codes for controlling the plotter and what is put on the screen that is GPU reset GPU drop point and GPU erase point and GPU granular so the GPU reset this is pretty self-explanatory this just sends a signal to the GPU to be to clear the screen essentially and

That’ll wipe all of the pixel data off of the screen and then we have the GPU drop point and erase point commands or op codes and essentially what this will do is that this will enable a specific coordinate to be sent to the GPU since the screen is 15 by 15 every

Single pixel on here can be encoded into an 8-bit number which is oh so convenient it’s not like I plan that or anything but essentially how you send this encoded coordinate to the GPU it takes a multitude of steps but we will start off in the RAM here so let’s say

You wanted to encode the point 5 comma 7 so what you would do is that you would read the numbers 5 and 7 from RAM and then that would propagate up through these buses into the input of the core or input of the ALU here rather or just

The yeah the core in general and this signal will be sent through to the GPU encoder which I mentioned I would talk about and here we are talking about it so this is a GPU point encoder and essentially what this does is that since

The screen is only a 15 by 15 there only you know can be 15 by 15 amount of pixels so what it’ll do is that it’ll take each a bit input and have it has it split in half and take one half from the first input and one half from the second input

And combine them into one 8-bit number so for example if we had five column of seven the GPU point encoder would take that five which is only encoding three bits out of four and it would put that in the first part of a new 8-bit number

And then seven it would also do the same thing so now you have those two numbers five and seven in one 8-bit number which is then once it’s encoded is sent back to the output of the ALU and saved in the register and then if you want to

Draw a certain point or erase a certain point now that that point is encoded all you have to do is send it to the GPU so that encoded point will be sent on to the master output bus and it would make its way onto this bus right here where

It basically makes its way into the GPU controller which is back here and I will go in more depth into that in a minute and once that encoded point and sense and you have a drop point or erase point command it will be executed and then you will see that point essentially appear

Or disappear on the screen alright so that covers three GPU op codes but the fourth GPU opcode here that we have is GPU granular now this is a pretty data intensive opcode and that is the only function of let me see if I can get through here of this massive 30 bit bus

Right here that you see that runs into the GPU plotter and all that stuff and it’s connected to all four cores as you can see here so it is a pretty massive number and it carries a massive amount of data to say the least alright so how does this GPU granular

Opcode work specifically well you can send to specific points of X and y coordinate data to the GPU all at once instead of sending it individually one time like you would with the drop point and erase point op codes so for example if I wanted to draw an entire line on

The GPU at one time instead of drawing each and every single point on that line we would be able to use the GPU granular opcode and the way that works is that you just toggle the opcode here and then you input your image data in the

Instruction set in the 30 bit gray bus so 15 bits are for X and 15 bits are for Y and that corresponds for each for each position rather on the x and y plane for the plotter and there are some options that you also can select in the options

Component here the instruction set to do a thing called fill X or fill Y and essentially that is filling certain points excuse me certain points of the display so if you had a point here and a point here instead of specifying to draw all the points in between in this bus

You could just say fill X and then it would fill everything in between for you so that is just a convenient little tool you can use so that is essentially how the GPU granular opcode works and that is how the checkerboard program is able to run so quickly in just 2 lines of

Code you have exactly half the screens like 128 bits or 8 or 8 bytes of image data sent to the screen and just 2 cycles which is pretty crazy because if you were to do that with the GPU and a race point and GPU drop point if you

Were to do it one at a time it would take significantly longer and you wouldn’t have I wouldn’t think you’d have enough space on one core to execute that operation so that is just shows the power of the GPU granular system that is included in the Redstone computer 4.0

All right so now that I have explained the GPU operation and how to control the GPU and everything let’s go ahead and take a look at the controller behind this thing so if we look back here we have this is essentially the same controller or the same plotter vram

Video memory that the rights to computer 3.0 has except I have modified and added some things to it and this originally has been II cubes design so I want to give him credit for that I think he makes an amazing design here and that’s why I’ve decided to use

It so let’s begin down here so the data for the specific encoded points is here and it runs down and it splits up here into decoders and these lines of four bits each because remember is only you only can have 0 through 15 so that’s for

4 bit numbers so those two encode of 4 bit numbers gets split up and then it runs through these two coders here and essentially this selects one x position and one Y position to select on the screen and then once that happens and then that actually runs through up here

So let’s see here the Y data like the see which row – right – is controlled by these wires here and then the X data runs through here and then this runs into the back of the memory and into the memory itself so this is basically a bunch of D flip-flops essentially in

Here so it’s super compact and I love it and let’s see here so that data runs into there and then we have our 4 op codes right here the GPIO so you have GPU reset that runs up into here and this essentially clears all of the memory system essentially sets or right

To zeros – every single position in the screen and then we have GPU drop point and that draws a specific point on the screen and that runs into the controller and then we have a race point and that also runs into the vram here and I had to modify

Benni cubes original vram design here to include a singular erase point option but I thought that would be necessary so that we could have a functional plotter here and then the GPU granular opcode essentially runs down here and enables the different options I was talking

About with the fill X and the fill Y and it opens all of that up so it basically allows all of these signals to run through into the VM as well and since we’re here I’ll explain how to fill X in the fill why work so essentially if you

Have two coordinates so let’s say you wanted got a coordinate here and you under coordinate there anyone to fill everything in between when you selected the fill X or the fill why it would literally if you see here there’s repeaters that are basically chained all the way down and it will essentially

Power every single input in between those two and that is how that works and then that all of that data is sent up here to be updated with the screens that can be shown on the display so that is essentially how the controller works and how the data is

Processed for the GPU and yeah another thing that is different between the rights to computers 3 point on the register computer 4.0 is that pretty obviously as you can see here this has a lot more program memory compared to the rights in computer 3.0 in the rights to

Computer 3.0 there was a there were 20 bytes not 20 bytes excuse me 20 lines of code that were in the read secure 3.0 with a hardware maximum of 31 lines of code and for the rights of computer 34.0 here excuse me there are 63 lines or 64 lines of code

Rather 6463 I’m pretty sure it’s 63 but 63 lines of code so that essentially triples the lines of code from the writes give you a 3.0 to the 4.0 so you can have much larger programs on the rights to computer 4.0 compared to the 3.0 and also another difference in the

Instruction set for the rights to computer 4.0 compared to the rights on computer 3.0 is the fact that the register computer 4.0 has the ability to change the speed of its own core through the program instead of through the user input panel here so as you can see we have four bits

Of orange space here and essentially if you want to change the speed of the core so let’s say you anticipated operations where the computer can run faster and execute those instructions faster you can change the speed in advance to speed up the computer to allow faster execution of those lines of code and

Then let’s say you have started you knew you were approaching more core or computer intensive instructions such as drawing for the GPU or doing ALU calculations you can slow down the the computer in advance the core specifically so that everything stays stable and that sort of thing alrighty so that is basically the

Entirety of the redstone computer 4.0 broken down and hopefully by the end of the video here you guys know now know at least a little better than you did before how the computer works how things are managed how the data flows through the computer how this GPU works or the

Plotter how their cache works how all of this mass of redstone comes together to make what I call a redstone computer so yeah thank you guys for watching and thank you guys for the immense amount of support that I have received throughout these past several months I know I say

It all the time but I’ve been super busy and I haven’t been able to put figures up but I’m going to start putting more videos out hopefully soon I have a lot of projects I’m working on a lot of ideas so I just want to thank you guys

For your immense amount of support throughout this time and yeah thank you guys so much I will see you guys in the next video and yeah peace guys