python 代码：





```python
import os
import shutil
import traceback
def delete_folder(path):
    if os.path.exists(path):
        print(f"删除文件夹: {path}")
        shutil.rmtree(path)
        print("删除完成")
def delete_file(path):
    if os.path.exists(path):
        print(f"删除文件: {path}")
        os.remove(path)
        print("删除完成")
def clean_project(src_root):
    for root, dirs, files in os.walk(src_root):
        try:
            for filename in files:
                apath = os.path.join(root, filename)
                # 文件大于10M就打印
                if os.path.getsize(apath) > 10 * 1024 * 1024:
                    print(f"文件: {apath} 大小: {os.path.getsize(apath) / (1024 ** 2):.2f}M")
            # 删除.gradle文件夹
            if ".gradle" in dirs:
                dir_path = os.path.join(root, ".gradle")
                dir_size = shutil.disk_usage(dir_path).used / (1024 ** 2)
                if dir_size > 5:
                    delete_folder(dir_path)
                else:
                    print(f"文件夹: {dir_path} 大小: {dir_size:.2f}M")
            # 删除.idea文件夹
            if ".idea" in dirs:
                delete_folder(os.path.join(root, ".idea"))
            # 删除.iml文件和local.properties文件
            for file in files:
                file_path = os.path.join(root, file)
                if file.endswith(".iml") or file == "local.properties":
                    delete_file(file_path)
            # 删除build文件夹
            if "build" in dirs:
                delete_folder(os.path.join(root, "build"))
            # 删除libs文件夹
            if "libs" in dirs:
                delete_folder(os.path.join(root, "libs"))
            # 删除androidTest文件夹
            if "androidTest" in dirs:
                delete_folder(os.path.join(root, "androidTest"))
            # 删除test文件夹
            if "test" in dirs:
                delete_folder(os.path.join(root, "test"))
        except:
            traceback.print_exc()
if __name__ == "__main__":
    src_root = r"F:\workcode\android_project"
    clean_project(src_root)
```

Android 清除临时文件，清空缓存

近期，我不得不将深度学习项目部署到 Docker 环境中，而在这个过程中避免不了涉足 NVIDIA Docker 的坑。尽管确认其为非常实用的工具，但容器里却一片干净，什么都没有，需要一些时间去进行配置。在这篇博客中，我将详细记录在 Docker Hub 上 nvidia/cuda 镜像中，不同版本的 CUDA 镜像文件的区别。





## CUDA 镜像版本概述

### base 版本

这个版本从 CUDA 9.0 开始，包含了最基本的 CUDA 应用程序的预构建部署（libcudart）。如果用户希望自行安装所需的 CUDA 包，可以选择使用这个版本的镜像。然而，如果希望更加便捷，建议不要选择这个镜像版本，因为它可能会引入很多不必要的麻烦。

### runtime 版本

通过添加 CUDA 工具包中的所有共享库，该版本扩展了基本镜像。如果使用了多个 CUDA 库的预构建应用程序，可以选择使用此镜像。然而，如果想要使用 CUDA 中的头文件编译自己的工程，可能会遇到找不到文件的错误。

### devel 版本

通过添加编译器工具链、测试工具、头文件和静态库，该版本扩展了运行时的镜像。如果想要将 CUDA 应用程序从源代码编译，建议选择这个镜像版本。

如果希望将 Docker 镜像用作开发环境，强烈建议选择 devel 版本的镜像。

## 镜像使用建议

在选择 CUDA 镜像版本时，可以根据项目需求和开发环境的要求进行合理选择。以下是一些示例用法：

- 运行一个隔离到第一个 GPU 的交互式 CUDA 会话：

  ```bash
  docker run -ti --rm --runtime=nvidia -e NVIDIA_VISIBLE_DEVICES=0 nvidia/cuda
  ```

- 查询 CUDA 7.5 编译器版本：

  ```bash
  docker run --rm --runtime=nvidia nvidia/cuda:7.5-devel nvcc --version
  ```

## 总结

在使用 runtime 版本的包时需要注意，它并没有 CUDA 的编译工具 nvcc。因此，在选择镜像版本时，务必根据具体需求仔细权衡，以确保 Docker 环境能够满足项目的开发和部署要求。

通过这篇博客，希望能够帮助大家更好地理解和选择适用于自己深度学习项目的 NVIDIA Docker CUDA 镜像版本。在配置 Docker 环境时，合理选择镜像版本是保障项目顺利进行的关键一步。

深度学习项目部署：解析 NVIDIA Docker 中的 CUDA 镜像版本：base 版本、 runtime 版本、devel 版本

# 内存不够用，可以用硬盘当内存吗





是的，可以使用硬盘作为虚拟内存来扩展容器中的内存。这个过程被称为“交换”或“交换空间”。

在Linux系统中，你可以通过以下步骤将硬盘用作交换空间：

1. **创建交换文件：**

   ```
   sudo fallocate -l 4G /root/swapfile
   ```

   或者，如果`fallocate`不可用，可以使用`dd`命令：

   ```
   sudo dd if=/dev/zero of=/path/to/swapfile bs=1G count=[大小]
   ```

   这将创建一个指定大小的交换文件。

2. **设置文件权限：**

   ```
   sudo chmod 600 /root/swapfile
   ```

3. **将文件设置为交换空间：**

   ```
   sudo mkswap /root/swapfile
   ```

4. **启用交换空间：**

   ```
   sudo swapon /root/swapfile
   ```

   如果希望在系统启动时自动启用交换空间，可以将交换文件的信息添加到 `/etc/fstab` 文件中。

请注意，虽然使用交换空间可以扩展可用内存，但硬盘的读写速度相对较慢，因此与物理内存相比，交换空间的性能较差。过度依赖交换空间可能会导致系统性能下降。最好的解决方案是确保容器分配足够的物理内存以满足应用程序的需求。

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

# 如何取消这种交换空间

取消交换空间的扩展也是可能的。以下是一些步骤，你可以按照这些步骤来禁用或删除交换空间：

1. **禁用交换空间：**

   ```
   sudo swapoff /path/to/swapfile
   ```

   这将禁用交换空间，但并不会从系统中删除交换文件。

2. **永久性删除交换文件：**

   ```
   sudo rm /path/to/swapfile
   ```

   如果你确定不再需要交换文件，可以删除它。请确保在删除之前已禁用交换空间。

3. **从 /etc/fstab 中删除相关行（可选）：**

   如果你已将交换文件信息添加到 `/etc/fstab` 文件中，并希望在系统启动时不再自动启用交换空间，可以手动编辑该文件并删除相关行。请小心编辑 `/etc/fstab`，以避免引起系统启动问题。

请注意，在运行某些任务时，可能会有瞬时的内存需求。因此，在禁用交换空间之前，请确保你了解应用程序和系统的内存使用情况，以免影响系统的稳定性。


# 交换空间是优先使用的还是说原始内存是会被优先使用的

在Linux系统中，内核会根据系统的内存管理策略来决定何时使用交换空间和何时使用物理内存。通常情况下，物理内存（RAM）是首选，而交换空间则被用作备用。系统倾向于将经常使用的数据和进程存储在物理内存中，因为物理内存的访问速度远远快于交换空间（硬盘或 SSD）。

当系统的物理内存不足以满足当前运行的任务时，Linux内核会将部分不常用的数据移动到交换空间中，以释放物理内存供更紧急的用途。这个过程被称为页面交换（paging）。

要注意的是，使用交换空间是一种权衡，因为硬盘的访问速度相对较慢，交换操作可能导致性能下降。因此，最好的做法是确保系统分配足够的物理内存，以尽量减少对交换空间的依赖。

总体而言，内核会尽量保持数据在物理内存中，但在需要时会使用交换空间来缓解内存不足的情况。

【运维】将Linux的硬盘当内存用，Linux内存不够用的时候如何用硬盘提升内存

项目：[https://github.com/ehang-io/nps](https://github.com/ehang-io/nps)





有个公网服务器，搭建服务端。



然后客户端使用：

`-server`是服务端的访问方式。`-vkey`是秘钥。

```clike
./npc -server=192.227.19.12:8024 -vkey=oies8gq3wml -type=tcp
```

然后在服务端配置TCP隧道即可。

如何访问内部网络做内网穿透

[https://github.com/notifications/subscriptions](https://github.com/notifications/subscriptions)

Github提过的issue在哪里

在Linux系统中，你可以使用各种工具来查看文件的哈希值。下面是一些常见的方法：





1. **md5sum命令：**

   ```bash
   md5sum 文件名
   ```

   例如：

   ```bash
   md5sum example.txt
   ```

2. **sha1sum命令：**

   ```bash
   sha1sum 文件名
   ```

   例如：

   ```bash
   sha1sum example.txt
   ```

3. **sha256sum命令：**

   ```bash
   sha256sum 文件名
   ```

   例如：

   ```bash
   sha256sum example.txt
   ```

4. **sha512sum命令：**

   ```bash
   sha512sum 文件名
   ```

   例如：

   ```bash
   sha512sum example.txt
   ```

这些命令将返回文件的哈希值，以及文件名。你可以将哈希值与其他用户分享，以确保文件的完整性或验证其身份。请注意，md5算法已经不再被推荐用于安全目的，因为它的碰撞（collision）风险相对较高。在需要更高安全性的情况下，建议使用sha256或更高等级的哈希算法。

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

linux如何查看文件的hash数值

`find` 命令可以用于在 Linux 或 macOS 系统中查找文件和目录。如果你想查找大于1GB的文件，可以使用 `-size` 选项结合 `+` 参数。以下是一个示例：





```bash
find /path/to/search -type f -size +1G
```

这里的 `/path/to/search` 是你要搜索的目录的路径。这个命令将查找该目录及其子目录中大于1GB的文件。

解释一下命令参数：

- `/path/to/search`：替换成你要搜索的目录的实际路径。

- `-type f`：表示只查找文件，不包括目录。

- `-size +1G`：表示查找大于1GB的文件。如果要查找精确的1GB文件，可以使用 `-size 1G`。

请注意，在某些系统上，`+1G` 可能需要用引号括起来，如 `'+1G'`，以防止 shell 对其进行解释。

这个命令会列出所有符合条件的文件的路径。如果你只想看到文件数量，可以使用 `-exec` 选项执行 `du` 命令，如下所示：

```bash
find /path/to/search -type f -size +1G -exec du -h {} +
```

这个命令会显示每个大于1GB的文件的大小和路径。

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

Linux如何查找某个路径下大于1G的文件

利用github的api工具，





首先拿到用户名为kevin的所有仓库的url：
```bash
curl "https://api.github.com/users/kevin/repos?per_page=100&&page=1" | grep -w clone_url  >clone.txt
```

过滤一下：
```bash
grep -o 'https://[^"]*' clone.txt >new_clone.txt
```

在txt文件中每一行前面加一个字符串git clone --depth=1 并保存到新的txt文件：

```bash
sed 's/^/git clone --depth=1 /' new_clone.txt > last_clone.sh
```

执行所有指令：

```bash
bash last_clone.sh 
```

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

github批量仓库克隆，git clone某个用户的所有仓库

# 限制docker 上传速度





然而，你可以使用第三方工具来实现这个目的。一个常用的工具是 `trickle`，它可以模拟网络带宽。

首先，你需要安装 `trickle`。在 Ubuntu 上，可以使用以下命令安装：

```bash
sudo apt-get install trickle
```

然后，你可以使用 `trickle` 来限制 Docker 推送的速度。例如：

```bash
trickle -s -u 300 docker push kevinchina/deeplearning:CodeFormerv1.000
```

在这个例子中，`-u 300` 表示将带宽限制为每秒 300KB。你可以根据需要调整这个值。

请注意，这种方法并不是 Docker 的原生功能，而是通过使用额外的工具来实现的。


# https://blog.desdelinux.net/en/trickle-bandwidth-limiter-for-linux/

Installation

sudo apt-get install trickle

How to use trickle

Trickle's syntax is as follows:

trickle -d Download_Bandwidth -u Upload_Bandwidth Command

Here are some examples:


a) Limit the download bandwidth to 10kbps used to transfer a file using ssh:

trickle -d 10 scp file.mp3 10.0.0.1:/home/puntolibre/musica/

b) Limit the bandwidth to 200kpbs of download of a system update through Apt:


trickle -d 200 apt-get upgrade

c) To modify the bandwidth of an application, such as Firefox:

trickle -d 10 -u 10 firefox% u

d) Using trickle to limit wget's bandwidth

trickle -d 50 wget -O “planet earth.divx” http://video.stage6.com/1402821/.divx


Run trickle like a demon

To start trickle like a daemon and limit ALL bandwidth, use the trickled command:

sudo trickled -d 20 -u 20

… Where the parameters -d and -u respond to the download and upload limit, respectively.


Configuring trickle

Trickle has a configuration file that will allow us to fine-tune some parameters and make them permanent individually for each service.

The configuration file is as follows: /etc/trickled.conf

The simplest configuration file that can be made looks like this:

[ssh] Priority = 1

[www] Priority = 8

With this method we get quite good download speeds and at the same time we can do ssh sessions to the machine that is downloading. Basically, a config file like the one above tells trickle to prioritize ssh transfers over www.

Trickle's documentation recommends the use of the Time-Smoothing and Length-Smoothing parameters to avoid fluctuations in transfer rates.

[ssh] Priority = 1

Time-Smoothing = 0.1

Length-Smoothing = 2

[www] Priority = 8

Time-Smoothing = 5

Length-Smoothing = 20

These values define the normalization time and length that Trickle applies to the program it is controlling.

【Linux 带宽限速】trickle，限制docker 上传速度

关闭手机开发者模式，再次打开手机开发者模式。