/*@
PetscBinaryWrite - Writes to a binary file.
Not Collective
Input Parameters:
+ fd - the file
. p - the buffer
. n - the number of items to write
. type - the type of items to read (PETSC_INT, PETSC_DOUBLE or PETSC_SCALAR)
- istemp - PETSC_FALSE if buffer data should be preserved, PETSC_TRUE otherwise.
Level: advanced
Notes:
PetscBinaryWrite() uses byte swapping to work on all machines; the files
are written using big-endian ordering to the file. On small-endian machines the numbers
are converted to the big-endian format when they are written to disk.
When PETSc is config/configure.py with --with-64bit-indices the integers are written to the
file as 64 bit integers, this means they can only be read back in when the option --with-64bit-indices
is used.
The Buffer p should be read-write buffer, and not static data.
This way, byte-swapping is done in-place, and then the buffer is
written to the file.
This routine restores the original contents of the buffer, after
it is written to the file. This is done by byte-swapping in-place
the second time. If the flag istemp is set to PETSC_TRUE, the second
byte-swapping operation is not done, thus saving some computation,
but the buffer corrupted is corrupted.
Because byte-swapping may be done on the values in data it cannot be declared const
Concepts: files^writing binary
Concepts: binary files^writing
.seealso: PetscBinaryRead(), PetscBinaryOpen(), PetscBinaryClose(), PetscViewerBinaryGetDescriptor(), PetscBinarySynchronizedWrite(),
PetscBinarySynchronizedRead(), PetscBinarySynchronizedSeek()
@*/
PetscErrorCode PETSC_DLLEXPORT PetscBinaryWrite(int fd,void *p,PetscInt n,PetscDataType type,PetscTruth istemp)
{
char *pp = (char*)p;
int err,wsize;
size_t m = (size_t)n,maxblock=65536;
#if !defined(PETSC_WORDS_BIGENDIAN)
PetscErrorCode ierr;
void *ptmp = p;
#endif
PetscFunctionBegin;
if (n < 0) SETERRQ1(PETSC_ERR_ARG_OUTOFRANGE,"Trying to write a negative amount of data %D",n);
if (!n) PetscFunctionReturn(0);
if (type == PETSC_INT) m *= sizeof(PetscInt);
else if (type == PETSC_SCALAR) m *= sizeof(PetscScalar);
else if (type == PETSC_DOUBLE) m *= sizeof(double);
else if (type == PETSC_SHORT) m *= sizeof(short);
else if (type == PETSC_CHAR) m *= sizeof(char);
else if (type == PETSC_ENUM) m *= sizeof(PetscEnum);
else if (type == PETSC_TRUTH) m *= sizeof(PetscTruth);
else if (type == PETSC_LOGICAL) m = PetscBTLength(m)*sizeof(char);
else SETERRQ(PETSC_ERR_ARG_OUTOFRANGE,"Unknown type");
#if !defined(PETSC_WORDS_BIGENDIAN)
ierr = PetscByteSwap(ptmp,type,n);CHKERRQ(ierr);
#endif
while (m) {
wsize = (m < maxblock) ? m : maxblock;
err = write(fd,pp,wsize);
if (err < 0 && errno == EINTR) continue;
if (err != wsize) SETERRQ(PETSC_ERR_FILE_WRITE,"Error writing to file.");
m -= wsize;
pp += wsize;
}
#if !defined(PETSC_WORDS_BIGENDIAN)
if (!istemp) {
ierr = PetscByteSwap(ptmp,type,n);CHKERRQ(ierr);
}
#endif
PetscFunctionReturn(0);
}
/*@
PetscBinaryRead - Reads from a binary file.
Not Collective
Input Parameters:
+ fd - the file
. n - the number of items to read
- type - the type of items to read (PETSC_INT, PETSC_DOUBLE or PETSC_SCALAR)
Output Parameters:
. p - the buffer
Level: developer
Notes:
PetscBinaryRead() uses byte swapping to work on all machines; the files
are written to file ALWAYS using big-endian ordering. On small-endian machines the numbers
are converted to the small-endian format when they are read in from the file.
When PETSc is config/configure.py with --with-64bit-indices the integers are written to the
file as 64 bit integers, this means they can only be read back in when the option --with-64bit-indices
is used.
Concepts: files^reading binary
Concepts: binary files^reading
.seealso: PetscBinaryWrite(), PetscBinaryOpen(), PetscBinaryClose(), PetscViewerBinaryGetDescriptor(), PetscBinarySynchronizedWrite(),
PetscBinarySynchronizedRead(), PetscBinarySynchronizedSeek()
@*/
PetscErrorCode PETSC_DLLEXPORT PetscBinaryRead(int fd,void *p,PetscInt n,PetscDataType type)
{
int wsize,err;
size_t m = (size_t) n,maxblock = 65536;
char *pp = (char*)p;
#if !defined(PETSC_WORDS_BIGENDIAN)
PetscErrorCode ierr;
void *ptmp = p;
#endif
PetscFunctionBegin;
if (!n) PetscFunctionReturn(0);
if (type == PETSC_INT) m *= sizeof(PetscInt);
else if (type == PETSC_SCALAR) m *= sizeof(PetscScalar);
else if (type == PETSC_DOUBLE) m *= sizeof(double);
else if (type == PETSC_SHORT) m *= sizeof(short);
else if (type == PETSC_CHAR) m *= sizeof(char);
else if (type == PETSC_ENUM) m *= sizeof(PetscEnum);
else if (type == PETSC_TRUTH) m *= sizeof(PetscTruth);
else if (type == PETSC_LOGICAL) m = PetscBTLength(m)*sizeof(char);
else SETERRQ(PETSC_ERR_ARG_OUTOFRANGE,"Unknown type");
while (m) {
wsize = (m < maxblock) ? m : maxblock;
err = read(fd,pp,wsize);
if (err < 0 && errno == EINTR) continue;
if (!err && wsize > 0) SETERRQ(PETSC_ERR_FILE_READ,"Read past end of file");
if (err < 0) SETERRQ1(PETSC_ERR_FILE_READ,"Error reading from file, errno %d",errno);
m -= err;
pp += err;
}
#if !defined(PETSC_WORDS_BIGENDIAN)
ierr = PetscByteSwap(ptmp,type,n);CHKERRQ(ierr);
#endif
PetscFunctionReturn(0);
}
/*@
PetscBinaryWrite - Writes to a binary file.
Not Collective
Input Parameters:
+ fd - the file
. p - the buffer
. n - the number of items to write
. type - the type of items to read (PETSC_INT, PETSC_DOUBLE or PETSC_SCALAR)
- istemp - PETSC_FALSE if buffer data should be preserved, PETSC_TRUE otherwise.
Level: advanced
Notes:
PetscBinaryWrite() uses byte swapping to work on all machines; the files
are written using big-endian ordering to the file. On small-endian machines the numbers
are converted to the big-endian format when they are written to disk.
When PETSc is ./configure with --with-64bit-indices the integers are written to the
file as 64 bit integers, this means they can only be read back in when the option --with-64bit-indices
is used.
If running with __float128 precision the output is in __float128 unless one uses the -binary_write_double option
The Buffer p should be read-write buffer, and not static data.
This way, byte-swapping is done in-place, and then the buffer is
written to the file.
This routine restores the original contents of the buffer, after
it is written to the file. This is done by byte-swapping in-place
the second time. If the flag istemp is set to PETSC_TRUE, the second
byte-swapping operation is not done, thus saving some computation,
but the buffer is left corrupted.
Because byte-swapping may be done on the values in data it cannot be declared const
Concepts: files^writing binary
Concepts: binary files^writing
.seealso: PetscBinaryRead(), PetscBinaryOpen(), PetscBinaryClose(), PetscViewerBinaryGetDescriptor(), PetscBinarySynchronizedWrite(),
PetscBinarySynchronizedRead(), PetscBinarySynchronizedSeek()
@*/
PetscErrorCode PetscBinaryWrite(int fd,void *p,PetscInt n,PetscDataType type,PetscBool istemp)
{
char *pp = (char*)p;
int err,wsize;
size_t m = (size_t)n,maxblock=65536;
PetscErrorCode ierr;
void *ptmp = p;
char *fname = NULL;
#if defined(PETSC_USE_REAL___FLOAT128)
PetscBool writedouble = PETSC_FALSE;
double *ppp;
PetscReal *pv;
PetscInt i;
#endif
PetscDataType wtype = type;
PetscFunctionBegin;
if (n < 0) SETERRQ1(PETSC_COMM_SELF,PETSC_ERR_ARG_OUTOFRANGE,"Trying to write a negative amount of data %D",n);
if (!n) PetscFunctionReturn(0);
if (type == PETSC_FUNCTION) {
#if defined(PETSC_SERIALIZE_FUNCTIONS)
const char *fnametmp;
#endif
m = 64;
fname = (char*)malloc(m*sizeof(char));
if (!fname) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_MEM,"Cannot allocate space for function name");
#if defined(PETSC_SERIALIZE_FUNCTIONS)
if (n > 1) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_SUP,"Can only binary view a single function at a time");
ierr = PetscFPTFind(*(void**)p,&fnametmp);CHKERRQ(ierr);
ierr = PetscStrncpy(fname,fnametmp,m);CHKERRQ(ierr);
#else
ierr = PetscStrncpy(fname,"",m);CHKERRQ(ierr);
#endif
wtype = PETSC_CHAR;
pp = (char*)fname;
ptmp = (void*)fname;
}
#if defined(PETSC_USE_REAL___FLOAT128)
ierr = PetscOptionsGetBool(NULL,NULL,"-binary_write_double",&writedouble,NULL);CHKERRQ(ierr);
/* If using __float128 precision we still write in doubles to file */
if ((type == PETSC_SCALAR || type == PETSC_REAL) && writedouble) {
wtype = PETSC_DOUBLE;
ierr = PetscMalloc1(n,&ppp);CHKERRQ(ierr);
pv = (PetscReal*)pp;
for (i=0; i<n; i++) {
ppp[i] = (double) pv[i];
}
pp = (char*)ppp;
ptmp = (char*)ppp;
}
#endif
if (wtype == PETSC_INT) m *= sizeof(PetscInt);
else if (wtype == PETSC_SCALAR) m *= sizeof(PetscScalar);
else if (wtype == PETSC_REAL) m *= sizeof(PetscReal);
else if (wtype == PETSC_DOUBLE) m *= sizeof(double);
else if (wtype == PETSC_FLOAT) m *= sizeof(float);
else if (wtype == PETSC_SHORT) m *= sizeof(short);
else if (wtype == PETSC_LONG) m *= sizeof(long);
else if (wtype == PETSC_CHAR) m *= sizeof(char);
else if (wtype == PETSC_ENUM) m *= sizeof(PetscEnum);
else if (wtype == PETSC_BOOL) m *= sizeof(PetscBool);
else if (wtype == PETSC_INT64) m *= sizeof(PetscInt64);
else if (wtype == PETSC_BIT_LOGICAL) m = PetscBTLength(m)*sizeof(char);
else SETERRQ(PETSC_COMM_SELF,PETSC_ERR_ARG_OUTOFRANGE,"Unknown type");
if (!PetscBinaryBigEndian()) {ierr = PetscByteSwap(ptmp,wtype,n);CHKERRQ(ierr);}
while (m) {
wsize = (m < maxblock) ? m : maxblock;
err = write(fd,pp,wsize);
if (err < 0 && errno == EINTR) continue;
if (err != wsize) SETERRQ3(PETSC_COMM_SELF,PETSC_ERR_FILE_WRITE,"Error writing to file total size %d err %d wsize %d",(int)n,(int)err,(int)wsize);
m -= wsize;
pp += wsize;
}
if (!istemp) {
if (!PetscBinaryBigEndian()) {ierr = PetscByteSwap(ptmp,wtype,n);CHKERRQ(ierr);}
}
if (type == PETSC_FUNCTION) {
free(fname);
}
#if defined(PETSC_USE_REAL___FLOAT128)
if ((type == PETSC_SCALAR || type == PETSC_REAL) && writedouble) {
ierr = PetscFree(ppp);CHKERRQ(ierr);
}
#endif
PetscFunctionReturn(0);
}
/*@C
PetscBinaryRead - Reads from a binary file.
Not Collective
Input Parameters:
+ fd - the file descriptor
. num - the maximum number of items to read
- type - the type of items to read (PETSC_INT, PETSC_REAL, PETSC_SCALAR, etc.)
Output Parameters:
+ data - the buffer
- count - the number of items read, optional
Level: developer
Notes:
If count is not provided and the number of items read is less than
the maximum number of items to read, then this routine errors.
PetscBinaryRead() uses byte swapping to work on all machines; the files
are written to file ALWAYS using big-endian ordering. On small-endian machines the numbers
are converted to the small-endian format when they are read in from the file.
When PETSc is ./configure with --with-64bit-indices the integers are written to the
file as 64 bit integers, this means they can only be read back in when the option --with-64bit-indices
is used.
Concepts: files^reading binary
Concepts: binary files^reading
.seealso: PetscBinaryWrite(), PetscBinaryOpen(), PetscBinaryClose(), PetscViewerBinaryGetDescriptor(), PetscBinarySynchronizedWrite(),
PetscBinarySynchronizedRead(), PetscBinarySynchronizedSeek()
@*/
PetscErrorCode PetscBinaryRead(int fd,void *data,PetscInt num,PetscInt *count,PetscDataType type)
{
size_t typesize, m = (size_t) num, n = 0, maxblock = 65536;
char *p = (char*)data;
#if defined(PETSC_USE_REAL___FLOAT128)
PetscBool readdouble = PETSC_FALSE;
double *pdouble;
#endif
void *ptmp = data;
char *fname = NULL;
PetscErrorCode ierr;
PetscFunctionBegin;
if (count) *count = 0;
if (num < 0) SETERRQ1(PETSC_COMM_SELF,PETSC_ERR_ARG_OUTOFRANGE,"Trying to read a negative amount of data %D",num);
if (!num) PetscFunctionReturn(0);
if (type == PETSC_FUNCTION) {
m = 64;
type = PETSC_CHAR;
fname = (char*)malloc(m*sizeof(char));
p = (char*)fname;
ptmp = (void*)fname;
if (!fname) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_MEM,"Cannot allocate space for function name");
}
if (type == PETSC_BIT_LOGICAL) m = PetscBTLength(m);
ierr = PetscDataTypeGetSize(type,&typesize);CHKERRQ(ierr);
#if defined(PETSC_USE_REAL___FLOAT128)
ierr = PetscOptionsGetBool(NULL,NULL,"-binary_read_double",&readdouble,NULL);CHKERRQ(ierr);
/* If using __float128 precision we still read in doubles from file */
if ((type == PETSC_REAL || type == PETSC_COMPLEX) && readdouble) {
PetscInt cnt = num * ((type == PETSC_REAL) ? 1 : 2);
ierr = PetscMalloc1(cnt,&pdouble);CHKERRQ(ierr);
p = (char*)pdouble;
typesize /= 2;
}
#endif
m *= typesize;
while (m) {
size_t len = (m < maxblock) ? m : maxblock;
int ret = (int)read(fd,p,len);
if (ret < 0 && errno == EINTR) continue;
if (!ret && len > 0) break; /* Proxy for EOF */
if (ret < 0) SETERRQ1(PETSC_COMM_SELF,PETSC_ERR_FILE_READ,"Error reading from file, errno %d",errno);
m -= ret;
p += ret;
n += ret;
}
if (m && !count) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_FILE_READ,"Read past end of file");
num = (PetscInt)(n/typesize); /* Should we require `n % typesize == 0` ? */
if (count) *count = num; /* TODO: This is most likely wrong for PETSC_BIT_LOGICAL */
#if defined(PETSC_USE_REAL___FLOAT128)
if ((type == PETSC_REAL || type == PETSC_COMPLEX) && readdouble) {
PetscInt i, cnt = num * ((type == PETSC_REAL) ? 1 : 2);
PetscReal *preal = (PetscReal*)data;
if (!PetscBinaryBigEndian()) {ierr = PetscByteSwapDouble(pdouble,cnt);CHKERRQ(ierr);}
for (i=0; i<cnt; i++) preal[i] = pdouble[i];
ierr = PetscFree(pdouble);CHKERRQ(ierr);
PetscFunctionReturn(0);
}
#endif
if (!PetscBinaryBigEndian()) {ierr = PetscByteSwap(ptmp,type,num);CHKERRQ(ierr);}
if (type == PETSC_FUNCTION) {
#if defined(PETSC_SERIALIZE_FUNCTIONS)
ierr = PetscDLSym(NULL,fname,(void**)data);CHKERRQ(ierr);
#else
*(void**)data = NULL;
#endif
free(fname);
}
PetscFunctionReturn(0);
}
/*@
PetscBinaryWrite - Writes to a binary file.
Not Collective
Input Parameters:
+ fd - the file
. p - the buffer
. n - the number of items to write
. type - the type of items to read (PETSC_INT, PETSC_DOUBLE or PETSC_SCALAR)
- istemp - PETSC_FALSE if buffer data should be preserved, PETSC_TRUE otherwise.
Level: advanced
Notes:
PetscBinaryWrite() uses byte swapping to work on all machines; the files
are written using big-endian ordering to the file. On small-endian machines the numbers
are converted to the big-endian format when they are written to disk.
When PETSc is ./configure with --with-64bit-indices the integers are written to the
file as 64 bit integers, this means they can only be read back in when the option --with-64bit-indices
is used.
The Buffer p should be read-write buffer, and not static data.
This way, byte-swapping is done in-place, and then the buffer is
written to the file.
This routine restores the original contents of the buffer, after
it is written to the file. This is done by byte-swapping in-place
the second time. If the flag istemp is set to PETSC_TRUE, the second
byte-swapping operation is not done, thus saving some computation,
but the buffer is left corrupted.
Because byte-swapping may be done on the values in data it cannot be declared const
Concepts: files^writing binary
Concepts: binary files^writing
.seealso: PetscBinaryRead(), PetscBinaryOpen(), PetscBinaryClose(), PetscViewerBinaryGetDescriptor(), PetscBinarySynchronizedWrite(),
PetscBinarySynchronizedRead(), PetscBinarySynchronizedSeek()
@*/
PetscErrorCode PetscBinaryWrite(int fd,void *p,PetscInt n,PetscDataType type,PetscBool istemp)
{
char *pp = (char*)p;
int err,wsize;
size_t m = (size_t)n,maxblock=65536;
PetscErrorCode ierr;
#if !defined(PETSC_WORDS_BIGENDIAN)
void *ptmp = p;
#endif
char *fname = NULL;
PetscFunctionBegin;
if (n < 0) SETERRQ1(PETSC_COMM_SELF,PETSC_ERR_ARG_OUTOFRANGE,"Trying to write a negative amount of data %D",n);
if (!n) PetscFunctionReturn(0);
if (type == PETSC_FUNCTION) {
#if defined(PETSC_SERIALIZE_FUNCTIONS)
const char *fnametmp;
#endif
m = 64;
fname = (char*)malloc(m*sizeof(char));
if (!fname) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_MEM,"Cannot allocate space for function name");
#if defined(PETSC_SERIALIZE_FUNCTIONS)
if (n > 1) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_SUP,"Can only binary view a single function at a time");
ierr = PetscFPTFind(*(void**)p,&fnametmp);CHKERRQ(ierr);
ierr = PetscStrncpy(fname,fnametmp,m);CHKERRQ(ierr);
#else
ierr = PetscStrncpy(fname,"",m);CHKERRQ(ierr);
#endif
type = PETSC_CHAR;
pp = (char*)fname;
#if !defined(PETSC_WORDS_BIGENDIAN)
ptmp = (void*)fname;
#endif
}
if (type == PETSC_INT) m *= sizeof(PetscInt);
else if (type == PETSC_SCALAR) m *= sizeof(PetscScalar);
else if (type == PETSC_DOUBLE) m *= sizeof(double);
else if (type == PETSC_FLOAT) m *= sizeof(float);
else if (type == PETSC_SHORT) m *= sizeof(short);
else if (type == PETSC_CHAR) m *= sizeof(char);
else if (type == PETSC_ENUM) m *= sizeof(PetscEnum);
else if (type == PETSC_BOOL) m *= sizeof(PetscBool);
else if (type == PETSC_BIT_LOGICAL) m = PetscBTLength(m)*sizeof(char);
else SETERRQ(PETSC_COMM_SELF,PETSC_ERR_ARG_OUTOFRANGE,"Unknown type");
#if !defined(PETSC_WORDS_BIGENDIAN)
ierr = PetscByteSwap(ptmp,type,n);CHKERRQ(ierr);
#endif
while (m) {
wsize = (m < maxblock) ? m : maxblock;
err = write(fd,pp,wsize);
if (err < 0 && errno == EINTR) continue;
if (err != wsize) SETERRQ3(PETSC_COMM_SELF,PETSC_ERR_FILE_WRITE,"Error writing to file total size %d err %d wsize %d",(int)n,(int)err,(int)wsize);
m -= wsize;
pp += wsize;
}
#if !defined(PETSC_WORDS_BIGENDIAN)
if (!istemp) {
ierr = PetscByteSwap(ptmp,type,n);CHKERRQ(ierr);
}
#endif
if (type == PETSC_FUNCTION) {
free(fname);
}
PetscFunctionReturn(0);
}
/*@
PetscBinaryRead - Reads from a binary file.
Not Collective
Input Parameters:
+ fd - the file
. n - the number of items to read
- type - the type of items to read (PETSC_INT, PETSC_DOUBLE or PETSC_SCALAR)
Output Parameters:
. p - the buffer
Level: developer
Notes:
PetscBinaryRead() uses byte swapping to work on all machines; the files
are written to file ALWAYS using big-endian ordering. On small-endian machines the numbers
are converted to the small-endian format when they are read in from the file.
When PETSc is ./configure with --with-64bit-indices the integers are written to the
file as 64 bit integers, this means they can only be read back in when the option --with-64bit-indices
is used.
Concepts: files^reading binary
Concepts: binary files^reading
.seealso: PetscBinaryWrite(), PetscBinaryOpen(), PetscBinaryClose(), PetscViewerBinaryGetDescriptor(), PetscBinarySynchronizedWrite(),
PetscBinarySynchronizedRead(), PetscBinarySynchronizedSeek()
@*/
PetscErrorCode PetscBinaryRead(int fd,void *p,PetscInt n,PetscDataType type)
{
int wsize,err;
size_t m = (size_t) n,maxblock = 65536;
char *pp = (char*)p;
#if defined(PETSC_USE_REAL___FLOAT128)
PetscBool readdouble = PETSC_FALSE;
double *ppp;
#endif
#if !defined(PETSC_WORDS_BIGENDIAN) || defined(PETSC_USE_REAL___FLOAT128)
PetscErrorCode ierr;
#endif
#if !defined(PETSC_WORDS_BIGENDIAN)
void *ptmp = p;
#endif
char *fname = NULL;
PetscFunctionBegin;
if (n < 0) SETERRQ1(PETSC_COMM_SELF,PETSC_ERR_ARG_OUTOFRANGE,"Trying to write a negative amount of data %D",n);
if (!n) PetscFunctionReturn(0);
if (type == PETSC_FUNCTION) {
m = 64;
type = PETSC_CHAR;
fname = (char*) malloc(m*sizeof(char));
if (!fname) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_MEM,"Cannot allocate space for function name");
pp = (char*)fname;
#if !defined(PETSC_WORDS_BIGENDIAN)
ptmp = (void*)fname;
#endif
}
if (type == PETSC_INT) m *= sizeof(PetscInt);
else if (type == PETSC_SCALAR) m *= sizeof(PetscScalar);
else if (type == PETSC_DOUBLE) m *= sizeof(double);
else if (type == PETSC_FLOAT) m *= sizeof(float);
else if (type == PETSC_SHORT) m *= sizeof(short);
else if (type == PETSC_CHAR) m *= sizeof(char);
else if (type == PETSC_ENUM) m *= sizeof(PetscEnum);
else if (type == PETSC_BOOL) m *= sizeof(PetscBool);
else if (type == PETSC_BIT_LOGICAL) m = PetscBTLength(m)*sizeof(char);
else SETERRQ(PETSC_COMM_SELF,PETSC_ERR_ARG_OUTOFRANGE,"Unknown type");
#if defined(PETSC_USE_REAL___FLOAT128)
ierr = PetscOptionsGetBool(NULL,"-binary_read_double",&readdouble,NULL);CHKERRQ(ierr);
/* If using __float128 precision we still read in doubles from file */
if (type == PETSC_SCALAR && readdouble) {
m = m/2;
ierr = PetscMalloc1(n,&ppp);CHKERRQ(ierr);
pp = (char*)ppp;
}
#endif
while (m) {
wsize = (m < maxblock) ? m : maxblock;
err = read(fd,pp,wsize);
if (err < 0 && errno == EINTR) continue;
if (!err && wsize > 0) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_FILE_READ,"Read past end of file");
if (err < 0) SETERRQ1(PETSC_COMM_SELF,PETSC_ERR_FILE_READ,"Error reading from file, errno %d",errno);
m -= err;
pp += err;
}
#if defined(PETSC_USE_REAL___FLOAT128)
if (type == PETSC_SCALAR && readdouble) {
PetscScalar *pv = (PetscScalar*) p;
PetscInt i;
#if !defined(PETSC_WORDS_BIGENDIAN)
ierr = PetscByteSwapDouble(ppp,n);CHKERRQ(ierr);
#endif
for (i=0; i<n; i++) pv[i] = ppp[i];
ierr = PetscFree(ppp);CHKERRQ(ierr);
PetscFunctionReturn(0);
}
#endif
#if !defined(PETSC_WORDS_BIGENDIAN)
ierr = PetscByteSwap(ptmp,type,n);CHKERRQ(ierr);
#endif
if (type == PETSC_FUNCTION) {
#if defined(PETSC_SERIALIZE_FUNCTIONS)
ierr = PetscDLSym(NULL,fname,(void**)p);CHKERRQ(ierr);
#else
*(void**)p = NULL;
#endif
free(fname);
}
PetscFunctionReturn(0);
}
