This is a list of some of the projects that final-year and MSc students may undertake. Projects are allocated on a first-come first-served basis. However, I am willing to discuss alternative projects and to accept modifications of these projects.
Cache memory Simulator
Over the past few years, the speed of microprocessors has increased faster than the speed of semiconductor memories. The effective speed of memory can be increased by using a small amount of high-speed cache memory to hold frequently accessed data and instructions.
The purpose of this project is to create a cache memory simulator in order to analyze the effect of changing a cache's parameters (size, organization, line size). Ideally, the simulator would be written as a Java applet.
Address and Data Simulator
Computers generate addresses and either read data from memory or write data to memory. Instructions are read from memory sequentially, unless a branch or jump instruction modifies the flow of control.
Cache memory systems rely on the "locality of reference" of data; that is, data elements are frequently accessed from locations that are close together.
The goal of this project is to produce a CPU simulator that generates random addresses and data to simulate a real processor. The simulator can be programmed to behave in various modes. You can select how clustered the data is, the frequency of subroutine calls, the size of subroutines, and so on.
Advanced Processor Simulator
There have been two trends in computer design. One is towards simplicity and cut-down instruction sets (the RISC trend) and the other is towards complexity and powerful instructions (the CISC trend).
The goal of this project is to design a simulator for a sophisticated architecture that implements advanced addressing modes (e.g., memory indirect with indexing) and complex instructions such as bit field operations. The user should be able to enter instructions in mnemonic form and the simulator will execute them.
In order to keep the project simple, the number of different instructions can be kept small.
68000 Monitor
Chapter 11 of "Microprocessor Systems Design" includes a simple 68000 monitor (control program or simple operating system) that enables you to test a single-board computer. This code was written in 68000 assembly language.
The goal of this project is to construct a more sophisticated monitor with greater functionality. Ideally, this monitor should be written in C and compiled to 68000 code.
Real-time Kernel for a 68K-based Single-board Computer
The purpose of this project is to design and construct a real-time kernel that switches between tasks in a multitasking environment. The kernel should be written in C and compiled to 68K code. The project must include the design of the task-switching system and include means of creating and removing tasks. The system must support prioritized tasks, communication between tasks, and dynamic task creation.
Pilot’s Intelligent Knee-pad
A private pilot in a single-engine aircraft has to fly, navigate, and communicate with air traffic control, ATC, all at the same time. These operations have to be performed without the benefit of a copilot or an autopilot.
The objective of this project is to design a special-purpose computer that can be used to remove some of the load from the pilot. The computer will store the information supplied by ATC and perform aviation-related calculations (e.g., the current location). The computer will contain a data-base of information about other airports and the pilot will be able to find important information rapidly (e.g., the approach frequency of an airport or the length of its runways).
The computer to be designed will be, essentially, a special-purpose notebook computer. For the purposes of the project, this computer will be simulated on a PC.
An important part of the project will be the ergonomic and HCI considerations. Any successful system must be easy to use. A good system should anticipate the pilot’s needs (e.g., by making periodic suggestions).
Assembly Language Teaching Aid
Almost all computer science courses include a first-year component on computer architecture and assembly language programming. Some students regard assembly language programming as difficult and find it hard to visualize what is happening as an assembly language program is executed.
This project requires the design of a CPU simulator that can execute a simple assembly language program. The flow of information within the CPU should be shown as the program is executed.
The user should be able to operate at the microprogram level (i.e., the execution of each instruction in terms of operations within the CPU), or at the macroprogram level (i.e., the machine level instructions).
The final system should be able to display the CPU’s registers and the contents of a block of memory. A good system will also provide interactive, context-sensitive help.
Computerized Student Testing System
Monitoring the performance of students is very time-consuming because it is so labour-intensive. The goal of this project is to devise an automated means of testing a student’s knowledge of computer arithmetic, computer logic and computer architecture.
The system will generate questions at random from a database. Some questions will be factual, multi-choice questions. Some will require an exact answer. For example, the computer may generate a random 8-bit binary integer and the student will be asked to convert it into a decimal value.
The testing system should be diagnostic and locate the student’s problems. For example, if a students performs well in one area, further questions at the same level in the same area will not be asked. If a student performs baldly in one area, the region of "uncertainty" will be probed.
CPU Visualization
One of the areas of computer science that students find most difficult is the operation of the CPU at the machine level (i.e., the fetch/execute cycle and the role of the buses and registers)
The operation of the CPU is a good candidate for visualization. The aim of this project is to construct an interactive system that explains the operation of a simple CPU. The user should be able to observe the flow of information within the CPU and be able to zoom in on or expand internal operations (that is, they should be able to control the level of the detail).
The project will involve examining the CPU and determining the "conceptual bottlenecks" before constructing and implementing a system.
Map Manipulation
Pilots in light aircraft normally have to perform their own navigation and receive relatively little help from air traffic control. Many pilots use specially designed aviation maps to perform their navigation. However, such maps suffer from limitations. The scale and level of detail is fixed. Moreover, if you orient a map in the direction of flight, the text might be upside down.
Since laptop PCs are widely available, it seems reasonable to use a laptop as a display device. A computer-based map can be constructed to provide a variable scale (you need more detail approaching an airport than when en route). Names and features can be added or removed to reduce clutter. Moreover, the map can be designed so that text does not change as the map is rotated (i.e., the up direction can be the direction of flight without changing and text).
Automatic Terrain Generation
Computer techniques involving fractals and similar mechanisms can be used to construct random landscapes. Such landscapes can be used in simulators for various environments (e.g., computer games, flight simulators).
The goal of this project is to construct a general-purpose landscape simulator (by, for example, using "plasma techniques"). The user should be able to control the general nature of the landscape by selecting appropriate parameters.
The depth and the general direction of this project will be determined by the student. Some students might wish to add features to the landscape and others might wish to concentrate on the texture of the landscape.
Simulating a Novel Architecture
There is remarkably little variation between the structure and instruction sets of many microprocessors.
The purpose of this project is to construct a new microprocessor architecture with novel features. Some of these will be suggested by myself (e.g., support for high-level language constructs). Others will be suggested by the student after reading literature on computer organization.
Once an architecture has been constructed, the second part of the project will be to implement it in software. This will involve the design of a simple simulator that can execute a program written in the machine code of this new processor.
A Timing Diagram Generator
A timing diagram displays the relationship between the signals in a digital system as a function of time, and is used by engineers wishing to interface memory and peripheral components to a microprocessor.
The purpose of this project is to design an animated timing diagram generator that demonstrates the sequence of events that the timing diagram illustrated. In other words, the project is concerned with taking a static diagram and animating it in order to show the reader the sequence of events that the diagram illustrates.
Any student underrating this problem should have some knowledge of graphics programming.
Software to Support Teaching Computer Architecture
Students find some topics are harder to understand than others (for example, the subject of addressing modes is regarded as notoriously difficult).
A simple textual description of a topic (with diagrams) does not suit all students-particularly when the topic is conceptually difficult to understand. Hypertext systems help a little by enabling the user to seek details at a higher or lower level. Keywords are highlighted and the user can seek further detail by selecting and clicking on such an element.
When people explain things to each other verbally the often ask "why" or "how". The aim of this project is to produce a lesson that covers some suitably complex topic. The system will automatically generate suitable "how", "why" and "what if" questions at appropriate points in the lesson.
If time permits, some elements of the project should be animated to demonstrate sequences of events and the relationship between cause and effect.
Advanced Architecture Simulator
A complex processor architecture (unlike the CISC) has a rich instruction set in terms of addressing modes and instructions.
The aim of this project is to simulate such a processor so that students can contrast it with RISC processors. This "complex" processor does not require a full instruction set because it is intended only to demonstrate certain principles. The computer should interpret instructions directly (i.e., the assembly language does not need to be converted into machine code).
If possible, the simulation should be done in Java in order to convert the simulator into an applet that students can access from the Internet. However, this simulator could also be written in one of the "visual" languages.
Road Traffic Simulator
From personal experience it appears that the flow of traffic on a highway is a sensitive function of its volume. When the traffic density reaches a certain level, hold-ups begin to appear.
This effect is caused by one car slowing and setting up a chain reaction in the vehicles behind.
The aim of this project is to construct a visual road traffic simulator. The number and characteristics of the vehicles should be programmable (e.g., the range of reaction times of the drivers, the type of vehicles, the skill of the drivers, the effect of obstacles, etc).
The simulator should be capable of testing ways of improving traffic flow (e.g., limiting the number of vehicles that can enter a junction over a given period).
Flight Scenario Tester
Pilots use flight simulators to test their ability to fly. Unfortunately, the difficulty of flying the aircraft sometimes gets in the way of the simulation. This is particularly true of "instrument flying" when the pilot is so busy trying to fly the simulator that he or she doesn't have time to deal with the navigational aspects of the flight. "Instrument flight" indicates flight that is carried out by reference to instruments alone and that does not rely of visual cues (e.g., flight in cloud).
The aim of this project is to construct a flight simulator where the aircraft flies itself. The user (pilot) is able to enter the direction of flight from the keyboard and the aircraft flies automatically in the selected direction. The pilot will get feedback from the various simulated navigational aids. The principal purpose of this simulator is to help the pilot to visualize his or her position by interpreting the navigational aids.
The simulator will take account of the affects of wind (which will have to be modeled).
This system is called a "scenario tester" because the user will be able to investigate what will happen if they perform certain actions (e.g., they can check whether they have estimated the effect of wind-drift accurately during the hold).
The output of the simulator will be the path that the aircraft follows over the ground (there will be no view from the cockpit).
Digital Filter Simulator
Analog signals can be sampled, converted into digital form, and stored in a digital computer as a sequence of numerical values. Once these values have been stored in the computer, they can be processed just like any other data. After processing, the digital signals can be converted back into analog form.
Digital signal processing can be applied to these stored values to modify the characteristics of the signal. For example, y = xi + kxi-j represents the ith sample of a signal plus a fraction of the signal j samples earlier. This expression represents an "echo".
The aim of this project is to construct a test bed (using a visual environment) that allows users to examine the effect of digital filters. Filter coefficients (e.g., k and j in the last example) should be modified by graphical objects such as sliders.
The project can be extended to include digital control systems.
Microprogram Simulator
A CPU can be implemented by means of microprogramming in which each machine level (i.e., assembly language) instruction is converted into a series of even more primitive micro-instructions. These micro-instructions directly control the registers, buses, and functional units of the computer.
The aim of the project is to create and to simulate an architecture consisting of registers and buses etc, and a microprogrammed control unit that can control these units.
The user of the simulator will be able to define machine-level instructions in terms of micro-operations. These micro-operations will be executed, step-by-step on the simulated target machine. The user should be able to display either the macro-level machine (i.e., the buses and registers) or the micro-level machine (i.e., the microprogram, control store, micro-program counter, micro-instruction register).
No comments:
Post a Comment