/*
* Write out just the numrecs member.
* (A relatively expensive way to do things.)
*/
int
write_numrecs(NC *ncp)
{
int status = NC_NOERR;
void *xp = NULL;
assert(!NC_readonly(ncp));
assert(!NC_indef(ncp));
status = ncp->nciop->get(ncp->nciop,
NC_NUMRECS_OFFSET, NC_NUMRECS_EXTENT, RGN_WRITE, &xp);
if(status != NC_NOERR)
return status;
{
const size_t nrecs = NC_get_numrecs(ncp);
status = ncx_put_size_t(&xp, &nrecs);
}
(void) ncp->nciop->rel(ncp->nciop, NC_NUMRECS_OFFSET, RGN_MODIFIED);
if(status == NC_NOERR)
fClr(ncp->flags, NC_NDIRTY);
return status;
}
/*
* Read just the numrecs member.
* (A relatively expensive way to do things.)
*/
int
read_numrecs(NC *ncp)
{
int status = NC_NOERR;
const void *xp = NULL;
size_t nrecs = NC_get_numrecs(ncp);
assert(!NC_indef(ncp));
#define NC_NUMRECS_OFFSET 4
#define NC_NUMRECS_EXTENT 4
status = ncp->nciop->get(ncp->nciop,
NC_NUMRECS_OFFSET, NC_NUMRECS_EXTENT, 0, (void **)&xp);
/* cast away const */
if(status != NC_NOERR)
return status;
status = ncx_get_size_t(&xp, &nrecs);
(void) ncp->nciop->rel(ncp->nciop, NC_NUMRECS_OFFSET, 0);
if(status == NC_NOERR)
{
NC_set_numrecs(ncp, nrecs);
fClr(ncp->flags, NC_NDIRTY);
}
return status;
}
/*
* Write out the header
*/
static int
write_NC(NC *ncp)
{
int status = NC_NOERR;
assert(!NC_readonly(ncp));
status = ncx_put_NC(ncp, NULL, 0, 0);
if(status == NC_NOERR)
fClr(ncp->flags, NC_NDIRTY | NC_HDIRTY);
return status;
}
/*
* Read in the header
* It is expensive.
*/
static int
read_NC(NC *ncp)
{
int status = NC_NOERR;
free_NC_dimarrayV(&ncp->dims);
free_NC_attrarrayV(&ncp->attrs);
free_NC_vararrayV(&ncp->vars);
status = nc_get_NC(ncp);
if(status == NC_NOERR)
fClr(ncp->flags, NC_NDIRTY | NC_HDIRTY);
return status;
}
int
nc_set_fill(int ncid,
int fillmode, int *old_mode_ptr)
{
int status;
NC *ncp;
int oldmode;
status = NC_check_id(ncid, &ncp);
if(status != NC_NOERR)
return status;
if(NC_readonly(ncp))
return NC_EPERM;
oldmode = fIsSet(ncp->flags, NC_NOFILL) ? NC_NOFILL : NC_FILL;
if(fillmode == NC_NOFILL)
{
fSet(ncp->flags, NC_NOFILL);
}
else if(fillmode == NC_FILL)
{
if(fIsSet(ncp->flags, NC_NOFILL))
{
/*
* We are changing back to fill mode
* so do a sync
*/
status = NC_sync(ncp);
if(status != NC_NOERR)
return status;
}
fClr(ncp->flags, NC_NOFILL);
}
else
{
return NC_EINVAL; /* Invalid fillmode */
}
if(old_mode_ptr != NULL)
*old_mode_ptr = oldmode;
return NC_NOERR;
}
/*
* In data mode, same as ncclose.
* In define mode, restore previous definition.
* In create, remove the file.
*/
int
nc_abort(int ncid)
{
int status;
NC *ncp;
int doUnlink = 0;
status = NC_check_id(ncid, &ncp);
if(status != NC_NOERR)
return status;
doUnlink = NC_IsNew(ncp);
if(ncp->old != NULL)
{
/* a plain redef, not a create */
assert(!NC_IsNew(ncp));
assert(fIsSet(ncp->flags, NC_INDEF));
free_NC(ncp->old);
ncp->old = NULL;
fClr(ncp->flags, NC_INDEF);
}
else if(!NC_readonly(ncp))
{
status = NC_sync(ncp);
if(status != NC_NOERR)
return status;
}
(void) ncio_close(ncp->nciop, doUnlink);
ncp->nciop = NULL;
del_from_NCList(ncp);
free_NC(ncp);
return NC_NOERR;
}
/* See ncd3dispatch.c for other version */
int
NCD3_open(const char * path, int mode,
int basepe, size_t *chunksizehintp,
int useparallel, void* mpidata,
NC_Dispatch* dispatch, NC** ncpp)
{
NCerror ncstat = NC_NOERR;
OCerror ocstat = OC_NOERR;
NC* drno = NULL;
NCDAPCOMMON* dapcomm = NULL;
const char* value;
char* tmpname = NULL;
if(!nc3dinitialized) nc3dinitialize();
if(path == NULL)
return NC_EDAPURL;
if(dispatch == NULL) PANIC("NC3D_open: no dispatch table");
/* Setup our NC and NCDAPCOMMON state*/
drno = (NC*)calloc(1,sizeof(NC));
if(drno == NULL) {ncstat = NC_ENOMEM; goto done;}
/* compute an ncid */
ncstat = add_to_NCList(drno);
if(ncstat != NC_NOERR) {THROWCHK(ncstat); goto done;}
dapcomm = (NCDAPCOMMON*)calloc(1,sizeof(NCDAPCOMMON));
if(dapcomm == NULL) {ncstat = NC_ENOMEM; goto done;}
drno->dispatch = dispatch;
drno->dispatchdata = dapcomm;
dapcomm->controller = (NC*)drno;
dapcomm->cdf.separator = ".";
dapcomm->cdf.smallsizelimit = DFALTSMALLLIMIT;
dapcomm->cdf.cache = createnccache();
#ifdef HAVE_GETRLIMIT
{ struct rlimit rl;
if(getrlimit(RLIMIT_NOFILE, &rl) >= 0) {
dapcomm->cdf.cache->cachecount = (size_t)(rl.rlim_cur / 2);
}
}
#endif
#ifdef OCCOMPILEBYDEFAULT
/* set the compile flag by default */
dapcomm->oc.rawurltext = (char*)emalloc(strlen(path)+strlen("[compile]")+1);
strcpy(dapcomm->oc.rawurltext,"[compile]");
strcat(dapcomm->oc.rawurltext, path);
#else
dapcomm->oc.rawurltext = strdup(path);
#endif
nc_uriparse(dapcomm->oc.rawurltext,&dapcomm->oc.url);
/* parse the client parameters */
nc_uridecodeparams(dapcomm->oc.url);
if(!constrainable34(dapcomm->oc.url))
SETFLAG(dapcomm->controls,NCF_UNCONSTRAINABLE);
/* Use libsrc code for storing metadata */
tmpname = nulldup(PSEUDOFILE);
/* Now, use the file to create the netcdf file */
if(sizeof(size_t) == sizeof(unsigned int))
ncstat = nc_create(tmpname,NC_CLOBBER,&drno->substrate);
else
ncstat = nc_create(tmpname,NC_CLOBBER|NC_64BIT_OFFSET,&drno->substrate);
if(ncstat != NC_NOERR) {THROWCHK(ncstat); goto done;}
/* free the filename so it will automatically go away*/
unlink(tmpname);
nullfree(tmpname);
/* Avoid fill */
nc_set_fill(drno->substrate,NC_NOFILL,NULL);
dapcomm->oc.dapconstraint = (DCEconstraint*)dcecreate(CES_CONSTRAINT);
dapcomm->oc.dapconstraint->projections = nclistnew();
dapcomm->oc.dapconstraint->selections = nclistnew();
/* Parse constraints to make sure they are syntactically correct */
ncstat = parsedapconstraints(dapcomm,dapcomm->oc.url->constraint,dapcomm->oc.dapconstraint);
if(ncstat != NC_NOERR) {THROWCHK(ncstat); goto done;}
/* Complain if we are unconstrainable but have constraints */
if(FLAGSET(dapcomm->controls,NCF_UNCONSTRAINABLE)) {
if(dapcomm->oc.url->constraint != NULL
&& strlen(dapcomm->oc.url->constraint) > 0) {
nclog(NCLOGWARN,"Attempt to constrain an unconstrainable data source: %s",
dapcomm->oc.url->constraint);
}
}
/* Construct a url for oc minus any parameters */
dapcomm->oc.urltext = nc_uribuild(dapcomm->oc.url,NULL,NULL,
(NC_URIALL ^ NC_URICONSTRAINTS));
/* Pass to OC */
ocstat = oc_open(dapcomm->oc.urltext,&dapcomm->oc.conn);
if(ocstat != OC_NOERR) {THROWCHK(ocstat); goto done;}
nullfree(dapcomm->oc.urltext); /* clean up */
dapcomm->oc.urltext = NULL;
/* process control client parameters */
applyclientparamcontrols3(dapcomm);
/* Turn on logging; only do this after oc_open*/
if((value = paramvalue34(dapcomm,"log")) != NULL) {
ncloginit();
ncsetlogging(1);
nclogopen(value);
oc_loginit();
oc_setlogging(1);
oc_logopen(value);
}
/* fetch and build the (almost) unconstrained DDS for use as
template */
ncstat = fetchtemplatemetadata3(dapcomm);
if(ncstat != NC_NOERR) goto done;
/* fetch and build the constrained DDS */
ncstat = fetchconstrainedmetadata3(dapcomm);
if(ncstat != NC_NOERR) goto done;
#ifdef DEBUG2
fprintf(stderr,"constrained dds: %s\n",dumptree(dapcomm->cdf.ddsroot));
#endif
/* The following actions are (mostly) WRT to the constrained tree */
/* Accumulate useful nodes sets */
ncstat = computecdfnodesets3(dapcomm);
if(ncstat) {THROWCHK(ncstat); goto done;}
/* Fix grids */
ncstat = fixgrids3(dapcomm);
if(ncstat) {THROWCHK(ncstat); goto done;}
/* Locate and mark usable sequences */
ncstat = sequencecheck3(dapcomm);
if(ncstat) {THROWCHK(ncstat); goto done;}
/* suppress variables not in usable sequences */
ncstat = suppressunusablevars3(dapcomm);
if(ncstat) {THROWCHK(ncstat); goto done;}
/* apply client parameters */
ncstat = applyclientparams34(dapcomm);
if(ncstat) {THROWCHK(ncstat); goto done;}
/* Add (as needed) string dimensions*/
ncstat = addstringdims(dapcomm);
if(ncstat) {THROWCHK(ncstat); goto done;}
if(nclistlength(dapcomm->cdf.seqnodes) > 0) {
/* Build the sequence related dimensions */
ncstat = defseqdims(dapcomm);
if(ncstat) {THROWCHK(ncstat); goto done;}
}
/* Define the dimsetplus and dimsetall lists */
ncstat = definedimsets3(dapcomm);
if(ncstat) {THROWCHK(ncstat); goto done;}
/* Re-compute the dimension names*/
ncstat = computecdfdimnames34(dapcomm);
if(ncstat) {THROWCHK(ncstat); goto done;}
/* Deal with zero size dimensions */
ncstat = fixzerodims3(dapcomm);
if(ncstat) {THROWCHK(ncstat); goto done;}
/* Attempt to use the DODS_EXTRA info to turn
one of the dimensions into unlimited.
Assume computecdfdimnames34 has already been called.
*/
ncstat = defrecorddim3(dapcomm);
if(ncstat) {THROWCHK(ncstat); goto done;}
if(dapcomm->cdf.recorddimname != NULL
&& nclistlength(dapcomm->cdf.seqnodes) > 0) {
/*nclog(NCLOGWARN,"unlimited dimension specified, but sequences exist in DDS");*/
PANIC("unlimited dimension specified, but sequences exist in DDS");
}
/* Re-compute the var names*/
ncstat = computecdfvarnames3(dapcomm,dapcomm->cdf.ddsroot,dapcomm->cdf.varnodes);
if(ncstat) {THROWCHK(ncstat); goto done;}
/* Transfer data from the unconstrained DDS data to the unconstrained DDS */
ncstat = dimimprint3(dapcomm);
if(ncstat) goto done;
/* Process the constraints to map to the constrained CDF tree */
/* (must follow fixgrids3 */
ncstat = mapconstraints3(dapcomm->oc.dapconstraint,dapcomm->cdf.ddsroot);
if(ncstat != NC_NOERR) goto done;
/* Canonicalize the constraint */
ncstat = fixprojections(dapcomm->oc.dapconstraint->projections);
if(ncstat != NC_NOERR) {THROWCHK(ncstat); goto done;}
/* Fill in segment information */
ncstat = qualifyconstraints3(dapcomm->oc.dapconstraint);
if(ncstat != NC_NOERR) goto done;
/* using the modified constraint, rebuild the constraint string */
if(FLAGSET(dapcomm->controls,NCF_UNCONSTRAINABLE)) {
/* ignore all constraints */
dapcomm->oc.urltext = nc_uribuild(dapcomm->oc.url,NULL,NULL,0);
} else {
char* constraintstring = buildconstraintstring3(dapcomm->oc.dapconstraint);
nc_urisetconstraints(dapcomm->oc.url,constraintstring);
nullfree(constraintstring);
dapcomm->oc.urltext = nc_uribuild(dapcomm->oc.url,NULL,NULL,NC_URICONSTRAINTS);
}
#ifdef DEBUG
fprintf(stderr,"ncdap3: final constraint: %s\n",dapcomm->oc.url->constraint);
#endif
/* Estimate the variable sizes */
estimatevarsizes3(dapcomm);
/* Build the meta data */
ncstat = buildncstructures3(dapcomm);
if(ncstat != NC_NOERR) {THROWCHK(ncstat); goto done;}
/* Do any necessary data prefetch */
if(FLAGSET(dapcomm->controls,NCF_PREFETCH)) {
ncstat = prefetchdata3(dapcomm);
if(ncstat != NC_NOERR) {
del_from_NCList((NC*)drno); /* undefine here */
{THROWCHK(ncstat); goto done;}
}
}
{
/* Mark as no longer writable and no longer indef;
requires breaking abstraction */
NC* nc;
ncstat = NC_check_id(drno->substrate, &nc);
/* Mark as no longer writeable */
fClr(nc->nciop->ioflags, NC_WRITE);
/* Mark as no longer indef;
(do NOT use nc_enddef until diskless is working)*/
fSet(nc->flags, NC_INDEF);
}
if(ncpp) *ncpp = (NC*)drno;
return ncstat;
done:
if(drno != NULL) NCD3_abort(drno->ext_ncid);
if(ocstat != OC_NOERR) ncstat = ocerrtoncerr(ocstat);
return THROW(ncstat);
}
/* This function is collective */
int
ncmpio_close(void *ncdp)
{
int err=NC_NOERR, status=NC_NOERR;
NC *ncp = (NC*)ncdp;
if (NC_indef(ncp)) { /* currently in define mode */
status = ncmpio__enddef(ncp, 0, 0, 0, 0); /* TODO: defaults */
if (status != NC_NOERR ) {
/* To do: Abort new definition, if any */
if (ncp->old != NULL) {
ncmpio_free_NC(ncp->old);
ncp->old = NULL;
fClr(ncp->flags, NC_MODE_DEF);
}
}
}
if (!NC_readonly(ncp) && /* file is open for write */
NC_indep(ncp)) { /* exit independent data mode will sync header */
err = ncmpio_end_indep_data(ncp);
if (status == NC_NOERR ) status = err;
}
/* if entering this function in collective data mode, we do not have to
* update header in file, as file header is always up-to-date */
#ifdef ENABLE_SUBFILING
/* ncmpio__enddef() will update ncp->num_subfiles */
/* TODO: should check ncid_sf? */
/* if the file has subfiles, close them first */
if (ncp->num_subfiles > 1)
ncmpio_subfile_close(ncp);
#endif
/* We can cancel or complete all outstanding nonblocking I/O.
* For now, cancelling makes more sense. */
#ifdef COMPLETE_NONBLOCKING_IO
if (ncp->numLeadGetReqs > 0) {
ncmpio_wait(ncp, NC_GET_REQ_ALL, NULL, NULL, NC_REQ_INDEP);
if (status == NC_NOERR ) status = NC_EPENDING;
}
if (ncp->numLeadPutReqs > 0) {
ncmpio_wait(ncp, NC_PUT_REQ_ALL, NULL, NULL, NC_REQ_INDEP);
if (status == NC_NOERR ) status = NC_EPENDING;
}
#else
if (ncp->numLeadGetReqs > 0) {
int rank;
MPI_Comm_rank(ncp->comm, &rank);
printf("PnetCDF warning: %d nonblocking get requests still pending on process %d. Cancelling ...\n",ncp->numLeadGetReqs,rank);
ncmpio_cancel(ncp, NC_GET_REQ_ALL, NULL, NULL);
if (status == NC_NOERR ) status = NC_EPENDING;
}
if (ncp->numLeadPutReqs > 0) {
int rank;
MPI_Comm_rank(ncp->comm, &rank);
printf("PnetCDF warning: %d nonblocking put requests still pending on process %d. Cancelling ...\n",ncp->numLeadPutReqs,rank);
ncmpio_cancel(ncp, NC_PUT_REQ_ALL, NULL, NULL);
if (status == NC_NOERR ) status = NC_EPENDING;
}
#endif
/* If the user wants a stronger data consistency by setting NC_SHARE */
if (NC_doFsync(ncp))
ncmpio_file_sync(ncp); /* calling MPI_File_sync() */
/* calling MPI_File_close() */
ncmpio_close_files(ncp, 0);
/* free up space occupied by the header metadata */
ncmpio_free_NC(ncp);
return status;
}
/*
* End define mode.
* Common code for ncendef, ncclose(endef)
* Flushes I/O buffers.
*/
static int
NC_endef(NC *ncp,
size_t h_minfree, size_t v_align,
size_t v_minfree, size_t r_align)
{
int status = NC_NOERR;
assert(!NC_readonly(ncp));
assert(NC_indef(ncp));
status = NC_check_vlens(ncp);
if(status != NC_NOERR)
return status;
status = NC_begins(ncp, h_minfree, v_align, v_minfree, r_align);
if(status != NC_NOERR)
return status;
if(ncp->old != NULL)
{
/* a plain redef, not a create */
assert(!NC_IsNew(ncp));
assert(fIsSet(ncp->flags, NC_INDEF));
assert(ncp->begin_rec >= ncp->old->begin_rec);
assert(ncp->begin_var >= ncp->old->begin_var);
if(ncp->vars.nelems != 0)
{
if(ncp->begin_rec > ncp->old->begin_rec)
{
status = move_recs_r(ncp, ncp->old);
if(status != NC_NOERR)
return status;
if(ncp->begin_var > ncp->old->begin_var)
{
status = move_vars_r(ncp, ncp->old);
if(status != NC_NOERR)
return status;
}
/* else if (ncp->begin_var == ncp->old->begin_var) { NOOP } */
}
else
{ /* Even if (ncp->begin_rec == ncp->old->begin_rec)
and (ncp->begin_var == ncp->old->begin_var)
might still have added a new record variable */
if(ncp->recsize > ncp->old->recsize)
{
status = move_recs_r(ncp, ncp->old);
if(status != NC_NOERR)
return status;
}
}
}
}
status = write_NC(ncp);
if(status != NC_NOERR)
return status;
if(NC_dofill(ncp))
{
if(NC_IsNew(ncp))
{
status = fillerup(ncp);
if(status != NC_NOERR)
return status;
}
else if(ncp->vars.nelems > ncp->old->vars.nelems)
{
status = fill_added(ncp, ncp->old);
if(status != NC_NOERR)
return status;
status = fill_added_recs(ncp, ncp->old);
if(status != NC_NOERR)
return status;
}
}
if(ncp->old != NULL)
{
free_NC(ncp->old);
ncp->old = NULL;
}
fClr(ncp->flags, NC_CREAT | NC_INDEF);
return ncp->nciop->sync(ncp->nciop);
}
