The Exercises

1. In class, you've been introduced to malloc() and related functions. And you used malloc/realloc in q3 of the last lab.
   
   It was emphasized that you should always check the return value of malloc, and take special steps if it is NULL - usually output a message to standard error and quit with a non-zero exit status. Generally, students learn to put in such code, but never get to see it run; i.e. they never see malloc fail. Your job here will be to make it fail.
   
   To make malloc fail, you must set the resource limits for the process (the shell and all of its descendants, i.e. programs you run).
   • First, see the man page for ulimit at the shell level. That's

     $ help ulimit
     

     Use help instead of man because ulimit is a shell built-in command/subroutine, not an executable file.
   
   
   • Try ulimit -a to see the current limits. You'll note that the size of virtual memory is unlimited.
   
   
   • Change the upper limit on virtual memory with

     $ ulimit -S -v someNumberYouChoose
     

     Note that that's a capital S (for soft limit).
     
     Play around with different values for someNumberYouChoose, like 10000, 9000, 8000 ... (these are in kilobytes). After each, try to clear the screen with the clear command. At some point you won't have enough memory to do that. Then set the virtual memory limit back to unlimited with

     $ ulimit -S -v unlimited
     

     and the clear command should work again.
   
   
   Now write a C program called q1.c. It should repeatedly call malloc on larger and larger arguments until it fails. Here, roughly, is how you do this:
   • Start with something like

     #define SIZE 102400
     ...
     long currentSize = SIZE;
     ...
     char * p;
     ...
     p = (char *) malloc(currentSize)
     while (p != null)
     {
     	print message that you can allocate currentSize bytes.
     
     	change currentSize to currentSize + SIZE
     
     	you are going to reassign p, so free the memory it points to or
     	you will have a memory leak:
     	free(p);
     
     	try to allocate the new amount
     	p = (char *)malloc(currentSize)
     }
     

     Now you are out of the loop, so malloc must have failed. Print an error message. Use perror(). perror() is almost alway followed by exit(1);

     perror("some message you make up");
     

     Note that this will result in output: "some message you make up" plus a colon plus a space plus an appropriate system error message, as in

     some message you make up: cannot allocate memory
     

     If you need something fancier, e.g. to include the size on which malloc failed, you can use strerror(errno), as in

     fprintf(stderr, "cannot malloc %ld bytes: %s\n", currentSize, strerror(errno));
     

     Normally you would use just one of these methods of writing an error message, but for this exercise use both.
     
     Finally quit, but with non-zero exit status

     exit(1);
     

   
   
   • Compile this to an executable called q1. If there are any warnings, fix the code so that the warnings are eliminated. Before you run it, limit the amout of virtual memory available with

     $ ulimit -S -v 10000
     

   
   
   • Run the program and see the messages produced when malloc fails. Remember that you can kill a running program with <ctrl>c.
   
   
   • Be sure to change the virtual memory limit back to unlimited with

     $ ulimit -S -v unlimited
     

   
   
   And a final note: if you try replacing calls to malloc with calls to calloc, as in

   calloc(1, currentSize);
   

   you should find that the results are the same.
   
   BUT this will not work if you use realloc - the resource limits set with ulimit will be ignored. Try it if you like, and use <ctrl>C to kill the running program.
   
   Submit your program with the following command:

   $ submit 2031 lab6 q1.c