Current Architectures
Some current computer architectures include:
Task 2
Address Bus – The address bus (that may be 8, 16 or 32 bits wide) and sends an address to memory.
Data Bus – The data bus (that maybe 8, 16 or 32 bits wide) and can send/receive data to/from memory.
3-State Buffer – A tri-state buffer can pass a 1, o a 0 or it can essentially disconnect its output. A tri-state buffer allows multiple outputs to connect to a wire, but only one of them to actually drive a 1 or a 0 onto the line.
Program Counter – The program counter holds the memory address of the current location in the program.
Address Latch – The Address latch holds the memory address that data is to be read from or written to.
Register A, B, C – These registers simply hold data values, A and B are data values ready to be manipulated by the ALU and C is the output.
ALU – The ALU performs functions like subtraction, multiplication, division and other functions on up to 64 bits at a time.
Instruction Register – A special storage location in which addresses of the instructions are stored in order to control their sequential retrieval from memory during the execution of a program.
Instruction Decoder – The Instruction Decoder interprets and implements the instruction.
Memory
There are a number of different ways data is saved into memory on a computer, and many different types of memory, three of these types are:
ROM – Form of computer that does not lose its contents when the power supply is cut off and that is not rewritable once it is manufactured or written. It is generally employed for programs designed for repeated use without modification for example, BIOS.
SRAM – A fast memory technology that requires power to hold its content. Static RAM (SRAM, S-RAM) is used for high-speed registers, caches and relatively small memory banks such as a frame buffer on a display adapter.
DRAM – The most common type of computer memory. Dynamic RAM (DRAM, D-RAM) chips are very dense because they use only one transistor and one storage capacitor for each bit.
Pipelining (Wikipedia n.d.)
Pipelining is a procedure for processing instructions more rapidly, in which each instruction is split into numerous stages. In the diagram above there are 4 different instructions to be executed and the table to the right shows what the first 4 cycles do.
Parallel Processing
The simultaneous use of more than one CPU to execute a program. Ideally, parallel processing makes a program run faster because there are more engines (CPUs) running it. In practice, it is often difficult to divide a program in such a way that separate CPUs can execute different portions without interfering with each other. Most computers have just one CPU, but some models have several. There are even computers with thousands of CPUs. With single-CPU computers, it is possible to perform parallel processing by connecting the computers in a network. However, this type of parallel processing requires very sophisticated software called distributed processing software.
Task 3
A program written for this microprocessor consists of the following 4 instructions (shown in hex):
01000250
02000254
06000000
05000258
Fetch – Decode – Execute
Fetch
00020C > Program Counter
Enable Program Counter Tri-state
Enable Data In Tri-state
Set Read line
Enable Instruction Register for input
Read contents of memory at 00020C
Place Data In Bus
05000258 > Instruction Register
Decode
Enable Register C Tri-state
Enable Address Latch for input
Enable Address Latch Tri-state
Enable Data Out Tri-state
Set Write Line
Execute
000258 > Address Latch
000001FF > Data Bus
Write contents of Data Bus into Memory Address > 000258
Increment Program Counter > 000210
Task 4
Core Duo vs. G5 (Anandtech n.d.)
At the heart of today's comparison are two processors, Intel's Core Duo and IBM's PowerPC 970FX, otherwise known as the G5.
The G5 is considered virtually the best of both worlds, a very wide superscalar CPU that is also very deeply pipelined. While these characteristics give the G5 a fairly competitive performance profile, they also make it quite power hungry (particularly the pipeline depth). But thanks to still being stuck with a small 512KB L2 cache, the G5 only weighs in at a meagre 58 million transistors with the 90nm die taking up 66 mm2.
The Core Duo, on the other hand, is composed of 151.6 million transistors, 2.6x the number of transistors in the G5. But because it was built on Intel's 65nm process, the die size is still quite reasonable at 90.24 mm2. Most importantly, the Core Duo is based on a very power optimized mobile architecture, so it should have the power consumption advantage as well.
These processors have needed to be compared, the G5 to x86 processors, for a while now, but there was always the problem of achieving equal platforms. Thankfully, Apple has two iMacs, one based on the Core Duo and one based on the G5, that are virtually identical, thus facilitating our comparison.
From the end-user's standpoint, it's virtually impossible to tell the G5 from the Core Duo iMac. If you look at the right preference panels or open up the system profiler, it is obvious; but from normal application usage and interaction, the transition is truly seamless (which is very impressive considering that they completely changed CPU architectures).
Obviously, the Core Duo is a dual core processor, while the G5 in the iMac is a single core, so there are inherent performance advantages in that. But one thing that surprised me was the fact that the move from a single to dual core system under OS X wasn't nearly as earth shattering of an experience as it is under Windows. The problem under Windows is that there are so many cases where you run into poor scheduling, which results in a serious reduction in performance on a single core processor, meaning that the move to dual core is quite tangible. But for whatever reason, it's a lot more difficult to tell on the iMacs.
It could be that the OS X scheduler just does a better job, or it could be that the 512MB of memory on these machines was enough of a bottleneck that I couldn't really gauge the improvement in responsiveness, thanks to a dual core machine. My best guess is that it is a combination of both. It's not that you don't notice a benefit when moving to dual core. Rather, it's just that the difference in responsiveness isn't as great as what I was expecting. One other potential reason is that the OS X interface in general isn't particularly responsive, so it may just be that the dual core effect is dulled, thanks to a slower UI (slower compared to Windows that is).
The other thing worth pointing out is that the Core Duo based iMac offers no settings for CPU power consumption. On the iMac G5, you can set processor performance to Automatic, Highest or Reduced, giving the user the option of choosing the balance between power consumption and CPU performance. On the Core Duo based iMac, no such setting exists, presumably because the CPU seems to manage the balance very well on its own. In theory, the G5's Automatic setting should be the same, behaving a lot like Cool'n'Quiet on an AMD system (or EIST on an Intel system). It should barely impact performance by fulfilling CPU demand when necessary and really kicking in during idle or low use periods; the problem is that this isn't always the case.
For the majority of performance tests that I conducted on the iMacs, leaving the G5 set to Automatic actually gave me performance within about 3% of the system's performance if I set the energy saver setting to Highest. However, there were some benchmarks where the iMac incorrectly would not increase CPU frequency in order to accommodate a very high demand task. The best example that I could find was my QuickTime Pro 7 H.264 encoding test. With the G5 running in Automatic mode, the test took over 25 minutes to complete, compared to 9.8 minutes for the Core Duo. Setting the processor performance to Highest, the G5's time dropped down to a more respectable 12.3 minutes, a reduction of more than 50%! The goal of the Automatic processor performance setting should be to crank up CPU frequency when it's needed, and scale it back when it's not. The results that I saw in my QuickTime test show that it fails at that goal in a major way, which isn't acceptable. There were a few other isolated cases where the same was true, forcing me to leave the iMac G5 in its highest performance state for all of my performance tests.
In conclusion to this review I found that the Core Duo processor is far more effective and is even slightly cheaper than the G5 version.
Bibliography
Anandtech. http://www.anandtech.com/mac/showdoc.aspx?i=2685&p=6.
Wikipedia. http://en.wikipedia.org/wiki/Instruction_pipeline.
Wikipedia. http://en.wikipedia.org/wiki/Von_Neumann_architecture.
Note: all tests for Task 4 were carried out by a third party and not by the author of this document.