ece264/solutions/ECE264Solutions/PA05/expected/strexpected3

       #include <stdlib.h>
       /proc/sys/vm/overcommit_memory and /proc/sys/vm/oom_adj in proc(5), and
       By  default,  Linux  follows  an optimistic memory allocation strategy.
       C89, C99.
       Crashes  in  malloc(), calloc(), realloc(), or free() are almost always
       LOC_CHECK_ is set to  0,  any  detected  heap  corruption  is  silently
       LOC_CHECK_ value can be useful because otherwise  a  crash  may  happen
       MMAP_THRESHOLD  is  128  kB  by  default,  but is adjustable using mal†      NULL  or  a  pointer  suitable  to be passed to free() is returned.  If
       NULL, it must have been returned by an earlier call to  malloc(),  cal†      Normally, malloc() allocates memory from the heap, and adjusts the size
       OOM   killer.    For   more   information,   see   the  description  of
       RLIMIT_DATA resource limit (see getrlimit(2)).
       Recent  versions  of  Linux  libc  (later  than 5.4.23) and glibc (2.x)
       The  UNIX 98 standard requires malloc(), calloc(), and realloc() to set
       The  calloc()  function allocates memory for an array of nmemb elements
       The  realloc() function changes the size of the memory block pointed to
       The free() function frees the memory space pointed  to  by  ptr,  which
       The free() function returns no value.
       The malloc() and calloc() functions return a pointer to  the  allocated
       The malloc() function allocates size bytes and returns a pointer to the
       The realloc() function returns a pointer to the newly allocated memory,
       This means that when malloc() returns non-NULL there  is  no  guarantee
       This page is part of release 3.35 of the Linux  man-pages  project.   A
       allocated memory.  The memory is not initialized.  If size is  0,  then
       allocates the memory as a  private  anonymous  mapping  using  mmap(2).
       be found at http://man7.org/linux/man-pages/.
       be successfully passed to free().
       brk(2), mallopt(3), mmap(2), alloca(3), posix_memalign(3)
       by ptr to size bytes.  The contents will be unchanged in the range from
       call  to  malloc() with a size of zero, or by a successful call to cal†      description  of  the project, and information about reporting bugs, can
       done.
       either NULL, or a unique pointer value that can later  be  successfully
       errno to ENOMEM upon failure.  Glibc assumes that this is done (and the
       errors, such as double calls of free() with the same argument, or over†      freeing the same pointer twice.
       from ptr, or NULL if the request fails.  If size was equal to 0, either
       glibc  versions of these routines do this); if you use a private malloc
       ignored; if set to 1, a diagnostic message is printed on stderr; if set
       implementation is used which is designed to be tolerant against  simple
       implementation that does not set errno, then certain  library  routines
       include a malloc() implementation  which  is  tunable  via  environment
       initialized.   If  ptr  is  NULL,  then  the call is equivalent to mal†      is  printed on stderr and the program is aborted.  Using a nonzero MAL†      loc()  or  realloc().  If the area pointed to was moved, a free(ptr) is
       loc() with nmemb or size equal to zero.
       loc(size), for all values of size; if size is equal to zero, and ptr is
       lopt(3).  Allocations performed using mmap(2)  are  unaffected  by  the
       malloc()  returns either NULL, or a unique pointer value that can later
       malloc, free, calloc, realloc - Allocate and free dynamic memory
       may fail without having a reason in errno.
       memory  is  set  to zero.  If nmemb or size is 0, then calloc() returns
       memory  that  is  suitably aligned for any kind of variable.  On error,
       much  later,  and  the  true cause for the problem is then very hard to
       must  have  been  returned  by a previous call to malloc(), calloc() or
       not  NULL,  then  the  call  is equivalent to free(ptr).  Unless ptr is
       of size bytes each and returns a pointer to the allocated memory.   The
       of the heap as required, using sbrk(2).  When allocating blocks of mem†      or moved.
       ory larger than MMAP_THRESHOLD bytes, the glibc malloc() implementation
       passed to free().
       protected  against,  however,  and  memory  leaks  can result.  If MAL†      realloc() fails the original block is left untouched; it is  not  freed
       realloc().  Otherwise, or if free(ptr) has already been called  before,
       related to heap corruption, such as overflowing an allocated  chunk  or
       runs of a single byte (off-by-one bugs).  Not all such  errors  can  be
       system is out of memory, one or more processes will be  killed  by  the
       that  the  memory  really  is available.  In case it turns out that the
       the kernel source file Documentation/vm/overcommit-accounting.
       the new size is larger than the old size, the added memory will not  be
       the start of the region up to the minimum of the old and new sizes.  If
       these functions return NULL.  NULL may also be returned by a successful
       to 2, abort(3) is called immediately; if set to 3, a diagnostic message
       track down.
       undefined behavior occurs.  If ptr is NULL, no operation is performed.
       variables.   When  MALLOC_CHECK_  is  set,  a  special (less efficient)
       void *calloc(size_t nmemb, size_t size);
       void *malloc(size_t size);
       void *realloc(void *ptr, size_t size);
       void free(void *ptr);
       which is suitably aligned for any kind of variable and may be different
COLOPHON
CONFORMING TO
DESCRIPTION
GNU                               2011-09-08                         MALLOC(3)
MALLOC(3)                  Linux Programmer's Manual                 MALLOC(3)
NAME
NOTES
RETURN VALUE
SEE ALSO
SYNOPSIS
�
�
�
�
�
�
�
�