root/opal/mca/pmix/pmix4x/pmix/src/util/crc.h

INCLUDED FROM

DEFINITIONS

1. pmix_bcopy_csum
2. pmix_bcopy_uicsum
3. pmix_csum
4. pmix_csum16
5. pmix_uicsum
6. pmix_bcopy_uicrc
7. pmix_uicrc

   1 /*
   2  * Copyright (c) 2004-2005 The Trustees of Indiana University and Indiana
   3  *                         University Research and Technology
   4  *                         Corporation.  All rights reserved.
   5  * Copyright (c) 2004-2006 The University of Tennessee and The University
   6  *                         of Tennessee Research Foundation.  All rights
   7  *                         reserved.
   8  * Copyright (c) 2004-2005 High Performance Computing Center Stuttgart,
   9  *                         University of Stuttgart.  All rights reserved.
  10  * Copyright (c) 2004-2005 The Regents of the University of California.
  11  *                         All rights reserved.
  12  * Copyright (c) 2009      IBM Corporation.  All rights reserved.
  13  * Copyright (c) 2009      Los Alamos National Security, LLC.  All rights
  14  *                         reserved.
  15  * Copyright (c) 2015-2016 Intel, Inc.  All rights reserved.
  16  * $COPYRIGHT$
  17  *
  18  * Additional copyrights may follow
  19  *
  20  * $HEADER$
  21  */
  22 
  23 #ifndef _PMIX_CRC_H_
  24 #define _PMIX_CRC_H_
  25 
  26 #include <src/include/pmix_config.h>
  27 
  28 
  29 #include <stddef.h>
  30 
  31 BEGIN_C_DECLS
  32 
  33 #define CRC_POLYNOMIAL ((unsigned int)0x04c11db7)
  34 #define CRC_INITIAL_REGISTER ((unsigned int)0xffffffff)
  35 
  36 
  37 #define PMIX_CSUM( SRC, LEN )  pmix_uicsum( SRC, LEN )
  38 #define PMIX_CSUM_PARTIAL( SRC, LEN, UI1, UI2 ) \
  39     pmix_uicsum_partial( SRC, LEN, UI1, UI2 )
  40 #define PMIX_CSUM_BCOPY_PARTIAL( SRC, DST, LEN1, LEN2, UI1, UI2 ) \
  41     pmix_bcopy_uicsum_partial( SRC, DST, LEN1, LEN2, UI1, UI2 )
  42 #define PMIX_CSUM_ZERO  0
  43 
  44 
  45 unsigned long
  46 pmix_bcopy_csum_partial(
  47     const void *  source,
  48     void *  destination,
  49     size_t copylen,
  50     size_t csumlen,
  51     unsigned long*  lastPartialLong,
  52     size_t*  lastPartialLength
  53     );
  54 
  55 static inline unsigned long
  56 pmix_bcopy_csum (
  57     const void *  source,
  58     void *  destination,
  59     size_t copylen,
  60     size_t csumlen
  61     )
  62 {
  63     unsigned long plong = 0;
  64     size_t plength = 0;
  65     return pmix_bcopy_csum_partial(source, destination, copylen, csumlen, &plong, &plength);
  66 }
  67 
  68 unsigned int
  69 pmix_bcopy_uicsum_partial (
  70     const void *  source,
  71     void *  destination,
  72     size_t copylen,
  73     size_t csumlen,
  74     unsigned int*  lastPartialInt,
  75     size_t*  lastPartialLength
  76     );
  77 
  78 static inline unsigned int
  79 pmix_bcopy_uicsum (
  80     const void *  source,
  81     void *  destination,
  82     size_t copylen,
  83     size_t csumlen
  84     )
  85 {
  86     unsigned int pint = 0;
  87     size_t plength = 0;
  88     return pmix_bcopy_uicsum_partial(source, destination, copylen, csumlen, &pint, &plength);
  89 }
  90 
  91 unsigned long
  92 pmix_csum_partial (
  93     const void *  source,
  94     size_t csumlen,
  95     unsigned long*  lastPartialLong,
  96     size_t*  lastPartialLength
  97     );
  98 
  99 
 100 static inline unsigned long
 101 pmix_csum(const void *  source, size_t csumlen)
 102 {
 103     unsigned long lastPartialLong = 0;
 104     size_t lastPartialLength = 0;
 105     return pmix_csum_partial(source, csumlen, &lastPartialLong, &lastPartialLength);
 106 }
 107 /*
 108  * The buffer passed to this function is assumed to be 16-bit aligned
 109  */
 110 static inline uint16_t
 111 pmix_csum16 (const void *  source, size_t csumlen)
 112 {
 113     uint16_t *src = (uint16_t *) source;
 114     register uint32_t csum = 0;
 115 
 116     while (csumlen > 1) {
 117             csum += *src++;
 118         csumlen -= 2;
 119     }
 120     /* Add leftover byte, if any */
 121     if(csumlen > 0)
 122         csum += *((unsigned char*)src);
 123     /* Fold 32-bit checksum to 16 bits */
 124     while(csum >> 16) {
 125         csum = (csum & 0xFFFF) + (csum >> 16);
 126     }
 127     return csum;
 128 }
 129 
 130 unsigned int
 131 pmix_uicsum_partial (
 132     const void *  source,
 133     size_t csumlen,
 134     unsigned int *  lastPartialInt,
 135     size_t*  lastPartialLength
 136     );
 137 
 138 static inline unsigned int
 139 pmix_uicsum(const void *  source, size_t csumlen)
 140 {
 141     unsigned int lastPartialInt = 0;
 142     size_t lastPartialLength = 0;
 143     return pmix_uicsum_partial(source, csumlen, &lastPartialInt, &lastPartialLength);
 144 }
 145 
 146 /*
 147  * CRC Support
 148  */
 149 
 150 void pmix_initialize_crc_table(void);
 151 
 152 unsigned int
 153 pmix_bcopy_uicrc_partial(
 154     const void *  source,
 155     void *  destination,
 156     size_t copylen,
 157     size_t crclen,
 158     unsigned int partial_crc);
 159 
 160 static inline unsigned int
 161 pmix_bcopy_uicrc(
 162     const void *  source,
 163     void *  destination,
 164     size_t copylen,
 165     size_t crclen)
 166 {
 167     return pmix_bcopy_uicrc_partial(source, destination, copylen, crclen, CRC_INITIAL_REGISTER);
 168 }
 169 
 170 unsigned int
 171 pmix_uicrc_partial(
 172     const void *  source,
 173     size_t crclen,
 174     unsigned int partial_crc);
 175 
 176 
 177 static inline unsigned int
 178 pmix_uicrc(const void *  source, size_t crclen)
 179 {
 180     return pmix_uicrc_partial(source, crclen, CRC_INITIAL_REGISTER);
 181 }
 182 
 183 END_C_DECLS
 184 
 185 #endif