The physical architecture of the memory is as follows:
The green highlight on the top left and orange on the bottom are the two buffers. The green for the byte values , and orange for the chunk address in which the bytes will be stored to. The red highlight is the actual location of data storage with the yellow underneath being the address bus and decoders. The values buffer stores the same number of bits as the chunks do (in the above image a chunk contains 2 bytes , a byte containing 4 bits, except for the address, which for now is 3 bit). Once the Bytes and address values are filled, they are released. The address goes to the respective chunk which then calls 3 functions:
eraseByteValue()
openByteShutter()
read()
void read() {
if (readInputValue == YES)
openReadShutter();
}
p.s This is what a shutter is:
| Its basicly a vertical nand gate (ignore the two not gates at the top). |
eraseByteValue() erases the previous values stored making way for the new. openByteShutter() opens the shutter to allow the values from the byte value buffer in (The image above is precisely that shutter, the row of blocks at the top is the value from the buffer, the control is the signal sent by openByteShutter() and the top of the flip-flop is visible at the bottom). Read() is also called but as shown in the function definition unless the read line value is on, it will not execute reading.
The openByteShutter() function definition is as follows:
void openByteShutter() {
usePulseLengh(1tick);
int i;
while (i <= # of bytes in chunk)
sendPulseTo(byte i);
wait(5tick);
}
The chunk opens a shutter to a single byte for a certain amount of time (defined by pulse length), then waits for a certain amount of time before opening the shutter to the next byte. The delay between the opening of byte shutters is a safety to prevent data from going everywhere in a mess of uncoordinatedness. This brings out the problem of timing, the value of the bytes in the buffer must be precisely transported to the proper bytes in memory. This is visualized below in its full glory.
This chart shows the sequence of events from the point of view of the components and the amount of time they take to send the signal to the next. It starts when the buffers are filled and the memory is ready to write there for sending a signal to “input”. The units that should be combined with the numbers are redstone ticks. “Exposure” describes the values going into the open shutters. The pulse length and delay between the pulses of byte value sent to the bus is precisely timed so that they synchronize with the opening and closing of the byte shutters in the memory. The amount of time it takes to write into memory can be shortened but increases the chance of a glitch. For instance, I gave the override delay (which is to prevent the new values coming in from accidentally being erased upon entry) a overly generous 7 ticks when it should only need about 2 ticks. (optimization can come later)
Byte functions, in order of read, write and erase are controlled via a chunk, or a collection of bytes. Because of this the memory can handle most of its own data management and still occupy a smaller amount of space. This is because memory is controlled in chunks thus reducing the data storage to data management ratio.
The drawback to this system is that through controlling the memory via chunks, you are forced to read by chunk and thus requiring a temporary storage component to transfer the read data into. This makes chunk controlled memory more viable to be used as a long term storage component rather then a temporary storage.
The bit storage is comprised of a flip – flop between two shutters and buses on ether side. The flip – flop control is used when erasing the bit.
The following image shows a exploded version of the bit storage and the sequence of events the component might see in a single cycle.
Computer Science 