/*********************************************************************

  Blosc - Blocked Shuffling and Compression Library

  Copyright (c) 2021  Blosc Development Team <blosc@blosc.org>

  https://blosc.org

  License: BSD 3-Clause (see LICENSE.txt)

  See LICENSE.txt for details about copyright and rights to use.

**********************************************************************/

/*********************************************************************

  Generic (non-hardware-accelerated) shuffle/unshuffle routines.

  These are used when hardware-accelerated functions aren't available

  for a particular platform; they are also used by the hardware-

  accelerated functions to handle any remaining elements in a block

  which isn't a multiple of the hardware's vector size.

**********************************************************************/

#ifndef BLOSC_SHUFFLE_GENERIC_H

#define BLOSC_SHUFFLE_GENERIC_H

#include "blosc2/blosc2-common.h"

#include <stdint.h>

#include <string.h>

/**

  Generic (non-hardware-accelerated) shuffle routine.

  This is the pure element-copying nested loop. It is used by the

  generic shuffle implementation and also by the vectorized shuffle

  implementations to process any remaining elements in a block which

  is not a multiple of (type_size * vector_size).

*/

static inline void shuffle_generic_inline(const int32_t type_size,

                                   const int32_t vectorizable_blocksize, const int32_t blocksize,

                                   const uint8_t *_src, uint8_t *_dest) {

  int32_t i, j;

  /* Calculate the number of elements in the block. */

  const int32_t neblock_quot = blocksize / type_size;

  const int32_t neblock_rem = blocksize % type_size;

  const int32_t vectorizable_elements = vectorizable_blocksize / type_size;

  /* Non-optimized shuffle */

  for (j = 0; j < type_size; j++) {

    for (i = vectorizable_elements; i < (int32_t)neblock_quot; i++) {

      _dest[j * neblock_quot + i] = _src[i * type_size + j];

    }

  }

  /* Copy any leftover bytes in the block without shuffling them. */

  memcpy(_dest + (blocksize - neblock_rem), _src + (blocksize - neblock_rem), neblock_rem);

}

Unexecuted instantiation: shuffle.c:shuffle_generic_inline

shuffle-generic.c:shuffle_generic_inline

Line

Count

Source

36

14.6k

                                   const uint8_t *_src, uint8_t *_dest) {

37

14.6k

  int32_t i, j;

38

  /* Calculate the number of elements in the block. */

39

14.6k

  const int32_t neblock_quot = blocksize / type_size;

40

14.6k

  const int32_t neblock_rem = blocksize % type_size;

41

14.6k

  const int32_t vectorizable_elements = vectorizable_blocksize / type_size;

42

43

44

  /* Non-optimized shuffle */

45

29.3k

  for (j = 0; j < type_size; j++) {

46

23.2M

    for (i = vectorizable_elements; i < (int32_t)neblock_quot; i++) {

47

23.2M

      _dest[j * neblock_quot + i] = _src[i * type_size + j];

48

23.2M

    }

49

14.6k

  }

50

51

  /* Copy any leftover bytes in the block without shuffling them. */

52

14.6k

  memcpy(_dest + (blocksize - neblock_rem), _src + (blocksize - neblock_rem), neblock_rem);

53

14.6k

}

Unexecuted instantiation: shuffle-sse2.c:shuffle_generic_inline

Unexecuted instantiation: shuffle-avx2.c:shuffle_generic_inline

/**

  Generic (non-hardware-accelerated) unshuffle routine.

  This is the pure element-copying nested loop. It is used by the

  generic unshuffle implementation and also by the vectorized unshuffle

  implementations to process any remaining elements in a block which

  is not a multiple of (type_size * vector_size).

*/

static inline void unshuffle_generic_inline(const int32_t type_size,

                                     const int32_t vectorizable_blocksize, const int32_t blocksize,

                                     const uint8_t *_src, uint8_t *_dest) {

  int32_t i, j;

  /* Calculate the number of elements in the block. */

  const int32_t neblock_quot = blocksize / type_size;

  const int32_t neblock_rem = blocksize % type_size;

  const int32_t vectorizable_elements = vectorizable_blocksize / type_size;

  /* Non-optimized unshuffle */

  for (i = vectorizable_elements; i < (int32_t)neblock_quot; i++) {

    for (j = 0; j < type_size; j++) {

      _dest[i * type_size + j] = _src[j * neblock_quot + i];

    }

  }

  /* Copy any leftover bytes in the block without unshuffling them. */

  memcpy(_dest + (blocksize - neblock_rem), _src + (blocksize - neblock_rem), neblock_rem);

}

Unexecuted instantiation: shuffle.c:unshuffle_generic_inline

shuffle-generic.c:unshuffle_generic_inline

Line

Count

Source

64

7.42k

                                     const uint8_t *_src, uint8_t *_dest) {

65

7.42k

  int32_t i, j;

66

67

  /* Calculate the number of elements in the block. */

68

7.42k

  const int32_t neblock_quot = blocksize / type_size;

69

7.42k

  const int32_t neblock_rem = blocksize % type_size;

70

7.42k

  const int32_t vectorizable_elements = vectorizable_blocksize / type_size;

71

72

  /* Non-optimized unshuffle */

73

9.57M

  for (i = vectorizable_elements; i < (int32_t)neblock_quot; i++) {

74

19.2M

    for (j = 0; j < type_size; j++) {

75

9.69M

      _dest[i * type_size + j] = _src[j * neblock_quot + i];

76

9.69M

    }

77

9.56M

  }

78

79

  /* Copy any leftover bytes in the block without unshuffling them. */

80

7.42k

  memcpy(_dest + (blocksize - neblock_rem), _src + (blocksize - neblock_rem), neblock_rem);

81

7.42k

}

Unexecuted instantiation: shuffle-sse2.c:unshuffle_generic_inline

shuffle-avx2.c:unshuffle_generic_inline

Line

Count

Source

64

552

                                     const uint8_t *_src, uint8_t *_dest) {

65

552

  int32_t i, j;

66

67

  /* Calculate the number of elements in the block. */

68

552

  const int32_t neblock_quot = blocksize / type_size;

69

552

  const int32_t neblock_rem = blocksize % type_size;

70

552

  const int32_t vectorizable_elements = vectorizable_blocksize / type_size;

71

72

  /* Non-optimized unshuffle */

73

6.77k

  for (i = vectorizable_elements; i < (int32_t)neblock_quot; i++) {

74

195k

    for (j = 0; j < type_size; j++) {

75

189k

      _dest[i * type_size + j] = _src[j * neblock_quot + i];

76

189k

    }

77

6.21k

  }

78

79

  /* Copy any leftover bytes in the block without unshuffling them. */

80

552

  memcpy(_dest + (blocksize - neblock_rem), _src + (blocksize - neblock_rem), neblock_rem);

81

552

}

/**

  Generic (non-hardware-accelerated) shuffle routine.

*/

BLOSC_NO_EXPORT void shuffle_generic(const int32_t bytesoftype, const int32_t blocksize,

                                     const uint8_t *_src, uint8_t *_dest);

/**

  Generic (non-hardware-accelerated) unshuffle routine.

*/

BLOSC_NO_EXPORT void unshuffle_generic(const int32_t bytesoftype, const int32_t blocksize,

                                       const uint8_t *_src, uint8_t *_dest);

#endif /* BLOSC_SHUFFLE_GENERIC_H */