nco/nco_mmr.h File Reference

#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/resource.h>
#include <netcdf.h>
#include "nco_netcdf.h"
#include "nco.h"
#include "nco_ctl.h"

Include dependency graph for nco_mmr.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions
void *	nco_calloc (const size_t lmn_nbr, const size_t lmn_sz)
void *	nco_free (void *vp)
void *	nco_malloc (const size_t size)
void *	nco_malloc_flg (const size_t size)
void *	nco_malloc_dbg (const size_t sz, const char *fnc_nm, const char *msg)
void	nco_malloc_err_hnt_prn (void)
long	nco_mmr_rusage_prn (const int rusage_who)
long	nco_mmr_stt (const nco_mmr_typ_enm nco_mmr_typ, const size_t sz)
const char *	nco_mmr_typ_sng (const nco_mmr_typ_enm nco_mmr_typ)
void *	nco_realloc (void *ptr, const size_t size)

---

Function Documentation

void* nco_calloc (  const size_t  lmn_nbr, const size_t  lmn_sz )

Definition at line 32 of file nco_mmr.c. References EXIT_FAILURE, nco_exit(), nco_mmr_calloc, nco_mmr_stt(), and prg_nm_get(). Referenced by nco_msa_rec_clc(), and nco_var_lst_mk(). { /* Purpose: Custom wrapper for calloc(), modified from nco_malloc() Routine prints error when calloc() returns a NULL pointer Routine does not call calloc() when lmn_sz == 0 or lmn_nbr == 0 */ void *ptr; /* [ptr] Pointer to new buffer */ /* Circumvent calloc() calls when lmn_sz == 0 */ if(lmn_sz == 0 || lmn_nbr == 0) return NULL; ptr=calloc(lmn_nbr,lmn_sz); /* [ptr] Pointer to new buffer */ if(ptr == NULL){ (void)fprintf(stdout,"%s: ERROR nco_calloc() unable to allocate %lu elements of %lu bytes = %lu bytes\n",prg_nm_get(),(unsigned long)lmn_nbr,(unsigned long)lmn_sz,(unsigned long)(lmn_nbr*lmn_sz)); nco_exit(EXIT_FAILURE); } /* endif */ #ifdef NCO_MMR_DBG (void)nco_mmr_stt(nco_mmr_calloc,lmn_nbr*lmn_sz); /* fxm dbg */ #endif /* !NCO_MMR_DBG */ return ptr; /* [ptr] Pointer to new buffer */ } /* nco_calloc() */

void* nco_free (  void *  vp  )

Definition at line 57 of file nco_mmr.c. References nco_mmr_free, and nco_mmr_stt(). Referenced by copyright_prn(), cvs_vrs_prs(), glb_init_free(), lst_heapsort(), lst_prs_2D(), main(), ncap_att_init(), ncap_att_stretch(), ncap_do_cst(), ncap_var_init(), ncap_var_stretch(), ncap_var_write(), NcapVar::NcapVar(), nco_aed_prc(), nco_arm_time_install(), nco_att_cpy(), nco_cnv_ccm_ccsm_cf_inq(), nco_cnv_mss_val_typ(), nco_cpy_var_dfn(), nco_cpy_var_dfn_lmt(), nco_cpy_var_val(), nco_cpy_var_val_lmt(), nco_cpy_var_val_mlt_lmt(), nco_dmn_free(), nco_dmn_lst_free(), nco_exit_gracefully(), nco_fl_cp(), nco_fl_info_get(), nco_fl_lst_att_cat(), nco_fl_lst_mk(), nco_fl_mk_lcl(), nco_fl_mv(), nco_fl_nm_prs(), nco_fl_out_open(), nco_fl_rm(), nco_hst_att_cat(), nco_lbr_vrs_prn(), nco_lmt_all_free(), nco_lmt_all_lst_free(), nco_lmt_evl(), nco_lmt_free(), nco_lmt_lst_free(), nco_lmt_prs(), nco_msa_clc_cnt(), nco_msa_clc_idx(), nco_msa_prn_var_val(), nco_msa_ram_2_dsk(), nco_msa_rec_clc(), nco_mss_val_get(), nco_nm_id_lst_free(), nco_prn_att(), nco_prn_var_dfn(), nco_prn_var_val_lmt(), nco_prs_aed_lst(), nco_realloc(), nco_sng_lst_free(), nco_usg_prn(), nco_var_avg(), nco_var_cnf_dmn(), nco_var_cnf_typ(), nco_var_dmn_rdr_mtd(), nco_var_free(), nco_var_lst_crd_xcl(), nco_var_lst_free(), nco_var_lst_mk(), nco_var_lst_mrg(), nco_var_lst_xcl(), nco_var_pck(), nco_var_upk(), nco_var_upk_swp(), nco_var_val_cpy(), prg_prs(), ptr_unn_2_scl_dbl(), and sng_lst_cat(). { /* Purpose: Custom wrapper for free() Free memory and set pointer to NULL Routine does not call free() when vp == NULL Usage: vp=nco_free(vp) */ if(vp != NULL) free(vp); #ifdef NCO_MMR_DBG (void)nco_mmr_stt(nco_mmr_free,(size_t)0L); /* fxm dbg */ #endif /* !NCO_MMR_DBG */ return NULL; /* [ptr] Pointer to new buffer */ } /* nco_free() */

void* nco_malloc (  const size_t  size  )

Definition at line 72 of file nco_mmr.c. References EXIT_FAILURE, nco_exit(), nco_malloc_err_hnt_prn(), nco_mmr_malloc, nco_mmr_stt(), and prg_nm_get(). Referenced by copyright_prn(), cvs_vrs_prs(), lst_heapsort(), lst_prs_1D(), lst_prs_2D(), main(), ncap_att_init(), ncap_att_stretch(), ncap_mk_cst(), ncap_scv_2_ptr_unn(), ncap_sym_init(), ncap_var_init(), nco_aed_prc(), nco_arm_time_install(), nco_att_cpy(), nco_cmd_ln_sng(), nco_cnv_ccm_ccsm_cf_inq(), nco_cnv_mss_val_typ(), nco_cpy_var_dfn(), nco_cpy_var_dfn_lmt(), nco_cpy_var_val(), nco_cpy_var_val_lmt(), nco_cpy_var_val_mlt_lmt(), nco_dmn_dpl(), nco_dmn_fll(), nco_dmn_lst(), nco_dmn_lst_ass_var(), nco_dmn_lst_mk(), nco_fl_cp(), nco_fl_lst_att_cat(), nco_fl_lst_mk(), nco_fl_mk_lcl(), nco_fl_mv(), nco_fl_nm_prs(), nco_fl_out_open(), nco_fl_rm(), nco_hst_att_cat(), nco_lbr_vrs_prn(), nco_lmt_evl(), nco_lmt_prs(), nco_lmt_sct_mk(), nco_lmt_udu_cnv(), nco_msa_clc_cnt(), nco_msa_clc_idx(), nco_msa_prn_idx(), nco_msa_prn_var_val(), nco_msa_ram_2_dsk(), nco_msa_rec_clc(), nco_msa_wrp_splt(), nco_mss_val_get(), nco_mss_val_mk(), nco_nm_id_lst_crd_make(), nco_prn_att(), nco_prn_var_dfn(), nco_prn_var_val_lmt(), nco_prs_aed_lst(), nco_prs_rnm_lst(), nco_realloc(), nco_var_avg(), nco_var_cnf_dmn(), nco_var_cnf_typ(), nco_var_dmn_rdr_mtd(), nco_var_dpl(), nco_var_fll(), nco_var_lst_add(), nco_var_lst_add_crd(), nco_var_lst_copy(), nco_var_lst_crd_xcl(), nco_var_lst_dvd(), nco_var_lst_mk(), nco_var_lst_mk_old(), nco_var_lst_mrg(), nco_var_lst_sub(), nco_var_lst_xcl(), nco_var_pck(), nco_var_upk(), nco_var_val_cpy(), ptr_unn_2_scl_dbl(), scl_dbl_mk_var(), scl_ptr_mk_var(), sng_lst_cat(), and var_lst_convert(). { /* Purpose: Custom plugin wrapper for malloc() Top of nco_mmr.c explains usage of nco_malloc(), nco_malloc_flg(), and nco_malloc_dbg() */ void *ptr; /* [ptr] Pointer to new buffer */ /* malloc(0) is ANSI-legal, albeit unnecessary NCO sometimes employs this degenerate case behavior of malloc() to simplify code Some debugging tools like Electric Fence consider any NULL returned by malloc() to be an error So circumvent malloc() calls when sz == 0 */ if(sz == 0) return NULL; ptr=malloc(sz); /* [ptr] Pointer to new buffer */ if(ptr == NULL){ (void)fprintf(stdout,"%s: ERROR nco_malloc() unable to allocate %lu bytes\n",prg_nm_get(),(unsigned long)sz); (void)nco_malloc_err_hnt_prn(); /* fxm: Should be exit(8) on ENOMEM errors? */ nco_exit(EXIT_FAILURE); } /* endif */ #ifdef NCO_MMR_DBG (void)nco_mmr_stt(nco_mmr_malloc,sz); /* fxm dbg */ #endif /* !NCO_MMR_DBG */ return ptr; /* [ptr] Pointer to new buffer */ } /* nco_malloc() */

void* nco_malloc_dbg (  const size_t  sz, const char *  fnc_nm, const char *  msg )

Definition at line 139 of file nco_mmr.c. References EXIT_FAILURE, nco_exit(), nco_malloc_err_hnt_prn(), nco_mmr_malloc, nco_mmr_stt(), and prg_nm_get(). Referenced by ncap_var_stretch(), nco_cpy_var_val(), nco_cpy_var_val_lmt(), nco_var_dpl(), and nco_var_get(). { /* Purpose: Custom wrapper for malloc(), non-plugin, receives and prints more diagnostics Top of nco_mmr.c explains usage of nco_malloc(), nco_malloc_flg(), and nco_malloc_dbg() */ #ifndef __GNUG__ extern int errno; /* [enm] Error code in errno.h */ #endif /* __GNUG__ */ void *ptr; /* [ptr] Pointer to new buffer */ /* malloc(0) is ANSI-legal, albeit unnecessary NCO sometimes employs this degenerate case behavior of malloc() to simplify code Some debugging tools like Electric Fence consider any NULL returned by malloc() to be an error So circumvent malloc() calls when sz == 0 */ if(sz == 0) return NULL; ptr=malloc(sz); /* [ptr] Pointer to new buffer */ if(ptr == NULL){ (void)fprintf(stdout,"%s: ERROR malloc() returns error on %s request for %lu bytes\n",prg_nm_get(),fnc_nm,(unsigned long)sz); #ifndef __GNUG__ /* 20051205: Triggers G++ error: undefined reference to `__errno_location()' */ (void)fprintf(stdout,"%s: malloc() error is \"%s\"\n",prg_nm_get(),strerror(errno)); #endif /* __GNUG__ */ (void)fprintf(stdout,"%s: User-supplied supplemental error message is \"%s\"\n",prg_nm_get(),msg); (void)nco_malloc_err_hnt_prn(); nco_exit(EXIT_FAILURE); } /* endif */ #ifdef NCO_MMR_DBG (void)nco_mmr_stt(nco_mmr_malloc,sz); /* fxm dbg */ #endif /* !NCO_MMR_DBG */ return ptr; /* [ptr] Pointer to new buffer */ } /* nco_malloc_dbg() */

void nco_malloc_err_hnt_prn (  void   )

Definition at line 177 of file nco_mmr.c. References prg_nm_get(). Referenced by nco_malloc(), nco_malloc_dbg(), and nco_malloc_flg(). { /* Purpose: Explain meaning and workarounds for malloc() failures */ (void)fprintf(stdout,"%s: INFO NCO has reported a malloc() failure. malloc() failures usually indicate that your machine does not have enough free memory (RAM+swap) to perform the requested operation. As such, malloc() failures result from the physical limitations imposed by your hardware. Read http://nco.sf.net/nco.html#mmr for a description of NCO memory usage. There are two workarounds in this scenario. One is to process your data in smaller chunks. The other is to use a machine with more free memory.\n\nLarge tasks may uncover memory leaks in NCO. This is likeliest to occur with ncap. ncap scripts are completely dynamic and may be of arbitrary length and complexity. A script that contains many thousands of operations may uncover a slow memory leak even though each single operation consumes little additional memory. Memory leaks are usually identifiable by their memory usage signature. Leaks cause peak memory usage to increase monotonically with time regardless of script complexity. Slow leaks are very difficult to find. Sometimes a malloc() failure is the only noticeable clue to their existance. If you have good reasons to believe that your malloc() failure is ultimately due to an NCO memory leak (rather than inadequate RAM on your system), then we would be very interested in receiving a detailed bug report.",prg_nm_get()); } /* nco_malloc_err_hnt_prn() */

void* nco_malloc_flg (  const size_t  size  )

Definition at line 100 of file nco_mmr.c. References EXIT_FAILURE, nco_exit(), nco_malloc_err_hnt_prn(), nco_mmr_malloc, nco_mmr_stt(), and prg_nm_get(). Referenced by main(), ncap_mk_cst(), and nco_aed_prc(). { /* Purpose: Custom plugin wrapper for malloc() that allows ENOMEM errors Top of nco_mmr.c explains usage of nco_malloc(), nco_malloc_flg(), and nco_malloc_dbg() */ #ifndef __GNUG__ extern int errno; /* [enm] Error code in errno.h */ #endif /* __GNUG__ */ void *ptr; /* [ptr] Pointer to new buffer */ /* malloc(0) is ANSI-legal, albeit unnecessary NCO sometimes employs this degenerate case behavior of malloc() to simplify code Some debugging tools like Electric Fence consider any NULL returned by malloc() to be an error So circumvent malloc() calls when sz == 0 */ if(sz == 0) return NULL; ptr=malloc(sz); /* [ptr] Pointer to new buffer */ if(ptr == NULL){ (void)fprintf(stdout,"%s: WARNING nco_malloc_flg() unable to allocate %lu bytes\n",prg_nm_get(),(unsigned long)sz); #ifndef __GNUG__ /* 20051205: Triggers G++ error: undefined reference to `__errno_location()' */ (void)fprintf(stdout,"%s: malloc() error is \"%s\"\n",prg_nm_get(),strerror(errno)); if(errno == ENOMEM) return NULL; /* Unlike nco_malloc(), allow simple OOM errors */ #else return NULL; /* Unlike nco_malloc(), allow simple OOM errors */ #endif /* __GNUG__ */ (void)fprintf(stdout,"%s: ERROR is not ENOMEM, exiting...\n",prg_nm_get()); (void)nco_malloc_err_hnt_prn(); nco_exit(EXIT_FAILURE); } /* endif */ #ifdef NCO_MMR_DBG (void)nco_mmr_stt(nco_mmr_malloc,sz); /* fxm dbg */ #endif /* !NCO_MMR_DBG */ return ptr; /* [ptr] Pointer to new buffer */ } /* nco_malloc_flg() */

long nco_mmr_rusage_prn (  const int  rusage_who  )

Definition at line 309 of file nco_mmr.c. References prg_nm_get(). Referenced by ncap_var_write(). { /* Purpose: Track memory statistics */ /* NB: As of kernel 2.6.9, Linux only maintains the fields ru_utime, ru_stime, ru_minflt, ru_majflt, and ru_nswap */ int rcd; int sz_pg; /* [B] Page size in Bytes */ struct rusage usg; /* Get page size */ sz_pg=getpagesize(); /* fxm: CEWI, not necessary */ rcd=rusage_who; /* fxm: use input argument rusage_who instead or RUSAGE_SELF */ rcd=getrusage(RUSAGE_SELF,&usg); #ifdef AIX (void)fprintf(stdout,"%s: INFO nco_mmr_rusage_prn() reports system type is AIX so rusage uses kilobytes [kB] for size and seconds [s] for time. Page size is %d B.\n",prg_nm_get(),sz_pg); #endif /* !AIX */ #ifdef LINUX (void)fprintf(stdout,"%s: INFO nco_mmr_rusage_prn() reports system type is LINUX so rusage does not implement ru_maxrss, ru_ixrss, ru_idrss, and ru_idrss. Page size is %d B.\n",prg_nm_get(),sz_pg); #endif /* !LINUX */ #ifdef SUNMP (void)fprintf(stdout,"%s: INFO nco_mmr_rusage_prn() reports system type is SUNMP so rusage uses pages [pg] for size and ticks [tck] for time. Page size is %d B.\n",prg_nm_get(),sz_pg); #endif /* !SUNMP */ /* rusage reports size and time in OS-dependent units: AIX uses kilobytes [kB] for size [sz] and seconds [s] for time [tm]: ru_maxrss [kB], ru_ixrss [kB s], ru_idrss [kB], ru_idrss [kB] http://publib.boulder.ibm.com/infocenter/pseries/index.jsp?topic=/com.ibm.aix.doc/libs/basetrf1/getrusage_64.htm Linux does not implement these fields yet ru_maxrss, ru_ixrss, ru_idrss, ru_idrss Solaris uses pages [pg] for size and ticks [tck] for time: ru_maxrss [pg], ru_ixrss [pg tck], ru_idrss [pg], ru_idrss [pg] http://docs.sun.com/app/docs/doc/816-5168/6mbb3hr9o?a=view */ (void)fprintf(stdout,"%s: INFO nco_mmr_rusage_prn() reports: rusage.ru_utime.tv_sec = user time used = %li s, rusage.ru_utime.tv_usec = user time used = %li us, rusage.ru_stime.tv_sec = system time used = %li s, rusage.ru_stime.tv_usec = system time used = %li us, rusage.ru_maxrss = maximum resident set size = %li [sz], rusage.ru_ixrss = integral shared memory size = %li [sz tm], rusage.ru_idrss = integral unshared data size = %li [sz], rusage.ru_isrss = integral unshared stack size = %li [sz], rusage.ru_minflt = page reclaims = %li, rusage.ru_majflt = page faults = %li, rusage.ru_nswap = swaps = %li\n",prg_nm_get(),usg.ru_utime.tv_sec,usg.ru_utime.tv_usec,usg.ru_stime.tv_sec,usg.ru_stime.tv_usec,usg.ru_maxrss,usg.ru_ixrss,usg.ru_idrss,usg.ru_isrss,usg.ru_minflt,usg.ru_majflt,usg.ru_nswap); return (long)usg.ru_maxrss; /* [B] Maximum resident set size */ } /* nco_mmr_rusage_prn() */

long nco_mmr_stt (  const nco_mmr_typ_enm  nco_mmr_typ, const size_t  sz )

Definition at line 262 of file nco_mmr.c. References EXIT_FAILURE, nco_exit(), nco_mmr_calloc, nco_mmr_free, nco_mmr_malloc, nco_mmr_realloc, nco_mmr_typ_sng(), prg_nm_get(), and True. Referenced by nco_calloc(), nco_free(), nco_malloc(), nco_malloc_dbg(), nco_malloc_flg(), and nco_realloc(). { /* Purpose: Track memory statistics */ static long mll_nbr=0L; /* [nbr] Number of malloc() invocations */ static long fre_nbr=0L; /* [nbr] Number of free() invocations */ static long mmr_mll_ttl=0L; /* [B] Total memory malloc()'d */ static long mmr_fre_ttl=0L; /* [B] Total memory free()'d */ static long mmr_net_crr=0L; /* [B] Net memory currently allocated */ long sz_lng; /* [B] Bytes allocated, deallocated, or reallocated, long */ sz_lng=(long)sz; /* [B] Bytes allocated, deallocated, or reallocated */ switch(nco_mmr_typ){ case nco_mmr_calloc: mll_nbr++; /* [nbr] Number of malloc() invocations */ mmr_mll_ttl+=sz_lng; /* [B] Total memory malloc()'d */ mmr_net_crr+=sz_lng; /* [B] Net memory currently allocated */ break; case nco_mmr_free: fre_nbr++; /* [nbr] Number of free() invocations */ mmr_fre_ttl-=sz_lng; /* [B] Total memory free()'d */ mmr_net_crr-=sz_lng; /* [B] Net memory currently allocated */ break; case nco_mmr_malloc: mll_nbr++; /* [nbr] Number of malloc() invocations */ mmr_mll_ttl+=sz_lng; /* [B] Total memory malloc()'d */ mmr_net_crr+=sz_lng; /* [B] Net memory currently allocated */ break; case nco_mmr_realloc: mll_nbr++; /* [nbr] Number of malloc() invocations */ mmr_mll_ttl+=sz_lng; /* [B] Total memory malloc()'d */ mmr_net_crr+=sz_lng; /* [B] Net memory currently allocated */ break; default: nco_exit(EXIT_FAILURE); break; } /* end case */ if(True){ (void)fprintf(stdout,"%s: INFO nco_mmr_stt() called by %s(): fre_nbr=%li, mll_nbr=%li, mmr_mll_ttl=%li, mmr_fre_ttl=%li, mmr_net_crr=%li bytes\n",prg_nm_get(),nco_mmr_typ_sng(nco_mmr_typ),fre_nbr,mll_nbr,mmr_mll_ttl,mmr_fre_ttl,mmr_net_crr); } /* endif */ return mmr_net_crr; /* [B] Net memory currently allocated */ } /* nco_mmr_stt() */

const char* nco_mmr_typ_sng (  const nco_mmr_typ_enm  nco_mmr_typ  )

Definition at line 186 of file nco_mmr.c. References nco_dfl_case_nc_type_err(), nco_mmr_calloc, nco_mmr_free, nco_mmr_malloc, and nco_mmr_realloc. Referenced by nco_mmr_stt(). { /* Purpose: Return name of memory function invoked */ switch(nco_mmr_typ){ case nco_mmr_calloc: return "nco_mmr_calloc"; case nco_mmr_free: return "nco_mmr_free"; case nco_mmr_malloc: return "nco_mmr_malloc"; case nco_mmr_realloc: return "nco_mmr_realloc"; default: nco_dfl_case_nc_type_err(); break; } /* end switch */ /* fxm: any advantage to this form? defining with file scope in header? static const char * const nco_mmr_calloc_sng="nco_mmr_calloc_sng"; static const char * const nco_mmr_free_sng="nco_mmr_free_sng"; static const char * const nco_mmr_malloc_sng="nco_mmr_malloc_sng"; static const char * const nco_mmr_realloc_sng="nco_mmr_realloc_sng"; switch(nco_mmr_typ){ case nco_mmr_calloc: return nco_mmr_calloc_sng; case nco_mmr_free: return nco_mmr_free_sng; case nco_mmr_malloc: return nco_mmr_malloc_sng; case nco_mmr_realloc: return nco_mmr_realloc_sng; default: nco_dfl_case_nc_type_err(); break; } *//* end switch */ /* Some compilers, e.g., SGI cc, need return statement to end non-void functions */ return (char *)NULL; } /* end nco_mmr_typ_sng() */

void* nco_realloc (  void *  ptr, const size_t  size )

Definition at line 225 of file nco_mmr.c. References EXIT_FAILURE, nco_exit(), nco_free(), nco_malloc(), nco_mmr_realloc, nco_mmr_stt(), and prg_nm_get(). Referenced by glb_init_free(), main(), nco_att_lst_mk(), nco_dmn_lst_ass_var(), nco_dmn_out_grow(), nco_fl_lst_mk(), nco_fl_mk_lcl(), nco_msa_wrp_splt(), nco_mss_val_cp(), nco_mss_val_get(), nco_nm_id_lst_crd_make(), nco_var_avg(), nco_var_lst_add(), nco_var_lst_add_crd(), nco_var_lst_ass_crd_add(), nco_var_lst_crd_xcl(), nco_var_lst_dvd(), nco_var_lst_mk(), nco_var_lst_mrg(), nco_var_lst_sub(), and nco_var_lst_xcl(). { /* Purpose: Custom wrapper for realloc() Routine prints error when realloc() returns a NULL pointer Routine does not call realloc() when sz == 0 */ void *new_ptr; /* [ptr] Pointer to new buffer */ /* This degenerate case sometimes occurs Performing realloc() call here would be ANSI-legal but would trigger Electric Fence */ if(ptr == NULL && sz == 0) return ptr; if(ptr != NULL && sz == 0){ ptr=nco_free(ptr); ptr=NULL; return ptr; } /* endif */ /* Passing NULL to realloc() is ANSI-legal, but may cause portability problems */ if(ptr == NULL && sz != 0){ new_ptr=nco_malloc(sz); /* [ptr] Pointer to new buffer */ }else{ new_ptr=realloc(ptr,sz); /* [ptr] Pointer to new buffer */ } /* endif */ if(new_ptr == NULL && sz != 0){ (void)fprintf(stdout,"%s: ERROR nco_realloc() unable to realloc() %lu bytes\n",prg_nm_get(),(unsigned long)sz); /* fxm: Should be exit(8) on ENOMEM errors? */ nco_exit(EXIT_FAILURE); } /* endif */ #ifdef NCO_MMR_DBG (void)nco_mmr_stt(nco_mmr_realloc,sz); /* fxm dbg */ #endif /* !NCO_MMR_DBG */ return new_ptr; /* [ptr] Pointer to new buffer */ } /* nco_realloc() */

---