Goals

  • Simulate the behavior of a stock using a random walk.

  • Learn to program in the TOY machine language.

  • Appreciate the programming and debugging advantages of a structured programming language over machine language!

    • Part 0:   Preparation  

  • Review the TOY lecture notes and also the more detailed Notes on TOY.

  • Copy the following files from /u/cs126/files/toy/ to an empty directory: 
    toy.c   bits.toy
    You may do this with the following command: 
    mkdir toy
cd toy
cp /u/cs126/files/toy/* .

  • To execute a TOY program first compile the TOY simulator with: 
    gcc126 toy.c
    Then, simulate your TOY program with: 
    a.out < bits.toy

  • Or if you prefer, you can use the Java TOY simulator from lecture. (Our experience is that most students prefer the C simulator.) This enables you to step through your program one instruction at a time. The downside is that the input format does not currently support comments. (Sorry, it's on the to-do list, but it's rather annoying to do in Java. Any volunteers?) To use the Java simulator, copy the file toy.html to your machine, and edit accordingly.

    • Part 1:   option.toy

    For this assignment you will write a TOY machine language program. You will not have to write any C code.

  • You may find it useful to use the sample TOY program bits.toy as a starting point, and build from there. It prints out 30 pseudo-random bits using a linear feedback shift register. (The TOY simulator also prints out a "core dump", i.e., a listing of all the registers and the nonzero main memory locations. You may find this useful in debugging, e.g., to make sure your TOY code was read in properly.) Pay careful attention to the mechanics of a "for-loop" since you will have to write one later.

  • Here's a few hints for getting started.

  • Step 0. Write pseudocode on paper (or write an analogous C program), and figure out which registers will get used for each task.

  • Step 1. Modify bits.toy so that it perform 1 experiment. Initialize one register, say R4, to the hex equivalent of $50. Then increment or decrement R4 thirty times, depending on the value returned by the LFBSR function call. If you print R4, you should get the following output.

  • Step 2. Determine the value of the option: it is the maximum of 0 and R4 - 55.

  • Step 3. Repeat this experiment 255 times. Here are the cumulative profits after each experiment. An estimate of the option's expected value is the last value divided by 255. Note: you are not required to write TOY code to compute this value.

    • Debugging Hints

    Here are some debugging hints that may help you out.

  • Remember that all values, "line numbers", and arithmetic are in hex. This is by far the most common error.

  • The pc is initially set to 10, so this should be the first line of your TOY program.

  • Comment your TOY code. Also, this may sound silly, but don't accidentally update your comments and forget to update the actual code! The Java simulator does not currently support comments, but be sure to include them in your final submission.

  • You have only 8 registers to work with, so you may need to reuse some registers for different purposes. Be grateful that you have 8; many early computers had only 2, so you would need to store variables in memory, and transfer them back and forth to the registers as needed. Recall that there is no register R8, and that all registers are global variables, so be careful.

  • Check the initial "core dump" to be sure that your program was read in correctly. This will fix common errors like having two or more instructions with the same line number, or forgetting the colon after the memory address.

  • Watch out for jump statements - if you insert a new line of code between existing lines, the location that you want to jump to may change. Also, after updating the line numbers, check that there are no inadvertent "gaps" in line numbering. You need to be careful to use consecutive "line numbers", since if you don't specify the initial contents of some memory address, it is set to 0000 which means halt. You may use "dummy" instructions as in the TOY notes.

  • If you use the C version of the TOY simulator, use opcode 4 to print out the value of a particular register. This is the analog of printf() debugging in C. In the Java version, the output goes to the Java console. To view this in Netscape 4.7, select Communicator-Tools-Java Console; in IE 5, select Tools-Internet Options-Advanced-Java Console Enabled.

  • If you are using the C version of the simulator, you may find it helpful to add extra dump() and dumpreg() commands in the simulator for debugging.

    • Submission and readme

  • Use the following submit command: 
    submit126 5 readme option.toy
    Do not use different file names.

  • Your option.toy program should be amply commented. It should also be cleaned up so that the only system call instructions (opcode 4) are to print out the 255 successive sums (the ith successive sum is the total profit obtained in the first i option experiments). You will lose points if you don't follow these instructions.

  • The readme file should contain the following information. Here is a readme template.

  • Name, precept number.

  • High level description of code,any serious problems you encountered, and whatever outside help that you received.

  • Include a table indicating what each of the registers are used for.

  • Give your estimate of the value of 1 option in dollars and cents. Use a calculator to do the division. (If you feel adventuresome, feel free to write TOY code to do it.)

  • Indicate whether you used the C or Java TOY simulator to develop your code.


    • Kevin Wayne