From 4f3bca907f467fb4147d8cd7f91e6480c5ed21b8 Mon Sep 17 00:00:00 2001 From: George Bosilca Date: Thu, 18 Mar 2004 19:38:02 +0000 Subject: [PATCH] Move some functions in the datatype.h file and make them static inline. Remove dt_old_limit.c file. Correctly define the lam_datatype_t This commit was SVN r920. --- src/datatype/Makefile.am | 2 +- src/datatype/datatype.c | 43 ---- src/datatype/datatype.h | 92 ++++--- src/datatype/datatype_copy.c | 58 ----- src/datatype/datatype_crc32.c | 165 ------------ src/datatype/datatype_create.c | 343 ------------------------- src/datatype/datatype_delete.c | 15 -- src/datatype/datatype_internal.h | 2 + src/datatype/datatype_iovec.c | 121 --------- src/datatype/datatype_memcpy.c | 43 ---- src/datatype/datatype_pack.c | 122 --------- src/datatype/datatype_sum32.c | 413 ------------------------------- src/datatype/dt_add.c | 2 + src/datatype/dt_create.c | 2 +- src/datatype/dt_create_array.c | 2 + src/datatype/dt_create_dup.c | 2 + src/datatype/dt_create_indexed.c | 2 + src/datatype/dt_create_struct.c | 2 + src/datatype/dt_create_vector.c | 2 + src/datatype/dt_destroy.c | 2 + src/datatype/dt_module.c | 2 + src/datatype/dt_old_limits.c | 48 ---- src/datatype/dt_optimize.c | 2 +- src/datatype/dt_pack.c | 2 +- src/datatype/dt_unpack.c | 2 +- 25 files changed, 77 insertions(+), 1414 deletions(-) delete mode 100644 src/datatype/datatype.c delete mode 100644 src/datatype/datatype_copy.c delete mode 100644 src/datatype/datatype_crc32.c delete mode 100644 src/datatype/datatype_create.c delete mode 100644 src/datatype/datatype_delete.c delete mode 100644 src/datatype/datatype_iovec.c delete mode 100644 src/datatype/datatype_memcpy.c delete mode 100644 src/datatype/datatype_pack.c delete mode 100644 src/datatype/datatype_sum32.c delete mode 100644 src/datatype/dt_old_limits.c diff --git a/src/datatype/Makefile.am b/src/datatype/Makefile.am index 1700dbe49c..83da54fd13 100644 --- a/src/datatype/Makefile.am +++ b/src/datatype/Makefile.am @@ -14,7 +14,7 @@ headers = datatype.h datatype_internal.h libdatatype_la_SOURCES = \ $(headers) \ dt_add.c dt_create.c dt_create_array.c dt_create_dup.c dt_create_indexed.c \ - dt_create_struct.c dt_create_vector.c dt_destroy.c dt_module.c dt_old_limits.c \ + dt_create_struct.c dt_create_vector.c dt_destroy.c dt_module.c \ dt_optimize.c dt_pack.c dt_unpack.c # Conditionally install the header files diff --git a/src/datatype/datatype.c b/src/datatype/datatype.c deleted file mode 100644 index b85bde39ab..0000000000 --- a/src/datatype/datatype.c +++ /dev/null @@ -1,43 +0,0 @@ -/* - * $HEADER$ - */ - -/* - * lam_datatype_t implementation - */ - -#include "lam_config.h" -#include "datatype/datatype.h" - -/* - * Global variables - * Sizes and alignments from configure - */ - -int lam_sizeof_f77_integer = LAM_SIZEOF_FORTRAN_INT; -int lam_sizeof_f77_real = LAM_SIZEOF_FORTRAN_REAL; -int lam_sizeof_f77_dblprec = LAM_SIZEOF_FORTRAN_DBLPREC; -int lam_sizeof_f77_complex = LAM_SIZEOF_FORTRAN_COMPLEX; -int lam_sizeof_f77_dblcomplex = LAM_SIZEOF_FORTRAN_DBLCOMPLEX; - -int lam_alignment_f77_integer = LAM_ALIGNMENT_FORTRAN_INT; -int lam_alignment_f77_real = LAM_ALIGNMENT_FORTRAN_REAL; -int lam_alignment_f77_dblprec = LAM_ALIGNMENT_FORTRAN_DBLPREC; -int lam_alignment_f77_complex = LAM_ALIGNMENT_FORTRAN_COMPLEX; -int lam_alignment_f77_dblcomplex = LAM_ALIGNMENT_FORTRAN_DBLCOMPLEX; - - -static void lam_datatype_t_construct(lam_datatype_t *datatype); -static void lam_datatype_t_destruct(lam_datatype_t *datatype); - -OBJ_CLASS_INSTANCE(lam_datatype_t, - lam_object_t, - lam_datatype_t_construct, - lam_datatype_t_destruct); - - -static void lam_datatype_t_construct(lam_datatype_t *datatype) {} - - -static void lam_datatype_t_destruct(lam_datatype_t *datatype) {} - diff --git a/src/datatype/datatype.h b/src/datatype/datatype.h index 2200624cf1..e3238f691e 100644 --- a/src/datatype/datatype.h +++ b/src/datatype/datatype.h @@ -1,4 +1,12 @@ -/* -*- Mode: C; c-basic-offset:3 ; -*- */ +/* -*- Mode: C; c-basic-offset:4 ; -*- */ + +/** + * lam_datatype_t interface for LAM internal data type representation + * + * lam_datatype_t is a class which represents contiguous or + * non-contiguous data together with constituent type-related + * information. + */ #ifndef DATATYPE_H_HAS_BEEN_INCLUDED #define DATATYPE_H_HAS_BEEN_INCLUDED @@ -32,16 +40,16 @@ #define DT_MAX_PREDEFINED 0x10 /* flags for the datatypes. */ -#define DT_FLAG_DESTROYED 0x0001 /* user destroyed but some other layers still have a reference */ -#define DT_FLAG_COMMITED 0x0002 /* ready to be used for a send/recv operation */ -#define DT_FLAG_CONTIGUOUS 0x0004 /* contiguous datatype */ -#define DT_FLAG_OVERLAP 0x0008 /* datatype is unpropper for a recv operation */ -#define DT_FLAG_USER_LB 0x0010 /* has a user defined LB */ -#define DT_FLAG_USER_UB 0x0020 /* has a user defined UB */ -#define DT_FLAG_FOREVER 0x0040 /* cannot be removed: initial and predefined datatypes */ -#define DT_FLAG_IN_LOOP 0x0080 /* we are inside a loop */ -#define DT_FLAG_INITIAL 0x0100 /* one of the initial datatype */ -#define DT_FLAG_DATA 0x0200 /* data or control structure */ +#define DT_FLAG_DESTROYED 0x0001 /**< user destroyed but some other layers still have a reference */ +#define DT_FLAG_COMMITED 0x0002 /**< ready to be used for a send/recv operation */ +#define DT_FLAG_CONTIGUOUS 0x0004 /**< contiguous datatype */ +#define DT_FLAG_OVERLAP 0x0008 /**< datatype is unpropper for a recv operation */ +#define DT_FLAG_USER_LB 0x0010 /**< has a user defined LB */ +#define DT_FLAG_USER_UB 0x0020 /**< has a user defined UB */ +#define DT_FLAG_FOREVER 0x0040 /**< cannot be removed: initial and predefined datatypes */ +#define DT_FLAG_IN_LOOP 0x0080 /**< we are inside a loop */ +#define DT_FLAG_INITIAL 0x0100 /**< one of the initial datatype */ +#define DT_FLAG_DATA 0x0200 /**< data or control structure */ #define DT_FLAG_BASIC (DT_FLAG_INITIAL | DT_FLAG_COMMITED | DT_FLAG_FOREVER | DT_FLAG_CONTIGUOUS) #define DT_INCREASE_STACK 32 @@ -50,11 +58,11 @@ * by a set of basic elements. */ typedef struct __dt_elem_desc { - unsigned short flags; /* flags for the record */ - unsigned short type; /* the basic data type id */ - unsigned int count; /* number of elements */ - long disp; /* displacement of the first element */ - unsigned int extent; /* extent of each element */ + unsigned short flags; /**< flags for the record */ + unsigned short type; /**< the basic data type id */ + unsigned int count; /**< number of elements */ + long disp; /**< displacement of the first element */ + unsigned int extent; /**< extent of each element */ } dt_elem_desc_t; typedef struct { @@ -83,28 +91,28 @@ typedef struct __dt_struct_desc { /* the data description. */ -typedef struct __dt_desc { - lam_object_t super; - unsigned int size; /* total size in bytes of the memory used by the data if +typedef struct lam_datatype_t { + lam_object_t super; /**< basic superclass */ + unsigned int size; /**< total size in bytes of the memory used by the data if * the data is put on a contiguous buffer */ long true_lb; - long true_ub; /* the true ub of the data without user defined lb and ub */ - unsigned int align; /* data should be aligned to */ - long lb; /* lower bound in memory */ - long ub; /* upper bound in memory */ - unsigned short flags; /* the flags */ - unsigned short id; /* data id, normally the index in the data array. */ - unsigned int nbElems; /* total number of elements inside the datatype */ - unsigned int bdt_used; /* which basic datatypes are used in the data description */ + long true_ub; /**< the true ub of the data without user defined lb and ub */ + unsigned int align; /**< data should be aligned to */ + long lb; /**< lower bound in memory */ + long ub; /**< upper bound in memory */ + unsigned short flags; /**< the flags */ + unsigned short id; /**< data id, normally the index in the data array. */ + unsigned int nbElems; /**< total number of elements inside the datatype */ + unsigned int bdt_used; /**< which basic datatypes are used in the data description */ /* Attribute fields */ lam_hash_table_t *keyhash; char name[MPI_MAX_OBJECT_NAME]; - dt_type_desc_t desc; /* the data description */ - dt_type_desc_t opt_desc; /* short description of the data used when conversion is useless + dt_type_desc_t desc; /**< the data description */ + dt_type_desc_t opt_desc; /**< short description of the data used when conversion is useless * or in the send case (without conversion) */ - void* args; /* data description for the user */ + void* args; /**< data description for the user */ /* basic elements count used to compute the size of the datatype for * remote nodes */ @@ -174,15 +182,23 @@ int dt_create_darray( int size, int rank, int ndims, int* pGSizes, int *pDistrib int dt_add( dt_desc_t* pdtBase, dt_desc_t* pdtNew, unsigned int count, long disp, long extent ); -int dt_type_lb( dt_desc_t* pData, long* disp ); -int dt_type_ub( dt_desc_t* pData, long* disp ); -int dt_type_size ( dt_desc_t* pData, int *size ); -int dt_type_extent( dt_desc_t* pData, long* extent ); +static inline int dt_type_lb( dt_desc_t* pData, long* disp ) +{ *disp = pData->lb; return 0; }; +static inline int dt_type_ub( dt_desc_t* pData, long* disp ) +{ *disp = pData->ub; return 0; }; +static inline int dt_type_size ( dt_desc_t* pData, int *size ) +{ *size = pData->size; return 0; }; +static inline int dt_type_extent( dt_desc_t* pData, long* extent ) +{ *extent = (pData->ub - pData->lb); return 0; }; -int dt_type_resize( dt_desc_t* pOld, long lb, long extent, dt_desc_t** pNew ); -int dt_get_extent( dt_desc_t* datatype, long* lb, long* extent); -int dt_get_true_extent( dt_desc_t* datatype, long* true_lb, long* true_extent); -int dt_get_element_count( dt_desc_t* datatype, size_t iSize ); +static inline int dt_type_resize( dt_desc_t* pOld, long lb, long extent, dt_desc_t** pNew ) +{ /* empty function */ return -1; }; +static inline int dt_get_extent( dt_desc_t* pData, long* lb, long* extent) +{ *lb = pData->lb; *extent = pData->ub - pData->lb; return 0; }; +static inline int dt_get_true_extent( dt_desc_t* pData, long* true_lb, long* true_extent) +{ *true_lb = pData->true_lb; *true_extent = (pData->true_ub - pData->true_lb); return 0; }; + +int dt_get_element_count( dt_desc_t* pData, size_t iSize ); int dt_copy_content_same_dt( dt_desc_t* pData, int count, char* pDestBuf, char* pSrcBuf ); #define dt_increase_ref(PDT) OBJ_RETAIN( PDT ) diff --git a/src/datatype/datatype_copy.c b/src/datatype/datatype_copy.c deleted file mode 100644 index 80effdcbf3..0000000000 --- a/src/datatype/datatype_copy.c +++ /dev/null @@ -1,58 +0,0 @@ -/* - * $HEADER$ - */ - -/* lam_dataype_t copy function */ - -#include - -#include "datatype.h" - -/* - * Copy (the contents of) an array of data types - */ -int lam_datatype_copy(void *dst, - const void *src, - size_t count, - lam_datatype_t *d, - lam_memcpy_fn_t *memcpy_fn, - lam_memcpy_state_t *memcpy_state) -{ - int status; - - status = LAM_SUCCESS; - - if (NULL == src || NULL == dst) { - status = LAM_ERROR; - } - - if (LAM_SUCCESS == status) { - if (NULL == d) { - (*memcpy_fn)(dst, src, count, memcpy_state); - } else if (LAM_DATATYPE_STATE_CONTIGUOUS & d->flags) { - (*memcpy_fn)(dst, src, count * d->extent, memcpy_state); - } else { - lam_datavec_t *dv = d->datavec; - unsigned char *p = (unsigned char *) dst; - unsigned char *q = (unsigned char *) src; - size_t i, j; - - while (count--) { - for (i = 0; i < d->datavec_size; i++) { - for (j = 0; j < dv->nrepeat; j++) { - (*memcpy_fn)(p + dv->element[i].offset, - q + dv->element[i].offset, - dv->element[i].size, - memcpy_state); - } - p += dv->repeat_offset; - q += dv->repeat_offset; - } - p += d->extent; - q += d->extent; - } - } - } - - return status; -} diff --git a/src/datatype/datatype_crc32.c b/src/datatype/datatype_crc32.c deleted file mode 100644 index 5b1d33bb99..0000000000 --- a/src/datatype/datatype_crc32.c +++ /dev/null @@ -1,165 +0,0 @@ -/* - * $HEADER$ - */ - -/** @file - * - * 32-bit cyclic redundancy check implementation - */ - -#include - -#include "lam_config.h" -#include "datatype.h" - -#define CRC_POLYNOMIAL ((uint32_t) 0x04c11db7) -#define CRC_INITIAL_REGISTER ((uint32_t) 0xffffffff) - - -/* - * Look-up table for CRC32 generation - */ -static bool crc_table_initialized = false; -static uint32_t crc_table[256]; - - -/** - * CRC32 table generation - * - * One time initializtion of CRC32 look-up table. Thanks to Charles - * Michael Heard for his optimized CRC32 code. - */ -static void initialize_crc_table(void) -{ - register int i, j; - register uint32_t crc_accum; - - for (i = 0; i < 256; i++) { - crc_accum = (i << 24); - for (j = 0; j < 8; j++) { - if (crc_accum & 0x80000000) { - crc_accum = (crc_accum << 1) ^ CRC_POLYNOMIAL; - } else { - crc_accum = (crc_accum << 1); - } - } - crc_table[i] = crc_accum; - } - - crc_table_initialized = 1; -} - - -/* - * Generate a 32-bit CRC for a buffer - */ -uint32_t lam_crc32(const void *buffer, size_t size, uint32_t initial_crc) -{ - register int i, j; - register unsigned char *t; - uint32_t tmp; - uint32_t crc = initial_crc; - - if (!crc_table_initialized) { - initialize_crc_table(); - } - - if (lam_aligned32((void *) buffer)) { - register uint32_t *restrict src = (uint32_t *) buffer; - while (size >= sizeof(uint32_t)) { - tmp = *src++; - t = (unsigned char *) &tmp; - for (j = 0; j < (int) sizeof(uint32_t); j++) { - i = ((crc >> 24) ^ *t++) & 0xff; - crc = (crc << 8) ^ crc_table[i]; - } - size -= sizeof(uint32_t); - } - t = (unsigned char *) src; - while (size--) { - i = ((crc >> 24) ^ *t++) & 0xff; - crc = (crc << 8) ^ crc_table[i]; - } - } else { - register unsigned char *restrict src = (unsigned char *) buffer; - while (size--) { - i = ((crc >> 24) ^ *src++) & 0xff; - crc = (crc << 8) ^ crc_table[i]; - } - } - - return crc; -} - - -/* - * Copy data from one buffer to another and calculate a 32-bit CRC - */ -void *lam_memcpy_crc32(void *dst, - const void *src, - size_t size, - lam_memcpy_state_t *state) -{ - size_t crclenresidue = (state->size > size) ? (state->size - size) : 0; - register int i, j; - uint32_t tmp; - register unsigned char t; - uint32_t crc = state->sum; - - if (!crc_table_initialized) { - initialize_crc_table(); - } - - if (state->first_call) { - state->first_call = false; - state->sum = CRC_INITIAL_REGISTER; - } - - if (lam_aligned32((void *) src) && lam_aligned32(dst)) { - register uint32_t *restrict p = (uint32_t *) dst; - register uint32_t *restrict q = (uint32_t *) src; - register unsigned char *ts, *td; - /* copy whole integers */ - while (size >= sizeof(uint32_t)) { - tmp = *q++; - *p++ = tmp; - ts = (unsigned char *) &tmp; - for (j = 0; j < (int) sizeof(uint32_t); j++) { - i = ((crc >> 24) ^ *ts++) & 0xff; - crc = (crc << 8) ^ crc_table[i]; - } - size -= sizeof(uint32_t); - } - ts = (unsigned char *) q; - td = (unsigned char *) p; - /* copy partial integer */ - while (size--) { - t = *ts++; - *td++ = t; - i = ((crc >> 24) ^ t) & 0xff; - crc = (crc << 8) ^ crc_table[i]; - } - /* calculate CRC over remaining bytes... */ - while (crclenresidue--) { - i = ((crc >> 24) ^ *ts++) & 0xff; - crc = (crc << 8) ^ crc_table[i]; - } - } else { - register unsigned char *restrict q = (unsigned char *) src; - register unsigned char *restrict p = (unsigned char *) dst; - while (size--) { - t = *q++; - *p++ = t; - i = ((crc >> 24) ^ t) & 0xff; - crc = (crc << 8) ^ crc_table[i]; - } - while (crclenresidue--) { - i = ((crc >> 24) ^ *q++) & 0xff; - crc = (crc << 8) ^ crc_table[i]; - } - } - - state->sum = crc; - - return dst; -} diff --git a/src/datatype/datatype_create.c b/src/datatype/datatype_create.c deleted file mode 100644 index f4357deb6a..0000000000 --- a/src/datatype/datatype_create.c +++ /dev/null @@ -1,343 +0,0 @@ -/* - * $HEADER$ - */ - -/** @file datatype creation function */ - -#include "datatype.h" - -/** - * Create a LAM/MPI datatype - * - * @param combiner integer identifying the kind of MPI create function - * @param ninteger number of integers passed to the create function - * @param integer array of integers passed to the create function - * @param naddress number of addresses passed to the create function - * @param address array of addresses passed to the create function - * @param ntype number of data types passed to the create function - * @param type array of data types passed to the create function - * @param newtype pointer to address of new type - * @return LAM_SUCCESS on successful creation, LAM_ERROR otherwise - * - * This is the central location for creation of data types in LAM/MPI. - * All MPI_Type_create functions rely upon this to do the actual type - * creation. - */ -int lam_datatype_create(int combiner, - int nintegers, - int integers[], - int naddresses, - ssize_t addresses[], - int ntypes, - lam_datatype_t *types[], - lam_datatype_t **newtype) -{ -#if 0 - lam_datatype_t *newtype, *t; - lam_datatype_t **types = (lam_datatype_t **) array_of_types; - int i, j, k; - int mpi_lb_i, mpi_ub_i; - int min_lb, max_ub; - int min_disp_i, max_disp_i; - int typemap_i; - ssize_t lb, ub, min_disp, max_disp, typemap_off, current_offset, - new_offset; - size_t current_size, new_size; - int rc; - - if (newdatatype == NULL) { - ulm_err(("Error: MPI_Type_struct: Invalid newtype pointer\n")); - rc = MPI_ERR_TYPE; - _mpi_errhandler(MPI_COMM_WORLD, rc, __FILE__, __LINE__); - return rc; - } - - if (count < 0) { - ulm_err(("Error: MPI_Type_struct: count %d is invalid\n", count)); - rc = MPI_ERR_INTERN; - _mpi_errhandler(MPI_COMM_WORLD, rc, __FILE__, __LINE__); - return rc; - } - - if (count == 0) { - newtype = (lam_datatype_t *) malloc(sizeof(lam_datatype_t)); - if (newtype == NULL) { - ulm_err(("Error: MPI_Type_struct: Out of memory\n")); - rc = MPI_ERR_TYPE; - _mpi_errhandler(MPI_COMM_WORLD, rc, __FILE__, __LINE__); - return rc; - } - - newtype->isbasic = 0; - newtype->layout = CONTIGUOUS; - newtype->num_pairs = 0; - newtype->extent = 0; - newtype->lower_bound = 0; - newtype->type_map = NULL; - newtype->committed = 0; - newtype->ref_count = 1; - - *newdatatype = newtype; - - /* save "envelope" information */ - newtype->envelope.combiner = MPI_COMBINER_STRUCT; - newtype->envelope.nints = 1; - newtype->envelope.naddrs = 0; - newtype->envelope.ndatatypes = 0; - newtype->envelope.iarray = (int *) malloc(sizeof(int)); - newtype->envelope.aarray = NULL; - newtype->envelope.darray = NULL; - newtype->envelope.iarray[0] = count; - - if (_mpi.fortran_layer_enabled) { - newtype->fhandle = _mpi_ptr_table_add(_mpif.type_table, newtype); - } - - return MPI_SUCCESS; - } - - /* Allocate new type */ - newtype = malloc(sizeof(lam_datatype_t)); - if (newtype == NULL) { - ulm_err(("Error: MPI_Type_struct: Out of memory\n")); - rc = MPI_ERR_TYPE; - _mpi_errhandler(MPI_COMM_WORLD, rc, __FILE__, __LINE__); - return rc; - } - - /* Initialize newtype */ - newtype->isbasic = 0; - newtype->op_index = 0; - newtype->layout = NON_CONTIGUOUS; - newtype->committed = 0; - newtype->ref_count = 1; - - /* save "envelope" information */ - newtype->envelope.combiner = MPI_COMBINER_STRUCT; - newtype->envelope.nints = count + 1; - newtype->envelope.naddrs = count; - newtype->envelope.ndatatypes = count; - newtype->envelope.iarray = - (int *) malloc(newtype->envelope.nints * sizeof(int)); - newtype->envelope.aarray = - (MPI_Aint *) malloc(newtype->envelope.naddrs * - sizeof(MPI_Aint)); - newtype->envelope.darray = - (MPI_Datatype *) malloc(newtype->envelope.ndatatypes * - sizeof(MPI_Datatype)); - newtype->envelope.iarray[0] = count; - for (i = 0; i < count; i++) { - newtype->envelope.iarray[i + 1] = array_of_blocklengths[i]; - newtype->envelope.aarray[i] = array_of_displacements[i]; - newtype->envelope.darray[i] = array_of_types[i]; - t = array_of_types[i]; - fetchNadd(&(t->ref_count), 1); - } - - /* - * Look for MPI_LB, MPI_UB markers, smallest/largest - * displacements, and save off indices - */ - mpi_lb_i = -1; - mpi_ub_i = -1; - /* initialize min_lb and max_lb to quiet not-so-bright compilers */ - min_lb = 0; - max_ub = 0; - min_disp = array_of_displacements[0]; - max_disp = array_of_displacements[0]; - min_disp_i = 0; - max_disp_i = 0; - for (i = 0; i < count; i++) { - if (types[i]->extent == 0) { - if (types[i]->op_index == -1) { - if ((mpi_lb_i == -1) - || (array_of_displacements[i] < min_lb)) { - min_lb = array_of_displacements[i]; - mpi_lb_i = i; - } - } else if (types[i]->op_index == -2) { - if ((mpi_lb_i == -1) - || (array_of_displacements[i] > max_ub)) { - max_ub = array_of_displacements[i]; - mpi_ub_i = i; - } - } - } - if (types[i]->lower_bound > 0) { - if ((mpi_lb_i == -1) || (types[i]->lower_bound < min_lb)) { - min_lb = types[i]->lower_bound; - mpi_lb_i = i; - } - } - if (array_of_displacements[i] < min_disp) { - min_disp = array_of_displacements[i]; - min_disp_i = i; - } - if (array_of_displacements[i] > max_disp) { - max_disp = array_of_displacements[i]; - max_disp_i = i; - } - } - - /* - * calculate the new datatype's extent, and set the - * lower bound - */ - lb = 0, ub = 0; - if (mpi_lb_i != -1) { - lb = min_lb; - } else { - lb = array_of_displacements[min_disp_i]; - } - if (mpi_ub_i != -1) { - ub = max_ub; - } else { - ub = array_of_displacements[max_disp_i] - + array_of_blocklengths[max_disp_i] - * types[max_disp_i]->extent; - } - /* extent should never be less than zero */ - if (ub < lb) { - ub = lb; - } - newtype->extent = ub - lb; - newtype->lower_bound = lb; - - /* calculate the number of entries needed for the new type_map */ - typemap_i = 0; - current_size = current_offset = 0; - for (i = 0; i < count; i++) { - if (types[i]->extent > 0) { - typemap_off = array_of_displacements[i]; - for (j = 0; j < array_of_blocklengths[i]; j++) { - for (k = 0; k < types[i]->num_pairs; k++) { - new_size = types[i]->type_map[k].size; - new_offset = types[i]->type_map[k].offset + - typemap_off; - if ((typemap_i != 0) - && (current_size + current_offset == new_offset)) { - /* consolidate entries */ - current_size += new_size; - if (_MPI_DTYPE_TRIM - && current_size + current_offset > ub) { - current_size = ub - current_offset; - } - } else { - if (!_MPI_DTYPE_TRIM - || ((new_offset + new_size > lb) - && (new_offset < ub))) { - /* create new type_map entry if there is still something - * left after possible trimming */ - if (_MPI_DTYPE_TRIM && new_offset < lb) { - new_size -= (lb - new_offset); - new_offset = lb; - } - if (_MPI_DTYPE_TRIM - && new_offset + new_size > ub) { - new_size = (ub - new_offset); - } - if (new_size > 0) { - current_size = new_size; - current_offset = new_offset; - typemap_i++; - } - } - } - } - typemap_off += types[i]->extent; - } - } - } - /* more newtype initialization */ - newtype->num_pairs = typemap_i; - if (newtype->num_pairs > 0) { - /* allocate the type_map */ - newtype->type_map = (ULMTypeMapElt_t *) - malloc(newtype->num_pairs * sizeof(ULMTypeMapElt_t)); - if (newtype->type_map == NULL) { - ulm_err(("Error: MPI_Type_struct: Out of memory\n")); - rc = MPI_ERR_TYPE; - _mpi_errhandler(MPI_COMM_WORLD, rc, __FILE__, __LINE__); - return rc; - } - - /* - * Fill in new datatype's type_map.... - */ - typemap_i = 0; - for (i = 0; i < count; i++) { - if (types[i]->extent > 0) { - typemap_off = array_of_displacements[i]; - for (j = 0; j < array_of_blocklengths[i]; j++) { - for (k = 0; k < types[i]->num_pairs; k++) { - new_size = types[i]->type_map[k].size; - new_offset = types[i]->type_map[k].offset + - typemap_off; - if ((typemap_i != 0) - && - ((newtype->type_map[typemap_i - 1].size + - newtype->type_map[typemap_i - 1].offset) == - new_offset)) { - /* consolidate entries - trim at ub */ - newtype->type_map[typemap_i - 1].size += - new_size; - if (_MPI_DTYPE_TRIM - && (newtype->type_map[typemap_i - 1].size + - newtype->type_map[typemap_i - - 1].offset > ub)) { - newtype->type_map[typemap_i - 1].size = - ub - newtype->type_map[typemap_i - - 1].offset; - } - } else { - if (!_MPI_DTYPE_TRIM - || ((new_offset + new_size > lb) - && (new_offset < ub))) { - /* create new type_map entry if there is still something - * left after possible trimming */ - if (_MPI_DTYPE_TRIM && new_offset < lb) { - new_size -= (lb - new_offset); - new_offset = lb; - } - if (_MPI_DTYPE_TRIM - && new_offset + new_size > ub) { - new_size = (ub - new_offset); - } - if (new_size > 0) { - newtype->type_map[typemap_i].size = - new_size; - newtype->type_map[typemap_i].offset = - new_offset; - typemap_i++; - } - } - } - } - typemap_off += types[i]->extent; - } - } - } - } /* end if newtype->numpairs > 0 */ - else { - newtype->type_map = NULL; - } - - /* mark the datatype as contiguous if it clearly is ... */ - if (_MPI_MARK_AS_CONTIGUOUS) { - if (((newtype->num_pairs == 0) && (newtype->extent == 0)) - || ((newtype->num_pairs == 1) - && (newtype->extent == newtype->type_map[0].size))) { - newtype->layout = CONTIGUOUS; - } - } - - *newdatatype = newtype; - - if (_mpi.fortran_layer_enabled) { - newtype->fhandle = _mpi_ptr_table_add(_mpif.type_table, newtype); - } - -#endif - - return LAM_SUCCESS; -} diff --git a/src/datatype/datatype_delete.c b/src/datatype/datatype_delete.c deleted file mode 100644 index 3cc582d955..0000000000 --- a/src/datatype/datatype_delete.c +++ /dev/null @@ -1,15 +0,0 @@ -/* - * $HEADER$ - */ - -/* lam_datatype_t deletion function */ - -#include "datatype.h" - -/* - * Delete a LAM/MPI datatype (actually, just mark it for deletion) - */ -int lam_datatype_delete(lam_datatype_t *type) -{ - return LAM_SUCCESS; -} diff --git a/src/datatype/datatype_internal.h b/src/datatype/datatype_internal.h index c0a4563370..655bd80fa6 100644 --- a/src/datatype/datatype_internal.h +++ b/src/datatype/datatype_internal.h @@ -1,3 +1,5 @@ +/* -*- Mode: C; c-basic-offset:4 ; -*- */ + #ifndef DATATYPE_INTERNAL_H_HAS_BEEN_INCLUDED #define DATATYPE_INTERNAL_H_HAS_BEEN_INCLUDED diff --git a/src/datatype/datatype_iovec.c b/src/datatype/datatype_iovec.c deleted file mode 100644 index 46d43b11df..0000000000 --- a/src/datatype/datatype_iovec.c +++ /dev/null @@ -1,121 +0,0 @@ -/* - * $HEADER$ - */ - -/* lam_dataype_t pack function(s) */ - -#include - -#include "datatype.h" - -/** - * Incrementally generate an iovec referencing a datatype (or fragment - * of a dataype). - * - * @param state current state of the incremental pack/unpack - * @param vec iovec buffer - * @param vec_count maximum length of iovec buffer - * @param max_bytes maximum bytes addressed by iovec - * @param typebuf array of types - * @param ntype size of type array - * @param type type descriptor - * @return 0 if complete, non-zero otherwise - * - * Incrementally traverse an array of datatypes and generate an iovec - * of at most length vec_count and addressing at most max_bytes. This - * can be used to do a (partial) RDMA gather of the datatype array. - * - * The state (all members) should be initialized to 0 before the first - * call. - */ -int lam_datatype_get_iovec(lam_pack_state_t *state, - struct iovec *vec, - size_t vec_count, - size_t max_bytes, - const void *typebuf, - size_t ntype, - lam_datatype_t *datatype) -{ - return 0; -} - - - - -/**** OLD STUFF BELOW ****/ - - -/** - * Incrementally generate an iovec for gathering from an array of - * datatypes - * - * @param state current state of the incremental pack/unpack - * @param base_addr base address for iovec offsets - * @param vec iovec buffer - * @param vec_count maximum length of iovec buffer - * @param max_bytes maximum bytes addressed by iovec - * @param buf buffer to pack into/unpack from - * @param bufsize size of buffer - * @param typebuf array of types - * @param ntype size of type array - * @param type type descriptor - * @return 0 if complete, non-zero otherwise - * - * Incrementally traverse an array of datatypes and generate an iovec - * of at most length vec_count and addressing at most max_bytes. This - * can be used to do a (partial) RDMA gather of the datatype array. - * - * The state (all members) should be initialized to 0 before the first - * call. - */ -int lam_datatype_gather_iovec(lam_pack_state_t *state, - void *base_addr, - struct iovec *vec, - size_t vec_count, - size_t max_bytes, - const void *typebuf, - size_t ntype, - lam_datatype_t *datatype, - lam_memcpy_fn_t *memcpy_fn, - lam_memcpy_state_t *memcpy_state); - -/** - * Incrementally generate an iovec for scattering from a packed array - * of datatypes - * - * @param state current state of the incremental pack/unpack - * @param base_addr base address for iovec offsets - * @param vec iovec buffer - * @param vec_count maximum length of iovec buffer - * @param max_bytes maximum bytes addressed by iovec - * @param buf packed buffer - * @param bufsize size of buffer - * @param typebuf array of types - * @param ntype size of type array - * @param type type descriptor - * @return 0 if complete, non-zero otherwise - * - * Incrementally copy data type arrays to/from a packed buffer. by - * iterating over the type and type_map until we finish or run out of - * room. - * - * Incrementally traverse a packed array of datatypes and generate an - * iovec of at most length vec_count and addressing at most max_bytes. - * This can be used to do a (partial) RDMA scatter of the datatype - * array. - * - * The state (all members) should be initialized to 0 before the first - * call. - */ -int lam_datatype_scatter_iovec(lam_pack_state_t *state, - void *base_addr, - struct iovec *vec, - size_t vec_count, - size_t max_bytes, - const void *buf, - size_t bufsize, - lam_datatype_t *datatype, - lam_memcpy_fn_t *memcpy_fn, - lam_memcpy_state_t *memcpy_state); - - diff --git a/src/datatype/datatype_memcpy.c b/src/datatype/datatype_memcpy.c deleted file mode 100644 index 4d96ade5b4..0000000000 --- a/src/datatype/datatype_memcpy.c +++ /dev/null @@ -1,43 +0,0 @@ -/* - * $HEADER$ - */ - -/* alternative memcpy function */ - -#include -#include -#include - -#include "lam_config.h" -#include "datatype.h" - -/* - * Alternative memcpy function: On some systems, this performs better - * than the system memcpy. - */ -void *lam_memcpy_alt(void *dst, const void *src, size_t size, - lam_memcpy_state_t *dummy) -{ - assert(dst); - assert(src); - - if (lam_aligned32((void *) src) && lam_aligned32(dst)) { - uint32_t *restrict p = (uint32_t *) dst; - uint32_t *restrict q = (uint32_t *) src; - uint32_t i; - uint32_t n = size >> 2; - for (i = 0; i < n; i++) { - *p++ = *q++; - } - size -= n * sizeof(size_t); - if (size != 0) { - while (size--) { - *p++ = *q++; - } - } - } else { - memcpy(dst, src, size); - } - - return dst; -} diff --git a/src/datatype/datatype_pack.c b/src/datatype/datatype_pack.c deleted file mode 100644 index c8bd2f7e04..0000000000 --- a/src/datatype/datatype_pack.c +++ /dev/null @@ -1,122 +0,0 @@ -/* - * $HEADER$ - */ - -/* lam_dataype_t pack function(s) */ - -#include - -#include "datatype.h" - -/* - * Incrementally pack or unpack an array of datatypes to/from a buffer - */ -int lam_datatype_packer(lam_pack_state_t *state, - void *buf, - size_t bufsize, - void *typebuf, - size_t ntype, - lam_datatype_t *d, - lam_memcpy_fn_t *memcpy_fn, - lam_memcpy_state_t *check, - int pack_direction) -{ - if (LAM_DATATYPE_STATE_CONTIGUOUS & d->flags) { - - unsigned char *b; - unsigned char *t; - size_t copied_so_far; - size_t left_to_copy; - size_t size; - - b = (unsigned char *) buf + state->packed_offset; - t = (unsigned char *) typebuf - + state->type_index * d->extent - + state->repeat_index * d->datavec->repeat_offset - + state->datavec_offset; - bufsize -= state->packed_offset; - - copied_so_far = - state->type_index * d->extent + state->datavec_offset; - size = bufsize; - left_to_copy = ntype * d->extent - copied_so_far; - if (size > left_to_copy) { - size = left_to_copy; - } - if (LAM_DATATYPE_PACK == pack_direction) { - memcpy(b, t, size); - } else { - memcpy(t, b, size); - } - copied_so_far += size; - state->packed_offset += size; - state->type_index = copied_so_far / d->extent; - state->datavec_offset = - copied_so_far - state->type_index * d->extent; - if (copied_so_far != (ntype * d->extent)) { - return LAM_DATATYPE_PACK_INCOMPLETE; - } - - } else { - - unsigned char *ptr; - unsigned char *b; - unsigned char *t; - size_t size; - lam_datavec_t *dv; - - ptr = (unsigned char *) typebuf - + state->type_index * d->extent - + state->repeat_index * dv->repeat_offset; - b = (unsigned char *) buf + state->packed_offset; - bufsize -= state->packed_offset; - dv = d->datavec; - - while (state->type_index < ntype) { - while (state->repeat_index < dv->nrepeat) { - while (state->element_index < dv->nelement) { - t = ptr + dv->element[state->element_index].offset; - size = dv->element[state->element_index].size; - if (state->datavec_offset > 0) { - t += state->datavec_offset; - size -= state->datavec_offset; - if (size <= bufsize) { - state->datavec_offset = 0; - } - } - if (size > bufsize) { - size = bufsize; - state->datavec_offset += size; - } - if (LAM_DATATYPE_PACK == pack_direction) { - memcpy(b, t, size); - } else { - memcpy(t, b, size); - } - state->packed_offset += size; - if (state->datavec_offset > 0) { - return LAM_DATATYPE_PACK_INCOMPLETE; - } - bufsize -= size; - b += size; - state->element_index += 1; - if (bufsize == 0 - && state->element_index < (size_t) dv->nelement) { - return LAM_DATATYPE_PACK_INCOMPLETE; - } - } - ptr += dv->repeat_offset; - state->repeat_index += 1; - } - ptr += d->extent; - state->type_index += 1; - state->element_index = 0; - if (bufsize == 0 && state->type_index < ntype) { - return LAM_DATATYPE_PACK_INCOMPLETE; - } - } - - } - - return LAM_DATATYPE_PACK_COMPLETE; -} diff --git a/src/datatype/datatype_sum32.c b/src/datatype/datatype_sum32.c deleted file mode 100644 index 939308242a..0000000000 --- a/src/datatype/datatype_sum32.c +++ /dev/null @@ -1,413 +0,0 @@ -/* - * $HEADER$ - */ - -/** @file - * - * 32-bit checksum implementation - */ - -#include - -#include "lam_config.h" -#include "datatype.h" - - -/* - * Generate a 32-bit checksum for a buffer - */ -uint32_t lam_sum32(const void *buffer, size_t size) -{ - return 0; -} - - -/* - * Copy data from one buffer to another and calculate a 32-bit checksum - */ -void *lam_memcpy_sum32(void *dst, - const void *src, - size_t size, lam_memcpy_state_t *state) -{ - uint32_t *restrict p = (uint32_t *) dst; - uint32_t *restrict q = (uint32_t *) src; - size_t csumlen = state->size; - size_t i; - ssize_t csumlenresidue; - uint32_t csum = 0; - uint32_t temp; - - if (state->first_call) { - state->first_call = false; - state->partial_int = 0; - state->partial_size = 0; - } - - csumlenresidue = (csumlen > size) ? (csumlen - size) : 0; - temp = state->partial_int; - - if (lam_aligned32(p) && lam_aligned32(q)) { - if (state->partial_size) { - /* do we have enough data to fill out the partial word? */ - if (size >= (sizeof(uint32_t) - state->partial_size)) { - /* YES, we do... */ - memcpy(((char *) &temp + state->partial_size), q, - (sizeof(uint32_t) - state->partial_size)); - memcpy(p, ((char *) &temp + state->partial_size), - (sizeof(uint32_t) - state->partial_size)); - q = (uint32_t *) ((char *) q + sizeof(uint32_t) - - state->partial_size); - p = (uint32_t *) ((char *) p + sizeof(uint32_t) - - state->partial_size); - csum += (temp - state->partial_int); - size -= sizeof(uint32_t) - state->partial_size; - /* - * now we have an unaligned source and an unaligned - * destination - */ - for (; size >= sizeof(*q); size -= sizeof(*q)) { - memcpy(&temp, q, sizeof(temp)); - q++; - csum += temp; - memcpy(p, &temp, sizeof(temp)); - p++; - } - state->partial_size = 0; - state->partial_int = 0; - } else { - /* NO, we don't... */ - memcpy(((char *) &temp + state->partial_size), q, size); - memcpy(p, ((char *) &temp + state->partial_size), size); - q = (uint32_t *) ((char *) q + size); - p = (uint32_t *) ((char *) p + size); - csum += (temp - state->partial_int); - state->partial_int = temp; - state->partial_size += size; - size = 0; - } - } else { /* fast path... */ - size_t numLongs = size / sizeof(uint32_t); - for (i = 0; i < numLongs; i++) { - csum += *q; - *p++ = *q++; - } - state->partial_int = 0; - state->partial_size = 0; - if (lam_aligned32((void *) size) && (csumlenresidue == 0)) { - state->sum = csum; - return dst; - } else { - size -= i * sizeof(uint32_t); - } - } - } else if (lam_aligned32(q)) { - if (state->partial_size) { - /* do we have enough data to fill out the partial word? */ - if (size >= (sizeof(uint32_t) - state->partial_size)) { - /* YES, we do... */ - memcpy(((char *) &temp + state->partial_size), q, - (sizeof(uint32_t) - state->partial_size)); - memcpy(p, ((char *) &temp + state->partial_size), - (sizeof(uint32_t) - state->partial_size)); - q = (uint32_t *) ((char *) q + sizeof(uint32_t) - - state->partial_size); - p = (uint32_t *) ((char *) p + sizeof(uint32_t) - - state->partial_size); - csum += (temp - state->partial_int); - size -= sizeof(uint32_t) - state->partial_size; - /* - * now we have an unaligned source and an unknown - * alignment for our destination - */ - if (lam_aligned32(p)) { - size_t numLongs = size / sizeof(uint32_t); - for (i = 0; i < numLongs; i++) { - memcpy(&temp, q, sizeof(temp)); - q++; - csum += temp; - *p++ = temp; - } - size -= i * sizeof(uint32_t); - } else { - for (; size >= sizeof(*q); size -= sizeof(*q)) { - memcpy(&temp, q, sizeof(temp)); - q++; - csum += temp; - memcpy(p, &temp, sizeof(temp)); - p++; - } - } - state->partial_int = 0; - state->partial_size = 0; - } else { - /* NO, we don't... */ - memcpy(((char *) &temp + state->partial_size), q, size); - memcpy(p, ((char *) &temp + state->partial_size), size); - q = (uint32_t *) ((char *) q + size); - p = (uint32_t *) ((char *) p + size); - csum += (temp - state->partial_int); - state->partial_int = temp; - state->partial_size += size; - size = 0; - } - } else { - for (; size >= sizeof(*q); size -= sizeof(*q)) { - temp = *q++; - csum += temp; - memcpy(p, &temp, sizeof(temp)); - p++; - } - state->partial_int = 0; - state->partial_size = 0; - } - } else if (lam_aligned32(p)) { - if (state->partial_size) { - /* do we have enough data to fill out the partial word? */ - if (size >= (sizeof(uint32_t) - state->partial_size)) { - /* YES, we do... */ - memcpy(((char *) &temp + state->partial_size), q, - (sizeof(uint32_t) - state->partial_size)); - memcpy(p, ((char *) &temp + state->partial_size), - (sizeof(uint32_t) - state->partial_size)); - q = (uint32_t *) ((char *) q + sizeof(uint32_t) - - state->partial_size); - p = (uint32_t *) ((char *) p + sizeof(uint32_t) - - state->partial_size); - csum += (temp - state->partial_int); - size -= sizeof(uint32_t) - state->partial_size; - /* - * now we have a source of unknown alignment and a - * unaligned destination - */ - if (lam_aligned32(q)) { - for (; size >= sizeof(*q); size -= sizeof(*q)) { - temp = *q++; - csum += temp; - memcpy(p, &temp, sizeof(temp)); - p++; - } - state->partial_int = 0; - state->partial_size = 0; - } else { - for (; size >= sizeof(*q); size -= sizeof(*q)) { - memcpy(&temp, q, sizeof(temp)); - q++; - csum += temp; - memcpy(p, &temp, sizeof(temp)); - p++; - } - state->partial_size = 0; - state->partial_int = 0; - } - } else { - /* NO, we don't... */ - memcpy(((char *) &temp + state->partial_size), q, size); - memcpy(p, ((char *) &temp + state->partial_size), size); - q = (uint32_t *) ((char *) q + size); - p = (uint32_t *) ((char *) p + size); - csum += (temp - state->partial_int); - state->partial_int = temp; - state->partial_size += size; - size = 0; - } - } else { - for (; size >= sizeof(*q); size -= sizeof(*q)) { - memcpy(&temp, q, sizeof(temp)); - q++; - csum += temp; - *p++ = temp; - } - state->partial_size = 0; - state->partial_int = 0; - } - } else { - if (state->partial_size) { - /* do we have enough data to fill out the partial word? */ - if (size >= (sizeof(uint32_t) - state->partial_size)) { - /* YES, we do... */ - memcpy(((char *) &temp + state->partial_size), q, - (sizeof(uint32_t) - state->partial_size)); - memcpy(p, ((char *) &temp + state->partial_size), - (sizeof(uint32_t) - state->partial_size)); - q = (uint32_t *) ((char *) q + sizeof(uint32_t) - - state->partial_size); - p = (uint32_t *) ((char *) p + sizeof(uint32_t) - - state->partial_size); - csum += (temp - state->partial_int); - size -= sizeof(uint32_t) - state->partial_size; - /* - * now we have an unknown alignment for our source and - * destination - */ - if (lam_aligned32(q) && lam_aligned32(p)) { - size_t numLongs = size / sizeof(uint32_t); - for (i = 0; i < numLongs; i++) { - csum += *q; - *p++ = *q++; - } - size -= i * sizeof(uint32_t); - } else { /* safe but slower for all other alignments */ - for (; size >= sizeof(*q); size -= sizeof(*q)) { - memcpy(&temp, q, sizeof(temp)); - q++; - csum += temp; - memcpy(p, &temp, sizeof(temp)); - p++; - } - } - state->partial_int = 0; - state->partial_size = 0; - } else { - /* NO, we don't... */ - memcpy(((char *) &temp + state->partial_size), q, size); - memcpy(p, ((char *) &temp + state->partial_size), size); - q = (uint32_t *) ((char *) q + size); - p = (uint32_t *) ((char *) p + size); - csum += (temp - state->partial_int); - state->partial_int = temp; - state->partial_size += size; - size = 0; - } - } else { - for (; size >= sizeof(*q); size -= sizeof(*q)) { - memcpy(&temp, q, sizeof(temp)); - q++; - csum += temp; - memcpy(p, &temp, sizeof(temp)); - p++; - } - state->partial_size = 0; - state->partial_int = 0; - } - } - - /* - * if size is non-zero there was a bit left, less than an - * uint32_t's worth - */ - - if ((size != 0) && (csumlenresidue == 0)) { - temp = state->partial_int; - if (state->partial_size) { - if (size >= (sizeof(uint32_t) - state->partial_size)) { - /* copy all remaining bytes from q to p */ - uint32_t copytemp = 0; - memcpy(©temp, q, size); - memcpy(p, ©temp, size); - /* fill out rest of partial word and add to checksum */ - memcpy(((char *) &temp + state->partial_size), q, - (sizeof(uint32_t) - state->partial_size)); - /* - * avoid unsigned arithmetic overflow by subtracting - * the old partial word from the new one before adding - * to the checksum... - */ - csum += (temp - state->partial_int); - size -= sizeof(uint32_t) - state->partial_size; - q = (uint32_t *) ((char *) q + sizeof(uint32_t) - - state->partial_size); - state->partial_size = size; - /* reset temp, and calculate next partial word */ - temp = 0; - if (size) { - memcpy(&temp, q, size); - } - /* add it to the the checksum */ - csum += temp; - state->partial_int = temp; - } else { - /* copy all remaining bytes from q to p */ - uint32_t copytemp = 0; - memcpy(©temp, q, size); - memcpy(p, ©temp, size); - /* fill out rest of partial word and add to checksum */ - memcpy(((char *) &temp + state->partial_size), q, size); - /* - * avoid unsigned arithmetic overflow by subtracting - * the old partial word from the new one before adding - * to the checksum... - */ - csum += temp - state->partial_int; - state->partial_int = temp; - state->partial_size += size; - } - } else { /* fast path... */ - /* - * temp and state->partial_int are 0 if - * state->partial_size is 0... - */ - memcpy(&temp, q, size); - csum += temp; - memcpy(p, &temp, size); - state->partial_int = temp; - state->partial_size = size; - /* done...return the checksum */ - } - } else if (csumlenresidue != 0) { - if (size != 0) { - temp = 0; - memcpy(&temp, q, size); - memcpy(p, &temp, size); - } - if (csumlenresidue < - (ssize_t) (sizeof(uint32_t) - size - state->partial_size)) { - temp = state->partial_int; - memcpy(((char *) &temp + state->partial_size), q, - (size + csumlenresidue)); - /* - * avoid unsigned arithmetic overflow by subtracting the - * old partial word from the new one before adding to the - * checksum... - */ - csum += temp - state->partial_int; - q++; - state->partial_int = temp; - state->partial_size += size + csumlenresidue; - csumlenresidue = 0; - } else { - /* - * we have enough chksum data to fill out our last partial - * word - */ - temp = state->partial_int; - memcpy(((char *) &temp + state->partial_size), q, - (sizeof(uint32_t) - state->partial_size)); - /* - * avoid unsigned arithmetic overflow by subtracting the - * old partial word from the new one before adding to the - * checksum... - */ - csum += temp - state->partial_int; - q = (uint32_t *) ((char *) q + sizeof(uint32_t) - - state->partial_size); - csumlenresidue -= - sizeof(uint32_t) - state->partial_size - size; - state->partial_size = 0; - state->partial_int = 0; - } - if (lam_aligned32(q)) { - for (i = 0; i < csumlenresidue / sizeof(uint32_t); i++) { - csum += *q++; - } - } else { - for (i = 0; i < csumlenresidue / sizeof(uint32_t); i++) { - memcpy(&temp, q, sizeof(temp)); - csum += temp; - q++; - } - } - csumlenresidue -= i * sizeof(uint32_t); - if (csumlenresidue) { - temp = 0; - memcpy(&temp, q, csumlenresidue); - csum += temp; - state->partial_int = temp; - state->partial_size = csumlenresidue; - } - } - /* end else if (csumlenresidue != 0) */ - - state->sum = csum; - - return dst; -} diff --git a/src/datatype/dt_add.c b/src/datatype/dt_add.c index ecb803530c..32c526f455 100644 --- a/src/datatype/dt_add.c +++ b/src/datatype/dt_add.c @@ -1,3 +1,5 @@ +/* -*- Mode: C; c-basic-offset:4 ; -*- */ + #include "datatype.h" /* When we add a datatype we should update it's definition depending on diff --git a/src/datatype/dt_create.c b/src/datatype/dt_create.c index 07bb54de1a..4095069ba7 100644 --- a/src/datatype/dt_create.c +++ b/src/datatype/dt_create.c @@ -1,4 +1,4 @@ -/* -*- Mode: C; c-basic-offset:3 ; -*- */ +/* -*- Mode: C; c-basic-offset:4 ; -*- */ #include "datatype.h" #include "limits.h" diff --git a/src/datatype/dt_create_array.c b/src/datatype/dt_create_array.c index b4e8a18bd9..6e9ed6396c 100644 --- a/src/datatype/dt_create_array.c +++ b/src/datatype/dt_create_array.c @@ -1,3 +1,5 @@ +/* -*- Mode: C; c-basic-offset:4 ; -*- */ + #include "datatype.h" int dt_create_subarray( int ndims, int* pSizes, int* pSubSizes, int* pStarts, diff --git a/src/datatype/dt_create_dup.c b/src/datatype/dt_create_dup.c index a0ea41ba57..33c8c27629 100644 --- a/src/datatype/dt_create_dup.c +++ b/src/datatype/dt_create_dup.c @@ -1,3 +1,5 @@ +/* -*- Mode: C; c-basic-offset:4 ; -*- */ + #include "datatype.h" int dt_duplicate( dt_desc_t* oldType, dt_desc_t** newType ) diff --git a/src/datatype/dt_create_indexed.c b/src/datatype/dt_create_indexed.c index a05f3ba8ab..dba4253d09 100644 --- a/src/datatype/dt_create_indexed.c +++ b/src/datatype/dt_create_indexed.c @@ -1,3 +1,5 @@ +/* -*- Mode: C; c-basic-offset:4 ; -*- */ + #include "datatype.h" /* We try to merge together data that are contiguous */ diff --git a/src/datatype/dt_create_struct.c b/src/datatype/dt_create_struct.c index ec5c21ca3a..1f4c2c68a5 100644 --- a/src/datatype/dt_create_struct.c +++ b/src/datatype/dt_create_struct.c @@ -1,3 +1,5 @@ +/* -*- Mode: C; c-basic-offset:4 ; -*- */ + #include "datatype.h" int dt_create_struct( size_t count, size_t* pBlockLength, long* pDisp, diff --git a/src/datatype/dt_create_vector.c b/src/datatype/dt_create_vector.c index 9870d14f6f..fcbd4f9bac 100644 --- a/src/datatype/dt_create_vector.c +++ b/src/datatype/dt_create_vector.c @@ -1,3 +1,5 @@ +/* -*- Mode: C; c-basic-offset:4 ; -*- */ + #include "datatype.h" /* Open questions ... diff --git a/src/datatype/dt_destroy.c b/src/datatype/dt_destroy.c index 753251f45f..0ad53ddc2a 100644 --- a/src/datatype/dt_destroy.c +++ b/src/datatype/dt_destroy.c @@ -1,3 +1,5 @@ +/* -*- Mode: C; c-basic-offset:4 ; -*- */ + #include "datatype.h" /* This function should never be called directly. It's called by the dt_decrease_ref diff --git a/src/datatype/dt_module.c b/src/datatype/dt_module.c index e65591acb2..e00cbb2ea5 100644 --- a/src/datatype/dt_module.c +++ b/src/datatype/dt_module.c @@ -1,3 +1,5 @@ +/* -*- Mode: C; c-basic-offset:4 ; -*- */ + #include "datatype.h" #include "datatype_internal.h" diff --git a/src/datatype/dt_old_limits.c b/src/datatype/dt_old_limits.c deleted file mode 100644 index 4bbad44880..0000000000 --- a/src/datatype/dt_old_limits.c +++ /dev/null @@ -1,48 +0,0 @@ -#include "datatype.h" - -int dt_type_ub( dt_desc_t* pData, long* disp ) -{ - *disp = pData->ub; - return 0; -} - -int dt_type_lb( dt_desc_t* pData, long* disp ) -{ - *disp = pData->lb; - return 0; -} - -int dt_type_extent( dt_desc_t* pData, long* extent ) -{ - *extent = pData->ub - pData->lb; - return 0; -} - -int dt_type_size ( dt_desc_t* pData, int *size ) -{ - *size = pData->size; - return 0; -} - -int dt_type_resize( dt_desc_t* pOld, long lb, long extent, dt_desc_t** pNew ) -{ - return 0; -} - -int dt_get_extent( dt_desc_t* datatype, long* lb, long* extent) -{ - dt_desc_t* pData = (dt_desc_t*)datatype; - - *lb = pData->lb; - *extent = pData->ub - pData->lb; - return 0; -} - -int dt_get_true_extent( dt_desc_t* datatype, long* true_lb, long* true_extent) -{ - dt_desc_t* pData = (dt_desc_t*)datatype; - - *true_lb = pData->true_lb; - *true_extent = pData->true_ub - pData->true_lb; - return 0; -} diff --git a/src/datatype/dt_optimize.c b/src/datatype/dt_optimize.c index b775653f04..4ba6f36d5a 100644 --- a/src/datatype/dt_optimize.c +++ b/src/datatype/dt_optimize.c @@ -1,4 +1,4 @@ -/* -*- Mode: C; c-basic-offset:3 ; -*- */ +/* -*- Mode: C; c-basic-offset:4 ; -*- */ #include "datatype.h" #include "datatype_internal.h" diff --git a/src/datatype/dt_pack.c b/src/datatype/dt_pack.c index 47e2756dbc..21b96fa9c7 100644 --- a/src/datatype/dt_pack.c +++ b/src/datatype/dt_pack.c @@ -1,4 +1,4 @@ -/* -*- Mode: C; c-basic-offset:3 ; -*- */ +/* -*- Mode: C; c-basic-offset:4 ; -*- */ #include "datatype.h" #include "datatype_internal.h" diff --git a/src/datatype/dt_unpack.c b/src/datatype/dt_unpack.c index 7a8af2b63f..dfab7747f8 100644 --- a/src/datatype/dt_unpack.c +++ b/src/datatype/dt_unpack.c @@ -1,4 +1,4 @@ -/* -*- Mode: C; c-basic-offset:3 ; -*- */ +/* -*- Mode: C; c-basic-offset:4 ; -*- */ #include "datatype.h" #include "datatype_internal.h"