2024年2月

目录

一、LVM概述

LVM

Logical Volume Manager(逻辑卷管理器)
的简写。逻辑卷管理器是Linux系统用于对硬盘分区进行管理的一种机制,理论性较强,其创建初衷是为了解决硬盘设备在创建分区后
不易修改分区大小
的缺陷。尽管对传统的硬盘分区进行强制扩容或缩容从理论上来讲是可行的,但是却可能造成数据的丢失。而LVM技术是
在硬盘分区和文件系统之间添加了一个逻辑层
,它提供了一个抽象的卷组,可以把多块硬盘进行卷组合并。这样一来,用户不必关心物理硬盘设备的底层架构和布局,就可以实现对硬盘分区的动态调整。

二、基本术语

  • 物理存储介质(PhysicalStorageMedia)

指系统的物理存储设备:磁盘,如:/dev/hda、/dev/sda等,是
存储系统
最底层的
存储单元

  • 物理卷(Physical Volume,PV)

指磁盘分区或从逻辑上与磁盘分区具有同样功能的设备(如RAID),是LVM的基本存储逻辑块,但和基本的物理存储介质(如分区、磁盘等)比较,却包含有与LVM相关的管理参数。

  • 卷组(Volume Group,VG)

类似于非LVM系统中的物理磁盘,其由一个或多个物理卷PV组成。可以在卷组上创建一个或多个LV(逻辑卷)。

  • 逻辑卷(Logical Volume,LV)

类似于非LVM系统中的磁盘分区,逻辑卷建立在卷组VG之上。在逻辑卷LV之上可以建立文件系统(比如/home或者/usr等)。

  • 物理块(Physical Extent,PE)

PE是物理卷PV的基本划分单元,具有唯一编号的PE是可以被LVM寻址的最小单元。PE的大小是可配置的,默认为4MB。所以物理卷(PV)由大小等同的基本单元PE组成。

  • 逻辑块(Logical Extent,LE)

逻辑卷LV也被划分为可被
寻址
的基本单位,称为LE。在同一个卷组中,LE的大小和PE是相同的,并且一一对应。

三、PE、PV、VG、LV之间的关系

image.png

四、LVM的工作原理

  1. 物理磁盘被格式化为PV,空间被划分为一个个的PE。
  2. 不同的PV加入到同一个VG中,不同PV的PE全部进入到了VG的PE池内。
  3. LV基于PE创建,大小为PE的整数倍,组成LV的PE可能来自不同的物理磁盘。
  4. LV现在就直接可以格式化后挂载使用了。
  5. LV的扩充缩减实际上就是增加或减少组成该LV的PE数量,其过程不会丢失原始数据 。

五、LVM的使用

1、部署逻辑卷

常用的LVM部署命令

功能/命令 物理卷管理 卷组管理 逻辑卷管理
扫描 pvscan vgscan lvscan
建立 pvcreate vgcreate lvcreate
显示 pvdisplay vgdisplay lvdisplay
删除 pvremove vgremove lvremove
扩展 vgextend lvextend
缩小 vgreduce lvreduce

第一步:

还原快照,并在虚拟机添加两块新硬盘设备,开机

image-20240206202408707

第二步:

让新添加的两块硬盘设备支持LVM技术

[root@localhost ~]# lsblk	#确保已正确新增两块硬盘
NAME                MAJ:MIN RM  SIZE RO TYPE MOUNTPOINT
sda                   8:0    0   20G  0 disk
├─sda1                8:1    0    1G  0 part /boot
└─sda2                8:2    0   19G  0 part
  ├─centos_192-root 253:0    0   17G  0 lvm  /
  └─centos_192-swap 253:1    0    2G  0 lvm  [SWAP]
sdb                   8:16   0   20G  0 disk
sdc                   8:32   0   20G  0 disk
sr0                  11:0    1  4.4G  0 rom
[root@localhost ~]# pvcreate /dev/sdb /dev/sdc	#来将磁盘设备 /dev/sdb 和 /dev/sdc 初始化为物理卷(PV)以支持LVM(逻辑卷管理器)技术。
  Physical volume "/dev/sdb" successfully created.
  Physical volume "/dev/sdc" successfully created.

image-20240206203227516

第三步:

把两块硬盘设备加入到storage卷组中,查看卷组状态

[root@localhost ~]# vgcreate storage /dev/sdb /dev/sdc	#将物理卷 /dev/sdb 和 /dev/sdc 合并在一起,形成一个新的名为"storage"卷组。
  Volume group "storage" successfully created
[root@localhost ~]# vgdisplay
  --- Volume group ---
  VG Name               centos_192
  System ID
  Format                lvm2
  Metadata Areas        1
  Metadata Sequence No  3
  VG Access             read/write
  VG Status             resizable
  MAX LV                0
  Cur LV                2
  Open LV               2
  Max PV                0
  Cur PV                1
  Act PV                1
  VG Size               <19.00 GiB
  PE Size               4.00 MiB
  Total PE              4863
  Alloc PE / Size       4863 / <19.00 GiB
  Free  PE / Size       0 / 0
  VG UUID               Qtwzup-pc0G-gAaa-Icyt-UfLP-CuM6-3VnATy

  --- Volume group ---
  VG Name               storage
  System ID
  Format                lvm2
  Metadata Areas        2
  Metadata Sequence No  1
  VG Access             read/write
  VG Status             resizable
  MAX LV                0
  Cur LV                0
  Open LV               0
  Max PV                0
  Cur PV                2
  Act PV                2
  VG Size               39.99 GiB
  PE Size               4.00 MiB
  Total PE              10238
  Alloc PE / Size       0 / 0
  Free  PE / Size       10238 / 39.99 GiB
  VG UUID               SJWDak-DLob-UssH-6d8g-Ms8Y-R2Di-dczcAw

image-20240206204450998

第四步:

切割出一个148MB的逻辑卷设备

在对逻辑卷进行切割时有两种计量单位

  • 以容量为单位,使用参数
    -L
    。例如使用
    -L 150M
    生成一个大小为150MB的逻辑卷。
  • 以基本单元的个数为单位,使用的参数为
    -l
    。每个基本单元的大小默认为
    4MB
    。例如使用
    -l 37
    可以生成一个大小为37*4MB=148MB的逻辑卷。

-l
切割:

[root@localhost ~]# lvcreate -n vo -l 37 storage	#参数-n后面跟的是要创建的逻辑卷名称
  Logical volume "vo" created.
[root@localhost ~]# lvdisplay
  --- Logical volume ---
  LV Path                /dev/centos_192/swap
  LV Name                swap
  VG Name                centos_192
  LV UUID                XDa9D8-hZj7-QVSC-qiQ0-lbaQ-QKRZ-LeZXcT
  LV Write Access        read/write
  LV Creation host, time 192.168.112.140, 2023-08-12 17:05:09 +0800
  LV Status              available
  # open                 2
  LV Size                2.00 GiB
  Current LE             512
  Segments               1
  Allocation             inherit
  Read ahead sectors     auto
  - currently set to     8192
  Block device           253:1

  --- Logical volume ---
  LV Path                /dev/centos_192/root
  LV Name                root
  VG Name                centos_192
  LV UUID                pHMI0L-5zIz-U6RU-g7L0-1Uy1-K01W-SNxrJi
  LV Write Access        read/write
  LV Creation host, time 192.168.112.140, 2023-08-12 17:05:09 +0800
  LV Status              available
  # open                 1
  LV Size                <17.00 GiB
  Current LE             4351
  Segments               1
  Allocation             inherit
  Read ahead sectors     auto
  - currently set to     8192
  Block device           253:0

  --- Logical volume ---
  LV Path                /dev/storage/vo
  LV Name                vo
  VG Name                storage
  LV UUID                h6L7tj-pz3i-Iear-RK9Y-Fu0M-iVEc-HOn8On
  LV Write Access        read/write
  LV Creation host, time localhost, 2024-02-06 20:50:44 +0800
  LV Status              available
  # open                 0
  LV Size                148.00 MiB
  Current LE             37
  Segments               1
  Allocation             inherit
  Read ahead sectors     auto
  - currently set to     8192
  Block device           253:2

image-20240206205306557

-L
切割:

[root@localhost ~]# lvcreate -n vo -L 148M storage
  Logical volume "vo" created.
[root@localhost ~]# lvdisplay
  --- Logical volume ---
  LV Path                /dev/centos_192/swap
  LV Name                swap
  VG Name                centos_192
  LV UUID                XDa9D8-hZj7-QVSC-qiQ0-lbaQ-QKRZ-LeZXcT
  LV Write Access        read/write
  LV Creation host, time 192.168.112.140, 2023-08-12 17:05:09 +0800
  LV Status              available
  # open                 2
  LV Size                2.00 GiB
  Current LE             512
  Segments               1
  Allocation             inherit
  Read ahead sectors     auto
  - currently set to     8192
  Block device           253:1

  --- Logical volume ---
  LV Path                /dev/centos_192/root
  LV Name                root
  VG Name                centos_192
  LV UUID                pHMI0L-5zIz-U6RU-g7L0-1Uy1-K01W-SNxrJi
  LV Write Access        read/write
  LV Creation host, time 192.168.112.140, 2023-08-12 17:05:09 +0800
  LV Status              available
  # open                 1
  LV Size                <17.00 GiB
  Current LE             4351
  Segments               1
  Allocation             inherit
  Read ahead sectors     auto
  - currently set to     8192
  Block device           253:0

  --- Logical volume ---
  LV Path                /dev/storage/vo
  LV Name                vo
  VG Name                storage
  LV UUID                uIyQ4u-fs8f-gDkr-L4Kw-eqC9-FQzq-PwgtL5
  LV Write Access        read/write
  LV Creation host, time localhost, 2024-02-06 21:10:05 +0800
  LV Status              available
  # open                 0
  LV Size                148.00 MiB
  Current LE             37
  Segments               1
  Allocation             inherit
  Read ahead sectors     auto
  - currently set to     8192
  Block device           253:2

image-20240206211250148

第五步:

把生成好的逻辑卷进行格式化,然后挂载使用

[root@localhost ~]# mkfs.ext4 /dev/storage/vo
mke2fs 1.42.9 (28-Dec-2013)
文件系统标签=
OS type: Linux
块大小=1024 (log=0)
分块大小=1024 (log=0)
Stride=0 blocks, Stripe width=0 blocks
38000 inodes, 151552 blocks
7577 blocks (5.00%) reserved for the super user
第一个数据块=1
Maximum filesystem blocks=33816576
19 block groups
8192 blocks per group, 8192 fragments per group
2000 inodes per group
Superblock backups stored on blocks:
        8193, 24577, 40961, 57345, 73729

Allocating group tables: 完成
正在写入inode表: 完成
Creating journal (4096 blocks): 完成
Writing superblocks and filesystem accounting information: 完成

[root@localhost ~]# mkdir /vo	#根目录下创建vo挂载点
[root@localhost ~]# mount /dev/storage/vo /vo
[root@localhost ~]# df -h	#查看成功挂载
文件系统                     容量  已用  可用 已用% 挂载点
devtmpfs                     1.9G     0  1.9G    0% /dev
tmpfs                        1.9G     0  1.9G    0% /dev/shm
tmpfs                        1.9G   12M  1.9G    1% /run
tmpfs                        1.9G     0  1.9G    0% /sys/fs/cgroup
/dev/mapper/centos_192-root   17G  2.0G   16G   12% /
/dev/sda1                   1014M  151M  864M   15% /boot
tmpfs                        378M     0  378M    0% /run/user/0
/dev/mapper/storage-vo       140M  1.6M  128M    2% /vo
[root@localhost ~]# echo "/dev/storage/vo /vo ext4 defaults 0 0" >> /etc/fstab		#写入配置文件使之永久生效	

image-20240206211936946

2、扩容逻辑卷

第一步:

把上一个实验中的逻辑卷
vo
扩展至292MB

[root@localhost ~]# umount /vo
[root@localhost ~]# lvextend -L 292M /dev/storage/vo
  Rounding size to boundary between physical extents: 292.00 MiB.
  Size of logical volume storage/vo changed from 148.00 MiB (37 extents) to 292.00 MiB (73 extents).
  Logical volume storage/vo successfully resized.

image-20240206213833026

第二步:

检查硬盘完整性,并重置硬盘容量

[root@localhost ~]# e2fsck -f /dev/storage/vo	#检查 ext2、ext3 和 ext4 文件系统的工具。这里的 -f 参数强制进行文件系统的完整性检查,即使文件系统是“干净”的(即上次关机时没有错误)。

e2fsck 1.42.9 (28-Dec-2013)
第一步: 检查inode,块,和大小
第二步: 检查目录结构
第3步: 检查目录连接性
Pass 4: Checking reference counts
第5步: 检查簇概要信息
/dev/storage/vo: 11/38912 files (0.0% non-contiguous), 10567/155648 blocks
[root@localhost ~]# resize2fs /dev/storage/vo	#同步更新文件系统的大小以匹配新的逻辑卷大小

resize2fs 1.42.9 (28-Dec-2013)
Resizing the filesystem on /dev/storage/vo to 299008 (1k) blocks.
The filesystem on /dev/storage/vo is now 299008 blocks long.

[root@localhost ~]# lvdisplay	#看到逻辑卷vo变为292MB
  --- Logical volume ---
  LV Path                /dev/centos_192/swap
  LV Name                swap
  VG Name                centos_192
  LV UUID                XDa9D8-hZj7-QVSC-qiQ0-lbaQ-QKRZ-LeZXcT
  LV Write Access        read/write
  LV Creation host, time 192.168.112.140, 2023-08-12 17:05:09 +0800
  LV Status              available
  # open                 2
  LV Size                2.00 GiB
  Current LE             512
  Segments               1
  Allocation             inherit
  Read ahead sectors     auto
  - currently set to     8192
  Block device           253:1

  --- Logical volume ---
  LV Path                /dev/centos_192/root
  LV Name                root
  VG Name                centos_192
  LV UUID                pHMI0L-5zIz-U6RU-g7L0-1Uy1-K01W-SNxrJi
  LV Write Access        read/write
  LV Creation host, time 192.168.112.140, 2023-08-12 17:05:09 +0800
  LV Status              available
  # open                 1
  LV Size                <17.00 GiB
  Current LE             4351
  Segments               1
  Allocation             inherit
  Read ahead sectors     auto
  - currently set to     8192
  Block device           253:0

  --- Logical volume ---
  LV Path                /dev/storage/vo
  LV Name                vo
  VG Name                storage
  LV UUID                MeqJRa-F8kt-jLi8-hmZV-co3K-KIvR-NjG9m0
  LV Write Access        read/write
  LV Creation host, time localhost, 2024-02-06 21:35:32 +0800
  LV Status              available
  # open                 0
  LV Size                292.00 MiB
  Current LE             73
  Segments               1
  Allocation             inherit
  Read ahead sectors     auto
  - currently set to     8192
  Block device           253:3

image-20240206214048080

第三步:

重新挂载硬盘设备并查看挂载状态

[root@localhost /]# mount /dev/storage/vo /vo
[root@localhost /]# df -h
文件系统                     容量  已用  可用 已用% 挂载点
devtmpfs                     1.9G     0  1.9G    0% /dev
tmpfs                        1.9G     0  1.9G    0% /dev/shm
tmpfs                        1.9G   12M  1.9G    1% /run
tmpfs                        1.9G     0  1.9G    0% /sys/fs/cgroup
/dev/mapper/centos_192-root   17G  2.0G   16G   12% /
/dev/sda1                   1014M  151M  864M   15% /boot
tmpfs                        378M     0  378M    0% /run/user/0
/dev/mapper/storage-vo       279M  2.1M  259M    1% /vo

image-20240206214728423

3、缩小逻辑卷

第一步:

检查文件系统的完整性

[root@localhost ~]# umount /vo
[root@localhost ~]# e2fsck -f /dev/storage/vo
e2fsck 1.42.9 (28-Dec-2013)
第一步: 检查inode,块,和大小
第二步: 检查目录结构
第3步: 检查目录连接性
Pass 4: Checking reference counts
第5步: 检查簇概要信息
/dev/storage/vo: 11/75776 files (0.0% non-contiguous), 15729/299008 blocks

image-20240206214926438

第二步:

把逻辑卷
vo
的容量减少到120MB

[root@localhost ~]# resize2fs /dev/storage/vo 120M
resize2fs 1.42.9 (28-Dec-2013)
Resizing the filesystem on /dev/storage/vo to 122880 (1k) blocks.
The filesystem on /dev/storage/vo is now 122880 blocks long.

[root@localhost ~]# lvreduce -L 120M /dev/storage/vo
  WARNING: Reducing active logical volume to 120.00 MiB.
  THIS MAY DESTROY YOUR DATA (filesystem etc.)
Do you really want to reduce storage/vo? [y/n]: y
  Size of logical volume storage/vo changed from 240.00 MiB (60 extents) to 120.00 MiB (30 extents).
  Logical volume storage/vo successfully resized.

image-20240206220637062

第三步:

重新挂载文件系统并查看系统状态

[root@localhost ~]# mount /dev/storage/vo /vo
[root@localhost ~]# df -h
文件系统                     容量  已用  可用 已用% 挂载点
devtmpfs                     1.9G     0  1.9G    0% /dev
tmpfs                        1.9G     0  1.9G    0% /dev/shm
tmpfs                        1.9G   12M  1.9G    1% /run
tmpfs                        1.9G     0  1.9G    0% /sys/fs/cgroup
/dev/mapper/centos_192-root   17G  2.0G   16G   12% /
/dev/sda1                   1014M  151M  864M   15% /boot
tmpfs                        378M     0  378M    0% /run/user/0
/dev/mapper/storage-vo       113M  1.6M  103M    2% /vo

image-20240206220810384

3、逻辑卷快照

LVM还具备有
快照卷
功能,该功能类似于虚拟机软件的还原时间点功能。例如,可以对某一个逻辑卷设备做一次快照,如果日后发现数据被改错了,就可以利用之前做好的快照卷进行覆盖还原。LVM的快照卷功能有两个特点:

  • 快照卷的容量必须等同于逻辑卷的容量;
  • 快照卷仅一次有效,一旦执行还原操作后则会被立即自动删除。

先在
/vo
下创建一个
readme.txt
文件用来验证逻辑卷快照还原前后状态变化

[root@localhost ~]# echo "hello LVM" >> /vo/readme.txt
[root@localhost ~]# ls -l /vo
总用量 13
drwx------ 2 root root 12288 2月   6 22:04 lost+found
-rw-r--r-- 1 root root    10 2月   6 22:10 readme.txt

image-20240206222949370

第一步:

使用
-s
参数生成一个快照卷,使用
-L
参数指定切割的大小

[root@localhost ~]# lvcreate -L 120M -s -n SNAP /dev/storage/vo	#在 "storage" 卷组下,基于名为 "vo" 的现有逻辑卷,创建一个容量为120MB的快照卷,并将这个新的快照卷命名为 "SNAP"

  Logical volume "SNAP" created.
[root@localhost ~]# lvdisplay
  --- Logical volume ---
  LV Path                /dev/storage/vo
  LV Name                vo
  VG Name                storage
  LV UUID                ywJ3ah-At9t-t65q-0JsQ-i45Q-pyeh-iHhxWN
  LV Write Access        read/write
  LV Creation host, time localhost, 2024-02-06 22:04:25 +0800
  LV snapshot status     source of
                         SNAP [active]
  LV Status              available
  # open                 1
  LV Size                120.00 MiB
  Current LE             30
  Segments               1
  Allocation             inherit
  Read ahead sectors     auto
  - currently set to     8192
  Block device           253:2

  --- Logical volume ---
  LV Path                /dev/storage/SNAP
  LV Name                SNAP
  VG Name                storage
  LV UUID                JZpfG2-T6Yl-ODCF-CVnR-34Uw-pGQ9-3skxG9
  LV Write Access        read/write
  LV Creation host, time localhost, 2024-02-06 22:11:07 +0800
  LV snapshot status     active destination for vo
  LV Status              available
  # open                 0
  LV Size                120.00 MiB
  Current LE             30
  COW-table size         120.00 MiB
  COW-table LE           30
  Allocated to snapshot  0.01%
  Snapshot chunk size    4.00 KiB
  Segments               1
  Allocation             inherit
  Read ahead sectors     auto
  - currently set to     8192
  Block device           253:5

image-20240206221654118

第二步:

在逻辑卷所挂载的目录中创建一个100MB的垃圾文件,然后再查看快照卷的状态。发现存储空间的占用量上升了

[root@localhost ~]# dd if=/dev/zero of=/vo/file bs=100M count=1
记录了1+0 的读入
记录了1+0 的写出
104857600字节(105 MB)已复制,1.21787 秒,86.1 MB/秒
[root@localhost ~]# ll -ht /vo/file
-rw-r--r-- 1 root root 100M 2月   6 22:19 /vo/file
[root@localhost ~]# lvdisplay
  --- Logical volume ---
  LV Path                /dev/storage/vo
  LV Name                vo
  VG Name                storage
  LV UUID                ywJ3ah-At9t-t65q-0JsQ-i45Q-pyeh-iHhxWN
  LV Write Access        read/write
  LV Creation host, time localhost, 2024-02-06 22:04:25 +0800
  LV snapshot status     source of
                         SNAP [active]
  LV Status              available
  # open                 1
  LV Size                120.00 MiB
  Current LE             30
  Segments               1
  Allocation             inherit
  Read ahead sectors     auto
  - currently set to     8192
  Block device           253:2

  --- Logical volume ---
  LV Path                /dev/storage/SNAP
  LV Name                SNAP
  VG Name                storage
  LV UUID                JZpfG2-T6Yl-ODCF-CVnR-34Uw-pGQ9-3skxG9
  LV Write Access        read/write
  LV Creation host, time localhost, 2024-02-06 22:11:07 +0800
  LV snapshot status     active destination for vo
  LV Status              available
  # open                 0
  LV Size                120.00 MiB
  Current LE             30
  COW-table size         120.00 MiB
  COW-table LE           30
  Allocated to snapshot  83.71%
  Snapshot chunk size    4.00 KiB
  Segments               1
  Allocation             inherit
  Read ahead sectors     auto
  - currently set to     8192
  Block device           253:5

image-20240206222615773

第三步:

为了校验SNAP快照卷的效果,需要对逻辑卷进行快照还原操作。在此之前记得先卸载掉逻辑卷设备与目录的挂载。

[root@localhost ~]# umount /vo
[root@localhost ~]# lvconvert --merge /dev/storage/SNAP	#合并(merge)快照卷 "SNAP" 回到其源卷 "vo"
  Merging of volume storage/SNAP started.
  storage/vo: Merged: 23.03%
  storage/vo: Merged: 100.00%

image-20240206223143333

第四步:

快照卷会被自动删除掉,并且刚刚在逻辑卷设备被执行快照操作后再创建出来的100MB的垃圾文件也被清除了而
/vo/readme.txt
还在

[root@localhost ~]# mount -a
[root@localhost ~]# ls /vo/
lost+found  readme.txt
[root@localhost ~]# cat /vo/readme.txt
hello LVM

4、删除逻辑卷

第一步:

取消逻辑卷与目录的挂载关联,删除配置文件中永久生效的设备参数。

[root@localhost ~]# umount /vo/
[root@localhost ~]# vim /etc/fstab
#
# /etc/fstab
# Created by anaconda on Sat Aug 12 17:05:10 2023
#
# Accessible filesystems, by reference, are maintained under '/dev/disk'
# See man pages fstab(5), findfs(8), mount(8) and/or blkid(8) for more info
#
/dev/mapper/centos_192-root /                       xfs     defaults        0 0
UUID=01838dd0-44b0-4056-b0e2-96760522a11b /boot                   xfs     defaults        0 0
/dev/mapper/centos_192-swap swap                    swap    defaults        0 0

image-20240206223809338

第二步:

删除逻辑卷设备,需要输入y来确认操作

[root@localhost ~]# lvremove /dev/storage/vo
Do you really want to remove active logical volume storage/vo? [y/n]: y
  Logical volume "vo" successfully removed

image-20240206224041096

第三步:

删除卷组,此处只写卷组名称即可,不需要设备的绝对路径。

[root@localhost ~]# vgremove storage
  Volume group "storage" successfully removed

image-20240206224142656

第四步:

删除物理卷设备

[root@localhost ~]# pvremove /dev/sdb /dev/sdc
  Labels on physical volume "/dev/sdb" successfully wiped.
  Labels on physical volume "/dev/sdc" successfully wiped.

image-20240206224248198

六、LVM的优缺点

优点:

  1. 动态扩展:在系统运行时可以在线增加或减少逻辑卷的大小,无需重启服务或操作系统,提供对存储空间的动态管理能力。
  2. 灵活性:允许文件系统跨越多个物理磁盘,突破单个硬盘容量限制,可以根据需要调整逻辑卷布局,实现存储资源的有效利用。
  3. 扩展性:可以方便地向现有的卷组中添加新的物理磁盘,进一步扩大存储池容量。
  4. 高可用与冗余:支持镜像和条带化技术,能够将数据冗余到多个磁盘上以提高数据安全性及读写性能。
  5. 数据迁移便捷:可以更容易地迁移或备份整个逻辑卷至其他系统或硬件环境。

缺点:

  1. 在从卷组中移除一个磁盘的时候必须使用reducevg命令(这个命令要求root权限,并且不允许在快照卷组中使用)。
  2. 当卷组中的一个磁盘损坏时,整个卷组都会受到影响。
  3. 因为加入了额外的操作,存储性能受到影响
  4. 不能减小文件系统大小(受文件系统类型限制)

七、Linux中的LVM

d23760519d0c4d7ba0a52ea0e6a34b8c

写在开头

在Java的世界里万物皆对象。但我认为是万物皆数据,世界由各种各样数据构建起来,我们通过程序去实现数据的增删改查、转入转出、加减乘除等等,不同语言的实现方式殊途同归。由此可见,数据对于程序语言的重要性。

这段话是在写数据类型那篇博客时说的,当时是为了引入Java中数据类型的重要性,现在放在这里,同样是为了引出Java中的
集合(容器)
,因为这是存储数据的媒介!在Java中有各种存储数据的集合类型,用来存储数据,做简单的逻辑处理,比如排序、取反、截取等等。
【注】

Java集合不能存放基本数据类型,只能存放对象的引用。每个集合元素都是一个引用变量,实际内容都存放在堆内或方法区里面,但是基本数据类型是在栈内存上分配空间的,栈上的数据随时会被收回。如何解决?可以通过包装类,把基本数据类型转化为对象类型,存放引用。

容器的分类

Java中的集合主要有大量派生接口:Collection、Map

  • Collection:
    英文释义收集,集合,用在储存单一元素的容器;
  • Map:
    英文释义地图,映射,非常贴切,所谓地图输入一个地点,定位对应的地址位置,所以Map存储的是键值对(Key-Value),输入唯一性的key值,可以找到对应的value。

【注】:本文中所涉及到继承派生关系都是部分的,只挑重点,没列举全部,毕竟搞完太多了(手动笑哭)

Collection

先看第一个派生接口Collection,它下面又继承了很多子接口,主要为
Set、List、Queue
它们各有特点,是我们在开发中几乎都会用的集合接口,也是很多互联网公司面试必问的话题!

Set

Set 的特点是存取无序,不可以存放重复的元素,不可以用下标对元素进行操作,为了直观的感受它的特点,我们直接以其子类HashSet为例去做一些增删改查的操作。

【源码速看1】

public class HashSet<E>
    extends AbstractSet<E>
    implements Set<E>, Cloneable, java.io.Serializable
{
    private transient HashMap<E,Object> map;

    // Dummy value to associate with an Object in the backing Map
    private static final Object PRESENT = new Object();

    public HashSet() {
        map = new HashMap<>();
    }

    public boolean add(E e) {
        return map.put(e, PRESENT)==null;
    }

    public boolean remove(Object o) {
        return map.remove(o)==PRESENT;
    }
}

虽然HashSet实现了Set接口,但通过源码我们能够看到,它的底层逻辑实现其实依据的是HashMap,通过操作map的key值来实现元素的增删改查,下面来使用一下HashSet。

【代码示例1】

public class Test {
    public static void main(String[] args) throws FileNotFoundException {
        // 创建一个新的HashSet
        HashSet<Integer> set = new HashSet<>();
        // 添加元素
        set.add(3);
        set.add(4);
        set.add(0);
        set.add(1);
        set.add(4);

        // 输出HashSet的元素个数
        System.out.println("HashSet size: " + set.size());

        // 判断元素是否存在于HashSet中
        boolean containsWanger = set.contains(2);
        System.out.println(containsWanger);

        // 删除元素
        boolean removeWanger = set.remove(1);
        System.out.println(set);

        // 修改元素,需要先删除后添加
        boolean removeChenmo = set.remove(3);
        boolean addBuChenmo = set.add(4);
        System.out.println(removeChenmo && addBuChenmo);

        // 输出修改后的HashSet
        System.out.println(set);
    }
}

【输出】

HashSet size: 4
false
[0, 3, 4]
false
[0, 4]

由代码结果进一步证明了我们的结论,1、存储数据不重复,但add重复数据并不报错,原因是第一个数据会被第二次重复数据覆盖掉;2,无序,很多人发现输出了一个有序的数字集合,这个其实与我们所说的有序是有区别的,在
Set中的有序无序是指输入的顺序与输出的顺序是否一致
当然,想要实现有序可以通过LinkedHashSet,底层通过链表记录元素插入顺序。

List

List 的特点是存取有序,可以存放重复的元素,可以用下标对元素进行操作,同样,我们还是选择其中一个子类ArrayList来验证一下。

【代码示例2】

public class Test {
    public static void main(String[] args) throws FileNotFoundException {
        // 创建一个集合
        ArrayList<String> list = new ArrayList<String>();
        // 添加元素
        list.add("a");
        list.add("b");
        list.add("c");
        list.add("c");

        // 遍历集合 for each
        for (String s : list) {
            System.out.println(s);
        }
        System.out.println("--------------");
        // 删除元素
        list.remove(1);
        // 遍历集合
        for (String s : list) {
            System.out.println(s);
        }
        System.out.println("--------------");
        // 修改元素
        list.set(1, "z");
        // 遍历集合
        for (String s : list) {
            System.out.println(s);
        }
    }
}

【输出】

a
b
c
c
--------------
a
c
c
--------------
a
z
c

通过代码输出结果进一步论证结论,可通过下标操作元素(下标以0为开始);输入输出一致(有序);可存储重复数据。

Queue

Queue,也就是队列,通常遵循先进先出(FIFO)的原则,新元素插入到队列的尾部,访问元素返回队列的头部。其实在日常的开发中,我们队列的使用场景不是很多,但在很多算法题中,还是有他独特的优势的。
比如,对Queue进行扩展出Deque, 实现双端队列,在队列的两端均可以插入或删除元素。

【代码示例3】

 // 创建一个ArrayDeque
        ArrayDeque<String> deque = new ArrayDeque<>();

        // 添加元素
        deque.add("a");
        deque.add("b");
        deque.add("c");

        // 删除元素
        deque.remove("b");

        // 修改元素
        deque.remove("b");
        deque.add("bb");

        // 查找队首元素
        System.out.println(deque.getFirst());
        //查找队尾元素
        System.out.println(deque.getLast());
        //遍历队列
        for (String s : deque) {
            System.out.print(s);
        }

【输出】

a
bb
acbb

List、Set、Queue三者的区别?

看望上面的几种集合类型,我们在这里进行一个区别总结

1、List(对付顺序的好帮手): 存储的元素是有序的、可重复的。
2、Set(注重独一无二的性质): 存储的元素不可重复的。
3、Queue(实现排队功能的叫号机): 按特定的排队规则来确定先后顺序,存储的元素是有序的、可重复的。

Map

键值对集合,存储键、值和之间的映射;Key无序,唯一;value 不要求有序,允许重复。

我们以Map下最经典的HasMap为例看一看Map的特点
【代码示例4】

// 创建一个 HashMap 对象
        HashMap<String, String> hashMap = new HashMap<>();

        // 添加键值对
        hashMap.put("1", "aa");
        hashMap.put("2", "bb");
        hashMap.put("3", "cc");

        // 获取指定键的值
        String value1 = hashMap.get("1");
        System.out.println("1对应的值:" + value1);

        // 修改键对应的值
        hashMap.put("1", "aaa");
        String value2 = hashMap.get("1");
        System.out.println("1对应的值:" + value2);

        // 删除指定键的键值对
        hashMap.remove("1");

        // 遍历 HashMap
        for (String key : hashMap.keySet()) {
            String value = hashMap.get(key);
            System.out.println(key + " 对应的值为:" + value);
        }

HashMap 实现了 Map 接口,可以根据键快速地查找对应的值——通过哈希函数将键映射到哈希表中的一个索引位置,从而实现快速访问。
【输出】

1对应的值:aa
1对应的值:aaa
2 对应的值为:bb
3 对应的值为:cc

总结

本文的重心是Java集合的盘点,Collection和Map的引出,各子类的特点比较,针对很多常用的子类并没有展开过多的叙述,后面会按个的学习按个的梳理滴,毕竟这一块内容有非常多的考点,至少得更新个十几篇博文才能讲个大概,继续保持耐心,继续保持学习,一起冲!!!

结尾彩蛋

如果本篇博客对您有一定的帮助,大家记得
留言+点赞+收藏
呀。原创不易,转载请联系Build哥!

前言

今天分享一款.NET Avalonia基于MIT License协议开源、免费的桌面UI库:SukiUI。

Avalonia介绍

Avalonia是一个强大的框架,使开发人员能够使用.NET创建跨平台应用程序。它使用自己的渲染引擎绘制UI控件,确保在Windows、macOS、Linux、Android、iOS和WebAssembly等不同平台上具有一致的外观和行为。这意味着开发人员可以共享他们的UI代码,并在不同的目标平台上保持统一的外观和感觉。

SukiUI项目介绍

SukiUI 包含 AvaloniaUI 基本控件的主题,支持浅色/深色主题。提供了在不同颜色主题之间选择和切换以及创建自定义主题的能力。并且SukiUI还包含额外的控件,以提供制作丰富多样的用户界面的可能性。

项目源代码

运行项目源代码

设置
SukiUI.Demo
为启动项目,F5运行:

SukiUI主题截图

项目源码地址



更多项目实用功能和特性欢迎前往项目开源地址查看

概要

所谓内存池,顾名思义和线程池的设计原理是一样的,为了减少频繁申请释放内存而带来的资源消耗,减少释放内存后产生的内存碎片。

设计理念

为了方便管理内存池的设计通常是划分出一定数量的内存块,这些内存块的长度是一样的; 用户申请内存块时返回空闲的内存块地址,如果内存块使用完毕就释放该内存块,将该内存块置为空闲状态,放回到内存池,供以后使用。

内存池的设计核心几大模块:创建内存池,申请内存块,释放内存块,销毁内存池!

当然这只是常用的内存池设计,实际项目中可以根据需求设计不同的线程池:内存块的长度不一,可以提供自定义的内存块设计等兼容性更高的内存池。

本文只做内存池原理的讲解和实现最基础的内存池!更多的功能根据实际的需求进行扩展即可。

内存池的设计思路有很多,可以给予链表,数组,队列等进行设计,核心就是怎么存储内存块信息;本期是基于链表进行的内存池设计。

模块设计

内存池结构

内存块节点结构

typedef structMemoryBlock{void *data;//内存块起始地址
    struct MemoryBlock *next;//下一个内存块的地址
}MemoryBlock;

内存池结构

typedef structMemoryPool{
MemoryBlock
*freeList;//空闲内存块链表 MemoryBlock *usedList;//占用内存块链表 int freeCount;//空闲内存块数量 int usedCount;//占用内存块数量 int blockCount;//内存块总数量 }MemoryPool;

创建内存池

通过参数确定内存池中内存块的大小和数量,然后给每个内存块开辟空间,然后初始化空闲链表,占用链表,空闲数量,占用数量等

MemoryPool *InitMemoryPool(int blockSize, intblockCount)
{
MemoryPool
*pool =NULL;


pool
= (MemoryPool *)malloc(sizeof(MemoryPool));//为内存池分配空间 pool->freeList =NULL;
pool
->usedList =NULL;for(int i = 0; i < blockCount; i++)
{
//创建内存块节点,插入到空闲链表 MemoryBlock * block = (MemoryBlock *)malloc(sizeof(MemoryBlock));
block
->data = malloc(blockSize);
block
->next = pool->freeList;
pool
->freeList =block;
}
//初始化状态 pool->freeCount =blockCount;
pool
->usedList = 0;
pool
->blockCount =blockCount;returnpool;
}

申请内存块

将内存池中空闲的内存块提供给用户使用,如果没有空闲内存块返回NULL。

void *AllocateBlock(MemoryPool *pool)
{
if(pool->freeList == NULL || pool->freeCount == 0)returnNULL;
MemoryBlock
*node = pool->freeList;//该内存块从空闲链表删除 pool->freeList = node->next;//该内存块插入到占用链表 node->next = pool->usedList;
pool
->usedList =node;//更新空闲,占用状态 pool->usedCount++;
pool
->freeCount--;return node->data;
}

释放内存块

将内存块放回到内存池

void FreeBlock(MemoryPool *pool, void *data)
{
MemoryBlock
*cur = pool->usedList;
MemoryBlock
*pre =NULL;//寻找给内存块的节点 while(pre != NULL && cur->data !=data)
{
pre
=cur;
cur
= cur->next;
}
if(cur ==NULL)return;//将该内存块从占用链表删除 if(pre !=NULL)
pre
->next = cur->next;elsepool->usedList = cur->next;//将该内存块插入到空闲链表 cur->next = pool->freeList;
pool
->freeList =cur;

pool
->freeCount++;
pool
->usedCount--;return;
}

销毁内存池

销毁所有的内存块及分配过的空间

void DestroyMemoryPool(MemoryPool *pool)
{
MemoryBlock
*pre =NULL;//释放所有空闲内存块空间 while(pool->freeList !=NULL)
{
pre
= pool->freeList;free(pool->freeList->data);
pool
->freeList = pool->freeList->next;free(pre);
}
//释放所有占用内存块空间 while(pool->usedList !=NULL)
{
pre
= pool->usedList;free(pool->usedList->data);
pool
->usedList = pool->usedList->next;free(pre);
}
//释放内存池空间 free(pool);

pool
->freeList =NULL;
pool
->usedList =NULL;
pool
->freeCount = 0;
pool
->usedCount = 0;return;
}

至此一个最基础的内存池算是已经完成,在实际项目中可以在此基础上进行扩展;

main函数调用

int main(void)
{
MemoryPool
*pool;

pool
= InitMemoryPool(10, 5);int *str = (int *)AllocateBlock(pool);*str = 2;int *ptr = (int *)AllocateBlock(pool);*ptr = 3;
printf(
"free block : %d, used block : %d\n", pool->freeCount, pool->usedCount);
FreeBlock(pool, ptr);
printf(
"free block : %d, used block : %d\n", pool->freeCount, pool->usedCount);

DestroyMemoryPool(pool);
return 0;
}

在 MacOS 上使用 OpenVINO™ C# API 部署 Yolov5
项目介绍

YOLOv5 是革命性的 "单阶段"对象检测模型的第五次迭代,旨在实时提供高速、高精度的结果,是世界上最受欢迎的视觉人工智能模型,代表了Ultralytics对未来视觉人工智能方法的开源研究,融合了数千小时研发中积累的经验教训和最佳实践。同时官方发布的模型已经支持 OpenVINO™ 部署工具加速模型推理,因此在该项目中,我们将结合之前开发的 OpenVINO™ C# API 部署 YOLOv5 DET 模型实现物体对象检测。

项目链接为:

https://github.com/guojin-yan/OpenVINO-CSharp-API

项目源码链接为:

https://github.com/guojin-yan/OpenVINO-CSharp-API-Samples/tree/master/model_samples/yolov5/yolov5_det_opencvsharp
https://github.com/guojin-yan/OpenVINO-CSharp-API-Samples/tree/master/model_samples/yolov5/yolov5_det_emgucv

1. 前言

1.1 OpenVINO™ C# API

英特尔发行版 OpenVINO™ 工具套件基于 oneAPI 而开发,可以加快高性能计算机视觉和深度学习视觉应用开发速度工具套件,适用于从边缘到云的各种英特尔平台上,帮助用户更快地将更准确的真实世界结果部署到生产系统中。通过简化的开发工作流程,OpenVINO™ 可赋能开发者在现实世界中部署高性能应用程序和算法。

OpenVINO™ 2023.2 于 2023 年 11 月 16 日发布,该工具包带来了挖掘生成人工智能全部潜力的新功能。更多的生成式 AI 覆盖和框架集成,以最大限度地减少代码更改,并且扩展了对直接 PyTorch 模型转换的模型支持。支持更多新的模型,包括 LLaVA、chatGLM、Bark 和 LCM 等著名模型。支持更广泛的大型语言模型(LLM)和更多模型压缩技术,支持运行时推理支持以下 Int4 模型压缩格式,通过神经网络压缩框架(NNCF) 进行本机 Int4 压缩等一系列新的功能。

OpenVINO™ C# API 是一个 OpenVINO™ 的 .Net wrapper,应用最新的 OpenVINO™ 库开发,通过 OpenVINO™ C API 实现 .Net 对 OpenVINO™ Runtime 调用,使用习惯与 OpenVINO™ C++ API 一致。OpenVINO™ C# API 由于是基于 OpenVINO™ 开发,所支持的平台与 OpenVINO™ 完全一致,具体信息可以参考 OpenVINO™。通过使用 OpenVINO™ C# API,可以在 .NET、.NET Framework等框架下使用 C# 语言实现深度学习模型在指定平台推理加速。

1.2 YOLOv5

​ YOLOv5 是革命性的 "单阶段"对象检测模型的第五次迭代,旨在实时提供高速、高精度的结果,是世界上最受欢迎的视觉人工智能模型,代表了Ultralytics对未来视觉人工智能方法的开源研究,融合了数千小时研发中积累的经验教训和最佳实践。

2. 模型下载与转换

2.1 环境安装

首先创建Yolov5模型下载与转换环境,此处为了更好的管理环境,使用
Anaconda
创建一个虚拟环境用于安装Yolov5模型下载与转换环境,首先使用
conda
创建一个虚拟环境,在命令行中依次输入以下指令:

conda create -n yolo python=3.10
conda activate yolo

接下来安装Yolov5模型下载与转换环境,基础的Yolov5模型下载需要通过克隆官方源码实现,在命令行中依次输入以下指令实现环境的安装与配置即可:

git clone https://github.com/ultralytics/yolov5
cd yolov5
pip install -r requirements.txt
pip install --upgrade openvino-nightly

2.2 Yolov5 模型下载

Yolov5 官方提供了模型导出与转换的方式,用户只需要调用该接口便可以,在命令行中输入以下指令便可以直接导出Yolov5模型:

cd yolov5
python export.py --weights yolov5s.pt --include onnx

结果输出如下图所示:

使用Netron工具打开模型文件,查看模型结构,如下图所示:

官方预训练模型是在COCO数据集上训练的,因此导出的模型可以识别80种物体。模型输入节点为
images
,输入为归一化后的图像数据,其输入大小为640×640;模型的输出节点为
output0
,输出大小为25200×85,其中25200(640÷8=80,640÷16=40,640÷32=20,3×80×80+3×40×40+3×20×20=25200)表示识别结果个数,85表示[cx, cy, w, h, confidence, score0, ···,score79],分别为识别框信息、识别结果中最大置信度以及80中类别结果的分数。

2.3 转换IR模型

接下来直接使用 OpenVINO™ 工具直接进行模型转换,在CMD中输入以下指令即可:

ovc yolov5s.onnx

3. Yolov5 DET 项目配置(OpenCvSharp版)

3.1 项目创建

如果开发者第一次在MacOS系统上使用C#编程语言,可以参考《在MacOS系统上配置OpenVINO™ C# API》文章进行配置。

首先使用dotnet创建一个测试项目,在终端中输入一下指令:

dotnet new console --framework net6.0 --use-program-main -o yolov5-det 

3.2 添加项目依赖

MacOS系统目前主要分为两类,一类是使用intel处理器的X64位的系统,一类是使用M系列芯片的arm64位系统,目前OpenVINO官方针对这两种系统都提供了编译后的系统,所以目前OpenVINO.CSharp.API针对这两种系统都提供了支持。

此处以M系列处理器的MacOS平台为例安装项目依赖,首先是安装OpenVINO™ C# API项目依赖,在命令行中输入以下指令即可:

dotnet add package OpenVINO.CSharp.API
dotnet add package OpenVINO.runtime.macos-arm64
dotnet add package OpenVINO.CSharp.API.Extensions
dotnet add package OpenVINO.CSharp.API.Extensions.OpenCvSharp

关于在MacOS上搭建 OpenVINO™ C# API 开发环境请参考以下文章:
在MacOS上搭建OpenVINO™C#开发环境

接下来安装使用到的图像处理库 OpenCvSharp,在命令行中输入以下指令即可:

dotnet add package OpenCvSharp4
dotnet add package OpenCvSharp4.Extensions
dotnet add package OpenCvSharp4.runtime.osx_arm64 --prerelease

关于在MacOS上搭建 OpenCvSharp 开发环境请参考以下文章:
【OpenCV】在MacOS上使用OpenCvSharp

添加完成项目依赖后,项目的配置文件如下所示:

<Project Sdk="Microsoft.NET.Sdk">

  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>net6.0</TargetFramework>
    <RootNamespace>yolov5_det</RootNamespace>
    <ImplicitUsings>enable</ImplicitUsings>
    <Nullable>enable</Nullable>
  </PropertyGroup>

  <ItemGroup>
    <PackageReference Include="OpenCvSharp4" Version="4.9.0.20240103" />
    <PackageReference Include="OpenCvSharp4.Extensions" Version="4.9.0.20240103" />
    <PackageReference Include="OpenCvSharp4.runtime.osx_arm64" Version="4.8.1-rc" />
    <PackageReference Include="OpenVINO.CSharp.API" Version="2023.2.0.4" />
    <PackageReference Include="OpenVINO.CSharp.API.Extensions" Version="1.0.1" />
    <PackageReference Include="OpenVINO.CSharp.API.Extensions.OpenCvSharp" Version="1.0.4" />
    <PackageReference Include="OpenVINO.runtime.macos-arm64" Version="2023.3.0.1" />
  </ItemGroup>

</Project>

3.3 定义预测方法

(1) 使用常规方式部署模型

Yolov5 属于比较经典单阶段目标检测模型,其模型输入为640*640的归一化处理后的图像数据,输出为未进行NMS的推理结果,因此在获取推理结果后,需要进行NMS,其实现代码如下所示:

static void yolov5_det(string model_path, string image_path, string device)
{
    // -------- Step 1. Initialize OpenVINO Runtime Core --------
    Core core = new Core();
    // -------- Step 2. Read inference model --------
    Model model = core.read_model(model_path);
    OvExtensions.printf_model_info(model);
    // -------- Step 3. Loading a model to the device --------
    start = DateTime.Now;
    CompiledModel compiled_model = core.compile_model(model, device);
    // -------- Step 4. Create an infer request --------
    InferRequest infer_request = compiled_model.create_infer_request();
    // -------- Step 5. Process input images --------
    Mat image = new Mat(image_path); // Read image by opencvsharp
    int max_image_length = image.Cols > image.Rows ? image.Cols : image.Rows;
    Mat max_image = Mat.Zeros(new OpenCvSharp.Size(max_image_length, max_image_length), MatType.CV_8UC3);
    Rect roi = new Rect(0, 0, image.Cols, image.Rows);
    image.CopyTo(new Mat(max_image, roi));
    float factor = (float)(max_image_length / 640.0);
    // -------- Step 6. Set up input data --------
    Tensor input_tensor = infer_request.get_input_tensor();
    Shape input_shape = input_tensor.get_shape();
    Mat input_mat = CvDnn.BlobFromImage(max_image, 1.0 / 255.0, new OpenCvSharp.Size(input_shape[2], input_shape[3]), 0, true, false);
    float[] input_data = new float[input_shape[1] * input_shape[2] * input_shape[3]];
    Marshal.Copy(input_mat.Ptr(0), input_data, 0, input_data.Length);
    input_tensor.set_data<float>(input_data);
    // -------- Step 7. Do inference synchronously --------
    infer_request.infer();
    // -------- Step 8. Get infer result data --------
    Tensor output_tensor = infer_request.get_output_tensor();
    int output_length = (int)output_tensor.get_size();
    float[] output_data = output_tensor.get_data<float>(output_length);

    // -------- Step 9. Process reault  --------
    Mat result_data = new Mat(25200, 85, MatType.CV_32F, output_data);
    // Storage results list
    List<Rect> position_boxes = new List<Rect>();
    List<int> class_ids = new List<int>();
    List<float> confidences = new List<float>();
    // Preprocessing output results
    for (int i = 0; i < result_data.Rows; i++)
    {
        float confidence = result_data.At<float>(i, 4);
        if (confidence < 0.5)
        {
            continue;
        }
        Mat classes_scores = new Mat(result_data, new Rect(5, i, 80, 1));
        OpenCvSharp.Point max_classId_point, min_classId_point;
        double max_score, min_score;
        // Obtain the maximum value and its position in a set of data
        Cv2.MinMaxLoc(classes_scores, out min_score, out max_score,
            out min_classId_point, out max_classId_point);
        // Confidence level between 0 ~ 1
        // Obtain identification box information
        if (max_score > 0.25)
        {
            float cx = result_data.At<float>(i, 0);
            float cy = result_data.At<float>(i, 1);
            float ow = result_data.At<float>(i, 2);
            float oh = result_data.At<float>(i, 3);
            int x = (int)((cx - 0.5 * ow) * factor);
            int y = (int)((cy - 0.5 * oh) * factor);
            int width = (int)(ow * factor);
            int height = (int)(oh * factor);
            Rect box = new Rect();
            box.X = x;
            box.Y = y;
            box.Width = width;
            box.Height = height;

            position_boxes.Add(box);
            class_ids.Add(max_classId_point.X);
            confidences.Add((float)confidence);
        }
    }
    // NMS non maximum suppression
    int[] indexes = new int[position_boxes.Count];
    CvDnn.NMSBoxes(position_boxes, confidences, 0.5f, 0.5f, out indexes);
    for (int i = 0; i < indexes.Length; i++)
    {
        int index = indexes[i];
        Cv2.Rectangle(image, position_boxes[index], new Scalar(0, 0, 255), 2, LineTypes.Link8);
        Cv2.Rectangle(image, new OpenCvSharp.Point(position_boxes[index].TopLeft.X, position_boxes[index].TopLeft.Y + 30),
            new OpenCvSharp.Point(position_boxes[index].BottomRight.X, position_boxes[index].TopLeft.Y), new Scalar(0, 255, 255), -1);
        Cv2.PutText(image, class_ids[index] + "-" + confidences[index].ToString("0.00"),
            new OpenCvSharp.Point(position_boxes[index].X, position_boxes[index].Y + 25),
            HersheyFonts.HersheySimplex, 0.8, new Scalar(0, 0, 0), 2);
    }
    string output_path = Path.Combine(Path.GetDirectoryName(Path.GetFullPath(image_path)),
        Path.GetFileNameWithoutExtension(image_path) + "_result.jpg");
    Cv2.ImWrite(output_path, image);
    Slog.INFO("The result save to " + output_path);
    Cv2.ImShow("Result", image);
    Cv2.WaitKey(0);
}

(2) 使用模型结构处理处理数据

目前 OpenVINO™ 已经支持在模型结构中增加数据的前后处理流程,并且在 OpenVINO™ C# API 中也已经实现了该功能接口,所以在此处演示了如何将模型输入数据处理流程封装到模型中,通过 OpenVINO™ 进行数据处理的加速处理,如下面代码所示:

static void yolov5_det_with_process(string model_path, string image_path, string device)
{
    ······
    // -------- Step 2. Read inference model --------
    start = DateTime.Now;
    Model model = core.read_model(model_path);
    OvExtensions.printf_model_info(model);
    PrePostProcessor processor = new PrePostProcessor(model);
    Tensor input_tensor_pro = new Tensor(new OvType(ElementType.U8), new Shape(1, 640, 640, 3));
    InputInfo input_info = processor.input(0);
    InputTensorInfo input_tensor_info = input_info.tensor();
    input_tensor_info.set_from(input_tensor_pro).set_layout(new Layout("NHWC")).set_color_format(ColorFormat.BGR);
    PreProcessSteps process_steps = input_info.preprocess();
    process_steps.convert_color(ColorFormat.RGB).resize(ResizeAlgorithm.RESIZE_LINEAR)
        .convert_element_type(new OvType(ElementType.F32)).scale(255.0f).convert_layout(new Layout("NCHW"));
    Model new_model = processor.build();
    // -------- Step 3. Loading a model to the device --------
    CompiledModel compiled_model = core.compile_model(new_model, device);
    // -------- Step 4. Create an infer request --------
    InferRequest infer_request = compiled_model.create_infer_request();
    // -------- Step 5. Process input images --------
    Mat image = new Mat(image_path); // Read image by opencvsharp
    int max_image_length = image.Cols > image.Rows ? image.Cols : image.Rows;
    Mat max_image = Mat.Zeros(new OpenCvSharp.Size(max_image_length, max_image_length), MatType.CV_8UC3);
    Rect roi = new Rect(0, 0, image.Cols, image.Rows);
    image.CopyTo(new Mat(max_image, roi));
    Cv2.Resize(max_image, max_image, new OpenCvSharp.Size(640, 640));
    float factor = (float)(max_image_length / 640.0);
    // -------- Step 6. Set up input data --------
    Tensor input_tensor = infer_request.get_input_tensor();
    Shape input_shape = input_tensor.get_shape();
    byte[] input_data = new byte[input_shape[1] * input_shape[2] * input_shape[3]];
    Marshal.Copy(max_image.Ptr(0), input_data, 0, input_data.Length);
    IntPtr destination = input_tensor.data();
    Marshal.Copy(input_data, 0, destination, input_data.Length);
    // -------- Step 7. Do inference synchronously --------
    ······
}

由于目前还没有完全实现所有的 OpenVINO™ 的预处理接口,因此只能实现部分预处理过程封装到模型中,此处主要是做了以下处理:

  • 数据类型转换:byte->float
  • 数据维度转换:NHWC->NCHW
  • 图像色彩空间转换:BGR->RGB
  • 数据归一化处理:[0,1]->[0,255]

因此将一些数据处理流程封装到模型中后,在进行模型推理时,只需要将读取到的图片数据Resize为640*640后,就可以直接将数据加载到模型即可。

(3) 使用 OpenVINO™ C# API 封装的接口

YOLOv5 是当前工业领域十分流行的目标检测模型,因此在封装 OpenVINO™ C# API 时,提供了快速部署 Yolov5 模型的接口,实现代码如下所示:

static void yolov5_det_using_extensions(string model_path, string image_path, string device)
{
    Yolov5DetConfig config = new Yolov5DetConfig();
    config.set_model(model_path);
    Yolov5Det yolov8 = new Yolov5Det(config);
    Mat image = Cv2.ImRead(image_path);
    DetResult result = yolov8.predict(image);
    Mat result_im = Visualize.draw_det_result(result, image);
    Cv2.ImShow("Result", result_im);
    Cv2.WaitKey(0);
}

3.4 预测方法调用

定义好上述方法后,便可以直接在主函数中调用该方法,只需要在主函数中增加以下代码即可:

yolov5_det("yolov5s.xml", "test_image.png", "AUTO");
yolov5_det_with_process("yolov5s.xml", "test_image.png", "AUTO");
yolov5_det_using_extensions("yolov5s.xml", "test_image.png", "AUTO");

如果开发者自己没有进行模型下载与转换,又同时想快速体验该项目,我此处提供了在线的转换后的模型以及带预测图片,开发者可以直接在主函数中增加以下代码,便可以直接自动下载模型以及推理数据,并调用推理方法,实现程序直接运行。

static void Main(string[] args)
{
    string model_path = "";
    string image_path = "";
    string device = "AUTO";
    if (args.Length == 0)
    {
        if (!Directory.Exists("./model"))
        {
            Directory.CreateDirectory("./model");
        }
        if (!File.Exists("./model/yolov5s.bin") && !File.Exists("./model/yolov5s.bin"))
        {
            if (!File.Exists("./model/yolov5s.tar"))
            {
                _ = Download.download_file_async("https://github.com/guojin-yan/OpenVINO-CSharp-API-Samples/releases/download/Model/yolov5s.tar",
                    "./model/yolov5s.tar").Result;
            }
            Download.unzip("./model/yolov585s.tar", "./model/");
        }

        if (!File.Exists("./model/test_image.jpg"))
        {
            _ = Download.download_file_async("https://github.com/guojin-yan/OpenVINO-CSharp-API-Samples/releases/download/Image/test_det_02.jpg",
                "./model/test_image.jpg").Result;
        }
        model_path = "./model/yolov5s.xml";
        image_path = "./model/test_image.jpg";
    }
    else if (args.Length >= 2)
    {
        model_path = args[0];
        image_path = args[1];
        device = args[2];
    }
    else
    {
        Console.WriteLine("Please enter the correct command parameters, for example:");
        Console.WriteLine("> 1. dotnet run");
        Console.WriteLine("> 2. dotnet run <model path> <image path> <device name>");
    }
    // -------- Get OpenVINO runtime version --------

    OpenVinoSharp.Version version = Ov.get_openvino_version();

    Slog.INFO("---- OpenVINO INFO----");
    Slog.INFO("Description : " + version.description);
    Slog.INFO("Build number: " + version.buildNumber);

    Slog.INFO("Predict model files: " + model_path);
    Slog.INFO("Predict image  files: " + image_path);
    Slog.INFO("Inference device: " + device);
    Slog.INFO("Start yolov8 model inference.");

    yolov5_det(model_path, image_path, device);
    //yolov5_det_with_process(model_path, image_path, device);
    //yolov5_det_using_extensions(model_path, image_path, device);
}

为了减少文章篇幅,所以此处只提供了有差异的代码,如果想获取完整代码,请访问GitHub代码仓库,获取项目源码,链接为:

https://github.com/guojin-yan/OpenVINO-CSharp-API-Samples/tree/master/model_samples/yolov5/yolov5_det_opencvsharp

4. Yolov5 DET 项目配置(Emgu.CV 版)

同样地,为了满足Emgu.CV开发者的需求,此处同样地提供了Emgu.CV版本的Yolov5的模型部署代码以及使用流程,此处为了简化文章内容,对于和上文重复的步骤不在进行展开讲述。

4.1 添加项目依赖

首先是安装OpenVINO™ C# API项目依赖,在命令行中输入以下指令即可:

dotnet add package OpenVINO.CSharp.API
dotnet add package OpenVINO.runtime.macos-arm64
dotnet add package OpenVINO.CSharp.API.Extensions
dotnet add package OpenVINO.CSharp.API.Extensions.EmguCV

接下来安装使用到的图像处理库 Emgu.CV,在命令行中输入以下指令即可:

dotnet add package Emgu.CV
dotnet add package Emgu.CV.runtime.mini.macos

关于在MacOS上搭建 OpenCvSharp 开发环境请参考以下文章:
【OpenCV】在MacOS上使用Emgu.CV

添加完成项目依赖后,项目的配置文件如下所示:

<Project Sdk="Microsoft.NET.Sdk">

  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>net6.0</TargetFramework>
    <RootNamespace>yolov5_det</RootNamespace>
    <ImplicitUsings>enable</ImplicitUsings>
    <Nullable>enable</Nullable>
  </PropertyGroup>

  <ItemGroup>
    <PackageReference Include="Emgu.CV" Version="4.8.1.5350" />
    <PackageReference Include="Emgu.CV.runtime.mini.macos" Version="4.8.1.5350" />
    <PackageReference Include="OpenVINO.CSharp.API" Version="2023.2.0.4" />
    <PackageReference Include="OpenVINO.CSharp.API.Extensions" Version="1.0.1" />
    <PackageReference Include="OpenVINO.CSharp.API.Extensions.EmguCV" Version="1.0.4.1" />
    <PackageReference Include="OpenVINO.runtime.macos-arm64" Version="2023.3.0.1" />
  </ItemGroup>

</Project>

4.2 定义预测方法

模型部署流程与上一节中使用OpenCvSharp的基本一致,主要是替换了图像处理的工具,同时提供了如上一节中所展示的三种部署方式。此处为了减少文章篇幅,此处不在展示详细的部署代码,如果想获取相关代码,请访问项目GitHub,下载所有的测试代码,项目链接为:

https://github.com/guojin-yan/OpenVINO-CSharp-API-Samples/tree/master/model_samples/yolov5/yolov5_det_emgucv

5. 项目运行与演示

5.1 项目编译

接下来输入项目编译指令进行项目编译,输入以下指令即可:

dotnet build

程序编译后输出为:

5.2 项目文件运行

接下来运行编译后的程序文件,在CMD中输入以下指令,运行编译后的项目文件:

dotnet run --no-build

运行后项目输出为:

6. 总结

在该项目中,我们结合之前开发的 OpenVINO C# API 项目部署YOLOv5模型,成功实现了对象目标检测,并且根据不同开发者的使用习惯,同时提供了OpenCvSharp以及Emgu.CV两种版本,供各位开发者使用。最后如果各位开发者在使用中有任何问题,欢迎大家与我联系。