2022¶

2022年1月31日
分类于 Artificial Intelligence
需要 2 分钟阅读时间

MLOptimizer

优化算法（Optimizer）目标是优化（最小化或最大化）一个损失函数，以调整模型参数，使模型在训练数据上表现得更好。
在深度学习中，优化算法是训练神经网络时至关重要的组成部分，它们决定了模型参数如何更新以最小化损失。
所以梯度下降、动量法、随机梯度下降、RMSprop、Adam、AdamW、LAMB等算法都是优化算法。

2022年1月26日
分类于 security
需要 1 分钟阅读时间

Safe File Transport

use OpenSSL to encrypt file by RSA key

已有文件

未加密文件 secretfile.txt
接受方的公钥 recipients-key.pub

产生一次性加密解密对称密钥secret.key

256 bit (32 byte) random key

openssl rand -out secret.key 32

使用secret.key 加密所需文件

生成加密后文件secretfile.txt.enc

openssl aes-256-cbc -in secretfile.txt -out secretfile.txt.enc -pass file:secret.key

使用公钥recipients-key.pub加密secret.key

得到加密过的一次性key : secret.key.enc

openssl rsautl -encrypt -oaep -pubin -inkey <(ssh-keygen -e -f recipients-key.pub -m PKCS8) -in secret.key -out secret.key.enc

<()是子进程的意思。

 rm secret.key

use OpenSSL to descrypt file

已有文件

加密文件 secretfile.txt.enc和 secret.key.enc
接受方的私钥

解密secret.key.enc

 openssl rsautl -decrypt -oaep -inkey ~/.ssh/id_rsa -in secret.key.enc -out secret.key

解密secretfile.txt.enc

openssl aes-256-cbc -d -in secretfile.txt.enc -out secretfile.txt -pass file:secret.key

需要进一步的研究学习

使用 publickey.pem 可以看这篇 https://blog.csdn.net/makenothing/article/details/54645578
id_rsa.pub.pem产生可以看这个 https://www.czeskis.com/random/openssl-encrypt-file.html

参考文献

https://www.bjornjohansen.com/encrypt-file-using-ssh-key

https://blog.csdn.net/makenothing/article/details/54645578

2022年1月24日
分类于 Architecture
需要 2 分钟阅读时间

Nvidia Arch : Ampere & Hopper & Pascal

基本概念

GPU Processing Clusters (GPCs),

Texture Processing Clusters (TPCs),

Streaming Multiprocessors (SMs)

CUDA cores: basic integer/floating point arithmetic – high throughput, low latency
Load/Store (LD/ST): issues memory accesses to appropriate controller – possibly high latency
Special Function Unit (SFU): trigonometric math functions, etc – reduced throughput
special tensor cores (Since Turing and Volta): have specialized matrix arithmetic capabilities

H100

GH100

上面两张图组成一个SM，Special Function Units (SFUs)

RTX 3090

10496个流处理器，核心加速频率1.70GHz，384-bit 24GB GDDR6X显存。

GA102

在之前的GA100大核心中，每组SM是64个INT32单元、64个FP32单元及32个FP64单元组成的，但在GA102核心中，FP64单元大幅减少，增加了RT Core，Tensor Core也略微减少。

游戏卡与专业卡的区别

应用方面不同
1. 游戏卡会对三维图像处理有特殊处理，有光线追踪单元
2. 专业计算卡，可能对某些格式的解压压缩有特殊单元，或者对半精度计算有特殊支持。
做工不同
1. 专业卡由于在服务器上24小时不同工作，在多相供电，散热都堆料处理，游戏卡不同(公版，非公版肯定不一样)
驱动不同
1. 游戏卡对应游戏软件的优化驱动，专业卡有对专业软件的驱动支持
价格不同
1. 专业卡贵4倍不止。
参数的不同，对于同一颗核心（以RTX3090与A100 40G举例）
1. A100的GA100是8块完整的，GA102是7块。
2. A100领先的地方 1. 堆料完爆对手 2. 显存往往更多，AI应用 3. 访存更快 4. 支持 High bandwidth memory (HBM) 5. 在多精度和半精度有优势（NVIDIA A100 SXM4 40 GB VS.NVIDIA GeForce RTX 3090）
3. RTX3090领先的地方 1. 频率更高 2. 有视频输出接口，支持OpenGL，DirectX 3. 有RT core 光追

参考文献

https://zhuanlan.zhihu.com/p/394352476

2022年1月24日
分类于 Overview
需要 4 分钟阅读时间

Nvidia

Nvidia 的系列产品的基本参数

2022年1月8日
分类于 Tutorials
需要 6 分钟阅读时间

OpenMP

线程绑定

OpenMP 4.0 提供 OMP_PLACES 和 OMP_PROC_BIND 环境变量来指定程序中的 OpenMP 线程如何绑定到处理器。这两个环境变量通常结合使用。OMP_PLACES 用于指定线程将绑定到的计算机位置（硬件线程、核心或插槽）。OMP_PROC_BIND 用于指定绑定策略（线程关联性策略），这项策略指定如何将线程分配到位置。

除了 OMP_PLACES 和 OMP_PROC_BIND 这两个环境变量外，OpenMP 4.0 还提供可在 parallel 指令中使用的 proc_bind 子句。proc_bind 子句用于指定如何将执行并行区域的线程组绑定到处理器。

SlURM MPI OpenMP绑定方法参考清华的文档

OMP_NUM_THREADS=28 OMP_PROC_BIND=true OMP_PLACES=cores：每个线程绑定到一个 core，使用默认的分布（线程 n 绑定到 core n）；
OMP_NUM_THREADS=2 OMP_PROC_BIND=true OMP_PLACES=sockets：每个线程绑定到一个 socket；
OMP_NUM_THREADS=4 OMP_PROC_BIND=close OMP_PLACES=cores：每个线程绑定到一个 core，线程在 socket 上连续分布（分别绑定到 core 0,1,2,3；
OMP_NUM_THREADS=4 OMP_PROC_BIND=spread OMP_PLACES=cores：每个线程绑定到一个 core，线程在 socket 上尽量散开分布（分别绑定到 core 0,7,14,21；

lscpu结合htop观察
NUMA 节点0 CPU：                 0-15,32-47              
NUMA 节点1 CPU：                 16-31,48-63

编译制导格式

静态扩展 * 文本代码在一个编译制导语句之后，被封装到一个结构块中

孤立语句 * 一个OpenMP的编译制导语句不依赖于其它的语句

sections

sections编译制导语句指定内部的代码被划分给线程组中的各线程

不同的section由不同的线程执行

single

single编译制导语句指定内部代码只有线程组中的一个线程执行。

线程组中没有执行single语句的线程会一直等待代码块的结束，使用nowait子句除外

来自 https://ppc.cs.aalto.fi/ch3/nowait/

组合parallel for / parallel sections 编译制导语句

Parallel for编译制导语句表明一个并行域包含一个独立的for语句
parallel sections编译制导语句表明一个并行域包含单独的一个sections语句

同步结构

master 制导语句
指定代码段只有主线程执行
critical制导语句
critical制导语句表明域中的代码一次只能执行一个线程，其他线程被阻塞在临界区
语句格式：#pragma omp critical [name] newline
barrier制导语句
同步一个线程组中所有的线程,先到达的线程在此阻塞，等待其他线程
atomic制导语句
指定特定的存储单元将被原子更新
#pragma omp atomic x++;
flush制导语句
标识一个同步点，用以确保所有的线程看到一致的存储器视图
ordered制导语句
相对于critical，多了一个顺序
只能出现在for或者parallel for语句的动态范围中
threadprivate语句使一个全局文件作用域的变量在并行域内变成每个线程私有
每个线程对该变量复制一份私有拷贝

The fastest way is neither critical nor atomic. Approximately, addition with critical section is 200 times more expensive than simple addition, atomic addition is 25 times more expensive then simple addition.(maybe no so much expensive, the atomic operation will have a few cycle overhead (synchronizing a cache line) on the cost of roughly a cycle. A critical section incurs the cost of a lock.)

The fastest option (not always applicable) is to give each thread its own counter and make reduce operation when you need total sum.

critical vs ordered

omp critical is for mutual exclusion(互斥), omp ordered refers to a specific loop and ensures that the region executes sequentually in the order of loop iterations. Therefore omp ordered is stronger than omp critical, but also only makes sense within a loop.

omp ordered has some other clauses, such as simd to enforce the use of a single SIMD lane only. You can also specify dependencies manually with the depend clause.

Note: Both omp critical and omp ordered regions have an implicit memory flush at the entry and the exit.

ordered example

vector<int> v;

#pragma omp parallel for ordered schedule(dynamic, anyChunkSizeGreaterThan1)
    for (int i = 0; i < n; ++i){
            ...
            ...
            ...
#pragma omp ordered
            v.push_back(i);
    }

tid  List of     Timeline
     iterations
0    0,1,2       ==o==o==o
1    3,4,5       ==.......o==o==o
2    6,7,8       ==..............o==o==o

= shows that the thread is executing code in parallel. o is when the thread is executing the ordered region. . is the thread being idle, waiting for its turn to execute the ordered region.

With schedule(static,1) the following would happen:

tid  List of     Timeline
     iterations
0    0,3,6       ==o==o==o
1    1,4,7       ==.o==o==o
2    2,5,8       ==..o==o==o

语句绑定与语句嵌套规则

Clauses 子句

见 https://docs.microsoft.com/en-us/cpp/parallel/openmp/reference/openmp-clauses?view=msvc-160

#pragma omp parallel for collapse(2)
for( int y = y1; y < y2; y++ )
{
    for( int x = x1; x < x2; x++ )
    {

schedule

| | ----- | | | | | | | | | | | | | | | | | | | | -

name="__codelineno-17-1" href="#__codelineno-17-1">------------------------------------------------ static | static | dynamic | dynamic | guided | 1 | 5 | 1 | 5 | | ------------------------------------------- 0 | 0 | 0 | 2 | 1 | 1 | 0 | 3 | 2 | 1 | 2 | 0 | 3 | 2 | 1 | 3 | 0 | 3 | 2 | 1 | 0 | 0 | 2 | 2 | 1 | 1 | 1 | 2 | 3 | 3 | 2 | 1 | 2 | 3 | 3 | 3 | 1 | 0 | 3 | 3 | 0 | 1 | 0 | 3 | 3 | 1 | 1 | 0 | 3 | 2 | 2 | 2 | 1 | 0 | 2 | 3 | 2 | 1 | 0 | 2 | 0 | 2 | 1 | 0 | 3 | 1 | 2 | 2 | 0 | 3 | 2 | 2 | 2 | 0 | 0 | 3 | 3 | 2 | 1 | 0 | 0 | 3 | 3 | 1 | 1 | 1 | 3 | 3 | 1 | 1 | 2 | 3 | 3 | 1 | 1 | 3 | 3 | 0 | 1 | 3 | -----------------------------------------------

private vs firstprivate vs lastprivate

private variables are not initialised, i.e. they start with random values like any other local automatic variable

firstprivate initial the value as the before value.

lastprivate save the value to the after region. 这个last的意思不是实际最后运行的一个线程，而是调度发射队列的最后一个线程。从另一个角度上说，如果你保存的值来自随机一个线程，这也是没有意义的。 firstprivate and lastprivate are just special cases of private

#pragma omp parallel
{
   #pragma omp for lastprivate(i)
      for (i=0; i<n-1; i++)
         a[i] = b[i] + b[i+1];
}
a[i]=b[i];

private vs threadprivate

A private variable is local to a region and will most of the time be placed on the stack. The lifetime of the variable's privacy is the duration defined of the data scoping clause. Every thread (including the master thread) makes a private copy of the original variable (the new variable is no longer storage-associated with the original variable).

A threadprivate variable on the other hand will be most likely placed in the heap or in the thread local storage (that can be seen as a global memory local to a thread). A threadprivate variable persist across regions (depending on some restrictions). The master thread uses the original variable, all other threads make a private copy of the original variable (the master variable is still storage-associated with the original variable).

omp_get_thread_num() //获取线程的num，即ID。在并行区域外，获取的是master线程的ID，即为0。
omp_get_num_threads/omp_set_num_threads()  //设置/获取线程数量，用于覆盖OMP_NUM_THREADS环境变量的设置。omp_set_num_threads在串行区域调用才会有效，omp_get_num_threads获取当前线程组的线程数量，一般在并行区域调用，在串行区域调用返回为1。
omp_get_max_threads() //返回OpenMP当前环境下能创建线程的最大数量。

环境变量

OMP_SCHEDULE：只能用到for,parallel for中。它的值就是处理器中循环的次数
OMP_NUM_THREADS：定义执行中最大的线程数
OMP_DYNAMIC：通过设定变量值TRUE或FALSE,来确定是否动态设定并行域执行的线程数
OMP_NESTED：确定是否可以并行嵌套

例子

#include <omp.h>

int main(int argc, _TCHAR* argv[])  
{
    printf("ID: %d, Max threads: %d, Num threads: %d \n",omp_get_thread_num(), omp_get_max_threads(), omp_get_num_threads());
    omp_set_num_threads(5);
    printf("ID: %d, Max threads: %d, Num threads: %d \n",omp_get_thread_num(), omp_get_max_threads(), omp_get_num_threads());

#pragma omp parallel num_threads(5)
    {
        // omp_set_num_threads(6);  // Do not call it in parallel region
        printf("ID: %d, Max threads: %d, Num threads: %d \n",omp_get_thread_num(), omp_get_max_threads(), omp_get_num_threads());
    }

    printf("ID: %d, Max threads: %d, Num threads: %d \n",omp_get_thread_num(), omp_get_max_threads(), omp_get_num_threads());

    omp_set_num_threads(6);
    printf("ID: %d, Max threads: %d, Num threads: %d \n",omp_get_thread_num(), omp_get_max_threads(), omp_get_num_threads());

    return 0;  
}