iws instructional work servers l.
Download
Skip this Video
Download Presentation
IWS (Instructional Work Servers)

Loading in 2 Seconds...

play fullscreen
1 / 40

IWS (Instructional Work Servers) - PowerPoint PPT Presentation


  • 142 Views
  • Uploaded on

IWS (Instructional Work Servers). There are 4 instructional Unix servers: ceylon , fiji , sumatra , and tahiti Accessing the servers: Terminal Programs: telnet (insecure; cannot be used) ssh (via the TeraTerm or Putty programs from Windows)

loader
I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.
capcha
Download Presentation

PowerPoint Slideshow about 'IWS (Instructional Work Servers)' - ania


Download Now An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.


- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript
iws instructional work servers
IWS (Instructional Work Servers)
  • There are 4 instructional Unix servers:
    • ceylon, fiji, sumatra, and tahiti
  • Accessing the servers:
    • Terminal Programs:
      • telnet (insecure; cannot be used)
      • ssh (via the TeraTerm or Putty programs from Windows)
        • Start -> Program Files -> Desktop Tools -> TeraTerm
    • File Transfer Programs
      • ftp (insecure; cannot be used at UW)
      • \\<server name>\<username> from Start -> Run menu
        • e.g -- \\fiji\zanfur
      • Secure file transfer (from C&C)
    • Xwindows
      • Run xgo from the command prompt
      • Come to the ACM tutorial!

This tutorial provided by UW ACM

http://www.cs.washington.edu/orgs/acm/Questions to hctang@cs, zanfur@cs, awong@cs

logging in
Logging In
  • Which server you use (almost) doesn’t matter – all four allow access to your files
  • Although your Windows and Unix usernames (and passwords) are the same, they are two separate accounts
    • Your z: drive is not your Unix account
  • Connecting:
    • We’ll connect to the Unix machines via ssh
    • After connection, you are presented with a login prompt
    • After logging in, you’re placed in your home directory (where your personal files are located)
the command prompt
The Command Prompt
  • Commands are the way to “do things” in Unix
  • A command consists of a command name and options called “flags”
  • Commands are typed at the command prompt
  • In Unix, everything (including commands) is case-sensitive

[prompt]$ <command> <flags> <args>

fiji:/u15/awong$ ls –l -a unix-tutorial

Command

(Optional) arguments

Command Prompt

(Optional) flags

Note: In Unix, you’re expected to know what you’re doing. Many

commands will print a message only if something went wrong.

two essential commands
Two Essential Commands
  • The most useful commands you’ll ever learn:
    • man (short for “manual”)
    • info
  • They help you find information about other commands
    • man <cmd> or info <cmd> retrieves detailed information about <cmd>
    • man –k <keyword> searches the man page summaries (faster, and will probably give better results)
    • man –K <keyword> searches the full text of the man pages

fiji:/u15/awong$ man –k password

passwd (5) - password file

xlock (1) - Locks the local X display until a password is entered

fiji:/u15/awong$ passwd

directories
Directories
  • In Unix, files are grouped together in other files called directories, which are analogous to folders in Windows
  • Directory paths are separated by a forward slash: /
    • Example: /u10/hctang/classes/cse326
  • The hierarchical structure of directories (the directory tree) begins at a special directory called the root, or /
    • Absolute paths start at /
      • Example: /u10/hctang/classes/cse326
    • Relative paths start in the current directory
      • Example: classes/cse326 (if you’re currently in /u10/hctang)
  • Your home directory is where your personal files are located, and where you start when you log in.
    • Example: /u10/hctang
directories cont d
Directories (cont’d)
  • Handy directories to know

~ Your home directory

.. The parent directory

. The current directory

  • ls
    • LiSts the contents of a specified files or directories (or the current directory if no files are specified)
    • Syntax: ls [<file> … ]
    • Example: ls backups
  • pwd
    • Print Working Directory
directories cont d further
Directories (cont’d further)
  • cd
    • Change Directory (or your home directory if unspecified)
    • Syntax: cd <directory>
    • Examples:
      • cd backups/unix-tutorial
      • cd ../class-notes
  • mkdir
    • MaKe DIRectory
    • Syntax: mkdir <directories>
    • Example: mkdir backups class-notes
  • rmdir
    • ReMove DIRectory, which must be empty
    • Syntax: rmdir <directories>
    • Example: rmdir backups class-notes
files
Files
  • Unlike Windows, in Unix file types (e.g. “executable files, ” “data files,” “text files”) are not determined by file extension (e.g. “foo.exe”, “foo.dat”, “foo.txt”)
  • Thus, the file-manipulation commands are few and simple …
  • rm
    • ReMoves a file, without a possibility of “undelete!”
    • Syntax: rm <file(s)>
    • Example: rm tutorial.txt backups/old.txt
files cont d
Files (cont’d)
  • cp
    • CoPies a file, preserving the original
    • Syntax: cp <sources> <destination>
    • Example: cp tutorial.txt tutorial.txt.bak
  • mv
    • MoVes or renames a file, destroying the original
    • Syntax: mv <sources> <destination>
    • Examples:
      • mv tutorial.txt tutorial.txt.bak
      • mv tutorial.txt tutorial-slides.ppt backups/

Note: Both of these commands will over-write existing files without warning you!

shell shortcuts
Shell Shortcuts
  • Tab completion
    • Type part of a file/directory name, hit <tab>, and the shell will finish as much of the name as it can
    • Works if you’re running tcsh or bash
  • Command history
    • Don’t re-type previous commands – use the up-arrow to access them
  • Wildcards
    • Special character(s) which can be expanded to match other file/directory names

* Zero or more characters

? Zero or one character

    • Examples:
      • ls *.txt
      • rm may-?-notes.txt
text editing
Text - editing
  • Which text editor is “the best” is a holy war. Pick one and get comfortable with it.
  • Three text editors you should be aware of:
    • pico – Comes with pine (Dante’s email program)
    • emacs/xemacs – A heavily-featured editor commonly used in programming
    • vim/vi – A lighter editor, also used in programming
  • Get familiar with one as soon as possible!
text printing
Text - printing
  • Printing:
    • Uselprto print
      • Use –h (no header) and –Zduplex (double-sided) to save paper
    • Check the print queue (including Windows print jobs!) with lpq
    • lprm to remove print jobs (including Windows print jobs)
    • For the above commands, you’ll need to specify the printer with–P<printer name>
  • Check out enscript (quizlet: how do you find information about commands?) to print text files nicely!
    • WARNING: Do NOT use enscript with postscript files!
  • Check out the ACM webpage for a printing reference card!
unix i o
Unix I/O
  • Input
    • stdin: usually the keyboard. It is equivalent to C++’s cin
  • Output
    • stdout: usually the monitor (but can be redirected to a file). It is equivalent to C++’s cout
    • stderr: usually the monitor (but usually cannot be redirected). It is equivalent to C++’s cerr

Note: It is a good programming practice to use cerr instead of cout for error messages.

redirecting i o
Redirecting I/O
  • Redirecting input: a.out < file
    • a.out will treat file as if file was a.out’s stdin
    • It’s as if the user was typing the contents of the file as input
  • Redirecting output: a.out > file
    • a.out will write any output from stdout to file
    • file will be created if it does not already exist, and will be overwritten otherwise
    • Messages from stderr will not be written to file
    • To append to the file (instead of overwriting), use >>
  • Piping: cmd1 | cmd2
    • Causes the stdout output of cmd1 to be sent as stdin input to cmd2
the unix philosophy
The Unix Philosophy
  • A large set of primitive tools, which can be put together in an infinite number of powerful ways
  • An example:
    • Three separate tools are necessary to develop software:
      • Text editor
      • Compiler
      • Debugger (You will need this, unless “j00 R l33t”)
    • MSVC is an “IDE” (“Integrated Development Environment”)
      • All three tools are found in one shrink-wrapped box
    • Although there are IDE’s for Unix, for this course, you will most likely use (mostly) separate tools:
      • Text editor: emacs/xemacs or vi/vim
      • Compiler: g++
      • Debugger: gdb

This tutorial provided by UW ACM

http://www.cs.washington.edu/orgs/acm/Questions to hctang@cs, zanfur@cs

compilation
Compilation
  • To compile a program:
    • g++ <options> <source files>
    • Recommended:g++ -Wall –ansi -g –o <executable_name> *.cpp
      • -Wall – Warnings: ALL
      • -ansi – Strict ANSI compliance
      • -g – Add debugging symbols to the executable (ie, make it debuggable!)
      • Quizlet: what does *.cpp mean?
  • What’s an “executable”?
    • In Windows, double-clicking on an icon runs a program
      • E.g. double-click on C:\Windows\notepad.exe
    • In Unix, you can run your executable from the command line!
      • Type the executable name at the prompt, just like a command
        • In fact, commands are actually executables
      • However, you may need to specify the path to your executables
        • ./<program> runs <program> in the current directory
      • Example:

fiji:ehsu% g++ -Wall –ansi -g –o hello hello.cpp

fiji:ehsu% ./hello

compilation or the big lie
Does this picture look familiar?

You saw this in 143!

These are the discrete steps to program “compilation”

Hitting the ‘!’ button in MSVC or typing a “g++ *.cpp” to build (not “compile”) your program hides all these separate steps.

Question: would you want to do this entire process (ie, pre-process and compile every file) every time you wanted to generate a new executable?

“Compilation” or “The Big Lie”

.h

.h

.cpp

.cpp

Pre-proc

Pre-proc

compiler

compiler

ANSI lib

linker

other libs

.exe file

selective recompilation and makefiles
Selective Recompilation and Makefiles
  • Answer:
    • No. You only want to compile those files which were changed (or were affected by a change in another file [quizlet: when might this happen?]). We can reuse the .o/.obj files for files which weren’t modified.
  • You could do this yourself…
    • g++ <options> <changed files>
    • g++ *.o
  • But you could also use the make command and a Makefile!
    • Create a Makefile to keep track of file dependancies and build options
    • The make command will read the Makefile and compile (and build) those files which have dependancies on modified files!
makefile syntax
Makefile Syntax
  • Makefiles consists of variables and rules.
  • Rule Syntax:

<target>: <requirements>

<command>

      • The <requirements> may be files and/or other targets
      • There must be a tab (not spaces) before <command>
      • The first rule in a Makefile is the default <target> for make
  • Variable Syntax:

<variable>=<string value>

      • All variable values default to the shell variable values
      • Example:
        • BUILD_FLAGS = -Wall -g -ansi
example makefile
Example Makefile

# Example Makefile

CXX=g++

CXXOPTS=-g –Wall -ansi -DDEBUG

foobar: foo.o bar.o

$(CXX) $(CXXOPTS) –o foobar foo.o bar.o

foo.o: foo.cc foo.hh

$(CXX) $(CXXOPTS) –c foo.cc

bar.o: bar.cc bar.hh

$(CXX) $(CXXOPTS) –c bar.cc

clean:

rm -f foo.o bar.o foobar

writing code
Writing Code
  • What causes a bug?
    • What you meant != what you wrote
  • Coding right the first time is making “what you meant” align with “what you write”
    • Invariants – assert() invariants to discover when your program’s state has changed unexpectedly
    • Error handling and notification – Fix or report errors. Your program should never be in a bad state
    • Code review
    • Use a debugger!
      • See next slide …
debugging
Debugging
  • How do you remove a bug?
    • Read the code. If you don’t understand it, the bug will happen again
    • Examine the state of the program at key points in the code
      • Print statements in the code (suggestion: wrap debug output with #ifdef DEBUG)
      • Use a debugger to view the state of your program with greater flexibility/control
  • Debugger advantages
    • Compile your code only once
    • Monitor all the values in the code
    • Make changes while executing the code
    • Examine core files that are produced when a program crashes
  • In other words, debuggers are tools which allow you to examine the state of a program in detail!
    • In fact, debuggers can (and should) be used to understand and improve your code
debugging techniques
Debugging Techniques
  • Goal: Isolate the problem, then fix it
    • Don’t try random things, looking for a solution
      • If you don’t understand it, it’ll be back
      • This method takes a long time
      • You don’t learn anything from it
    • Look for the problem, not the solution
      • Figure out two points in code that the problem is between, and close the gap from there.
gdb the gnu debugger
GDB - The GNU DeBugger
  • To run gdb (a text-based debugger):
    • gdb [<program file> [<core file>]]
      • <program file>Executable program file
      • <core file> Crashed program’s core dump
    • You must compile with -g for debug information!
  • Within gdb:
    • Running gdb:
      • run [<args>] Run program with arguments <args>
      • quit Quit the gdb debugger
      • help [<topic>] Access gdb’s internal help
    • Examining program state:
      • info [locals|args] Prints out info on [local variables|args]
      • backtrace[<n>]Prints the top <n> frames on the stack
      • p[rint] <expr> Print out <expr>
gdb continued
GDB continued
  • Controlling program flow
    • s[tep] Step one line, entering called functions
    • n[ext] Step one line, skipping called functions
    • finish Finish the current function and print the return value
  • Controlling program flow with breakpoints
    • c[ontinue] Continue execution (after a stop)
    • b[reak][<where>]Set a breakpoint
    • d[elete][<nums>]Deletes breakpoints by number
    • [r]watch <expr>Sets a watchpoint, which will break when <expr> is written to [or read]
  • Modifying program state
    • set <name> <expr> Set a variable to <expr>
    • jump <where> Resume program execution at <where>
slide26
/uns
  • There are actually threeg++s installed on the instructional machines
    • Version 3.0.4 is the one we’ll be using for 326
    • Version 2.96 is the default
  • To use version 3.0.4, you need to call uns-g++
  • uns-g++ is located in /uns/bin, which is not part of your standard Unix environment
setting up your environment to use uns
Setting Up Your Environment to use /uns
  • To set up your Unix environment, you’ll need:
    • csh/tcsh:
      • Edit (or create) your .mycshrc file
      • setenv PATH {$PATH}:/uns/bin
    • bash:
      • Edit (or create) your .bashrc file
      • export PATH=$PATH:/uns/bin
  • To get the full benefit of /uns, you can run the /uns/examples/setup-tutorial script
  • It’s a good idea to look at what’s in /uns/bin – there are many useful tools there:
    • xemacs - a different flavour of emacs
    • ddd - a graphical debugger
    • And much, much more …
other tools for cse 326
Other Tools for CSE 326
  • Shell scripts
    • A series of shell commands which are read and executed as-is by the shell (like a DOS batch script)
    • Very useful for automated tests!
    • “Shell commands” may be:
      • Executables such as emacs and time
      • Built-in primitives such as ls and for-loops
    • Search the internet for tutorials or sample shell scripts
      • “tcsh builtin commands” worked well at Google …
other tools for cse 326 cont d
Other Tools for CSE 326 (cont’d)
  • Awk
    • A pattern-scanning and processing utility. It searches files(s) for specified patterns and performs associated actions.
    • Search the internet for tutorials or samples
      • “awk tutorial” worked well at Google …
  • Gnuplot
    • A command-driven function- and data-plotting program.
    • Try emailing the course alias with websites you found; your classmates will thank you!
more information in the dept
More Information - In the Dept
  • In the department
    • Your neighbors!
    • info and man
    • uw-cs.lab-help newsgroup
    • .login, .cshrc, and /uns/examples to see how other people have things set up
    • Course staff - office hours, email
      • Why do you think we get paid the big bucks? =)
more information on the web
More Information - On the Web
  • On the web:
    • http://www.faqs.org (comp.unix questions FAQ)
    • http://www.google.com
    • http://www.refcards.com
    • ACM Tutorials:

http://www.cs.washington.edu/orgs/acm/tutorials/

    • CSE326 webpage

http://www.cs.washington.edu/education/courses/cse326/02wi/computing/class_links.html

  • If you’re curious, check out these topics:
    • Source control (try searching the web for “cvs”)
      • Multiple people working on a file concurrently
      • Easily revert file changes
    • Profiling (try searching the web for “gprof”)
      • Find and eliminate inefficiencies in code
c templates introduction
C++ Templates - Introduction
  • Templates are cookie-cutters with which the compiler generates real C++ code. Templates themselves do not exist.
  • When a template is used, (that is, specialized for a specific type), it get instantiated. This is when actual machine code is generated.
  • The instantiation creates a version of the template where each placeholder is replaced by its specialization. At this point, the specific version of the template comes into existence and can be compiled. It does not exist otherwise!
  • In a very real way, a template just does a search and replace for each type you specialize the template for. It’s just done for you, behind your back.

These template slides are freely stolen from Albert Wong (awong@cs)

http://www.cs.washington.edu/orgs/acm/tutorials/

c templates problems
C++ Templates - Problems
  • Problem:
    • Because templates do not really exist, they don’t exist to the compiler until they are instantiated!
  • Effects:
    • Template code will not get compiled until it is used (ie, instantiated). Thus, the compiler will not catch syntax errors until the template is used!
    • A specialization (a place where the template is actually used) instantiates all relevant templated code before it.
      • If templated code occurs in a different file, it will not get instantiated by that specialization.
      • If templated code occurs later in the same file, it will not get instantiated by that specialization.
    • Worse yet: implicit template instantiation
      • Only explicitly used templated code will be instantiated.
      • Thus, if templated code occurs in the same file and before the template specialization, it still will not get instantiated by that implicit specialization!
c templates possible problem i
C++ Templates - Possible Problem I
  • Unfortunately, yes. Although b is undeclared, no warnings or errors will be generated.
  • It appears to “compile” because nothing actually instantiates the template, so the compiler never sees the template code.

Will this code compile?

/* Array.hh */

#ifndef ARRAY_HH

#define ARRAY_HH

template <typename T>

class Array {

Array( int i ) {

b = “Hello Mom!”;

}

};

#endif /* ARRAY_HH */

c templates possible problem ii
C++ Templates - Possible Problem II

Will this program link?

The link error happens ata.GetCapacity()

  • Nothing from a template gets instantiated until it is either used or explicitly instantiated.
  • Array<int>::GetCapacity()is used at a.GetCapacity(), but the function definition is not in this file.
  • The definition of the function is in Array.cc, but it is never used there.

Thus the definition of Array<int>::GetCapacity()never gets instantiated and compiled to object code.

/* main.cc */

#include <iostream>

using namespace std;

#include “Array.hh”

int main(void) {

Array<int> a(10);

cout << a.GetCapacity() << endl;

return 0;

}

c templates avoiding the problems
C++ Templates - Avoiding the Problems
  • There are 3 conventions to avoiding template problems:
    • Write all the code inline in the .h file
    • Write the code in two files, but #include the implementation file at the bottom of the .h (essentially the same as above)
    • Write the templated class as you would with a normal class (using a header and implementation file)
      • Create a new source file and #include the implementation file there.
      • Inside this new file, explicitly instantiate all your templates.
      • This new instantiation file is the one that you compile, not the implementation file.
  • Advantages of the third method:
    • It is not necessary to recompile all the code that uses the template (just the template itself).
    • The third method instantiates the entire templated class all at once, removing potential link problems.
c templates the safe way

/* ArrayInst.cc */

#include “Array.cc”

template Array<int>;

template Array<double>;

This line forces the instantiation of the Array class template (and all its member functions), for ints.

C++ Templates - The Safe Way
  • To make the previously broken program link properly, explicitly instantiate an integer version of the Array template.
  • Remember, each specialization will require their own line in the instantiation file
  • Compile line:

g++ -Wall -ansi main.cc ArrayInst.cc

  • The proper procedure
  • Write the template, separated into a header and an implementation file
  • Create an instantiation file for the template which includes the implementation file.
  • Compile the instantiation file and not the template implementation file.
  • The instantiation file generates the object code for the template.
other tools for cse 32639
Other Tools for CSE 326
  • Shell scripts
    • A series of shell commands which are read and executed by the shell (like a DOS batch script).
    • “Shell commands” may be:
      • Executables such as emacs and time
      • Built-in primitives such as ls and for-loops
    • Search the internet for tutorials or sample shell scripts
      • “tcsh builtin commands” worked well at Google …
other tools for cse 326 part 2
Other Tools for CSE 326 (part 2)
  • Awk
    • A pattern scanning and processing utility. It searches file(s) for specified patterns and perform associated actions.
    • Search the internet for tutorials or samples
      • “awk tutorial” worked well at Google …
  • Gnuplot
    • A command-driven function and data plotting program
    • Try emailing the course alias with websites you found; your classmates will thank you!