2017-03-09 08:01:10 +08:00
|
|
|
/*********************************************************************
|
2018-12-07 05:24:28 +08:00
|
|
|
* Copyright 2018, UCAR/Unidata
|
2017-03-09 08:01:10 +08:00
|
|
|
* See netcdf/COPYRIGHT file for copying and redistribution conditions.
|
|
|
|
|
*********************************************************************/
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
External functions and state variables are
|
|
|
|
|
defined here, including function-like #defines.
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
#ifndef NCD4_H
|
|
|
|
|
#define NCD4_H 1
|
|
|
|
|
|
|
|
|
|
#include "d4includes.h"
|
|
|
|
|
#include "d4util.h"
|
|
|
|
|
#include "d4debug.h"
|
|
|
|
|
#include "nc4internal.h"
|
|
|
|
|
|
|
|
|
|
/**************************************************/
|
|
|
|
|
/* Constants */
|
|
|
|
|
|
|
|
|
|
#define RCFILEENV "DAPRCFILE"
|
|
|
|
|
|
|
|
|
|
/* Figure out a usable max path name max */
|
|
|
|
|
#ifdef PATH_MAX /* *nix* */
|
|
|
|
|
#define NC_MAX_PATH PATH_MAX
|
|
|
|
|
#else
|
|
|
|
|
# ifdef MAX_PATH /*windows*/
|
|
|
|
|
# define NC_MAX_PATH MAX_PATH
|
|
|
|
|
# else
|
|
|
|
|
# define NC_MAX_PATH 4096
|
|
|
|
|
# endif
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
#define COUNTERTYPE unsigned long long
|
|
|
|
|
#define COUNTERSIZE sizeof(COUNTERTYPE)
|
|
|
|
|
|
|
|
|
|
/* Clear allocated memory (see e.g. d4data.c); Potentially costly*/
|
|
|
|
|
#undef CLEARMEM
|
|
|
|
|
|
|
|
|
|
/* Clear empty structure alignment space; Potentially costly, but probably less than CLEARMEM */
|
|
|
|
|
#define CLEARSTRUCT
|
|
|
|
|
|
2018-10-31 10:48:12 +08:00
|
|
|
/* Always use fixed size opaques */
|
|
|
|
|
#define FIXEDOPAQUE
|
|
|
|
|
#define DFALTOPAQUESIZE 16
|
|
|
|
|
|
2020-01-09 06:18:31 +08:00
|
|
|
/* Size of a chunk header */
|
|
|
|
|
#define CHUNKHDRSIZE 4
|
|
|
|
|
|
2020-05-31 07:36:25 +08:00
|
|
|
/* Special attributes */
|
|
|
|
|
#define D4CHECKSUMATTR "_DAP4_Checksum_CRC32"
|
|
|
|
|
#define D4LEATTR "_DAP4_Little_Endian"
|
|
|
|
|
|
2017-03-09 08:01:10 +08:00
|
|
|
/**************************************************/
|
|
|
|
|
|
|
|
|
|
#undef nullfree
|
|
|
|
|
#ifndef nullfree
|
|
|
|
|
#define nullfree(m) ((m)==NULL?NULL:(free(m),NULL))
|
|
|
|
|
#endif
|
|
|
|
|
#define nulldup(s) ((s)==NULL?NULL:strdup(s))
|
|
|
|
|
|
|
|
|
|
/**************************************************/
|
|
|
|
|
/* DSP API wrappers */
|
|
|
|
|
|
|
|
|
|
#ifdef FIX
|
2022-02-09 11:53:30 +08:00
|
|
|
EXTERNL int dsp_getDMR(ND4dsp* dsp, DCR** dcrp);
|
|
|
|
|
EXTERNL int dsp_getDAP(ND4dsp* dsp, DCR** dcrp);
|
|
|
|
|
EXTERNL int dsp_close(ND4dsp* dsp);
|
2017-03-09 08:01:10 +08:00
|
|
|
|
|
|
|
|
/* DSP API */
|
2022-02-09 11:53:30 +08:00
|
|
|
EXTERNL int dsp_open(const char* path, ND4dsp** dspp);
|
2017-03-09 08:01:10 +08:00
|
|
|
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
/**************************************************/
|
|
|
|
|
|
|
|
|
|
/* From d4http.c */
|
2022-02-09 11:53:30 +08:00
|
|
|
EXTERNL long NCD4_fetchhttpcode(CURL* curl);
|
|
|
|
|
EXTERNL int NCD4_fetchurl(CURL* curl, const char* url, NCbytes* buf, long* filetime, int* httpcode);
|
|
|
|
|
EXTERNL int NCD4_curlopen(CURL** curlp);
|
|
|
|
|
EXTERNL void NCD4_curlclose(CURL* curl);
|
|
|
|
|
EXTERNL int NCD4_fetchlastmodified(CURL* curl, char* url, long* filetime);
|
|
|
|
|
EXTERNL int NCD4_ping(const char* url);
|
2017-03-09 08:01:10 +08:00
|
|
|
|
|
|
|
|
/* From d4read.c */
|
2023-10-09 09:59:28 +08:00
|
|
|
EXTERNL int NCD4_readDMR(NCD4INFO* state, int flags, NCURI* url, NCD4response*);
|
|
|
|
|
EXTERNL int NCD4_readDAP(NCD4INFO* state, int flags, NCURI* ceuri, NCD4response*);
|
|
|
|
|
EXTERNL int NCD4_seterrormessage(NCD4response*, size_t len, char* msg);
|
2017-03-09 08:01:10 +08:00
|
|
|
|
|
|
|
|
/* From d4parser.c */
|
2023-10-09 09:59:28 +08:00
|
|
|
EXTERNL int NCD4_parse(NCD4meta*, NCD4response*, int dapparse);
|
2022-02-09 11:53:30 +08:00
|
|
|
EXTERNL NCD4node* NCD4_findAttr(NCD4node* container, const char* attrname);
|
|
|
|
|
EXTERNL NCD4node* NCD4_groupFor(NCD4node* node);
|
|
|
|
|
EXTERNL int NCD4_defineattr(NCD4meta* meta, NCD4node* parent, const char* aname, const char* typename, NCD4node** attrp);
|
2023-10-09 09:59:28 +08:00
|
|
|
EXTERNL void NCD4_setdebuglevel(NCD4parser*,int);
|
2017-03-09 08:01:10 +08:00
|
|
|
|
|
|
|
|
/* From d4printer.c */
|
2022-02-09 11:53:30 +08:00
|
|
|
EXTERNL int NCD4_print(NCD4meta*, NCbytes* output);
|
2017-03-09 08:01:10 +08:00
|
|
|
|
|
|
|
|
/* From d4meta.c */
|
2022-02-09 11:53:30 +08:00
|
|
|
EXTERNL NCD4meta* NCD4_newmeta(NCD4INFO*);
|
|
|
|
|
EXTERNL void NCD4_attachraw(NCD4meta*, size_t size, void* rawdata);
|
|
|
|
|
EXTERNL void NCD4_reclaimMeta(NCD4meta*);
|
|
|
|
|
EXTERNL void NCD4_resetMeta(NCD4meta*);
|
|
|
|
|
EXTERNL void reclaimNode(NCD4node* node);
|
|
|
|
|
EXTERNL int NCD4_metabuild(NCD4meta*, int ncid);
|
|
|
|
|
EXTERNL size_t NCD4_computeTypeSize(NCD4meta*, NCD4node* type);
|
|
|
|
|
EXTERNL int NCD4_findvar(NC* ncp, int ncid, int varid, NCD4node** varp, NCD4node** grpp);
|
2023-10-09 09:59:28 +08:00
|
|
|
EXTERNL char* NCD4_getVarFQN(NCD4node* var, const char* tail);
|
|
|
|
|
|
2017-03-09 08:01:10 +08:00
|
|
|
|
|
|
|
|
/* From d4chunk.c */
|
2023-10-09 09:59:28 +08:00
|
|
|
EXTERNL int NCD4_dechunk(NCD4response*);
|
|
|
|
|
EXTERNL int NCD4_infermode(NCD4response*);
|
2021-01-15 12:39:08 +08:00
|
|
|
struct NCD4serial;
|
2022-02-09 11:53:30 +08:00
|
|
|
EXTERNL void NCD4_resetSerial(struct NCD4serial* serial, size_t rawsize, void* rawdata);
|
2023-10-09 09:59:28 +08:00
|
|
|
EXTERNL void NCD4_moveSerial(struct NCD4serial* serial, struct NCD4serial* dst);
|
2017-03-09 08:01:10 +08:00
|
|
|
|
|
|
|
|
/* From d4swap.c */
|
2023-10-09 09:59:28 +08:00
|
|
|
EXTERNL int NCD4_swapdata(NCD4response*, NCD4node* topvar, int doswap);
|
2017-03-09 08:01:10 +08:00
|
|
|
|
|
|
|
|
/* From d4fix.c */
|
2023-10-09 09:59:28 +08:00
|
|
|
EXTERNL int NCD4_delimit(NCD4meta*, NCD4node* var, NCD4offset* offset, int inferredchecksumming);
|
2022-11-16 11:29:21 +08:00
|
|
|
EXTERNL int NCD4_moveto(NCD4meta*, NCD4node* var, d4size_t count, NCD4offset* offset);
|
2022-02-09 11:53:30 +08:00
|
|
|
EXTERNL int NCD4_toposort(NCD4meta*);
|
2017-03-09 08:01:10 +08:00
|
|
|
|
|
|
|
|
/* From d4data.c */
|
2023-10-09 09:59:28 +08:00
|
|
|
EXTERNL int NCD4_parcelvars(NCD4meta* meta, NCD4response* resp);
|
|
|
|
|
EXTERNL int NCD4_processdata(NCD4meta*,NCD4response*);
|
|
|
|
|
EXTERNL int NCD4_movetoinstance(NCD4meta*, NCD4node* type, NCD4offset* offset, void** dstp, NClist* blobs);
|
2022-02-09 11:53:30 +08:00
|
|
|
EXTERNL int NCD4_getToplevelVars(NCD4meta* meta, NCD4node* group, NClist* toplevel);
|
2023-10-09 09:59:28 +08:00
|
|
|
EXTERNL int NCD4_inferChecksums(NCD4meta* meta, NCD4response* resp);
|
2017-03-09 08:01:10 +08:00
|
|
|
|
|
|
|
|
/* From d4util.c */
|
2022-02-09 11:53:30 +08:00
|
|
|
EXTERNL d4size_t NCD4_dimproduct(NCD4node* node);
|
|
|
|
|
EXTERNL size_t NCD4_typesize(nc_type tid);
|
|
|
|
|
EXTERNL int NCD4_isLittleEndian(void);/* Return 1 if this machine is little endian */
|
|
|
|
|
EXTERNL int NCD4_errorNC(int code, const int line, const char* file);
|
|
|
|
|
EXTERNL int NCD4_error(int code, const int line, const char* file, const char* fmt, ...);
|
|
|
|
|
EXTERNL char* NCD4_makeFQN(NCD4node* node);
|
|
|
|
|
EXTERNL char* NCD4_makeName(NCD4node*,const char* sep);
|
|
|
|
|
EXTERNL int NCD4_parseFQN(const char* fqn0, NClist* pieces);
|
|
|
|
|
EXTERNL char* NCD4_deescape(const char* esc);
|
|
|
|
|
EXTERNL char* NCD4_entityescape(const char* s);
|
|
|
|
|
EXTERNL size_t NCD4_elidenuls(char* s, size_t slen);
|
|
|
|
|
EXTERNL void* NCD4_getheader(void* p, NCD4HDR* hdr, int hostlittleendian);
|
2023-10-09 09:59:28 +08:00
|
|
|
EXTERNL void NCD4_reporterror(NCD4response*, NCURI* uri);
|
2017-03-09 08:01:10 +08:00
|
|
|
|
|
|
|
|
/* From d4dump.c */
|
2022-02-09 11:53:30 +08:00
|
|
|
EXTERNL void NCD4_dumpbytes(size_t size, const void* data0, int swap);
|
|
|
|
|
EXTERNL void NCD4_tagdump(size_t size, const void* data0, int swap, const char* tag);
|
|
|
|
|
EXTERNL void NCD4_dumpvars(NCD4node* group);
|
|
|
|
|
EXTERNL union ATOMICS* NCD4_dumpatomic(NCD4node* var, void* data);
|
2017-03-09 08:01:10 +08:00
|
|
|
|
|
|
|
|
/* From d4rc.c */
|
2022-02-09 11:53:30 +08:00
|
|
|
EXTERNL int NCD4_rcload(void);
|
|
|
|
|
EXTERNL int NCD4_rcprocess(NCD4INFO* info);
|
|
|
|
|
EXTERNL void NCD4_rcfree(NClist* rc);
|
|
|
|
|
EXTERNL char* NCD4_rclookup(char* key, char* hostport);
|
|
|
|
|
EXTERNL int NCD4_parseproxy(NCD4INFO* info, const char* surl);
|
|
|
|
|
EXTERNL int NCD4_rcdefault(NCD4INFO*);
|
2017-03-09 08:01:10 +08:00
|
|
|
|
|
|
|
|
/* From d4cvt.c */
|
2022-02-09 11:53:30 +08:00
|
|
|
EXTERNL int NCD4_convert(nc_type srctype, nc_type dsttype, char* memory0, char* value0, size_t count);
|
2017-03-09 08:01:10 +08:00
|
|
|
|
2018-10-31 10:48:12 +08:00
|
|
|
/* d4file.c */
|
2022-02-09 11:53:30 +08:00
|
|
|
EXTERNL int NCD4_readDMRorDAP(NCD4INFO* d4info, NCD4mode mode);
|
2022-11-14 04:15:11 +08:00
|
|
|
EXTERNL void NCD4_applyclientfragmentcontrols(NCD4INFO* d4info);
|
2023-10-09 09:59:28 +08:00
|
|
|
EXTERNL void NCD4_applychecksumcontrols(NCD4INFO* d4info, NCD4response*);
|
|
|
|
|
EXTERNL int NCD4_newInfo(NCD4INFO** d4infop);
|
|
|
|
|
EXTERNL void NCD4_reclaimInfo(NCD4INFO* d4info);
|
|
|
|
|
EXTERNL void NCD4_resetInfoforRead(NCD4INFO* d4info);
|
|
|
|
|
EXTERNL int NCD4_newResponse(NCD4INFO*,NCD4response** respp);
|
|
|
|
|
EXTERNL void NCD4_reclaimResponse(NCD4response* d4resp);
|
|
|
|
|
EXTERNL void NCD4_resetInfoForRead(NCD4INFO* d4info);
|
|
|
|
|
EXTERNL int NCD4_newMeta(NCD4INFO*,NCD4meta**);
|
|
|
|
|
EXTERNL void NCD4_reclaimMeta(NCD4meta*);
|
2017-03-09 08:01:10 +08:00
|
|
|
|
2020-05-31 07:36:25 +08:00
|
|
|
/* ncd4dispatch.c */
|
|
|
|
|
struct NC_reservedatt; /*forward*/
|
2022-02-09 11:53:30 +08:00
|
|
|
EXTERNL const struct NC_reservedatt* NCD4_lookupreserved(const char* name);
|
2020-05-31 07:36:25 +08:00
|
|
|
|
2017-03-09 08:01:10 +08:00
|
|
|
/* Add an extra function whose sole purpose is to allow
|
|
|
|
|
configure(.ac) to test for the presence of this code.
|
|
|
|
|
*/
|
2022-02-09 11:53:30 +08:00
|
|
|
EXTERNL int nc__dap4(void);
|
2017-03-09 08:01:10 +08:00
|
|
|
|
|
|
|
|
/**************************************************/
|
|
|
|
|
/* Macro defined functions */
|
|
|
|
|
|
|
|
|
|
#undef NCCHECK
|
|
|
|
|
#undef FAIL
|
|
|
|
|
#define NCCHECK(expr) if((ret=(expr))) {ret = NCD4_errorNC(ret,__LINE__,__FILE__); goto done;}else{}
|
|
|
|
|
#define FAIL(code,fmt,...) do{ret=NCD4_error(code,__LINE__,__FILE__,fmt , ##__VA_ARGS__); goto done;}while(0)
|
|
|
|
|
|
2022-11-16 11:29:21 +08:00
|
|
|
#undef BUILDOFFSET
|
|
|
|
|
#define BUILDOFFSET(base,size) NCD4_buildoffset(base,size)
|
|
|
|
|
EXTERNL NCD4offset* NCD4_buildoffset(void* base, d4size_t size);
|
|
|
|
|
|
2017-03-09 08:01:10 +08:00
|
|
|
#undef INCR
|
|
|
|
|
#undef DECR
|
|
|
|
|
#undef DELTA
|
2022-11-16 11:29:21 +08:00
|
|
|
#if 0
|
|
|
|
|
#define INCR(offset,size) ((void*)(((char*)(offset->offset))+(size)))
|
|
|
|
|
#define DECR(offset,size) ((void*)(((char*)(offset->offset))-(size)))
|
|
|
|
|
#define DELTA(p1,p2) ((ptrdiff_t)(((char*)(p1))-((char*)(p2))))
|
|
|
|
|
#endif
|
|
|
|
|
EXTERNL void NCD4_incr(NCD4offset* p, d4size_t size);
|
|
|
|
|
EXTERNL void NCD4_decr(NCD4offset* p, d4size_t size);
|
|
|
|
|
#define INCR(offset,size) NCD4_incr(offset,size)
|
|
|
|
|
#define DECR(offset,size) NCD4_decr(offset,size)
|
|
|
|
|
#define OFFSETSIZE(p,mark) ((d4size_t)(((ptrdiff_t)(p)->offset) - ((ptrdiff_t)(mark))))
|
|
|
|
|
#define TRANSFER(dst,src,size) memcpy((dst),(src)->offset,size)
|
2017-03-09 08:01:10 +08:00
|
|
|
#define DELTA(p1,p2) ((ptrdiff_t)(((char*)(p1))-((char*)(p2))))
|
2022-11-16 11:29:21 +08:00
|
|
|
#define MARK(p,mark) do {(mark) = (p)->offset;} while(0)
|
2017-03-09 08:01:10 +08:00
|
|
|
|
|
|
|
|
#undef GETCOUNTER
|
|
|
|
|
#undef SKIPCOUNTER
|
2020-10-18 05:19:37 +08:00
|
|
|
|
|
|
|
|
/* Unclear which macros are defined for which compilers.
|
|
|
|
|
see: https://sourceforge.net/p/predef/wiki/Architectures/
|
|
|
|
|
*/
|
2022-11-16 11:29:21 +08:00
|
|
|
#if 0
|
2020-10-20 01:01:52 +08:00
|
|
|
#if defined(__arm__) && __ARM_ARCH < 8
|
2020-10-20 03:32:09 +08:00
|
|
|
EXTERNL d4size_t NCD4_getcounter(void* p);
|
|
|
|
|
#define GETCOUNTER(p) NCD4_getcounter(p)
|
2020-10-18 05:19:37 +08:00
|
|
|
#else
|
2017-03-09 08:01:10 +08:00
|
|
|
#define GETCOUNTER(p) ((d4size_t)*((COUNTERTYPE*)(p)))
|
2022-11-16 11:29:21 +08:00
|
|
|
#endif
|
|
|
|
|
#endif /*0*/
|
|
|
|
|
EXTERNL d4size_t NCD4_getcounter(NCD4offset* p);
|
|
|
|
|
#define GETCOUNTER(p) NCD4_getcounter(p)
|
2020-10-20 01:01:52 +08:00
|
|
|
|
2022-11-16 11:29:21 +08:00
|
|
|
#define SKIPCOUNTER(p) INCR(p,COUNTERSIZE)
|
2017-03-09 08:01:10 +08:00
|
|
|
|
|
|
|
|
#undef PUSH
|
|
|
|
|
#define PUSH(list,value) do{if((list)==NULL) {(list)=nclistnew();} else{}; nclistpush((list),(value));}while(0)
|
|
|
|
|
|
|
|
|
|
#define getnc3id(d4) (getdap(d4)->nc4id)
|
|
|
|
|
|
|
|
|
|
#define ISTOPLEVEL(var) ((var)->container == NULL || (var)->container->sort == NCD4_GROUP)
|
|
|
|
|
|
|
|
|
|
#define FILEIDPART(NCID) (((unsigned int) (NCID)) >> ID_SHIFT)
|
|
|
|
|
#define GROUPIDPART(NCID) (((unsigned int) (NCID)) & GRP_ID_MASK)
|
|
|
|
|
#define MAKENCID(grp,file) ((((unsigned int)(file)) << ID_SHIFT) | (grp))
|
|
|
|
|
|
|
|
|
|
#define getdap(ncp) ((NCD4INFO*)((NC*)ncp)->dispatchdata)
|
|
|
|
|
#define getnc4id(ncp) (getdap(ncp)->substrate.nc4id)
|
|
|
|
|
|
|
|
|
|
/* Convert a dap4 grpid to a substrate id */
|
|
|
|
|
#define makenc4id(ncp,dap4id) (((dap4id) & GRP_ID_MASK) | getdap(ncp)->substrate.nc4id)
|
|
|
|
|
/* and the inverse */
|
|
|
|
|
#define makedap4id(ncp,nc4id) (((nc4id) & GRP_ID_MASK) | (ncp)->ext_ncid)
|
|
|
|
|
|
|
|
|
|
#ifdef CLEARMEM
|
|
|
|
|
#define d4alloc(n) (calloc(1,(size_t)(n)))
|
|
|
|
|
#else
|
|
|
|
|
#define d4alloc(n) (malloc((size_t)(n)))
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
/* A number of hacks have been inserted
|
|
|
|
|
to deal with issues in accessing hyrax
|
|
|
|
|
using DAP4.
|
|
|
|
|
*/
|
2020-05-31 07:36:25 +08:00
|
|
|
#define HYRAXHACK
|
2017-03-09 08:01:10 +08:00
|
|
|
|
Improve performance of the nc_reclaim_data and nc_copy_data functions.
re: Issue https://github.com/Unidata/netcdf-c/issues/2685
re: PR https://github.com/Unidata/netcdf-c/pull/2179
As noted in PR https://github.com/Unidata/netcdf-c/pull/2179,
the old code did not allow for reclaiming instances of types,
nor for properly copying them. That PR provided new functions
capable of reclaiming/copying instances of arbitrary types.
However, as noted by Issue https://github.com/Unidata/netcdf-c/issues/2685, using these
most general functions resulted in a significant performance
degradation, even for common cases.
This PR attempts to mitigate the cost of using the general
reclaim/copy functions in two ways.
First, the previous functions operating at the top level by
using ncid and typeid arguments. These functions were augmented
with equivalent versions that used the netcdf-c library internal
data structures to allow direct access to needed information.
These new functions are used internally to the library.
The second mitigation involves optimizing the internal functions
by providing early tests for common cases. This avoids
unnecessary recursive function calls.
The overall result is a significant improvement in speed by a
factor of roughly twenty -- your mileage may vary. These
optimized functions are still not as fast as the original (more
limited) functions, but they are getting close. Additional optimizations are
possible. But the cost is a significant "uglification" of the
code that I deemed a step too far, at least for now.
## Misc. Changes
1. Added a test case to check the proper reclamation/copy of complex types.
2. Found and fixed some places where nc_reclaim/copy should have been used.
3. Replaced, in the netcdf-c library, (almost all) occurrences of nc_reclaim_copy with calls to NC_reclaim/copy. This plus the optimizations is the primary speed-up mechanism.
4. In DAP4, the metadata is held in a substrate in-memory file; this required some changes so that the reclaim/copy code accessed that substrate dispatcher rather than the DAP4 dispatcher.
5. Re-factored and isolated the code that computes if a type is (transitively) variable-sized or not.
6. Clean up the reclamation code in ncgen; adding the use of nc_reclaim exposed some memory problems.
2023-05-21 07:11:25 +08:00
|
|
|
EXTERNL NC* NCD4_get_substrate_nc(NC* nc);
|
Fix various problem around VLEN's
re: https://github.com/Unidata/netcdf-c/issues/541
re: https://github.com/Unidata/netcdf-c/issues/1208
re: https://github.com/Unidata/netcdf-c/issues/2078
re: https://github.com/Unidata/netcdf-c/issues/2041
re: https://github.com/Unidata/netcdf-c/issues/2143
For a long time, there have been known problems with the
management of complex types containing VLENs. This also
involves the string type because it is stored as a VLEN of
chars.
This PR (mostly) fixes this problem. But note that it adds new
functions to netcdf.h (see below) and this may require bumping
the .so number. These new functions can be removed, if desired,
in favor of functions in netcdf_aux.h, but netcdf.h seems the
better place for them because they are intended as alternatives
to the nc_free_vlen and nc_free_string functions already in
netcdf.h.
The term complex type refers to any type that directly or
transitively references a VLEN type. So an array of VLENS, a
compound with a VLEN field, and so on.
In order to properly handle instances of these complex types, it
is necessary to have function that can recursively walk
instances of such types to perform various actions on them. The
term "deep" is also used to mean recursive.
At the moment, the two operations needed by the netcdf library are:
* free'ing an instance of the complex type
* copying an instance of the complex type.
The current library does only shallow free and shallow copy of
complex types. This means that only the top level is properly
free'd or copied, but deep internal blocks in the instance are
not touched.
Note that the term "vector" will be used to mean a contiguous (in
memory) sequence of instances of some type. Given an array with,
say, dimensions 2 X 3 X 4, this will be stored in memory as a
vector of length 2*3*4=24 instances.
The use cases are primarily these.
## nc_get_vars
Suppose one is reading a vector of instances using nc_get_vars
(or nc_get_vara or nc_get_var, etc.). These functions will
return the vector in the top-level memory provided. All
interior blocks (form nested VLEN or strings) will have been
dynamically allocated.
After using this vector of instances, it is necessary to free
(aka reclaim) the dynamically allocated memory, otherwise a
memory leak occurs. So, the recursive reclaim function is used
to walk the returned instance vector and do a deep reclaim of
the data.
Currently functions are defined in netcdf.h that are supposed to
handle this: nc_free_vlen(), nc_free_vlens(), and
nc_free_string(). Unfortunately, these functions only do a
shallow free, so deeply nested instances are not properly
handled by them.
Note that internally, the provided data is immediately written so
there is no need to copy it. But the caller may need to reclaim the
data it passed into the function.
## nc_put_att
Suppose one is writing a vector of instances as the data of an attribute
using, say, nc_put_att.
Internally, the incoming attribute data must be copied and stored
so that changes/reclamation of the input data will not affect
the attribute.
Again, the code inside the netcdf library does only shallow copying
rather than deep copy. As a result, one sees effects such as described
in Github Issue https://github.com/Unidata/netcdf-c/issues/2143.
Also, after defining the attribute, it may be necessary for the user
to free the data that was provided as input to nc_put_att().
## nc_get_att
Suppose one is reading a vector of instances as the data of an attribute
using, say, nc_get_att.
Internally, the existing attribute data must be copied and returned
to the caller, and the caller is responsible for reclaiming
the returned data.
Again, the code inside the netcdf library does only shallow copying
rather than deep copy. So this can lead to memory leaks and errors
because the deep data is shared between the library and the user.
# Solution
The solution is to build properly recursive reclaim and copy
functions and use those as needed.
These recursive functions are defined in libdispatch/dinstance.c
and their signatures are defined in include/netcdf.h.
For back compatibility, corresponding "ncaux_XXX" functions
are defined in include/netcdf_aux.h.
````
int nc_reclaim_data(int ncid, nc_type xtypeid, void* memory, size_t count);
int nc_reclaim_data_all(int ncid, nc_type xtypeid, void* memory, size_t count);
int nc_copy_data(int ncid, nc_type xtypeid, const void* memory, size_t count, void* copy);
int nc_copy_data_all(int ncid, nc_type xtypeid, const void* memory, size_t count, void** copyp);
````
There are two variants. The first two, nc_reclaim_data() and
nc_copy_data(), assume the top-level vector is managed by the
caller. For reclaim, this is so the user can use, for example, a
statically allocated vector. For copy, it assumes the user
provides the space into which the copy is stored.
The second two, nc_reclaim_data_all() and
nc_copy_data_all(), allows the functions to manage the
top-level. So for nc_reclaim_data_all, the top level is
assumed to be dynamically allocated and will be free'd by
nc_reclaim_data_all(). The nc_copy_data_all() function
will allocate the top level and return a pointer to it to the
user. The user can later pass that pointer to
nc_reclaim_data_all() to reclaim the instance(s).
# Internal Changes
The netcdf-c library internals are changed to use the proper
reclaim and copy functions. It turns out that the places where
these functions are needed is quite pervasive in the netcdf-c
library code. Using these functions also allows some
simplification of the code since the stdata and vldata fields of
NC_ATT_INFO are no longer needed. Currently this is commented
out using the SEPDATA \#define macro. When any bugs are largely
fixed, all this code will be removed.
# Known Bugs
1. There is still one known failure that has not been solved.
All the failures revolve around some variant of this .cdl file.
The proximate cause of failure is the use of a VLEN FillValue.
````
netcdf x {
types:
float(*) row_of_floats ;
dimensions:
m = 5 ;
variables:
row_of_floats ragged_array(m) ;
row_of_floats ragged_array:_FillValue = {-999} ;
data:
ragged_array = {10, 11, 12, 13, 14}, {20, 21, 22, 23}, {30, 31, 32},
{40, 41}, _ ;
}
````
When a solution is found, I will either add it to this PR or post a new PR.
# Related Changes
* Mark nc_free_vlen(s) as deprecated in favor of ncaux_reclaim_data.
* Remove the --enable-unfixed-memory-leaks option.
* Remove the NC_VLENS_NOTEST code that suppresses some vlen tests.
* Document this change in docs/internal.md
* Disable the tst_vlen_data test in ncdump/tst_nccopy4.sh.
* Mark types as fixed size or not (transitively) to optimize the reclaim
and copy functions.
# Misc. Changes
* Make Doxygen process libdispatch/daux.c
* Make sure the NC_ATT_INFO_T.container field is set.
2022-01-09 09:30:00 +08:00
|
|
|
|
2017-03-09 08:01:10 +08:00
|
|
|
#endif /*NCD4_H*/
|
|
|
|
|
|
