vlsvrs 1.0.0

VLSV reader with C and Python bindings
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96

#include "zfp.h"

#include <stdarg.h>
#include <stddef.h>
#include <stdint.h>
#include <setjmp.h>
#include <cmocka.h>

#include <stdlib.h>
#include <string.h>

struct setupVars {
  zfp_stream* stream;
  zfp_field* field;
  bitstream* bs;
  void* buffer;
  size_t streamSize;
};

static int
setup(void **state)
{
  struct setupVars *bundle = malloc(sizeof(struct setupVars));
  assert_non_null(bundle);

  bundle->stream = zfp_stream_open(NULL);
  assert_non_null(bundle);

  /* create a bitstream with buffer */
  size_t bufferSize = 50 * sizeof(int);
  bundle->buffer = malloc(bufferSize);
  assert_non_null(bundle->buffer);
  memset(bundle->buffer, 0, bufferSize);

  /* offset bitstream, so we can distinguish 0 from stream_size() returned from zfp_decompress() */
  bundle->bs = stream_open(bundle->buffer, bufferSize);
  stream_skip(bundle->bs, stream_word_bits + 1);

  bundle->streamSize = stream_size(bundle->bs);
  assert_int_not_equal(bundle->streamSize, 0);

  /* set cuda policy */
  assert_int_equal(1, zfp_stream_set_execution(bundle->stream, zfp_exec_cuda));

  /* create 4d field */
  bundle->field = zfp_field_4d(NULL, zfp_type_int32, 9, 5, 4, 4);
  assert_non_null(bundle->field);
  assert_int_equal(4, zfp_field_dimensionality(bundle->field));

  *state = bundle;

  return 0;
}

static int
teardown(void **state)
{
  struct setupVars *bundle = *state;

  zfp_field_free(bundle->field);

  stream_close(bundle->bs);
  free(bundle->buffer);
  zfp_stream_close(bundle->stream);

  free(bundle);

  return 0;
}

static void
given_withCuda_when_4dCompressCudaPolicy_expect_noop(void **state)
{
  struct setupVars *bundle = *state;

  assert_int_equal(zfp_compress(bundle->stream, bundle->field), 0);
  assert_int_equal(stream_size(bundle->bs), bundle->streamSize);
}

static void
given_withCuda_when_4dDecompressCudaPolicy_expect_noop(void **state)
{
  struct setupVars *bundle = *state;

  assert_int_equal(zfp_decompress(bundle->stream, bundle->field), 0);
  assert_int_equal(stream_size(bundle->bs), bundle->streamSize);
}

int main()
{
  const struct CMUnitTest tests[] = {
    cmocka_unit_test_setup_teardown(given_withCuda_when_4dCompressCudaPolicy_expect_noop, setup, teardown),
    cmocka_unit_test_setup_teardown(given_withCuda_when_4dDecompressCudaPolicy_expect_noop, setup, teardown),
  };
  return cmocka_run_group_tests(tests, NULL, NULL);
}