Coverage Report

Created: 2025-05-06 15:32

next uncovered line (L), next uncovered region (R), next uncovered branch (B)
/home/liu/actions-runner/_work/ccv/ccv/test/unit/nnc/partition.tests.c
Line
Count
Source
1
#include "case.h"
2
#include "ccv_case.h"
3
#include "ccv_nnc_case.h"
4
#include <ccv.h>
5
#include <nnc/ccv_nnc.h>
6
#include <nnc/ccv_nnc_easy.h>
7
8
TEST_SETUP()
9
{
10
  ccv_nnc_init();
11
}
12
13
TEST_CASE("partition a tensor by first axis")
14
1
{
15
1
  float ap[] = {
16
1
    1, 3,
17
1
    2, 5,
18
1
    3, 4,
19
1
  };
20
1
  ccv_nnc_tensor_t* const a = ccv_nnc_tensor_new(ap, CPU_TENSOR_NHWC(32F, 3, 2), 0);
21
1
  ccv_nnc_tensor_t* const b = ccv_nnc_tensor_new(0, CPU_TENSOR_NHWC(32F, 2, 2), 0);
22
1
  ccv_nnc_tensor_t* const indices = ccv_nnc_tensor_new(0, CPU_TENSOR_NHWC(32S, 2, 2), 0);
23
1
  ccv_nnc_cmd_exec(CMD_PARTITION_FORWARD(2, 0, 0), ccv_nnc_no_hint, 0, TENSOR_LIST(a), TENSOR_LIST(b, indices), 0);
24
1
  float btp[] = {
25
1
    1, 3,
26
1
    2, 4,
27
1
  };
28
1
  ccv_nnc_tensor_t const bt = ccv_nnc_tensor(btp, CPU_TENSOR_NHWC(32F, 2, 2), 0);
29
1
  REQUIRE_TENSOR_EQ(b, &bt, "should be equal");
30
1
  int indicestp[] = {
31
1
    0, 0,
32
1
    1, 2,
33
1
  };
34
1
  ccv_nnc_tensor_t const indicest = ccv_nnc_tensor(indicestp, CPU_TENSOR_NHWC(32S, 2, 2), 0);
35
1
  REQUIRE_TENSOR_EQ(indices, &indicest, "should be equal");
36
1
  ccv_nnc_tensor_free(a);
37
1
  ccv_nnc_tensor_free(b);
38
1
  ccv_nnc_tensor_free(indices);
39
1
}
40
41
TEST_CASE("partition a tensor by last axis")
42
1
{
43
1
  float ap[] = {
44
1
    1, 3,
45
1
    2, 1,
46
1
    3, 4,
47
1
  };
48
1
  ccv_nnc_tensor_t* const a = ccv_nnc_tensor_new(ap, CPU_TENSOR_NHWC(32F, 3, 2), 0);
49
1
  ccv_nnc_tensor_t* const b = ccv_nnc_tensor_new(0, CPU_TENSOR_NHWC(32F, 3, 1), 0);
50
1
  ccv_nnc_tensor_t* const indices = ccv_nnc_tensor_new(0, CPU_TENSOR_NHWC(32S, 3, 1), 0);
51
1
  ccv_nnc_cmd_exec(CMD_PARTITION_FORWARD(1, 1, 0), ccv_nnc_no_hint, 0, TENSOR_LIST(a), TENSOR_LIST(b, indices), 0);
52
1
  float btp[] = {
53
1
    1,
54
1
    1,
55
1
    3,
56
1
  };
57
1
  ccv_nnc_tensor_t const bt = ccv_nnc_tensor(btp, CPU_TENSOR_NHWC(32F, 3, 1), 0);
58
1
  REQUIRE_TENSOR_EQ(b, &bt, "should be equal");
59
1
  int indicestp[] = {
60
1
    0,
61
1
    1,
62
1
    0,
63
1
  };
64
1
  ccv_nnc_tensor_t const indicest = ccv_nnc_tensor(indicestp, CPU_TENSOR_NHWC(32S, 3, 1), 0);
65
1
  REQUIRE_TENSOR_EQ(indices, &indicest, "should be equal");
66
1
  ccv_nnc_tensor_free(a);
67
1
  ccv_nnc_tensor_free(b);
68
1
  ccv_nnc_tensor_free(indices);
69
1
}
70
71
TEST_CASE("partition a 1d tensor")
72
1
{
73
1
  float ap[] = {
74
1
    1, 3, 2, 4, 5
75
1
  };
76
1
  ccv_nnc_tensor_t* const a = ccv_nnc_tensor_new(ap, CPU_TENSOR_NHWC(32F, 5), 0);
77
1
  ccv_nnc_tensor_t* const b = ccv_nnc_tensor_new(0, CPU_TENSOR_NHWC(32F, 4), 0);
78
1
  ccv_nnc_tensor_t* const indices = ccv_nnc_tensor_new(0, CPU_TENSOR_NHWC(32S, 4), 0);
79
1
  ccv_nnc_cmd_exec(CMD_PARTITION_FORWARD(4, 0, 0), ccv_nnc_no_hint, 0, TENSOR_LIST(a), TENSOR_LIST(b, indices), 0);
80
1
  float btp[] = {
81
1
    1, 2, 3, 4,
82
1
  };
83
1
  ccv_nnc_tensor_t const bt = ccv_nnc_tensor(btp, CPU_TENSOR_NHWC(32F, 4), 0);
84
1
  REQUIRE_TENSOR_EQ(b, &bt, "should be equal");
85
1
  int indicestp[] = {
86
1
    0, 2, 1, 3
87
1
  };
88
1
  ccv_nnc_tensor_t const indicest = ccv_nnc_tensor(indicestp, CPU_TENSOR_NHWC(32S, 4), 0);
89
1
  REQUIRE_TENSOR_EQ(indices, &indicest, "should be equal");
90
1
  ccv_nnc_tensor_free(a);
91
1
  ccv_nnc_tensor_free(b);
92
1
  ccv_nnc_tensor_free(indices);
93
1
}
94
95
TEST_CASE("partition a tensor by first axis in int")
96
1
{
97
1
  int ap[] = {
98
1
    1, 3,
99
1
    2, 5,
100
1
    3, 4,
101
1
  };
102
1
  ccv_nnc_tensor_t* const a = ccv_nnc_tensor_new(ap, CPU_TENSOR_NHWC(32S, 3, 2), 0);
103
1
  ccv_nnc_tensor_t* const b = ccv_nnc_tensor_new(0, CPU_TENSOR_NHWC(32S, 2, 2), 0);
104
1
  ccv_nnc_tensor_t* const indices = ccv_nnc_tensor_new(0, CPU_TENSOR_NHWC(32S, 2, 2), 0);
105
1
  ccv_nnc_cmd_exec(CMD_PARTITION_FORWARD(2, 0, 0), ccv_nnc_no_hint, 0, TENSOR_LIST(a), TENSOR_LIST(b, indices), 0);
106
1
  int btp[] = {
107
1
    1, 3,
108
1
    2, 4,
109
1
  };
110
1
  ccv_nnc_tensor_t const bt = ccv_nnc_tensor(btp, CPU_TENSOR_NHWC(32S, 2, 2), 0);
111
1
  REQUIRE_TENSOR_EQ(b, &bt, "should be equal");
112
1
  int indicestp[] = {
113
1
    0, 0,
114
1
    1, 2,
115
1
  };
116
1
  ccv_nnc_tensor_t const indicest = ccv_nnc_tensor(indicestp, CPU_TENSOR_NHWC(32S, 2, 2), 0);
117
1
  REQUIRE_TENSOR_EQ(indices, &indicest, "should be equal");
118
1
  ccv_nnc_tensor_free(a);
119
1
  ccv_nnc_tensor_free(b);
120
1
  ccv_nnc_tensor_free(indices);
121
1
}
122
123
TEST_CASE("partition a tensor by last axis in int")
124
1
{
125
1
  int ap[] = {
126
1
    1, 3,
127
1
    2, 1,
128
1
    3, 4,
129
1
  };
130
1
  ccv_nnc_tensor_t* const a = ccv_nnc_tensor_new(ap, CPU_TENSOR_NHWC(32S, 3, 2), 0);
131
1
  ccv_nnc_tensor_t* const b = ccv_nnc_tensor_new(0, CPU_TENSOR_NHWC(32S, 3, 1), 0);
132
1
  ccv_nnc_tensor_t* const indices = ccv_nnc_tensor_new(0, CPU_TENSOR_NHWC(32S, 3, 1), 0);
133
1
  ccv_nnc_cmd_exec(CMD_PARTITION_FORWARD(1, 1, 0), ccv_nnc_no_hint, 0, TENSOR_LIST(a), TENSOR_LIST(b, indices), 0);
134
1
  int btp[] = {
135
1
    1,
136
1
    1,
137
1
    3,
138
1
  };
139
1
  ccv_nnc_tensor_t const bt = ccv_nnc_tensor(btp, CPU_TENSOR_NHWC(32S, 3, 1), 0);
140
1
  REQUIRE_TENSOR_EQ(b, &bt, "should be equal");
141
1
  int indicestp[] = {
142
1
    0,
143
1
    1,
144
1
    0,
145
1
  };
146
1
  ccv_nnc_tensor_t const indicest = ccv_nnc_tensor(indicestp, CPU_TENSOR_NHWC(32S, 3, 1), 0);
147
1
  REQUIRE_TENSOR_EQ(indices, &indicest, "should be equal");
148
1
  ccv_nnc_tensor_free(a);
149
1
  ccv_nnc_tensor_free(b);
150
1
  ccv_nnc_tensor_free(indices);
151
1
}
152
153
TEST_CASE("partition a 1d tensor in int")
154
1
{
155
1
  int ap[] = {
156
1
    1, 3, 2, 4, 5
157
1
  };
158
1
  ccv_nnc_tensor_t* const a = ccv_nnc_tensor_new(ap, CPU_TENSOR_NHWC(32S, 5), 0);
159
1
  ccv_nnc_tensor_t* const b = ccv_nnc_tensor_new(0, CPU_TENSOR_NHWC(32S, 4), 0);
160
1
  ccv_nnc_tensor_t* const indices = ccv_nnc_tensor_new(0, CPU_TENSOR_NHWC(32S, 4), 0);
161
1
  ccv_nnc_cmd_exec(CMD_PARTITION_FORWARD(4, 0, 0), ccv_nnc_no_hint, 0, TENSOR_LIST(a), TENSOR_LIST(b, indices), 0);
162
1
  int btp[] = {
163
1
    1, 2, 3, 4,
164
1
  };
165
1
  ccv_nnc_tensor_t const bt = ccv_nnc_tensor(btp, CPU_TENSOR_NHWC(32S, 4), 0);
166
1
  REQUIRE_TENSOR_EQ(b, &bt, "should be equal");
167
1
  int indicestp[] = {
168
1
    0, 2, 1, 3
169
1
  };
170
1
  ccv_nnc_tensor_t const indicest = ccv_nnc_tensor(indicestp, CPU_TENSOR_NHWC(32S, 4), 0);
171
1
  REQUIRE_TENSOR_EQ(indices, &indicest, "should be equal");
172
1
  ccv_nnc_tensor_free(a);
173
1
  ccv_nnc_tensor_free(b);
174
1
  ccv_nnc_tensor_free(indices);
175
1
}
176
177
TEST_CASE("partition a tensor by first axis, descending")
178
1
{
179
1
  float ap[] = {
180
1
    1, 3,
181
1
    2, 5,
182
1
    3, 4,
183
1
  };
184
1
  ccv_nnc_tensor_t* const a = ccv_nnc_tensor_new(ap, CPU_TENSOR_NHWC(32F, 3, 2), 0);
185
1
  ccv_nnc_tensor_t* const b = ccv_nnc_tensor_new(0, CPU_TENSOR_NHWC(32F, 2, 2), 0);
186
1
  ccv_nnc_tensor_t* const indices = ccv_nnc_tensor_new(0, CPU_TENSOR_NHWC(32S, 2, 2), 0);
187
1
  ccv_nnc_cmd_exec(CMD_PARTITION_FORWARD(2, 0, 1), ccv_nnc_no_hint, 0, TENSOR_LIST(a), TENSOR_LIST(b, indices), 0);
188
1
  float btp[] = {
189
1
    3, 5,
190
1
    2, 4,
191
1
  };
192
1
  ccv_nnc_tensor_t const bt = ccv_nnc_tensor(btp, CPU_TENSOR_NHWC(32F, 2, 2), 0);
193
1
  REQUIRE_TENSOR_EQ(b, &bt, "should be equal");
194
1
  int indicestp[] = {
195
1
    2, 1,
196
1
    1, 2,
197
1
  };
198
1
  ccv_nnc_tensor_t const indicest = ccv_nnc_tensor(indicestp, CPU_TENSOR_NHWC(32S, 2, 2), 0);
199
1
  REQUIRE_TENSOR_EQ(indices, &indicest, "should be equal");
200
1
  ccv_nnc_tensor_free(a);
201
1
  ccv_nnc_tensor_free(b);
202
1
  ccv_nnc_tensor_free(indices);
203
1
}
204
205
TEST_CASE("partition a tensor by last axis, descending")
206
1
{
207
1
  float ap[] = {
208
1
    1, 3,
209
1
    2, 1,
210
1
    3, 4,
211
1
  };
212
1
  ccv_nnc_tensor_t* const a = ccv_nnc_tensor_new(ap, CPU_TENSOR_NHWC(32F, 3, 2), 0);
213
1
  ccv_nnc_tensor_t* const b = ccv_nnc_tensor_new(0, CPU_TENSOR_NHWC(32F, 3, 1), 0);
214
1
  ccv_nnc_tensor_t* const indices = ccv_nnc_tensor_new(0, CPU_TENSOR_NHWC(32S, 3, 1), 0);
215
1
  ccv_nnc_cmd_exec(CMD_PARTITION_FORWARD(1, 1, 1), ccv_nnc_no_hint, 0, TENSOR_LIST(a), TENSOR_LIST(b, indices), 0);
216
1
  float btp[] = {
217
1
    3,
218
1
    2,
219
1
    4,
220
1
  };
221
1
  ccv_nnc_tensor_t const bt = ccv_nnc_tensor(btp, CPU_TENSOR_NHWC(32F, 3, 1), 0);
222
1
  REQUIRE_TENSOR_EQ(b, &bt, "should be equal");
223
1
  int indicestp[] = {
224
1
    1,
225
1
    0,
226
1
    1,
227
1
  };
228
1
  ccv_nnc_tensor_t const indicest = ccv_nnc_tensor(indicestp, CPU_TENSOR_NHWC(32S, 3, 1), 0);
229
1
  REQUIRE_TENSOR_EQ(indices, &indicest, "should be equal");
230
1
  ccv_nnc_tensor_free(a);
231
1
  ccv_nnc_tensor_free(b);
232
1
  ccv_nnc_tensor_free(indices);
233
1
}
234
235
TEST_CASE("partition a 1d tensor, descending")
236
1
{
237
1
  float ap[] = {
238
1
    1, 3, 2, 4, 5
239
1
  };
240
1
  ccv_nnc_tensor_t* const a = ccv_nnc_tensor_new(ap, CPU_TENSOR_NHWC(32F, 5), 0);
241
1
  ccv_nnc_tensor_t* const b = ccv_nnc_tensor_new(0, CPU_TENSOR_NHWC(32F, 4), 0);
242
1
  ccv_nnc_tensor_t* const indices = ccv_nnc_tensor_new(0, CPU_TENSOR_NHWC(32S, 4), 0);
243
1
  ccv_nnc_cmd_exec(CMD_PARTITION_FORWARD(4, 0, 1), ccv_nnc_no_hint, 0, TENSOR_LIST(a), TENSOR_LIST(b, indices), 0);
244
1
  float btp[] = {
245
1
    5, 4, 3, 2,
246
1
  };
247
1
  ccv_nnc_tensor_t const bt = ccv_nnc_tensor(btp, CPU_TENSOR_NHWC(32F, 4), 0);
248
1
  REQUIRE_TENSOR_EQ(b, &bt, "should be equal");
249
1
  int indicestp[] = {
250
1
    4, 3, 1, 2
251
1
  };
252
1
  ccv_nnc_tensor_t const indicest = ccv_nnc_tensor(indicestp, CPU_TENSOR_NHWC(32S, 4), 0);
253
1
  REQUIRE_TENSOR_EQ(indices, &indicest, "should be equal");
254
1
  ccv_nnc_tensor_free(a);
255
1
  ccv_nnc_tensor_free(b);
256
1
  ccv_nnc_tensor_free(indices);
257
1
}
258
259
TEST_CASE("partition a tensor by first axis in int, descending")
260
1
{
261
1
  int ap[] = {
262
1
    1, 3,
263
1
    2, 5,
264
1
    3, 4,
265
1
  };
266
1
  ccv_nnc_tensor_t* const a = ccv_nnc_tensor_new(ap, CPU_TENSOR_NHWC(32S, 3, 2), 0);
267
1
  ccv_nnc_tensor_t* const b = ccv_nnc_tensor_new(0, CPU_TENSOR_NHWC(32S, 2, 2), 0);
268
1
  ccv_nnc_tensor_t* const indices = ccv_nnc_tensor_new(0, CPU_TENSOR_NHWC(32S, 2, 2), 0);
269
1
  ccv_nnc_cmd_exec(CMD_PARTITION_FORWARD(2, 0, 1), ccv_nnc_no_hint, 0, TENSOR_LIST(a), TENSOR_LIST(b, indices), 0);
270
1
  int btp[] = {
271
1
    3, 5,
272
1
    2, 4,
273
1
  };
274
1
  ccv_nnc_tensor_t const bt = ccv_nnc_tensor(btp, CPU_TENSOR_NHWC(32S, 2, 2), 0);
275
1
  REQUIRE_TENSOR_EQ(b, &bt, "should be equal");
276
1
  int indicestp[] = {
277
1
    2, 1,
278
1
    1, 2,
279
1
  };
280
1
  ccv_nnc_tensor_t const indicest = ccv_nnc_tensor(indicestp, CPU_TENSOR_NHWC(32S, 2, 2), 0);
281
1
  REQUIRE_TENSOR_EQ(indices, &indicest, "should be equal");
282
1
  ccv_nnc_tensor_free(a);
283
1
  ccv_nnc_tensor_free(b);
284
1
  ccv_nnc_tensor_free(indices);
285
1
}
286
287
TEST_CASE("partition a tensor by last axis in int, descending")
288
1
{
289
1
  int ap[] = {
290
1
    1, 3,
291
1
    2, 1,
292
1
    3, 4,
293
1
  };
294
1
  ccv_nnc_tensor_t* const a = ccv_nnc_tensor_new(ap, CPU_TENSOR_NHWC(32S, 3, 2), 0);
295
1
  ccv_nnc_tensor_t* const b = ccv_nnc_tensor_new(0, CPU_TENSOR_NHWC(32S, 3, 1), 0);
296
1
  ccv_nnc_tensor_t* const indices = ccv_nnc_tensor_new(0, CPU_TENSOR_NHWC(32S, 3, 1), 0);
297
1
  ccv_nnc_cmd_exec(CMD_PARTITION_FORWARD(1, 1, 1), ccv_nnc_no_hint, 0, TENSOR_LIST(a), TENSOR_LIST(b, indices), 0);
298
1
  int btp[] = {
299
1
    3,
300
1
    2,
301
1
    4,
302
1
  };
303
1
  ccv_nnc_tensor_t const bt = ccv_nnc_tensor(btp, CPU_TENSOR_NHWC(32S, 3, 1), 0);
304
1
  REQUIRE_TENSOR_EQ(b, &bt, "should be equal");
305
1
  int indicestp[] = {
306
1
    1,
307
1
    0,
308
1
    1,
309
1
  };
310
1
  ccv_nnc_tensor_t const indicest = ccv_nnc_tensor(indicestp, CPU_TENSOR_NHWC(32S, 3, 1), 0);
311
1
  REQUIRE_TENSOR_EQ(indices, &indicest, "should be equal");
312
1
  ccv_nnc_tensor_free(a);
313
1
  ccv_nnc_tensor_free(b);
314
1
  ccv_nnc_tensor_free(indices);
315
1
}
316
317
TEST_CASE("partition a 1d tensor in int, descending")
318
1
{
319
1
  int ap[] = {
320
1
    1, 3, 2, 4, 5
321
1
  };
322
1
  ccv_nnc_tensor_t* const a = ccv_nnc_tensor_new(ap, CPU_TENSOR_NHWC(32S, 5), 0);
323
1
  ccv_nnc_tensor_t* const b = ccv_nnc_tensor_new(0, CPU_TENSOR_NHWC(32S, 4), 0);
324
1
  ccv_nnc_tensor_t* const indices = ccv_nnc_tensor_new(0, CPU_TENSOR_NHWC(32S, 4), 0);
325
1
  ccv_nnc_cmd_exec(CMD_PARTITION_FORWARD(4, 0, 1), ccv_nnc_no_hint, 0, TENSOR_LIST(a), TENSOR_LIST(b, indices), 0);
326
1
  int btp[] = {
327
1
    5, 4, 3, 2,
328
1
  };
329
1
  ccv_nnc_tensor_t const bt = ccv_nnc_tensor(btp, CPU_TENSOR_NHWC(32S, 4), 0);
330
1
  REQUIRE_TENSOR_EQ(b, &bt, "should be equal");
331
1
  int indicestp[] = {
332
1
    4, 3, 1, 2
333
1
  };
334
1
  ccv_nnc_tensor_t const indicest = ccv_nnc_tensor(indicestp, CPU_TENSOR_NHWC(32S, 4), 0);
335
1
  REQUIRE_TENSOR_EQ(indices, &indicest, "should be equal");
336
1
  ccv_nnc_tensor_free(a);
337
1
  ccv_nnc_tensor_free(b);
338
1
  ccv_nnc_tensor_free(indices);
339
1
}
340
341
TEST_CASE("partition a tensor by last axis in int, descending with model")
342
1
{
343
1
  int ap[] = {
344
1
    1, 3,
345
1
    2, 1,
346
1
    3, 4,
347
1
  };
348
1
  ccv_nnc_tensor_t* const a = ccv_nnc_tensor_new(ap, CPU_TENSOR_NHWC(32S, 3, 2), 0);
349
1
  ccv_nnc_tensor_t* const b = ccv_nnc_tensor_new(0, CPU_TENSOR_NHWC(32S, 3, 1), 0);
350
1
  ccv_nnc_tensor_t* const indices = ccv_nnc_tensor_new(0, CPU_TENSOR_NHWC(32S, 3, 1), 0);
351
1
  ccv_cnnp_model_t* const partition = ccv_cnnp_partition(1, 1, 1, "partition");
352
1
  ccv_cnnp_model_compile(partition, TENSOR_PARAM_LIST(a->info), CMD_NOOP(), CMD_NOOP());
353
1
  ccv_cnnp_model_evaluate(partition, (ccv_cnnp_evaluate_param_t){
354
1
    .requires_grad = 0,
355
1
  }, TENSOR_LIST(a), TENSOR_LIST(b, indices), 0, 0);
356
1
  int btp[] = {
357
1
    3,
358
1
    2,
359
1
    4,
360
1
  };
361
1
  ccv_nnc_tensor_t const bt = ccv_nnc_tensor(btp, CPU_TENSOR_NHWC(32S, 3, 1), 0);
362
1
  REQUIRE_TENSOR_EQ(b, &bt, "should be equal");
363
1
  int indicestp[] = {
364
1
    1,
365
1
    0,
366
1
    1,
367
1
  };
368
1
  ccv_nnc_tensor_t const indicest = ccv_nnc_tensor(indicestp, CPU_TENSOR_NHWC(32S, 3, 1), 0);
369
1
  REQUIRE_TENSOR_EQ(indices, &indicest, "should be equal");
370
1
  ccv_nnc_tensor_free(a);
371
1
  ccv_nnc_tensor_free(b);
372
1
  ccv_nnc_tensor_free(indices);
373
1
  ccv_cnnp_model_free(partition);
374
1
}
375
376
#include "case_main.h"