external/RSL_LITE/rsl_malloc.c

   1 /***********************************************************************
   2
   3                               COPYRIGHT
   4
   5      The following is a notice of limited availability of the code and
   6      Government license and disclaimer which must be included in the
   7      prologue of the code and in all source listings of the code.
   8
   9      Copyright notice
  10        (c) 1977  University of Chicago
  11
  12      Permission is hereby granted to use, reproduce, prepare
  13      derivative works, and to redistribute to others at no charge.  If
  14      you distribute a copy or copies of the Software, or you modify a
  15      copy or copies of the Software or any portion of it, thus forming
  16      a work based on the Software and make and/or distribute copies of
  17      such work, you must meet the following conditions:
  18
  19           a) If you make a copy of the Software (modified or verbatim)
  20              it must include the copyright notice and Government
  21              license and disclaimer.
  22
  23           b) You must cause the modified Software to carry prominent
  24              notices stating that you changed specified portions of
  25              the Software.
  26
  27      This software was authored by:
  28
  29      Argonne National Laboratory
  30      J. Michalakes: (630) 252-6646; email: michalak@mcs.anl.gov
  31      Mathematics and Computer Science Division
  32      Argonne National Laboratory, Argonne, IL  60439
  33
  34      ARGONNE NATIONAL LABORATORY (ANL), WITH FACILITIES IN THE STATES
  35      OF ILLINOIS AND IDAHO, IS OWNED BY THE UNITED STATES GOVERNMENT,
  36      AND OPERATED BY THE UNIVERSITY OF CHICAGO UNDER PROVISION OF A
  37      CONTRACT WITH THE DEPARTMENT OF ENERGY.
  38
  39                       GOVERNMENT LICENSE AND DISCLAIMER
  40
  41      This computer code material was prepared, in part, as an account
  42      of work sponsored by an agency of the United States Government.
  43      The Government is granted for itself and others acting on its
  44      behalf a paid-up, nonexclusive, irrevocable worldwide license in
  45      this data to reproduce, prepare derivative works, distribute
  46      copies to the public, perform publicly and display publicly, and
  47      to permit others to do so.  NEITHER THE UNITED STATES GOVERNMENT
  48      NOR ANY AGENCY THEREOF, NOR THE UNIVERSITY OF CHICAGO, NOR ANY OF
  49      THEIR EMPLOYEES, MAKES ANY WARRANTY, EXPRESS OR IMPLIED, OR
  50      ASSUMES ANY LEGAL LIABILITY OR RESPONSIBILITY FOR THE ACCURACY,
  51      COMPLETENESS, OR USEFULNESS OF ANY INFORMATION, APPARATUS,
  52      PRODUCT, OR PROCESS DISCLOSED, OR REPRESENTS THAT ITS USE WOULD
  53      NOT INFRINGE PRIVATELY OWNED RIGHTS.
  54
  55 ***************************************************************************/
  56
  57 #if 0
  58 #define PADIT           /* add page at beginning and end of allocation */
  59 #endif
  60 #if 0
  61 # define BASE_MALLOC   fence_malloc
  62 # define BASE_FREE     fence_free
  63 #else
  64 # define BASE_MALLOC   malloc
  65 # define BASE_FREE     free
  66 #endif
  67
  68 #ifdef _WIN32
  69 #define bzero(X,Y) memset(X,0,Y)
  70 #endif
  71
  72 #ifndef MS_SUA
  73 # include <stdio.h>
  74 #endif
  75 #include <stdlib.h>
  76 #ifndef MACOS
  77 # include <malloc.h>
  78 #else
  79 # include <malloc/malloc.h>
  80 #endif
  81 #ifdef T3D
  82 #include <errno.h>
  83 #endif
  84 #ifndef STUBMPI
  85 # include "mpi.h"
  86 #endif
  87 #include "rsl_lite.h"
  88 #include <strings.h>
  89 #include <unistd.h>
  90 /*
  91 extern int EF_ALIGNMENT;
  92 extern int EF_PROTECT_BELOW;
  93 extern int EF_PROTECT_FREE;
  94 */
  95
  96 /* define STUG to enable tracking of allocs and frees (performance and space penalty) */
  97 #ifdef STUG
  98 #define MAXSTUG  1000000
  99 struct stugtype {
 100    char *  ddr ;
 101    int     sz  ;
 102 } stug[MAXSTUG] ;
 103 static int stugfirst =1 ;
 104 int outy = 0 ;
 105 int nouty = 0 ;
 106 int maxstug = 0 ;
 107 int maxouty = 0 ;
 108 int bbb ;
 109 #endif
 110
 111
 112 static char zero_length_storage[] = "" ;
 113
 114 #if !(defined(vpp) || defined(vpp2) || defined(SUN) || defined(XT3_Catamount) || defined(crayx1) || defined(MACOS) || defined(MS_SUA) )
 115 static struct mallinfo minf ;
 116 #endif
 117
 118 static char *last_f ;
 119 static int last_l ;
 120 static int last_s ;
 121
 122 #ifdef O2K
 123 static struct mallinfo mallinfo() {} ;
 124 #endif
 125
 126 void * rsl_malloc(f,l,s)
 127    char * f ;
 128    int l, s ;
 129 {
 130    char mess[128] ;
 131    void *retval ;
 132    int s2, tries ;
 133
 134 /*
 135 EF_PROTECT_BELOW = 0 ;
 136 EF_PROTECT_FREE = 1 ;
 137 */
 138
 139 #ifdef STUG
 140    if ( stugfirst == 1 ) {
 141       stugfirst = 0 ;
 142       for ( bbb = 0 ; bbb < MAXSTUG ; bbb++ ) {
 143          stug[bbb].ddr = 0L ;
 144          stug[bbb].sz  = 0 ;
 145       }
 146    }
 147 #endif
 148
 149    if ( s == 0 )
 150    {
 151      retval = (void *) zero_length_storage ;
 152    }
 153    else
 154    {
 155 #ifdef PADIT
 156      s2 = s + 1024 ;
 157 #else
 158      s2 = s ;
 159 #endif
 160      tries = 0 ;
 161      while ((retval=(void *)BASE_MALLOC(s2))==(void *)NULL)
 162      {
 163        tries++ ;
 164        sprintf(mess,
 165 "rsl_malloc failed allocating %d bytes, called %s, line %d, try %d\n",
 166        s,f,l,tries) ;
 167        perror(mess) ;
 168 #if !(defined(vpp) || defined(vpp2) || defined(SUN) || defined(XT3_Catamount) || defined(crayx1) || defined(MACOS) || defined(MS_SUA) || defined(_WIN32))
 169        minf = mallinfo() ;
 170        fprintf(stderr,"mallinfo: arena %d\n",minf.arena)  ;
 171        fprintf(stderr,"mallinfo: ordblks %d\n",minf.ordblks)  ;
 172        fprintf(stderr,"mallinfo: smblks %d\n",minf.smblks)  ;
 173        fprintf(stderr,"mallinfo: hblks %d\n",minf.hblks)  ;
 174        fprintf(stderr,"mallinfo: hblkhd %d\n",minf.hblkhd)  ;
 175        fprintf(stderr,"mallinfo: usmblks %d\n",minf.usmblks)  ;
 176        fprintf(stderr,"mallinfo: fsmblks %d\n",minf.fsmblks)  ;
 177        fprintf(stderr,"mallinfo: uordblks %d\n",minf.uordblks)  ;
 178        fprintf(stderr,"mallinfo: fordblks %d\n",minf.fordblks)  ;
 179        fprintf(stderr,"mallinfo: keepcost %d\n",minf.keepcost)  ;
 180 #ifdef SUNINFO
 181        fprintf(stderr,"mallinfo: mkfast %d\n",minf.mkfast)  ;
 182        fprintf(stderr,"mallinfo: nblks %d\n",minf.nblks)  ;
 183        fprintf(stderr,"mallinfo: grain %d\n",minf.grain)  ;
 184        fprintf(stderr,"mallinfo: uordbytes %d\n",minf.uordbytes)  ;
 185        fprintf(stderr,"mallinfo: allocated %d\n",minf.allocated)  ;
 186        fprintf(stderr,"mallinfo: treeoverhead %d\n",minf.treeoverhead)  ;
 187 #endif
 188 #endif
 189        if ( tries >= 2 )
 190        {
 191          system("lsps -a") ;
 192 #if !defined (MS_SUA) && !defined(_WIN32)
 193          sleep(1) ;
 194 #endif
 195        }
 196        if ( tries >= 3 )
 197        {
 198          system("lsps -a") ;
 199          RSL_FATAL(2) ;
 200        }
 201      }
 202    }
 203 #if !(defined(vpp)||defined(vpp2)) || defined(sx) || defined(alphavector)
 204    if ( s > 0 )
 205      bzero( retval, s2 ) ;      /* return zero'd storage always */
 206 #else
 207    if ( s > 0 )
 208    { int l, lb ;
 209      l = s2/sizeof(int) ;
 210      lb = l*sizeof(int) ;
 211      vizero_( retval, &l  ) ;
 212      l = s2-lb ;
 213      vbzero_( retval+lb, &l ) ; /* return zero'd storage always */
 214    }
 215 #endif
 216
 217 #ifdef PADIT
 218    retval = retval + 512 ;
 219 #endif
 220
 221 #ifdef STUG
 222 for ( bbb = 0 ; bbb < MAXSTUG ; bbb++ )
 223 {
 224    if ( stug[bbb].ddr == 0 ) break ;
 225 }
 226 if ( bbb < MAXSTUG ) {
 227    stug[bbb].ddr = retval ;
 228    stug[bbb].sz  = s ;
 229    outy += stug[bbb].sz ;
 230 /* fprintf(stderr,"+ %10d.  %08x   %10d  %10d\n", bbb, stug[bbb].ddr, stug[bbb].sz, outy ) ; */
 231    nouty ++ ;
 232    if ( nouty > maxstug ) maxstug = nouty ;
 233    if ( outy > maxouty ) maxouty = outy ;
 234 }else{
 235 #ifndef MS_SUA
 236 fprintf(stderr,"stug full %d\n",bbb) ;
 237 #endif
 238 RSL_FATAL(2) ;
 239 }
 240 #endif
 241    return(retval) ;
 242 }
 243
 244 void rsl_free( p )
 245    char **p ;
 246 {
 247    if ( *p == zero_length_storage ) return ;    /* fix from ANU */
 248
 249 #ifdef STUG
 250 for ( bbb = 0 ; bbb < MAXSTUG ; bbb++ )
 251 {
 252    if ( stug[bbb].ddr == *p ) {
 253       outy -= stug[bbb].sz ;
 254 /* fprintf(stderr,"- %10d.  %08x   %10d  %10d\n", bbb, stug[bbb].ddr, stug[bbb].sz, outy ) ; */
 255       nouty -- ;
 256       stug[bbb].ddr = 0L ;
 257       break ;
 258    }
 259 }
 260 #endif
 261
 262 #ifdef PADIT
 263    BASE_FREE ( *p-512 ) ;
 264 #else
 265    BASE_FREE ( *p ) ;
 266 #endif
 267    *p = NULL ;
 268 }
 269
 270 #ifdef MS_SUA
 271 bzero( char *buf, int l )
 272 {
 273    int i ;
 274    char * p ;
 275    for ( p = buf, i=0 ; i < l ; i++ ) *p = '\0' ;
 276 }
 277 #endif
 278