Over the past few years, there has been an explosion of use for computers technology. Computers are now in almost every aspect of our daily lives!

This is due to two major factors- convenience and usefulness. Technology like the smartphone you have here with you right now is a perfect example of this.

Computers used to be very expensive, but not anymore! Due to lower costs and wider availability, they have become ubiquitous.

So how do all these gadgets work? That’s what we’re going to talk about today! We’ll take a look at some different computer architectures and how memory is accessed in each one.

We’ll also compare the x86 architecture, which most people are familiar with, to another common set of rules: ARM.

What is RAM (Random Access Memory)?

Memory is something that computers use to store information. More complex machines have more complicated ways to access this information.

In simpler machines, whatever bits of data stored in memory can be read, written, or both simultaneously using a device called a register. Registers make it easy to save time by accessing the same piece of data over and over again.

For instance, if you need to remember someone’s phone number, you could put their phone number into a register so you don’t have to write it out repeatedly.

Computer memories come in several varieties.

Memory-level caches

Another way to reduce latency is through what are called memory level caches. This can be done at two levels of software, which we will look at now.

At the first layer are things like CPU registers that hold information specific to an operation. These are very fast, typically having less than one nanosecond access time. Examples of this type of cache include general purpose registers such as AL, AX, or EAX, or special purpose ones such as program counters or frame buffers (which store recently accessed pixels so they do not have to be loaded from RAM).

The second level of caching comes after these register-level caches. A common example of this is when you want to perform a calculation. Rather than loading all of the numbers into registers before doing the math, it is much faster to add them together in a buffer and then do the calculations. When the result of the equation is known, the data is retrieved from the cache and put back into use.

This technique is how most modern processors work. By adding additional layers of caching between the CPU and main memory, computer designers were able to make computers many times more powerful while using the same amount of power.

Instruction-level caches

Another way to speed up your computer is by using an architecture that uses something called rasterizing as its basic computational engine. This type of processing breaks down large pieces of information into small chunks, or pixels, which are then stored as pictures in memory.

Computer programs such as Photoshop use this type of technology to process images very quickly. By only storing part of the image in memory at one time, computers can save space and time.

This type of cacheing is done at the level of instructions instead of individual numbers. Computer processors have long used instruction caches to help these engines run faster.

The term “rasterize” comes from how printers work. Printers scan lines of color across horizontal bars, so they must keep track of what colors are already printed and what new colors need to be added.

Instruction caches do just that for CPUs.

Memory address translation

When it comes to computer memory, there are two main types of technology that computers use- binary bit storage (1s and 0s) and trinary electronic charge (or levels) to represent information. Computers typically have very large amounts of both types of memory, but they are not easily accessible to users.

With respect to software, most programs can access RAM (randomly stored data) as read/write memory. This means that the program has direct access to the bits of information and is able to move them around, add new ones, or take away others.

The problem with this type of memory is that it is expensive! It takes lots of energy to produce enough electrons to store each bit, and electrical current must be constantly supplied to maintain these memories. In addition, due to the relatively small size of individual bits, a lot of transistors are needed to connect all of the memory together.

Traditionally, the way people accessed more advanced memory was by using special chips called microprocessors. These devices contained many transistors connected into logic circuits to perform complex calculations. They also had internal registers for short term storage of information.

By storing frequently used information in internal registers, microprocessor chip designers were able to reduce the amount of time it took to pass messages between the register and the next part of the processor device. This allowed for faster processing speeds.

Physical memory addresses

The next level of computer memory is what we refer to as physical address space. These are just plain old numbers that computers use to reference their internal components, such as registers or hard disks.

Physical addresses work similarly to house numbers for houses – they’re used to identify a location. Only this time, the locations may not be houses, but rather pieces of hardware (like a register) within your computer.

A logical explanation of why there are different types of RAM comes down to how fast each type can process information. Intel and AMD processors have separate memories optimized for different things, like working with large amounts of data or doing heavy mathematical calculations.

This article will focus mostly on the differences between DRAM (dynamic random access memory), SRAM (static random access memory) and GPU (graphics processing unit) memory.

Virtual memory addresses

Another way to think about how computer memories are accessed is by thinking about virtual address space instead of physical address space.

With this approach, rather than having one large chunk of RAM that contains all the programs we have, there is only enough room for as many applications as will fit into a certain amount of RAM.

Each application gets its own little piece of RAM where it can store information and data. The operating system uses software algorithms to move things around within these pieces of RAM so that each app has its own place to keep files, apps, or even whole directories.

This algorithm is what makes your computer run faster because it does not need to look up every location in the OS constantly. It knows where everything is stored, and can access it quickly when needed!

Virtual memory
is just another term for computer memory. Just like with real memory, there is no actual storage component to a virtual address space. What you get to use at any given time is the “space” represented by that virtual address.

In other words, if you have a 1 gigabyte hard drive, then there is an infinite number of bytes that make up that 1GB (one billion bytes). However, most people do not have access to 1TB worth of storage, which is why they limit themselves to something smaller.

Translation look-aside buffers

In addition to using registers as short term memory, some architectures have an additional layer of cache that can be used for this purpose. This type of cache is called a translation look aside buffer (TLB) or instruction caching buffer.

The TLB holds instructions fetched from RAM so that they do not need to first be translated into machine code. Once again, it uses internal registers to maintain its contents.

By having separate caches for each level of processing, we are giving your CPU more places to store information while also improving performance by reducing latency.

This article will go over how these different types of caches work for both x86 and ARM processors.

Memory banks

In most computer architectures, memory is separated into different “memory banks” that are independently accessible. This allows you to have two separate computers inside of your device with their own independent memories.

Computer processors work by switching ON and OFF various components within the processor. These components require energy to operate, and more powerful processors need more power!

By having multiple distinct memory banks, each bank can be connected to it’s own source of electricity which saves space and weight because you don’t need a bulky battery pack like you would if you only had one large tank of stored energy- just connect this pipe to an electrical socket and you’re good to go!

This also helps save money as you no longer need to buy expensive batteries that retain less charge than what manufacturers recommend. The truth is, some people put too much stock in these recommendations and spend lots of money buying replacements every time there is a low amount of charge left in the original product.

By having individual memory tanks you avoid this cost by not needing to replace them as often.

Memory chips

The way that most computer programs access memory is by using an interface called RAM, or random access memory. This is because you can directly read from or write to any part of the memory chip, making it easy to locate specific pieces of information such as numbers or strings.

Computer processors are designed to work with large chunks of memory, which is why most computers have several gigabytes (1024^2) of storage space. Some even have tens of gigabytes!

However, not every program needs a lot of memory. In fact, some apps only need a few hundred bytes at times. For example, someone could create an app like Keeptrack, where users can save notes and dates all throughout the day. Only very rarely does this app need more than a few kilobytes of data.

Because there is no cost to accessing empty parts of a memory chip, many CPUs use a technique called virtual memory to manage how much memory an app has available to it.

By creating an area of memory that seems blank, the CPU assumes that this area is already full of useful information that the app has accessed before. When the app needs to allocate additional memory, the software simply assigns its own location as “unknown” or “free” space.

The OS then goes ahead and uses the un-assigned memory for something else. Because these areas seem unused, other processes do not notice when your app gets larger allocations of memory.