nihui
/
ncnn
Not watched
1
0
Fork 0
Code
Releases 46 Wiki evaluate Activity
Issues 0 Pull Requests 0 Datasets Model Cloudbrain HPC
You can not select more than 25 topics Topics must start with a chinese character,a letter or number, can include dashes ('-') and can be up to 35 characters long.
Tree: 7365bb80a2
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '7365bb80a2'
${ noResults }
ncnn/src/layer/vulkan/concat_vulkan.cpp

765 lines
27 kB
Raw Blame History 

  1. // Tencent is pleased to support the open source community by making ncnn available.

  2. //

  3. // Copyright (C) 2019 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 "concat_vulkan.h"

  16. #include <algorithm>

  17. #include "layer_type.h"

  18. #include "layer_shader_type.h"

  19. 

  20. namespace ncnn {

  21. 

  22. DEFINE_LAYER_CREATOR(Concat_vulkan)

  23. 

  24. Concat_vulkan::Concat_vulkan()

  25. {

  26.     support_vulkan = true;

  27. 

  28.     packing_pack4 = 0;

  29.     packing_pack8 = 0;

  30. 

  31.     pipeline_concat[0] = 0;

  32.     pipeline_concat[1] = 0;

  33.     pipeline_concat_pack4[0] = 0;

  34.     pipeline_concat_pack4[1] = 0;

  35.     pipeline_concat_pack4to1[0] = 0;

  36.     pipeline_concat_pack4to1[1] = 0;

  37.     pipeline_concat_pack8[0] = 0;

  38.     pipeline_concat_pack8[1] = 0;

  39.     pipeline_concat_pack8to4[0] = 0;

  40.     pipeline_concat_pack8to4[1] = 0;

  41.     pipeline_concat_pack8to1[0] = 0;

  42.     pipeline_concat_pack8to1[1] = 0;

  43. }

  44. 

  45. int Concat_vulkan::create_pipeline(const Option& opt)

  46. {

  47.     const Mat& shape = bottom_shapes.empty() ? Mat() : bottom_shapes[0];

  48.     const Mat& out_shape = top_shapes.empty() ? Mat() : top_shapes[0];

  49. 

  50.     int out_elempack = 1;

  51.     if (out_shape.dims == 1) out_elempack = opt.use_shader_pack8 && out_shape.w % 8 == 0 ? 8 : out_shape.w % 4 == 0 ? 4 : 1;

  52.     if (out_shape.dims == 2) out_elempack = opt.use_shader_pack8 && out_shape.h % 8 == 0 ? 8 : out_shape.h % 4 == 0 ? 4 : 1;

  53.     if (out_shape.dims == 3) out_elempack = opt.use_shader_pack8 && out_shape.c % 8 == 0 ? 8 : out_shape.c % 4 == 0 ? 4 : 1;

  54. 

  55.     int elempack = 1;

  56.     if (axis == 0)

  57.     {

  58.         if (shape.dims == 1) elempack = opt.use_shader_pack8 && shape.w % 8 == 0 ? 8 : shape.w % 4 == 0 ? 4 : 1;

  59.         if (shape.dims == 2) elempack = opt.use_shader_pack8 && shape.h % 8 == 0 ? 8 : shape.h % 4 == 0 ? 4 : 1;

  60.         if (shape.dims == 3) elempack = opt.use_shader_pack8 && shape.c % 8 == 0 ? 8 : shape.c % 4 == 0 ? 4 : 1;

  61. 

  62.         for (size_t b=1; b<bottom_shapes.size(); b++)

  63.         {

  64.             const Mat& shape1 = bottom_shapes[b];

  65. 

  66.             int elempack1 = 1;

  67.             if (shape1.dims == 1) elempack1 = opt.use_shader_pack8 && shape1.w % 8 == 0 ? 8 : shape1.w % 4 == 0 ? 4 : 1;

  68.             if (shape1.dims == 2) elempack1 = opt.use_shader_pack8 && shape1.h % 8 == 0 ? 8 : shape1.h % 4 == 0 ? 4 : 1;

  69.             if (shape1.dims == 3) elempack1 = opt.use_shader_pack8 && shape1.c % 8 == 0 ? 8 : shape1.c % 4 == 0 ? 4 : 1;

  70. 

  71.             elempack = std::min(elempack, elempack1);

  72.         }

  73.     }

  74.     else

  75.     {

  76.         elempack = out_elempack;

  77.     }

  78. 

  79.     size_t elemsize;

  80.     if (opt.use_fp16_storage)

  81.     {

  82.         elemsize = elempack * 2u;

  83.     }

  84.     else if (opt.use_fp16_packed)

  85.     {

  86.         elemsize = elempack == 1 ? 4u : elempack * 2u;

  87.     }

  88.     else

  89.     {

  90.         elemsize = elempack * 4u;

  91.     }

  92. 

  93.     Mat out_shape_unpacked;

  94.     if (out_shape.dims == 1) out_shape_unpacked = Mat(out_shape.w / elempack, (void*)0, elemsize, elempack);

  95.     if (out_shape.dims == 2) out_shape_unpacked = Mat(out_shape.w, out_shape.h / elempack, (void*)0, elemsize, elempack);

  96.     if (out_shape.dims == 3) out_shape_unpacked = Mat(out_shape.w, out_shape.h, out_shape.c / elempack, (void*)0, elemsize, elempack);

  97. 

  98.     std::vector<vk_specialization_type> specializations(1 + 10);

  99.     specializations[0].i = axis;

  100.     specializations[1 + 0].i = 0;// TODO handle shape_packed for concat2

  101.     specializations[1 + 1].i = 0;

  102.     specializations[1 + 2].i = 0;

  103.     specializations[1 + 3].i = 0;

  104.     specializations[1 + 4].i = 0;

  105.     specializations[1 + 5].i = out_shape_unpacked.dims;

  106.     specializations[1 + 6].i = out_shape_unpacked.w;

  107.     specializations[1 + 7].i = out_shape_unpacked.h;

  108.     specializations[1 + 8].i = out_shape_unpacked.c;

  109.     specializations[1 + 9].i = out_shape_unpacked.cstep;

  110. 

  111.     Mat local_size_xyz;// TODO more precise group size guessed from out_shape_unpacked

  112.     if (out_shape_unpacked.dims == 1)

  113.     {

  114.         local_size_xyz.w = 64;

  115.         local_size_xyz.h = 1;

  116.         local_size_xyz.c = 1;

  117.     }

  118.     if (out_shape_unpacked.dims == 2)

  119.     {

  120.         local_size_xyz.w = 8;

  121.         local_size_xyz.h = 8;

  122.         local_size_xyz.c = 1;

  123.     }

  124.     if (out_shape_unpacked.dims == 3)

  125.     {

  126.         local_size_xyz.w = 4;

  127.         local_size_xyz.h = 4;

  128.         local_size_xyz.c = 4;

  129.     }

  130. 

  131.     // pack1

  132.     if (shape.dims == 0 || elempack == 1)

  133.     {

  134.         pipeline_concat[0] = new Pipeline(vkdev);

  135.         pipeline_concat[0]->set_optimal_local_size_xyz(local_size_xyz);

  136.         pipeline_concat[0]->create(LayerShaderType::concat, opt, specializations);

  137.         pipeline_concat[1] = new Pipeline(vkdev);

  138.         pipeline_concat[1]->set_optimal_local_size_xyz(local_size_xyz);

  139.         pipeline_concat[1]->create(LayerShaderType::concat, opt, specializations);

  140.     }

  141. 

  142.     // pack4

  143.     if (shape.dims == 0 || elempack == 4)

  144.     {

  145.         pipeline_concat_pack4[0] = new Pipeline(vkdev);

  146.         pipeline_concat_pack4[0]->set_optimal_local_size_xyz(local_size_xyz);

  147.         pipeline_concat_pack4[0]->create(LayerShaderType::concat_pack4, opt, specializations);

  148.         pipeline_concat_pack4[1] = new Pipeline(vkdev);

  149.         pipeline_concat_pack4[1]->set_optimal_local_size_xyz(local_size_xyz);

  150.         pipeline_concat_pack4[1]->create(LayerShaderType::concat_pack4, opt, specializations);

  151.     }

  152. 

  153.     // pack4to1

  154.     if ((axis == 0 && shape.dims == 0) || elempack == 1)

  155.     {

  156.         pipeline_concat_pack4to1[0] = new Pipeline(vkdev);

  157.         pipeline_concat_pack4to1[0]->set_optimal_local_size_xyz(local_size_xyz);

  158.         pipeline_concat_pack4to1[0]->create(LayerShaderType::concat_pack4to1, opt, specializations);

  159.         pipeline_concat_pack4to1[1] = new Pipeline(vkdev);

  160.         pipeline_concat_pack4to1[1]->set_optimal_local_size_xyz(local_size_xyz);

  161.         pipeline_concat_pack4to1[1]->create(LayerShaderType::concat_pack4to1, opt, specializations);

  162.     }

  163. 

  164.     // pack8

  165.     if (opt.use_shader_pack8 && (shape.dims == 0 || elempack == 8))

  166.     {

  167.         pipeline_concat_pack8[0] = new Pipeline(vkdev);

  168.         pipeline_concat_pack8[0]->set_optimal_local_size_xyz(local_size_xyz);

  169.         pipeline_concat_pack8[0]->create(LayerShaderType::concat_pack8, opt, specializations);

  170.         pipeline_concat_pack8[1] = new Pipeline(vkdev);

  171.         pipeline_concat_pack8[1]->set_optimal_local_size_xyz(local_size_xyz);

  172.         pipeline_concat_pack8[1]->create(LayerShaderType::concat_pack8, opt, specializations);

  173.     }

  174. 

  175.     // pack8to4

  176.     if (opt.use_shader_pack8 && ((axis == 0 && shape.dims == 0) || elempack == 4))

  177.     {

  178.         pipeline_concat_pack8to4[0] = new Pipeline(vkdev);

  179.         pipeline_concat_pack8to4[0]->set_optimal_local_size_xyz(local_size_xyz);

  180.         pipeline_concat_pack8to4[0]->create(LayerShaderType::concat_pack8to4, opt, specializations);

  181.         pipeline_concat_pack8to4[1] = new Pipeline(vkdev);

  182.         pipeline_concat_pack8to4[1]->set_optimal_local_size_xyz(local_size_xyz);

  183.         pipeline_concat_pack8to4[1]->create(LayerShaderType::concat_pack8to4, opt, specializations);

  184.     }

  185. 

  186.     // pack8to1

  187.     if (opt.use_shader_pack8 && ((axis == 0 && shape.dims == 0) || elempack == 1))

  188.     {

  189.         pipeline_concat_pack8to1[0] = new Pipeline(vkdev);

  190.         pipeline_concat_pack8to1[0]->set_optimal_local_size_xyz(local_size_xyz);

  191.         pipeline_concat_pack8to1[0]->create(LayerShaderType::concat_pack8to1, opt, specializations);

  192.         pipeline_concat_pack8to1[1] = new Pipeline(vkdev);

  193.         pipeline_concat_pack8to1[1]->set_optimal_local_size_xyz(local_size_xyz);

  194.         pipeline_concat_pack8to1[1]->create(LayerShaderType::concat_pack8to1, opt, specializations);

  195.     }

  196. 

  197.     if ((axis == 0 && shape.dims == 0) || (elempack < out_elempack && out_elempack == 4))

  198.     {

  199.         packing_pack4 = ncnn::create_layer(ncnn::LayerType::Packing);

  200.         packing_pack4->vkdev = vkdev;

  201. 

  202.         packing_pack4->bottom_shapes.resize(1);

  203.         packing_pack4->bottom_shapes[0] = out_shape_unpacked;

  204.         packing_pack4->top_shapes.resize(1);

  205.         packing_pack4->top_shapes[0] = out_shape;

  206. 

  207.         ncnn::ParamDict pd;

  208.         pd.set(0, 4);

  209. 

  210.         packing_pack4->load_param(pd);

  211. 

  212.         packing_pack4->create_pipeline(opt);

  213.     }

  214. 

  215.     if ((opt.use_shader_pack8 && axis == 0 && shape.dims == 0) || (elempack < out_elempack && out_elempack == 8))

  216.     {

  217.         packing_pack8 = ncnn::create_layer(ncnn::LayerType::Packing);

  218.         packing_pack8->vkdev = vkdev;

  219. 

  220.         packing_pack8->bottom_shapes.resize(1);

  221.         packing_pack8->bottom_shapes[0] = out_shape_unpacked;

  222.         packing_pack8->top_shapes.resize(1);

  223.         packing_pack8->top_shapes[0] = out_shape;

  224. 

  225.         ncnn::ParamDict pd;

  226.         pd.set(0, 8);

  227. 

  228.         packing_pack8->load_param(pd);

  229. 

  230.         packing_pack8->create_pipeline(opt);

  231.     }

  232. 

  233.     return 0;

  234. }

  235. 

  236. int Concat_vulkan::destroy_pipeline(const Option& opt)

  237. {

  238.     if (packing_pack4)

  239.     {

  240.         packing_pack4->destroy_pipeline(opt);

  241.         delete packing_pack4;

  242.         packing_pack4 = 0;

  243.     }

  244. 

  245.     if (packing_pack8)

  246.     {

  247.         packing_pack8->destroy_pipeline(opt);

  248.         delete packing_pack8;

  249.         packing_pack8 = 0;

  250.     }

  251. 

  252.     delete pipeline_concat[0];

  253.     delete pipeline_concat[1];

  254.     pipeline_concat[0] = 0;

  255.     pipeline_concat[1] = 0;

  256. 

  257.     delete pipeline_concat_pack4[0];

  258.     delete pipeline_concat_pack4[1];

  259.     pipeline_concat_pack4[0] = 0;

  260.     pipeline_concat_pack4[1] = 0;

  261. 

  262.     delete pipeline_concat_pack4to1[0];

  263.     delete pipeline_concat_pack4to1[1];

  264.     pipeline_concat_pack4to1[0] = 0;

  265.     pipeline_concat_pack4to1[1] = 0;

  266. 

  267.     delete pipeline_concat_pack8[0];

  268.     delete pipeline_concat_pack8[1];

  269.     pipeline_concat_pack8[0] = 0;

  270.     pipeline_concat_pack8[1] = 0;

  271. 

  272.     delete pipeline_concat_pack8to4[0];

  273.     delete pipeline_concat_pack8to4[1];

  274.     pipeline_concat_pack8to4[0] = 0;

  275.     pipeline_concat_pack8to4[1] = 0;

  276. 

  277.     delete pipeline_concat_pack8to1[0];

  278.     delete pipeline_concat_pack8to1[1];

  279.     pipeline_concat_pack8to1[0] = 0;

  280.     pipeline_concat_pack8to1[1] = 0;

  281. 

  282.     return 0;

  283. }

  284. 

  285. int Concat_vulkan::forward(const std::vector<VkMat>& bottom_blobs, std::vector<VkMat>& top_blobs, VkCompute& cmd, const Option& opt) const

  286. {

  287.     int dims = bottom_blobs[0].dims;

  288. 

  289.     if (dims == 1) // axis == 0

  290.     {

  291.         // concat vector

  292.         // total length

  293.         size_t elemsize = bottom_blobs[0].elemsize;

  294.         int elempack = bottom_blobs[0].elempack;

  295.         int top_w = 0;

  296.         for (size_t b=0; b<bottom_blobs.size(); b++)

  297.         {

  298.             const VkMat& bottom_blob = bottom_blobs[b];

  299.             elemsize = std::min(elemsize, bottom_blob.elemsize);

  300.             elempack = std::min(elempack, bottom_blob.elempack);

  301.             top_w += bottom_blob.w * bottom_blob.elempack;

  302.         }

  303. 

  304.         int out_elempack = opt.use_shader_pack8 && top_w % 8 == 0 ? 8 : top_w % 4 == 0 ? 4 : 1;

  305.         size_t out_elemsize = elemsize / elempack * out_elempack;

  306. 

  307.         if (opt.use_fp16_packed && !opt.use_fp16_storage)

  308.         {

  309.             if (out_elempack == 8) out_elemsize = 8*2u;

  310.             if (out_elempack == 4) out_elemsize = 4*2u;

  311.             if (out_elempack == 1) out_elemsize = 4u;

  312.         }

  313. 

  314.         VkMat& top_blob = top_blobs[0];

  315.         top_blob.create(top_w / out_elempack, out_elemsize, out_elempack, opt.blob_vkallocator);

  316.         if (top_blob.empty())

  317.             return -100;

  318. 

  319.         VkMat top_blob_unpacked = top_blob;

  320.         if (elempack < out_elempack)

  321.         {

  322.             top_blob_unpacked.create(top_w / elempack, elemsize, elempack, opt.workspace_vkallocator);

  323.             if (top_blob_unpacked.empty())

  324.                 return -100;

  325.         }

  326. 

  327.         int woffset = 0;

  328.         for (size_t b=0; b<bottom_blobs.size(); b++)

  329.         {

  330.             const VkMat& bottom_blob = bottom_blobs[b];

  331. 

  332.             std::vector<VkMat> bindings(2);

  333.             bindings[0] = bottom_blob;

  334.             bindings[1] = top_blob_unpacked;

  335. 

  336.             std::vector<vk_constant_type> constants(11);

  337.             constants[0].i = bottom_blob.dims;

  338.             constants[1].i = bottom_blob.w;

  339.             constants[2].i = bottom_blob.h;

  340.             constants[3].i = bottom_blob.c;

  341.             constants[4].i = bottom_blob.cstep;

  342.             constants[5].i = top_blob_unpacked.dims;

  343.             constants[6].i = top_blob_unpacked.w;

  344.             constants[7].i = top_blob_unpacked.h;

  345.             constants[8].i = top_blob_unpacked.c;

  346.             constants[9].i = top_blob_unpacked.cstep;

  347.             constants[10].i = woffset;

  348. 

  349.             const Pipeline* pipeline = 0;

  350.             if (bottom_blob.elempack == 1 && elempack == 1)

  351.             {

  352.                 pipeline = pipeline_concat[b%2];

  353.             }

  354.             else if (bottom_blob.elempack == 4 && elempack == 4)

  355.             {

  356.                 pipeline = pipeline_concat_pack4[b%2];

  357.             }

  358.             else if (bottom_blob.elempack == 4 && elempack == 1)

  359.             {

  360.                 pipeline = pipeline_concat_pack4to1[b%2];

  361.             }

  362.             else if (bottom_blob.elempack == 8 && elempack == 8)

  363.             {

  364.                 pipeline = pipeline_concat_pack8[b%2];

  365.             }

  366.             else if (bottom_blob.elempack == 8 && elempack == 4)

  367.             {

  368.                 pipeline = pipeline_concat_pack8to4[b%2];

  369.             }

  370.             else if (bottom_blob.elempack == 8 && elempack == 1)

  371.             {

  372.                 pipeline = pipeline_concat_pack8to1[b%2];

  373.             }

  374. 

  375.             cmd.record_pipeline(pipeline, bindings, constants, bottom_blob);

  376. 

  377.             woffset += bottom_blob.w * bottom_blob.elempack / elempack;

  378.         }

  379. 

  380.         // packing

  381.         if (elempack < out_elempack)

  382.         {

  383.             const Layer* packing = out_elempack == 8 ? packing_pack8 : packing_pack4;

  384.             packing->forward(top_blob_unpacked, top_blob, cmd, opt);

  385.         }

  386. 

  387.         return 0;

  388.     }

  389. 

  390.     if (dims == 2 && axis == 0)

  391.     {

  392.         // concat image

  393.         int w = bottom_blobs[0].w;

  394. 

  395.         // total height

  396.         size_t elemsize = bottom_blobs[0].elemsize;

  397.         int elempack = bottom_blobs[0].elempack;

  398.         int top_h = 0;

  399.         for (size_t b=0; b<bottom_blobs.size(); b++)

  400.         {

  401.             const VkMat& bottom_blob = bottom_blobs[b];

  402.             elemsize = std::min(elemsize, bottom_blob.elemsize);

  403.             elempack = std::min(elempack, bottom_blob.elempack);

  404.             top_h += bottom_blob.h * bottom_blob.elempack;

  405.         }

  406. 

  407.         int out_elempack = opt.use_shader_pack8 && top_h % 8 == 0 ? 8 : top_h % 4 == 0 ? 4 : 1;

  408.         size_t out_elemsize = elemsize / elempack * out_elempack;

  409. 

  410.         if (opt.use_fp16_packed && !opt.use_fp16_storage)

  411.         {

  412.             if (out_elempack == 8) out_elemsize = 8*2u;

  413.             if (out_elempack == 4) out_elemsize = 4*2u;

  414.             if (out_elempack == 1) out_elemsize = 4u;

  415.         }

  416. 

  417.         VkMat& top_blob = top_blobs[0];

  418.         top_blob.create(w, top_h / out_elempack, out_elemsize, out_elempack, opt.blob_vkallocator);

  419.         if (top_blob.empty())

  420.             return -100;

  421. 

  422.         VkMat top_blob_unpacked = top_blob;

  423.         if (elempack < out_elempack)

  424.         {

  425.             top_blob_unpacked.create(w, top_h / elempack, elemsize, elempack, opt.workspace_vkallocator);

  426.             if (top_blob_unpacked.empty())

  427.                 return -100;

  428.         }

  429. 

  430.         int hoffset = 0;

  431.         for (size_t b=0; b<bottom_blobs.size(); b++)

  432.         {

  433.             const VkMat& bottom_blob = bottom_blobs[b];

  434. 

  435.             std::vector<VkMat> bindings(2);

  436.             bindings[0] = bottom_blob;

  437.             bindings[1] = top_blob_unpacked;

  438. 

  439.             std::vector<vk_constant_type> constants(11);

  440.             constants[0].i = bottom_blob.dims;

  441.             constants[1].i = bottom_blob.w;

  442.             constants[2].i = bottom_blob.h;

  443.             constants[3].i = bottom_blob.c;

  444.             constants[4].i = bottom_blob.cstep;

  445.             constants[5].i = top_blob_unpacked.dims;

  446.             constants[6].i = top_blob_unpacked.w;

  447.             constants[7].i = top_blob_unpacked.h;

  448.             constants[8].i = top_blob_unpacked.c;

  449.             constants[9].i = top_blob_unpacked.cstep;

  450.             constants[10].i = hoffset;

  451. 

  452.             const Pipeline* pipeline = 0;

  453.             if (bottom_blob.elempack == 1 && elempack == 1)

  454.             {

  455.                 pipeline = pipeline_concat[b%2];

  456.             }

  457.             else if (bottom_blob.elempack == 4 && elempack == 4)

  458.             {

  459.                 pipeline = pipeline_concat_pack4[b%2];

  460.             }

  461.             else if (bottom_blob.elempack == 4 && elempack == 1)

  462.             {

  463.                 pipeline = pipeline_concat_pack4to1[b%2];

  464.             }

  465.             else if (bottom_blob.elempack == 8 && elempack == 8)

  466.             {

  467.                 pipeline = pipeline_concat_pack8[b%2];

  468.             }

  469.             else if (bottom_blob.elempack == 8 && elempack == 4)

  470.             {

  471.                 pipeline = pipeline_concat_pack8to4[b%2];

  472.             }

  473.             else if (bottom_blob.elempack == 8 && elempack == 1)

  474.             {

  475.                 pipeline = pipeline_concat_pack8to1[b%2];

  476.             }

  477. 

  478.             cmd.record_pipeline(pipeline, bindings, constants, bottom_blob);

  479. 

  480.             hoffset += bottom_blob.h * bottom_blob.elempack / elempack;

  481.         }

  482. 

  483.         // packing

  484.         if (elempack < out_elempack)

  485.         {

  486.             const Layer* packing = out_elempack == 8 ? packing_pack8 : packing_pack4;

  487.             packing->forward(top_blob_unpacked, top_blob, cmd, opt);

  488.         }

  489. 

  490.         return 0;

  491.     }

  492. 

  493.     if (dims == 2 && axis == 1)

  494.     {

  495.         // interleave image row

  496.         int h = bottom_blobs[0].h;

  497.         size_t elemsize = bottom_blobs[0].elemsize;

  498.         int elempack = bottom_blobs[0].elempack;

  499. 

  500.         // total width

  501.         int top_w = 0;

  502.         for (size_t b=0; b<bottom_blobs.size(); b++)

  503.         {

  504.             const VkMat& bottom_blob = bottom_blobs[b];

  505.             top_w += bottom_blob.w;

  506.         }

  507. 

  508.         VkMat& top_blob = top_blobs[0];

  509.         top_blob.create(top_w, h, elemsize, elempack, opt.blob_vkallocator);

  510.         if (top_blob.empty())

  511.             return -100;

  512. 

  513.         int woffset = 0;

  514.         for (size_t b=0; b<bottom_blobs.size(); b++)

  515.         {

  516.             const VkMat& bottom_blob = bottom_blobs[b];

  517. 

  518.             std::vector<VkMat> bindings(2);

  519.             bindings[0] = bottom_blob;

  520.             bindings[1] = top_blob;

  521. 

  522.             std::vector<vk_constant_type> constants(11);

  523.             constants[0].i = bottom_blob.dims;

  524.             constants[1].i = bottom_blob.w;

  525.             constants[2].i = bottom_blob.h;

  526.             constants[3].i = bottom_blob.c;

  527.             constants[4].i = bottom_blob.cstep;

  528.             constants[5].i = top_blob.dims;

  529.             constants[6].i = top_blob.w;

  530.             constants[7].i = top_blob.h;

  531.             constants[8].i = top_blob.c;

  532.             constants[9].i = top_blob.cstep;

  533.             constants[10].i = woffset;

  534. 

  535.             const Pipeline* pipeline = elempack == 8 ? pipeline_concat_pack8[b%2]

  536.                                      : elempack == 4 ? pipeline_concat_pack4[b%2]

  537.                                      : pipeline_concat[b%2];

  538. 

  539.             cmd.record_pipeline(pipeline, bindings, constants, bottom_blob);

  540. 

  541.             woffset += bottom_blob.w;

  542.         }

  543. 

  544.         return 0;

  545.     }

  546. 

  547.     if (dims == 3 && axis == 0)

  548.     {

  549.         // concat dim

  550.         int w = bottom_blobs[0].w;

  551.         int h = bottom_blobs[0].h;

  552. 

  553.         // total channels

  554.         size_t elemsize = bottom_blobs[0].elemsize;

  555.         int elempack = bottom_blobs[0].elempack;

  556.         int top_channels = 0;

  557.         for (size_t b=0; b<bottom_blobs.size(); b++)

  558.         {

  559.             const VkMat& bottom_blob = bottom_blobs[b];

  560.             elemsize = std::min(elemsize, bottom_blob.elemsize);

  561.             elempack = std::min(elempack, bottom_blob.elempack);

  562.             top_channels += bottom_blob.c * bottom_blob.elempack;

  563.         }

  564. 

  565.         int out_elempack = opt.use_shader_pack8 && top_channels % 8 == 0 ? 8 : top_channels % 4 == 0 ? 4 : 1;

  566.         size_t out_elemsize = elemsize / elempack * out_elempack;

  567. 

  568.         if (opt.use_fp16_packed && !opt.use_fp16_storage)

  569.         {

  570.             if (out_elempack == 8) out_elemsize = 8*2u;

  571.             if (out_elempack == 4) out_elemsize = 4*2u;

  572.             if (out_elempack == 1) out_elemsize = 4u;

  573.         }

  574. 

  575.         VkMat& top_blob = top_blobs[0];

  576.         top_blob.create(w, h, top_channels / out_elempack, out_elemsize, out_elempack, opt.blob_vkallocator);

  577.         if (top_blob.empty())

  578.             return -100;

  579. 

  580.         VkMat top_blob_unpacked = top_blob;

  581.         if (elempack < out_elempack)

  582.         {

  583.             top_blob_unpacked.create(w, h, top_channels / elempack, elemsize, elempack, opt.workspace_vkallocator);

  584.             if (top_blob_unpacked.empty())

  585.                 return -100;

  586.         }

  587. 

  588.         int coffset = 0;

  589.         for (size_t b=0; b<bottom_blobs.size(); b++)

  590.         {

  591.             const VkMat& bottom_blob = bottom_blobs[b];

  592. 

  593.             std::vector<VkMat> bindings(2);

  594.             bindings[0] = bottom_blob;

  595.             bindings[1] = top_blob_unpacked;

  596. 

  597.             std::vector<vk_constant_type> constants(11);

  598.             constants[0].i = bottom_blob.dims;

  599.             constants[1].i = bottom_blob.w;

  600.             constants[2].i = bottom_blob.h;

  601.             constants[3].i = bottom_blob.c;

  602.             constants[4].i = bottom_blob.cstep;

  603.             constants[5].i = top_blob_unpacked.dims;

  604.             constants[6].i = top_blob_unpacked.w;

  605.             constants[7].i = top_blob_unpacked.h;

  606.             constants[8].i = top_blob_unpacked.c;

  607.             constants[9].i = top_blob_unpacked.cstep;

  608.             constants[10].i = coffset;

  609. 

  610.             const Pipeline* pipeline = 0;

  611.             if (bottom_blob.elempack == 1 && elempack == 1)

  612.             {

  613.                 pipeline = pipeline_concat[b%2];

  614.             }

  615.             else if (bottom_blob.elempack == 4 && elempack == 4)

  616.             {

  617.                 pipeline = pipeline_concat_pack4[b%2];

  618.             }

  619.             else if (bottom_blob.elempack == 4 && elempack == 1)

  620.             {

  621.                 pipeline = pipeline_concat_pack4to1[b%2];

  622.             }

  623.             else if (bottom_blob.elempack == 8 && elempack == 8)

  624.             {

  625.                 pipeline = pipeline_concat_pack8[b%2];

  626.             }

  627.             else if (bottom_blob.elempack == 8 && elempack == 4)

  628.             {

  629.                 pipeline = pipeline_concat_pack8to4[b%2];

  630.             }

  631.             else if (bottom_blob.elempack == 8 && elempack == 1)

  632.             {

  633.                 pipeline = pipeline_concat_pack8to1[b%2];

  634.             }

  635. 

  636.             cmd.record_pipeline(pipeline, bindings, constants, bottom_blob);

  637. 

  638.             coffset += bottom_blob.c * bottom_blob.elempack / elempack;

  639.         }

  640. 

  641.         // packing

  642.         if (elempack < out_elempack)

  643.         {

  644.             const Layer* packing = out_elempack == 8 ? packing_pack8 : packing_pack4;

  645.             packing->forward(top_blob_unpacked, top_blob, cmd, opt);

  646.         }

  647. 

  648.         return 0;

  649.     }

  650. 

  651.     if (dims == 3 && axis == 1)

  652.     {

  653.         // interleave dim height

  654.         int w = bottom_blobs[0].w;

  655.         int channels = bottom_blobs[0].c;

  656.         size_t elemsize = bottom_blobs[0].elemsize;

  657.         int elempack = bottom_blobs[0].elempack;

  658. 

  659.         // total height

  660.         int top_h = 0;

  661.         for (size_t b=0; b<bottom_blobs.size(); b++)

  662.         {

  663.             const VkMat& bottom_blob = bottom_blobs[b];

  664.             top_h += bottom_blob.h;

  665.         }

  666. 

  667.         VkMat& top_blob = top_blobs[0];

  668.         top_blob.create(w, top_h, channels, elemsize, elempack, opt.blob_vkallocator);

  669.         if (top_blob.empty())

  670.             return -100;

  671. 

  672.         int hoffset = 0;

  673.         for (size_t b=0; b<bottom_blobs.size(); b++)

  674.         {

  675.             const VkMat& bottom_blob = bottom_blobs[b];

  676. 

  677.             std::vector<VkMat> bindings(2);

  678.             bindings[0] = bottom_blob;

  679.             bindings[1] = top_blob;

  680. 

  681.             std::vector<vk_constant_type> constants(11);

  682.             constants[0].i = bottom_blob.dims;

  683.             constants[1].i = bottom_blob.w;

  684.             constants[2].i = bottom_blob.h;

  685.             constants[3].i = bottom_blob.c;

  686.             constants[4].i = bottom_blob.cstep;

  687.             constants[5].i = top_blob.dims;

  688.             constants[6].i = top_blob.w;

  689.             constants[7].i = top_blob.h;

  690.             constants[8].i = top_blob.c;

  691.             constants[9].i = top_blob.cstep;

  692.             constants[10].i = hoffset;

  693. 

  694.             const Pipeline* pipeline = elempack == 8 ? pipeline_concat_pack8[b%2]

  695.                                      : elempack == 4 ? pipeline_concat_pack4[b%2]

  696.                                      : pipeline_concat[b%2];

  697. 

  698.             cmd.record_pipeline(pipeline, bindings, constants, bottom_blob);

  699. 

  700.             hoffset += bottom_blob.h;

  701.         }

  702. 

  703.         return 0;

  704.     }

  705. 

  706.     if (dims == 3 && axis == 2)

  707.     {

  708.         // interleave dim width

  709.         int h = bottom_blobs[0].h;

  710.         int channels = bottom_blobs[0].c;

  711.         size_t elemsize = bottom_blobs[0].elemsize;

  712.         int elempack = bottom_blobs[0].elempack;

  713. 

  714.         // total height

  715.         int top_w = 0;

  716.         for (size_t b=0; b<bottom_blobs.size(); b++)

  717.         {

  718.             const VkMat& bottom_blob = bottom_blobs[b];

  719.             top_w += bottom_blob.w;

  720.         }

  721. 

  722.         VkMat& top_blob = top_blobs[0];

  723.         top_blob.create(top_w, h, channels, elemsize, elempack, opt.blob_vkallocator);

  724.         if (top_blob.empty())

  725.             return -100;

  726. 

  727.         int woffset = 0;

  728.         for (size_t b=0; b<bottom_blobs.size(); b++)

  729.         {

  730.             const VkMat& bottom_blob = bottom_blobs[b];

  731. 

  732.             std::vector<VkMat> bindings(2);

  733.             bindings[0] = bottom_blob;

  734.             bindings[1] = top_blob;

  735. 

  736.             std::vector<vk_constant_type> constants(11);

  737.             constants[0].i = bottom_blob.dims;

  738.             constants[1].i = bottom_blob.w;

  739.             constants[2].i = bottom_blob.h;

  740.             constants[3].i = bottom_blob.c;

  741.             constants[4].i = bottom_blob.cstep;

  742.             constants[5].i = top_blob.dims;

  743.             constants[6].i = top_blob.w;

  744.             constants[7].i = top_blob.h;

  745.             constants[8].i = top_blob.c;

  746.             constants[9].i = top_blob.cstep;

  747.             constants[10].i = woffset;

  748. 

  749.             const Pipeline* pipeline = elempack == 8 ? pipeline_concat_pack8[b%2]

  750.                                      : elempack == 4 ? pipeline_concat_pack4[b%2]

  751.                                      : pipeline_concat[b%2];

  752. 

  753.             cmd.record_pipeline(pipeline, bindings, constants, bottom_blob);

  754. 

  755.             woffset += bottom_blob.w;

  756.         }

  757. 

  758.         return 0;

  759.     }

  760. 

  761.     return 0;

  762. }

  763. 

  764. } // namespace ncnn