## 1 需求





pytorch、tensorflow、mxnet等深度学习框架使用GPU的时候，不一样的版本会有一些CUDA要求，所以环境一直是困扰，Docker推出后，NVIDIA基于Docker给出解决方案，答案就是NVIDIA Container Toolkit。

github链接：

https://github.com/NVIDIA/nvidia-docker

架构图：

![在这里插入图片描述](/static/img/images/00345.png)

## 2 安装

### 2.1 安装前需要知道

我的机器是centOS 7，显卡是2080TI 11G，上面有GPU驱动和CUDA。

![在这里插入图片描述](/static/img/images/00346.png)

![在这里插入图片描述](/static/img/images/00347.png)




参考：[https://docs.nvidia.com/datacenter/cloud-native/container-toolkit/install-guide.html#install-guide](https://docs.nvidia.com/datacenter/cloud-native/container-toolkit/install-guide.html#install-guide)

必须要有英伟达GPU驱动，版本大于等于418.81.07。

![在这里插入图片描述](/static/img/images/00348.png)

安装必要包：

```powershell
sudo yum install -y tar bzip2 make automake gcc gcc-c++ vim pciutils elfutils-libelf-devel libglvnd-devel iptables
```


### 2.2 安装Docker

这样：
```powershell
sudo yum remove docker \
                  docker-client \
                  docker-client-latest \
                  docker-common \
                  docker-latest \
                  docker-latest-logrotate \
                  docker-logrotate \
                  docker-engine
sudo yum install -y yum-utils \
  device-mapper-persistent-data \
  lvm2
sudo yum-config-manager \
    --add-repo \
    http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo
sudo yum install docker-ce docker-ce-cli containerd.io -y
sudo systemctl start docker
sudo docker run hello-world
```


### 2.3 安装NVIDIA Container Toolkit

Setup the stable repository and the GPG key:

```powershell
distribution=$(. /etc/os-release;echo $ID$VERSION_ID) \
   && curl -s -L https://nvidia.github.io/nvidia-docker/$distribution/nvidia-docker.repo | sudo tee /etc/yum.repos.d/nvidia-docker.repo
```

```powershell
sudo yum clean expire-cache
```

安装nvidia-docker2
```powershell
sudo yum install -y nvidia-docker2
```

重启
```powershell
sudo systemctl restart docker
```

听说Docker版本大于19，可以用`yum install -y nvidia-container-toolkit` 代替nvidia-docker2安装，我觉得都行。

安装nvidia-docker2后，可以`vim /etc/docker/daemon.json`看一下Docker的配置文件，是改写了的，重启Docker后生效了。

测试安装是否成功：

```powershell
docker run --rm --gpus all nvidia/cuda:10.1-base nvidia-smi
```

会看到：

![在这里插入图片描述](/static/img/images/00349.png)

## 3 总结

### 3.1 如何安装CUDA 11.0

官网安装后测试用的是CUDA11，我没有执行成功，那么如何才能成功？

```powershell
sudo docker run --rm --gpus all nvidia/cuda:11.0-base nvidia-smi
```

官网的GPU驱动版本是：

```powershell
NVIDIA-SMI 450.51.06    Driver Version: 450.51.06    CUDA Version: 11.0   
```

所以在官网查看GPU驱动和CUDA对应，找到了官网的兼容性介绍：

[https://docs.nvidia.com/deploy/cuda-compatibility/](https://docs.nvidia.com/deploy/cuda-compatibility/)

![在这里插入图片描述](/static/img/images/00350.png)

所以对于我来说，机器上的CUDA和cudnn不用改动，但我升级gpu driver是OK的，向下兼容，一直保持gpu driver是最新版本是OK的。

此外[Docker Hub](https://hub.docker.com/r/nvidia/cuda)的介绍也很明确，NVIDIA推出的镜像包含CUDA和cuDNN。

![在这里插入图片描述](/static/img/images/00351.png)

### 3.2 如何升级gpu driver？

首先搜索显卡能用得了的驱动：[https://www.nvidia.cn/Download/index.aspx?lang=cn#](https://www.nvidia.cn/Download/index.aspx?lang=cn#)，然后下载下来即可。

![在这里插入图片描述](/static/img/images/00352.png)

依次执行：

```powershell
chmod a+x NVIDIA-Linux-x86_64-465.31.run  #修改权限
./NVIDIA-Linux-x86_64-465.31.run --uninstall #卸载原有版本
NVIDIA-Linux-x86_64-465.31.run #安装新版本
```

### 3.3 升级gpu driver报错

报错：
```
An NVIDIA kernel module 'nvidia-uvm' appears to already be loaded in your kernel. This may be because it is in use (for example, by an X server, a CUDA program, or the NVIDIA Persistence Daemon), but this may also happen if your kernel was configured without support for module unloading. Please be sure to exit any programs that may be using the GPU(s) before attempting to upgrade your driver. If no GPU-based programs are running, you know that your kernel supports module unloading, and you still receive this message, then an error may have occurred that has corrupted an NVIDIA kernel module's usage count, for which the simplest remedy is to reboot your computer.
```

怎么办？

原因是卸载的时候有别的程序占用显卡不放，所以无法安装新的显卡驱动。先停止那些占用就可以了。

参见：[https://haoyu.love/blog549.html](https://haoyu.love/blog549.html)

依次执行：

```powershell
fuser -v /dev/nvidia* 
fuser -v /dev/nvidia* | grep -o -E '[0-9]+' | xargs kill -9
```

## 4 容器：深度学习环境

### 4.1 实践目标

目标，在容器里用conda安装上torch gpu 1.7.1：

```powershell
# CUDA 11.0
conda install pytorch==1.7.1 torchvision==0.8.2 torchaudio==0.7.2 cudatoolkit=11.0 -c pytorch
```

### 4.2 找到合适的devel镜像

NVIDIA发布的devel镜像在之前图看到过，里面包含了runtime，还有一些别的，相当于最全了！

找到镜像，[https://hub.docker.com/r/nvidia/cuda/tags?page=1&ordering=last_updated&name=11.0](https://hub.docker.com/r/nvidia/cuda/tags?page=1&ordering=last_updated&name=11.0)

pull镜像：
```powershell
docker pull nvidia/cuda:11.0.3-devel-centos7
```

dockerpull 过慢，给一个阿里镜像。

Docker阿里镜像：

[https://cr.console.aliyun.com/cn-hangzhou/instances/mirrors](https://cr.console.aliyun.com/cn-hangzhou/instances/mirrors)

### 4.3 运行容器

运行容器，用--gpus all参数去把宿主机资源带入容器中，此时nvidia-docker2在发挥作用：

```powershell
docker run -it -v /root:/define/root --gpus all 72978189a95a /bin/bash  # 运行镜像，挂载卷方便文件传输
```

yum没镜像寸步难行

yum给镜像方法是这样：

```powershell
mv /etc/yum.repos.d/CentOS-Base.repo /etc/yum.repos.d/CentOS-Base.repo.backup
cd /etc/yum.repos.d/
wget http://mirrors.163.com/.help/CentOS7-Base-163.repo  # 配置为163源  可以不要这个 不执行这句
————————————————
版权声明：本文为CSDN博主「Q742971636」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/x1131230123/article/details/115007154
```

宿主机文件移动到/root,然后在容器内移动到/etc/yum.repos.d：

```powershell
cp /define/root/CentOS-Base.repo /etc/yum.repos.d
```

安装wget等工具：

```powershell
yum install -y wget vim git 
```

### 4.4 安装python

装miniconda：

```powershell
wget https://repo.anaconda.com/miniconda/Miniconda3-py38_4.9.2-Linux-x86_64.sh
sh Miniconda3-py38_4.9.2-Linux-x86_64.sh
source ~/.bashrc
```


装pytorch：

```powershell
# CUDA 11.0
conda install pytorch==1.7.1 torchvision==0.8.2 torchaudio==0.7.2 cudatoolkit=11.0 -c pytorch
```

### 4.5 用python程序测试环境

测试CUDA环境，写个py文件后执行，`touchtest.py`, `vim test.py` , 使用程序：

```python
import torch
flag = torch.cuda.is_available()
if flag:
    print("CUDA可使用")
else:
    print("CUDA不可用")
ngpu= 1
# Decide which device we want to run on
device = torch.device("cuda:0" if (torch.cuda.is_available() and ngpu > 0) else "cpu")
print("驱动为：",device)
print("GPU型号： ",torch.cuda.get_device_name(0))
```

执行程序 `python test.py` 后看到：

![在这里插入图片描述](/static/img/images/00353.png)

好，这样就成功了，能在容器里使用GPU了！

## 5 开始使用

退出容器，docker ps -a找到刚才容器id，使用docker commit 把容器变成镜像：
```powershell
docker commit -a "Kevin" -m "cuda11 pytorch1.7.1" 529cfd575f70 cuda11pytorch1_7_1:v1
```

使用docker images查看生成的镜像：

![在这里插入图片描述](/static/img/images/00354.png)

以后就能使用这个镜像进行开发：
```powershell
docker run -it -v /root:/define/root --gpus all 1d5c02b61178 /bin/bash  # 运行镜像，挂载卷方便文件传输
```

更进一步把镜像保存为rar文件：

```powershell
docker save -o cuda11pytorch1_7_1.tar cuda11pytorch1_7_1:v1
```

加载本地镜像rar文件：

```powershell
docker load -i cuda11pytorch1_7_1.tar
```

Docker 搭建GPU容器用于深度学习 NVIDIA Container Toolkit CentOS 如何升级gpu driver

身在Docker容器里身不由己，wget能很好解决：





下载：
```powershell
wget https://repo.anaconda.com/miniconda/Miniconda3-py38_4.9.2-Linux-x86_64.sh
```

安装：

-b是静默安装，无需交互。
```powershell
sh Miniconda3-py38_4.9.2-Linux-x86_64.sh -b
```

所以记住这2个仓库：

[https://repo.anaconda.com/miniconda/](https://repo.anaconda.com/miniconda/)

[https://repo.anaconda.com/archive/](https://repo.anaconda.com/archive/)

Linux wget miniconda 快速安装miniconda环境

# Docker 入门指南







## 参考

- 菜鸟教程: [Docker 教程](https://www.runoob.com/docker/docker-tutorial.html)

- 狂神Docker笔记: [链接](https://blog.csdn.net/weixin_43591980/article/details/106272050?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522162746190916780366597654%2522%252C%2522scm%2522%253A%252220140713.130102334.pc%255Fall.%2522%257D&request_id=162746190916780366597654&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2~all~first_rank_v2~rank_v29-1-106272050.pc_search_result_cache&utm_term=docker%20%E7%8B%82%E7%A5%9E&spm=1018.2226.3001.4187)

## 总览

Docker 的入门重点包括镜像命令学习、容器命令学习，之后学习 compose、网络。下面是关于 Docker 的一些图示：

![Docker总览图](/static/img/images/00361.png)

## Docker 安装

### centOS 安装

```bash
# 1. 卸载旧版本
yum remove docker \
    docker-client \
    docker-client-latest \
    docker-common \
    docker-latest \
    docker-latest-logrotate \
    docker-logrotate \
    docker-engine
# 2. 需要的安装包
yum install -y yum-utils
# 3. 设置镜像的仓库
yum-config-manager --add-repo https://download.docker.com/linux/centos/docker-ce.repo
# 推荐使用国内的
# yum-config-manager --add-repo https://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo
# 4. 更新 yum 软件包索引
yum makecache fast
# 5. 安装 docker 相关的 docker-ce 社区版
yum install docker-ce docker-ce-cli containerd.io
# 6. 启动 docker
systemctl start docker
# 7. 使用 docker version 查看是否安装成功
docker version
# 8. 测试
docker run hello-world
```

### Ubuntu 安装方式

详见：[Ubuntu 安装方式](https://qq742971636.blog.csdn.net/article/details/134116129)

## 镜像命令

```powershell
docker images # 查看所有本地主机上的镜像，也可以使用 docker image ls 代替
docker search # 搜索镜像
docker pull # 下载镜像 docker image pull
docker rmi # 删除镜像 docker image rm
```

## 容器命令

```powershell
docker run 镜像id # 新建容器并启动 docker run -it centos /bin/bash
docker ps # 列出所有运行的容器 docker container list
docker rm 容器id # 删除指定容器
docker start 容器id # 启动容器
docker restart 容器id # 重启容器
docker stop 容器id # 停止当前正在运行的容器
docker kill 容器id # 强制停止当前容器
```

删除容器

```powershell
docker rm -f 容器id # 删除指定的容器，不能删除正在运行的容器，如果要强制删除 rm -rf
docker rm -f $(docker ps -aq) # 删除所有的容器
docker ps -a -q|xargs docker rm # 删除所有的容器
```

## 从压缩包加载镜像

使用 Docker 安装:

```bash
curl -fsSL https://get.docker.com | bash -s docker --mirror aliyun
```

拉取 Docker Hub 的镜像，最好在 Docker Hub 搜索后找到需要的镜像。加载本地镜像：

```bash
docker load -i wrf_v1.tar
```

后台运行镜像：

```bash
docker run –itd -v /home/wrf2/project10/data:/usr/ly/data -v /home/wrf2/project10/wrf_env/wrf_local/local:/usr/ly/local wrf:v1 /bin/bash
```

查看在运行的容器：

```bash
docker ps
```

查看所有容器，无论运行与否：

```bash
docker ps -a
```

进入一个正在运行的容器：

```bash
docker exec -it c42e6710b18e /bin/bash
```

要退出容器，且不让容器停止运行：

1. 先按快捷键 `ctrl+P`

2. 再按快捷键 `ctrl+Q`

## 容器 >> 镜像 >> 压缩包

将容器提交为镜像：

```powershell
docker commit -a "Kevin" -m "yolo" 73021fc5a50f yolov5image:v1
```

将镜像保存为

 RAR 压缩包：

```powershell
docker save -o my_ubuntu_v3.tar 794ee56580a5
```


# 清除掉状态是停止的容器

```bash
docker container prune
```


# 删除所有没有TAG的镜像

你可以使用 Docker 命令来删除没有 TAG 的镜像。以下是具体的命令：

```bash
docker rmi $(docker images -q -f dangling=true)
```

这个命令的含义是：

- `docker images`：列出所有镜像。

- `-q`：仅显示镜像 ID。

- `-f dangling=true`：过滤出没有 TAG 的镜像。

- `docker rmi`：删除选定的镜像。

这个命令将会删除所有没有 TAG 的镜像。

【运维】Docker 基本使用教程 dockerhub cookbook

组装：





```csharp
memset(send_zigbee, 0, sizeof(send_zigbee));
sprintf(send_zigbee, "YT%03d,%03d,%03d,%01d,%01d,%03d\n",
        (int) dis_hr,
        (int) dis_spo2,
        (int) temperature,
        (int) have_droplets,
        (int) rain,
        (int) departures);
USART3_SendString(send_zigbee);
```

解析：

```csharp
sscanf(rev_Slave_bufferdata, "YT%03d,%03d,%03d,%01d,%01d,%03d\n",
       &dis_hr,
       &dis_spo2,
       &temperature,
       &have_droplets,
       &rain,
       &departures);
```

C语言中的字符串组装与解析

VS2019正式版 密钥 Visual Studio 2019   Key





 

 企业版安装包：

链接：https://pan.baidu.com/s/1cdawgsIngBaMhA7sUVcGgg?pwd=hojb 

提取码：hojb 

Visual Studio 2019 Enterprise 企业版：

BF8Y8-GN2QH-T84XB-QVY3B-RC4DF

![在这里插入图片描述](/static/img/images/03937.png)



Visual Studio 2019 Professional 专业版：

NYWVH-HT4XC-R2WYW-9Y3CM-X4V3Y

VS2019正式版 密钥 Visual Studio 2019 破解 激活码 Key

# 介绍





1.X 和 2.X 区别挺大的，2.X 更强了，这篇文章就是我学习2.X 的学习记录，耐心跟官网的教程走一遍，基本就会用这个工具了。

1.X 的文档：

https://docs.conan.io/en/1.46/introduction.html

2.X 的文档：

[https://docs.conan.io/2/tutorial/consuming_packages.html](https://docs.conan.io/2/tutorial/consuming_packages.html)


# Build a simple CMake project using Conan

跟着官网教程做一遍。

1、pip install conan后，conan最新是2.0.x的版本；

2、CMakeLists.txt 里这样去找的：

![在这里插入图片描述](/static/img/images/03939.png)

3、conanfile.txt 写需要的包。

[generators] generators告诉Conan生成编译器或构建系统将用于查找依赖项和构建项目所需的文件。在这种情况下，由于我们的项目基于CMake，我们将使用CMakeDeps生成关于Zlib库文件安装位置的信息，并使用CMakeToolchain通过CMake工具链文件将构建信息传递给CMake。

![在这里插入图片描述](/static/img/images/03940.png)

4、Conan profile 是必须的文件。Conan配置文件允许用户定义一组配置，如编译器、构建配置、架构、共享或静态库等。Conan默认不会自动检测配置文件，因此我们需要创建一个配置文件。如果想让Conan尝试根据当前操作系统和已安装的工具来猜测配置文件，请运行以下命令：

```c
conan profile detect --force
```

我用这个命令检测出来的还是有点错误，手动修改需要首先用这个指令看默认的文件在哪里：

```c
conan profile path default
```

然后修改成自己想要的：

![在这里插入图片描述](/static/img/images/03941.png)

5、最终使用conan install。

Conan从我们在教程开始时配置的远程服务器上安装了Zlib库。该服务器存储了Conan配方，这些配方定义了如何构建库，并且还存储了可以重用的二进制文件，因此我们不必每次都从源代码构建。

Conan在build文件夹下生成了几个文件。这些文件由我们在conanfile.txt中设置的CMakeToolchain和CMakeDeps生成器生成。CMakeDeps生成文件以便CMake可以找到我们刚刚下载的Zlib库。另一方面，CMakeToolchain为CMake生成一个工具链文件，以便我们可以使用与默认配置文件检测到的相同设置透明地使用CMake构建项目。

```c
conan install . --output-folder=build --build=missing
```


# Using build tools as Conan packages

Conan可以帮你搞定不同版本的CMake。你只要在conanfile.txt写出：

```c
[tool_requires]
cmake/3.22.6
```

可以在Conan中声明此依赖关系，使用一种名为tool_requires的要求类型。让我们看一个示例，了解如何向我们的项目添加tool_requires，并使用不同的CMake版本来构建它。

![在这里插入图片描述](/static/img/images/03942.png)

这个操作会在build文件夹中产生一个cmake的可执行程序，可以用你想要的cmake版本去编译程序：

![在这里插入图片描述](/static/img/images/03943.png)

# Building for multiple configurations:Release, Debug, Static and Shared 修改Conan profile，达到自己的编译目的

目前为止，我们构建了一个简单的CMake项目，该项目依赖于zlib库，并学习了tool_requires，这是一种用于构建工具（如CMake）的特殊要求类型。在这两种情况下，我们没有在任何地方指定我们希望以发布模式还是调试模式构建应用程序，或者我们希望链接静态库还是共享库。这是因为如果没有另外指示，Conan将使用在“default profile”中声明的默认配置。在第一个示例中运行conan profile detect命令时，该默认配置文件是自动生成的。

Conan profile有不同的部分。[settings]部分包含有关操作系统、架构、编译器和构建配置等信息。当您调用Conan命令并设置--profile参数时，Conan将获取配置文件中的所有信息，并应用于您要构建或安装的软件包。如果您没有指定该参数，相当于使用--profile=default进行调用。这两个命令的行为是相同的：

```c
$ conan install . --build=missing
$ conan install . --build=missing --profile=default
```

您可以存储不同的配置文件，并使用它们来针对不同的设置进行构建。例如，可以使用build_type=Debug，或在使用该配置文件构建的所有软件包中添加tool_requires。一个调试配置文件的示例如下所示：

```c
[settings]
os=Macos
arch=x86_64
compiler=apple-clang
compiler.version=14.0
compiler.libcxx=libc++
compiler.cppstd=gnu11
build_type=Debug
```


使用配置文件Conan profile不是设置要使用的配置的唯一方法。您还可以在Conan命令中使用--settings参数**覆盖**配置文件Conan profile中的设置。例如，您可以在调试配置中构建先前示例中的项目，而不是发布配置。


```c
$ conan install . --output-folder=build --build=missing --settings=build_type=Debug
```

到目前为止，我们一直在应用程序中静态链接Zlib。这是因为在Zlib的Conan包中，默认设置了以静态方式构建的属性。我们可以通过使用--options参数将shared选项设置为True，来改变从静态链接到共享链接。请执行以下命令来进行设置：

```c
conan install . --output-folder=build --build=missing --options=zlib/1.2.11:shared=True
```

这样做后，Conan将安装Zlib的共享库，生成使用它们构建的文件，并且还会在运行应用程序时生成必要的文件来定位这些动态库。在将应用程序配置为使用共享库链接Zlib之后，让我们再次构建应用程序：
```c
$ cd build
$ cmake .. -DCMAKE_TOOLCHAIN_FILE=conan_toolchain.cmake -DCMAKE_BUILD_TYPE=Release
$ cmake --build . --config Release
```

现在，如果您尝试运行编译后的可执行文件，您会看到一个错误，因为该可执行文件找不到我们刚刚安装的Zlib的共享库。

```c
$ ./compressor
```

这是因为共享库（在Windows中是.dll，在OSX中是.dylib，在Linux中是.so）是在运行时加载的。这意味着应用程序可执行文件需要知道在运行时需要哪些共享库的位置。在Windows上，动态链接器将先搜索相同的目录，然后再搜索PATH目录。在OSX上，它将搜索在DYLD_LIBRARY_PATH中声明的目录，而在Linux上则使用LD_LIBRARY_PATH。


Conan提供了一种机制来定义这些变量，并使可执行文件能够找到和加载这些共享库。这个机制是VirtualRunEnv生成器。如果您检查输出文件夹，您会看到Conan生成了一个名为conanrun.sh/bat的新文件。这是在进行conan安装时激活共享选项时自动调用VirtualRunEnv生成器的结果。这个生成的脚本将设置PATH、LD_LIBRARY_PATH、DYLD_LIBRARY_PATH和DYLD_FRAMEWORK_PATH环境变量，以便可执行文件可以找到共享库。

```c
$ source conanrun.sh
$ ./compressor
```

# Understanding the flexibility of using conanfile.py vs conanfile.txt

从conanfile.txt迁移到conanfile.py，可以提供更高的灵活性。下面的这个是conanfile.txt：

```c
[requires]
zlib/1.2.11
[tool_requires]
cmake/3.22.6
[generators]
CMakeDeps
CMakeToolchain
```

等价于下面这个conanfile.py，继承ConanFile类，复写属性settings、generators，方法self.requires、self.tool_requires表述需求。

```c
from conan import ConanFile
class CompressorRecipe(ConanFile):
    settings = "os", "compiler", "build_type", "arch"
    generators = "CMakeToolchain", "CMakeDeps"
    def requirements(self):
        self.requires("zlib/1.2.11")
    def build_requirements(self):
        self.tool_requires("cmake/3.22.6")
```

在之前的示例中，每次执行conan install命令时，我们都必须使用--output-folder参数来定义我们想要创建Conan生成文件的位置。有一种更简洁的方法可以决定我们希望Conan为构建系统生成文件的位置，这样我们可以根据所使用的CMake生成器的类型决定是否使用不同的输出文件夹。你可以直接在conanfile.py文件中的layout()方法中定义这个位置，并使其适用于每个平台，而不需要添加更多的更改。

```c
import os
from conan import ConanFile
class CompressorRecipe(ConanFile):
    settings = "os", "compiler", "build_type", "arch"
    generators = "CMakeToolchain", "CMakeDeps"
    def requirements(self):
        self.requires("zlib/1.2.11")
    def build_requirements(self):
        self.tool_requires("cmake/3.22.6")
    def layout(self):
        # We make the assumption that if the compiler is msvc the
        # CMake generator is multi-config
        multi = True if self.settings.get_safe("compiler") == "msvc" else False
        if multi:
            self.folders.generators = os.path.join("build", "generators")
        else:
            self.folders.generators = os.path.join("build", str(self.settings.build_type), "generators")
```

正如你所看到的，我们在layout()方法中定义了self.folders.generators属性。这是Conan生成的所有辅助文件（CMake工具链和CMake依赖文件）放置的文件夹。

请注意，如果是多配置生成器（如Visual Studio），文件夹的定义与单配置生成器（如Unix Makefiles）不同。在第一种情况下，无论构建类型如何，文件夹都是相同的，构建系统将在该文件夹内管理不同的构建类型。但是像Unix Makefiles这样的单配置生成器，必须为每个不同的配置（如不同的构建类型Release/Debug）使用不同的文件夹。在这种情况下，我们添加了一个简单的逻辑来判断如果编译器名称是msvc，则考虑多配置。请注意，如果运行与之前示例中相同的命令但没有--output-folder参数，将会得到与之前相同的结果。

使用raise ConanInvalidConfiguration去引发异常：

```c
...
from conan.errors import ConanInvalidConfiguration
class CompressorRecipe(ConanFile):
    ...
    def validate(self):
        if self.settings.os == "Macos" and self.settings.arch == "armv8":
            raise ConanInvalidConfiguration("ARM v8 not supported in Macos")
```

# How to cross-compile your applications using Conan: host and build contexts

交叉编译：比如编译平台是ubuntu，而运行平台是Android。

之前写的：

```c
$ conan install . --build=missing --profile=someprofile
```

其实是等价于：

```c
$ conan install . --build=missing --profile:host=someprofile --profile:build=default
```

profile:host: 这是定义构建二进制文件所运行平台的配置文件。【运行平台是Android】

profile:build: 这是定义构建二进制文件的平台的配置文件。【编译平台是ubuntu】

请注意，当您只使用一个参数来确定配置文件时，--profile与--profile:host等效。如果您不指定--profile:build参数，Conan将在内部使用default 配置文件。

# Introduction to versioning 第三方包的版本控制

conanfile.py

```c
from conan import ConanFile
class CompressorRecipe(ConanFile):
    settings = "os", "compiler", "build_type", "arch"
    generators = "CMakeToolchain", "CMakeDeps"
    def requirements(self):
        self.requires("zlib/[~1.2]")
```

`zlib/[~1.2]` ，意味着在conan center 找类似于zlib/1.2.8, zlib/1.2.11 or zlib/1.2.12中的最新版本包。

`zlib/[<1.2.12]`，如果这么写，就是找这个版本以下的，不包含这个版本。类似地使用大于小于等于就可以了。

`self.tool_requires("cmake/[>3.10]")` 也服从这个规则。

【conan】c++包管理工具，conan教程

使用C语言计算两个日期之间间隔了多少分钟的方法：





默认计算2000年之后的，否则请改一下year_afer2000 那个地方。

默认计算间隔了多少分钟，若要计算秒钟，需要对应修改一下整体。

```c
#include <stdio.h>
//#include <stdlib.h>
//#include <ctype.h>
//#include <string.h>
//#include <stdio.h>
//#include <time.h>
unsigned long cal_total_min( int year, int month, int day, int hour, int minute )
{
    unsigned long total_minutes1;
    unsigned long total_minutes2;
    unsigned long total_minutes3;
    unsigned long total_minutes4;
    unsigned long date1_minutes;
    int year_afer2000;
    int  i;
    int  month_days[12] = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
    /* 计算日期1到日期2的总分钟数 */
    total_minutes1 = 0;
    year_afer2000 = year - 2000;                                /* 默认计算2000年之后的 */
    for ( i = 0; i < year_afer2000; i++ )
    {
        if ( (i % 4 == 0 && i % 100 != 0) || i % 400 == 0 )     /* 闰年 */
            total_minutes1 += 366 * 24 * 60;
        else
            total_minutes1 += 365 * 24 * 60;
    }
    total_minutes2 = 0;
    for ( i = 0; i < month - 1; i++ )
        if ( i == 1 )                                                           /* 2月 */
        {
            if ( (year % 4 == 0 && year % 100 != 0) || year % 400 == 0 )    /* 闰年 */
                total_minutes2 += 29 * 24 * 60;
            else
                total_minutes2 += 28 * 24 * 60;
        } else {
            total_minutes2 += month_days[i] * 24 * 60;
        }
    total_minutes3 = day * 24 * 60;
    total_minutes4 = hour * 60 + minute;
    date1_minutes = total_minutes1 + total_minutes2 + total_minutes3 + total_minutes4;
    return(date1_minutes);
}
/* 计算两个日期相差多少分钟的绝对值,考虑每个月天数和闰年 */
unsigned long cal_two_time_diff( char *time1, char *time2 )
{
    int  year1, month1, day1, hour1, minute1;
    int  year2, month2, day2, hour2, minute2;
    unsigned long date1_minutes;
    unsigned long date2_minutes;
    sscanf( time1, "%4d%2d%2d%2d%2d", &year1, &month1, &day1, &hour1, &minute1 );
    sscanf( time2, "%4d%2d%2d%2d%2d", &year2, &month2, &day2, &hour2, &minute2 );
    date1_minutes = cal_total_min( year1, month1, day1, hour1, minute1 );
    date2_minutes = cal_total_min( year2, month2, day2, hour2, minute2 );
    /* 两个日期相差的绝对分钟数 */
    if ( date1_minutes > date2_minutes )
        return(date1_minutes - date2_minutes);
    else
        return(date2_minutes - date1_minutes);
}
int main() {
    unsigned long diff_minutes = cal_two_time_diff("202312312359", "200001010000");
    printf("两个日期相差的分钟数为:%lu\n", diff_minutes);
    return 0;
}
```

使用C语言计算两个日期之间间隔了多少分钟的程序

书籍下载：[程序员的自我修养：链接、装载与库.pdf - 经典技术书籍](https://awesome-programming-books.github.io/others/%E7%A8%8B%E5%BA%8F%E5%91%98%E7%9A%84%E8%87%AA%E6%88%91%E4%BF%AE%E5%85%BB%EF%BC%9A%E9%93%BE%E6%8E%A5%E3%80%81%E8%A3%85%E8%BD%BD%E4%B8%8E%E5%BA%93.pdf)






# GCC编译过程

- 预编译 prepressing，将cpp、hpp转为.i 结尾的文件；

- 编译 compilation

- 汇编 assembly

- 链接 linking

![在这里插入图片描述](/static/img/images/04601.png)

# 目标文件

![在这里插入图片描述](/static/img/images/04602.png)

![在这里插入图片描述](/static/img/images/04603.png)

【C++】GCC编译过程与目标文件类别

一开始想使用nmslib的，conan中引用后发现nmslib的C++示例代码太难写了，改为使用flann去实现，opencv中已纳入了flann，使用起来更方便了。






下面这段代码实现了使用 KD-Tree 算法进行 K 近邻搜索的函数 knn_nmslib，其中调用了 normalizeFeatures 函数用于对特征向量进行标准化处理。最终目的是计算每个特征的k近邻是谁，余弦距离是多少。

具体来说，该函数输入一个特征向量集合 feats，输出每个特征向量的前 k 个最近邻索引和对应的距离，存储在一个 vector<vector<int>> 和一个 vector<vector<float>> 中，分别表示索引和距离。

在函数中，首先复制一份输入特征向量 feats 到 feats_copy，然后对 feats_copy 中的每个特征向量进行标准化处理，即将其 L2 范数归一化为 1。标准化后，将 feats_copy 转换为一个 cv::Mat 对象 features，作为 K 近邻搜索的数据集。

接着，使用 cv::flann::Index 创建一个 KD-Tree 索引，使用欧几里得距离作为距离度量。然后，将 features 作为查询数据进行 K 近邻搜索，返回每个查询数据的前 k 个最近邻的索引和距离，存储在 cv::Mat 对象 indices 和 dists 中。

最后，对于每个查询数据，将其前 k 个最近邻的索引和距离存储到 neighbours 中，同时计算每个最近邻之间的余弦距离，并保存到 distance22 中，方便后续的计算。函数最后释放 KD-Tree 索引的内存。

```c
#include <opencv2/opencv.hpp>
#include <opencv2/flann.hpp>
#include <utility>
float findCosineSimilarity(const std::vector<float>& source_representation,
                           const std::vector<float>& test_representation) {
    return 1.0f - findCosineDistance(source_representation, test_representation);
}
float findCosineDistance(const std::vector<float>& source_representation,
                         const std::vector<float>& test_representation) {
    cv::Mat source(source_representation);
    cv::Mat test(test_representation);
    double dist = 1.0 - source.dot(test) / (cv::norm(source) * cv::norm(test, cv::NORM_L2) + 0.000001);
    return static_cast<float>(dist);
}
void normalizeFeatures(std::vector<std::vector<float>>& features) {
    for (auto& feature : features) {
        cv::Mat mat(feature);
        double norm = cv::norm(mat, cv::NORM_L2);
        mat = mat / norm;
        for (int i = 0; i < mat.cols; ++i) {
            feature[i] = mat.at<float>(0, i);
        }
    }
}
void knn_nmslib(const std::vector<std::vector<float>>& feats,
                std::vector<std::pair<std::vector<int>, std::vector<float>>>& neighbours,
                int k) {
    // 复制一份feats出来
    std::vector<std::vector<float>> feats_copy(feats);
    // 标准化
    normalizeFeatures(feats_copy);
    cv::Mat features(feats_copy.size(), feats_copy[0].size(), CV_32F);
    features.forEach<float>(
        [&](float& pixel, const int* position) -> void { pixel = feats_copy[position[0]][position[1]]; });
    // 设置搜索算法为KD-Tree，使用欧几里得距离
    cv::flann::Index flannIndex(features, cv::flann::KDTreeIndexParams(4), cvflann::FLANN_DIST_EUCLIDEAN);
    // 设置查询数据
    cv::Mat query = features;
    // 进行k近邻搜索
    cv::Mat indices(query.rows, k, CV_32S);
    cv::Mat dists(query.rows, k, CV_32F);
    flannIndex.knnSearch(query, indices, dists, k, cv::flann::SearchParams(256));
    std::map<std::pair<int, int>, float> distance22;
    float dist_tmp;
    for (int i = 0; i < query.rows; i++) {
        std::vector<int> index;
        std::vector<float> dist;
        for (int j = 0; j < k; j++) {
            index.push_back(indices.at<int>(i, j));
            // 查询distance22中是否存在（i,j）
            if (distance22.find(std::make_pair(i, indices.at<int>(i, j))) == distance22.end()) {
                dist_tmp = findCosineDistance(feats[i], feats[indices.at<int>(i, j)]);
                distance22[std::make_pair(i, indices.at<int>(i, j))] = dist_tmp;
                distance22[std::make_pair(indices.at<int>(i, j), i)] = dist_tmp;
            } else {
                dist_tmp = distance22[std::make_pair(i, indices.at<int>(i, j))];
            }
            dist.push_back(dist_tmp);  // 距离保存
        }
        neighbours.push_back(std::make_pair(index, dist));
    }
    //释放内存
    flannIndex.release();
}
```

使用opencv::flann C++进行k近邻搜索，余弦距离

conan openssl:





[https://conan.io/center/openssl](https://conan.io/center/openssl)

ubuntu需要安装：

```shell
 sudo apt-get install libvulkan-dev
```

示例代码：
```c
#include <openssl/md5.h>
std::string md5sum(const std::string& str) {
    std::string md5;
    MD5_CTX ctx;
    MD5_Init(&ctx);
    MD5_Update(&ctx, str.c_str(), str.size());
    unsigned char digest[MD5_DIGEST_LENGTH];
    MD5_Final(digest, &ctx);
    char hex[35];
    memset(hex, 0, sizeof(hex));
    for (int i = 0; i < MD5_DIGEST_LENGTH; ++i) {
        sprintf(hex + i * 2, "%02x", digest[i]);
    }
    md5 = std::string(hex);
    return md5;
}
```