Out: Wed, Sep 25
Due: Mon, Sep 30 by 8:59 pm
You will first fetch a source distribution that we have prepared.
Then you will trivially modify a simple "hello world" C
application, use make to compile it, and run it
to learn the magic code. You will also run a tool that checks
your code for memory leaks and another that checks for
potential style problems.
Finally, you will package up and submit your code.
As you can probably tell, the real goal of this homework is to make sure that all of the course infrastructure is working for you.
Assignments will be distributed and collected using your CSE 333 GitLab repository. Starter code will be added to your repository by the course staff and you will tag your repository when you are done with an assignment to indicate which revision should be evaluated and graded by the course staff. More information about git and GitLab is given below and in other writeups on the course web site. We will demonstrate and discuss the process in sections during the first week of class.
If you have not done so already, change to a directory where you want to store the local repository for your CSE 333 projects, then follow the instructions in the 333-Specific Git Setup Guide to clone your CSE 333 repository. The git writeup, CSE GitLab site, and other git resources are linked from the course's main page. You can use the CSE GitLab web interface to browse your files and find out information about your repository, but you must clone a copy to a Linux machine to do your work.
You might have additional personal projects and repositories in GitLab for your own work, but be sure to use the repository provided by us for your 333 course projects.
Once you have cloned the repository, change into that
directory (it will be named something like
cse333-19au-xyzzy, where
xyzzy is your NetID) then enter
a ls command. You should see something like this:
bash$ git clone git@gitlab.cs.washington.edu:cse333-19au-students/cse333-19au-xyzzy.git -- git output appears here bash$ cd cse333-19au-xyzzy bash$ ls -a .gitignore clint.py hw0
The .gitignore file lists file types that
should not normally be saved in the repository.
These are typically things like editor backup files
(names ending in ~) and object files (ending
in .o).
They are files that are generated and used locally while
you are working but are recreated as needed from files that
are in the repository rather than archived permanently.
If you originally cloned your repository before the
staff added the hw0 directory to it,
enter a git pull command to bring your
local copy up to date.
Once you see the hw0 directory, enter
cd hw0 to change into that directory
to work on the assignment.
In the hw0 directory, run the commands shown below.
This make command will use the instructions
in file Makefile to
compile the hello_world executable using the gcc compiler.
Running the hello_world executable should produce a
line of output that includes some <xxxxx>:
bash$ make bash$ ./hello_world The magic code is: <xxxxx> bash$
Now edit hello_world.c using your favorite
Unix-based editor (emacs, vim, etc.)
and change the printf so that it instead outputs:
bash$ make bash$ ./hello_world The magic word is: <xxxxx> bash$
Remember to execute make when you make
changes to your source file in order to rebuild the
executable before re-running it.
You're unlikely to have any run time bugs in this
homework, but let's
use
the debugger so that you know what it can do.
Here is a session that launches the debugger, sets a
breakpoint on source line 19 of hello_world.c,
prints the values of a couple of variables and an expression,
prints a "backtrace" of the stack (showing the sequence
of procedure calls that led to executing line 19
of hello_world.c), and then continues execution.
Type the italicized lines.
(You may see some differences in gdb or Linux version
numbers, or exact addresses
of variables and code, but the data values should be
basically the same.)
bash$ gdb ./hello_world GNU gdb (GDB) Red Hat Enterprise Linux 7.11-67.el7 Copyright (C) 2016 Free Software Foundation, Inc. License GPLv3+: GNU GPL version 3 or later <http://gnu.org/licenses/gpl.html> This is free software: you are free to change and redistribute it. There is NO WARRANTY, to the extent permitted by law. Type "show copying" and "show warranty" for details. This GDB was configured as "x86_64-redhat-linux-gnu". Type "show configuration" for configuration details. For bug reporting instructions, please see: <http://www.gnu.org/software/gdb/bugs/>. Find the GDB manual and other documentation resources online at: <http://www.gnu.org/software/gdb/documentation/>. For help, type "help". For bug reporting instructions, please see: ... Reading symbols from /home/auser/cse333/hw0/hello_world...done. (gdb) b 19 Breakpoint 1 at 0x400511: file hello_world.c, line 19. (gdb) r Starting program: /home/auser/cse333/hw0/hello_world Breakpoint 1, main (argc=1, argv=0x7fffffffe0c8) at hello_world.c:19 27 printf("The magic code is: %X\n", a + b); (gdb) p argv[0] $1 = 0x7fffffffe394 "/home/auser/cse333/hw0/hello_world" (gdb) p a $2 = -889262067 (gdb) p /x a $3 = 0xcafef00d (gdb) p a+b $4 = -559038737 (gdb) bt #0 main (argc=1, argv=0x7fffffffe0c8) at hello_world.c:19 (gdb) c Continuing. The magic word is: <xxxxx> [Inferior 1 (process 6760) exited normally] (gdb) q bash$
Notes: For gdb to be useful, you
must give the -g option
to gcc when compiling. The Makefile
we distributed does that.
Throughout the quarter, we'll also be testing whether your code has any memory leaks. We'll be using Valgrind to do this. Try out Valgrind for yourself, to make sure you can run it:
bash$ valgrind --leak-check=full ./hello_world
Valgrind should print out that no memory leaks were found.
Another requirement during the quarter is that your code must be written in good style. Although there are many opinions about what constitutes "good style," in this course we will generally follow the Google C++ Style Guide for both C and C++ code.
The repository files for this assignment included a
Python script clint.py
to check C source files for style issues. Try it
yourself to be sure you can run it:
bash$ ../clint.py hello_world.c
No style-checking tool is perfect, but you should try to clean up any problems that clint detects unless clint flags something that is definitely not a problem in this particular context (you should only ignore clint warnings if the course staff confirms that you may ignore them on Piazza).
Create a README.md file in directory
hw0 that contains:
We are not picky about the format of this file as long as it has all this information.
Once you're done, "turning in" the assignment is done by creating an appropriate tag in your git repository to designate the revision (commit) that the course staff should examine for grading. There are multiple ways to get this wrong, so you should carefully follow the following steps in this order. The idea is:
Commit all of your changes to your repository (see the
beginning of the assignment or the main course web page
for links to git information if you need
a refresher on how to do this).
Then in the hw0 directory:
bash$ git pull bash$ make clean bash$ git status On branch master Your branch is up-to-date with 'origin/master'. nothing to commit, working directory clean
If you see any messages about uncommitted changes or any other indications that the latest version of your code has not been pushed to the GitLab repository, fix those problems and push any unsaved changes before going on. Then repeat the above steps to verify that all is well.
This will indicate that the current commit is the version of hw0 that you are submitting for grading:
bash$ git tag hw0-final bash$ git push --tags
Do not do this until after you have
pushed all parts of your hw0 solution to GitLab.
To be sure that you really have updated everything properly, create a brand new, empty directory that is nowhere near your regular working directory, clone the repository into the new location, and verify that everything works as expected. It is really, really, REALLY important that this not be nested anywhere inside your regular, working repository directory. Do this:
bash$ cd <somewhere-completely-different> bash$ git clone git@gitlab.cs.washington.edu:cse333-19au-students/cse333-19au-xyzzy.git bash$ cd cse333-19au-xyzzy bash$ git checkout hw0-final bash$ ls hw0
Use your own userid instead of xyzzy, of
course. The commands after git clone change
to the newly cloned directory, then cause git to switch
to the tagged commit you created in Step 2 above.
We will do the same when we examine your files for grading.
At this point you should see your hw0
directory. cd into it, run make,
run any tests you wish
(something that will be crucial on future assignments).
If there are any problems, immediately erase this
newly cloned copy
of your repository (rm -rf cse333-19au-xyzzy)
go back to your regular working repository, and fix whatever
is wrong. It may be as simple as running a
missed git push --tags
command if the tag was not found in the repository.
If it requires more substantive changes, you may need to
do a little voodoo to get rid of the original
hw0-final tag from your repository and
re-tag after making your repairs.
To eliminate the hw0-final tag,
do this (this should not normally be necessary):
bash$ git tag -d hw0-final bash$ git push origin :refs/tags/hw0-final
Then make and commit and push your repairs, and only after all the changes are pushed, repeat the tag and tag push commands from step 2. And then repeat this verification step to be sure that the updated version is actually correct.
Note: if you discover that repairs are needed when you check your work, it is crucial that you delete the newly cloned copy and make the repairs back your regular working repository. If you modify files in the cloned copy you may wind up pushing changes to GitLab that will leave your repository in a strange state, and files may appear to mysteriously vanish. Please follow the instructions precisely.
For hw0, we'll give you full points if you learn the magic code and correctly submit your work.