ncnn

1
// Tencent is pleased to support the open source community by making ncnn available.
2
//
3
// Copyright (C) 2021 THL A29 Limited, a Tencent company. All rights reserved.
4
//
5
// Licensed under the BSD 3-Clause License (the "License"); you may not use this file except
6
// in compliance with the License. You may obtain a copy of the License at
7
//
8
// https://opensource.org/licenses/BSD-3-Clause
9
//
10
// Unless required by applicable law or agreed to in writing, software distributed
11
// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
12
// CONDITIONS OF ANY KIND, either express or implied. See the License for the
13
// specific language governing permissions and limitations under the License.
14

15
#include "command.h"
16
#include "gpu.h"
17
#include "mat.h"
18
#include "testutil.h"
19

20
static int test_command_upload_download(const ncnn::Mat& a)
21
{
22
    ncnn::VulkanDevice* vkdev = ncnn::get_gpu_device();
23

24
    ncnn::VkAllocator* blob_allocator = vkdev->acquire_blob_allocator();
25
    ncnn::VkAllocator* staging_allocator = vkdev->acquire_staging_allocator();
26

27
    ncnn::Option opt;
28
    opt.num_threads = 1;
29
    opt.use_vulkan_compute = true;
30
    opt.blob_vkallocator = blob_allocator;
31
    opt.staging_vkallocator = staging_allocator;
32

33
    if (!vkdev->info.support_fp16_packed()) opt.use_fp16_packed = false;
34
    if (!vkdev->info.support_fp16_storage()) opt.use_fp16_storage = false;
35

36
    ncnn::Mat d;
37
    ncnn::Mat e;
38
    {
39
        ncnn::VkCompute cmd(vkdev);
40

41
        ncnn::VkMat b1;
42
        ncnn::VkImageMat b2;
43
        ncnn::VkImageMat c1;
44
        ncnn::VkMat c2;
45
        cmd.record_upload(a, b1, opt);
46
        cmd.record_upload(a, c1, opt);
47
        cmd.record_buffer_to_image(b1, b2, opt);
48
        cmd.record_image_to_buffer(c1, c2, opt);
49
        cmd.record_download(b2, d, opt);
50
        cmd.record_download(c2, e, opt);
51

52
        cmd.submit_and_wait();
53
    }
54

55
    vkdev->reclaim_blob_allocator(blob_allocator);
56
    vkdev->reclaim_staging_allocator(staging_allocator);
57

58
    if (CompareMat(a, d, 0.001) != 0)
59
    {
60
        fprintf(stderr, "test_command_upload_download buffer failed a.dims=%d a=(%d %d %d)\n", a.dims, a.w, a.h, a.c);
61
        return -1;
62
    }
63

64
    if (CompareMat(a, e, 0.001) != 0)
65
    {
66
        fprintf(stderr, "test_command_upload_download image failed a.dims=%d a=(%d %d %d)\n", a.dims, a.w, a.h, a.c);
67
        return -1;
68
    }
69

70
    return 0;
71
}
72

73
static int test_command_clone(const ncnn::Mat& a)
74
{
75
    ncnn::VulkanDevice* vkdev = ncnn::get_gpu_device();
76

77
    ncnn::VkAllocator* blob_allocator = vkdev->acquire_blob_allocator();
78
    ncnn::VkAllocator* staging_allocator = vkdev->acquire_staging_allocator();
79

80
    ncnn::Option opt;
81
    opt.num_threads = 1;
82
    opt.use_vulkan_compute = true;
83
    opt.blob_vkallocator = blob_allocator;
84
    opt.staging_vkallocator = staging_allocator;
85

86
    if (!vkdev->info.support_fp16_packed()) opt.use_fp16_packed = false;
87
    if (!vkdev->info.support_fp16_storage()) opt.use_fp16_storage = false;
88

89
    ncnn::Mat d;
90
    ncnn::Mat e;
91
    {
92
        ncnn::VkCompute cmd(vkdev);
93

94
        ncnn::VkMat b1;
95
        ncnn::VkMat b2;
96
        ncnn::VkImageMat b3;
97
        ncnn::VkImageMat c1;
98
        ncnn::VkImageMat c2;
99
        ncnn::VkMat c3;
100
        cmd.record_clone(a, b1, opt);
101
        cmd.record_clone(a, c1, opt);
102
        cmd.record_clone(b1, b2, opt);
103
        cmd.record_clone(c1, c2, opt);
104
        cmd.record_clone(b2, b3, opt);
105
        cmd.record_clone(c2, c3, opt);
106
        cmd.record_clone(b3, d, opt);
107
        cmd.record_clone(c3, e, opt);
108

109
        cmd.submit_and_wait();
110
    }
111

112
    vkdev->reclaim_blob_allocator(blob_allocator);
113
    vkdev->reclaim_staging_allocator(staging_allocator);
114

115
    if (CompareMat(a, d, 0.001) != 0)
116
    {
117
        fprintf(stderr, "test_command_clone buffer failed a.dims=%d a=(%d %d %d)\n", a.dims, a.w, a.h, a.c);
118
        return -1;
119
    }
120

121
    if (CompareMat(a, e, 0.001) != 0)
122
    {
123
        fprintf(stderr, "test_command_clone image failed a.dims=%d a=(%d %d %d)\n", a.dims, a.w, a.h, a.c);
124
        return -1;
125
    }
126

127
    return 0;
128
}
129

130
static int test_command_transfer(const ncnn::Mat& a)
131
{
132
    ncnn::VulkanDevice* vkdev = ncnn::get_gpu_device();
133

134
    ncnn::VkAllocator* blob_allocator = vkdev->acquire_blob_allocator();
135
    ncnn::VkAllocator* staging_allocator = vkdev->acquire_staging_allocator();
136

137
    ncnn::Option opt;
138
    opt.num_threads = 1;
139
    opt.use_vulkan_compute = true;
140
    opt.blob_vkallocator = blob_allocator;
141
    opt.staging_vkallocator = staging_allocator;
142

143
    if (!vkdev->info.support_fp16_packed()) opt.use_fp16_packed = false;
144
    if (!vkdev->info.support_fp16_storage()) opt.use_fp16_storage = false;
145

146
    ncnn::Mat d;
147
    ncnn::Mat e;
148
    {
149
        ncnn::VkTransfer cmd1(vkdev);
150

151
        ncnn::VkMat b1;
152
        ncnn::VkImageMat c1;
153
        cmd1.record_upload(a, b1, opt, false);
154
        cmd1.record_upload(a, c1, opt);
155

156
        cmd1.submit_and_wait();
157

158
        ncnn::VkCompute cmd2(vkdev);
159

160
        cmd2.record_download(b1, d, opt);
161
        cmd2.record_download(c1, e, opt);
162

163
        cmd2.submit_and_wait();
164
    }
165

166
    vkdev->reclaim_blob_allocator(blob_allocator);
167
    vkdev->reclaim_staging_allocator(staging_allocator);
168

169
    if (CompareMat(a, d, 0.001) != 0)
170
    {
171
        fprintf(stderr, "test_command_transfer buffer failed a.dims=%d a=(%d %d %d)\n", a.dims, a.w, a.h, a.c);
172
        return -1;
173
    }
174

175
    if (CompareMat(a, e, 0.001) != 0)
176
    {
177
        fprintf(stderr, "test_command_transfer image failed a.dims=%d a=(%d %d %d)\n", a.dims, a.w, a.h, a.c);
178
        return -1;
179
    }
180

181
    return 0;
182
}
183

184
static int test_command_0()
185
{
186
    return 0
187
           || test_command_upload_download(RandomMat(5, 7, 24))
188
           || test_command_upload_download(RandomMat(7, 9, 12))
189
           || test_command_upload_download(RandomMat(3, 5, 13))
190
           || test_command_upload_download(RandomMat(15, 24))
191
           || test_command_upload_download(RandomMat(19, 12))
192
           || test_command_upload_download(RandomMat(17, 15))
193
           || test_command_upload_download(RandomMat(128))
194
           || test_command_upload_download(RandomMat(124))
195
           || test_command_upload_download(RandomMat(127));
196
}
197

198
static int test_command_1()
199
{
200
    return 0
201
           || test_command_clone(RandomMat(5, 7, 24))
202
           || test_command_clone(RandomMat(7, 9, 12))
203
           || test_command_clone(RandomMat(3, 5, 13))
204
           || test_command_clone(RandomMat(15, 24))
205
           || test_command_clone(RandomMat(19, 12))
206
           || test_command_clone(RandomMat(17, 15))
207
           || test_command_clone(RandomMat(128))
208
           || test_command_clone(RandomMat(124))
209
           || test_command_clone(RandomMat(127));
210
}
211

212
static int test_command_2()
213
{
214
    return 0
215
           || test_command_transfer(RandomMat(5, 7, 24))
216
           || test_command_transfer(RandomMat(7, 9, 12))
217
           || test_command_transfer(RandomMat(3, 5, 13))
218
           || test_command_transfer(RandomMat(15, 24))
219
           || test_command_transfer(RandomMat(19, 12))
220
           || test_command_transfer(RandomMat(17, 15))
221
           || test_command_transfer(RandomMat(128))
222
           || test_command_transfer(RandomMat(124))
223
           || test_command_transfer(RandomMat(127));
224
}
225

226
int main()
227
{
228
    SRAND(7767517);
229

230
    return test_command_0() || test_command_1() || test_command_2();
231
}
232