Posts on Lishengxie

分布式ID生成方案全解析：从数据库到雪花算法

Thu, 25 Jun 2026 22:53:20 +0800

在分布式系统中，全局唯一ID是一个常见的需求。无论是分库分表后的主键冲突，还是订单号、用户ID等需要唯一标识的场景，都离不开一个可靠的分布式ID生成器。本文将带你了解分布式ID的基本要求，并梳理多种实现方案，从简单的数据库自增到高性能的雪花算法，最后介绍各大厂的开源组件。

一、什么是分布式ID？

分布式ID是指在分布式环境下生成的全局唯一标识符。典型应用场景包括：

分库分表：数据量增长导致单库单表出现性能瓶颈时，分库分表后无法继续依赖数据库自增ID（会产生主键冲突），此时需要分布式ID保证全局唯一。
业务标识：订单号、用户ID、消息ID等需要全局唯一的场景。

二、分布式ID的基本要求

一个合格的分布式ID生成器通常需要满足以下几点：

全局唯一：这是最基本的要求，ID必须在整个分布式系统中不重复。
独立部署、高性能、高可用：ID生成服务应独立部署，具备高并发下的低延迟响应能力（接近100%可用性），不能成为业务系统的瓶颈。
安全：ID中不应包含敏感信息，避免信息泄露。
趋势递增：尽可能保证ID趋势递增，这有利于数据库的索引插入和排序性能。

三、实现方案

1. 数据库方案

1.1 基于数据库自增ID

使用MySQL的自增主键来充当分布式ID。创建一张专门用于生成ID的表，每次插入一条记录后获取返回的主键ID。

CREATE DATABASE `SEQ_ID`;
CREATE TABLE SEQID.SEQUENCE_ID (
    id bigint(20) unsigned NOT NULL auto_increment, 
    value char(10) NOT NULL default '',
    PRIMARY KEY (id)
) ENGINE=MyISAM;

INSERT INTO SEQUENCE_ID(value) VALUES ('values');

优点：简单、天然有序。缺点：单点故障风险、并发性能差、数据库写入压力大，且ID可反推出订单数量等敏感信息。

1.2 基于数据库集群模式

为解决单点故障，可以采用多主模式，部署多个MySQL实例独立生成自增ID。通过设置不同的起始值和步长避免重复（以两个节点为例）：

-- MySQL实例1
set @@auto_increment_offset = 1;     -- 起始值
set @@auto_increment_increment = 2;  -- 步长

-- MySQL实例2
set @@auto_increment_offset = 2;     -- 起始值
set @@auto_increment_increment = 2;  -- 步长

优点：缓解单点并发压力。缺点：不利于动态扩容，新增节点时需处理起始值冲突，甚至可能停机调整。

1.3 基于数据库号段模式

号段模式的核心思想是批量获取自增ID：每次从数据库取出一个ID范围（如(1,1000]），然后在内存中递增分配，用完后再去数据库获取新的号段。

Let's Encrypt 免费申请 SSL 证书，并实现自动续期

Sun, 14 Sep 2025 21:58:04 +0800

背景

对于公网可以访问的网站，使用 HTTPS 协议是保证安全访问的基础要求，而 SSL 证书又是 HTTPS 协议不可或缺的一环。SSL 证书需要 CA 机构颁发，当前使用了阿里云的个人测试证书（免费证书），申请后上传到服务器并更新 nginx 配置。

当前存在的问题是，阿里云的免费 SSL 证书每三个月过期一次，需要手动重新申请并部署到服务器上，流程比较复杂。在网上看到可以使用 Let’s Encrypt 免费申请 SSL 证书，并实现自动续期，于是做了尝试，这里记录下相关流程。

环境准备

一台可以访问公网的服务器，我使用的是 Linux/Ubuntu。
root 权限或者 sudo 权限。
存在 DNS 解析的域名。

Let’s Encrypt 证书颁发

Let’s Encrypt 是一个免费的、自动化的、开放的证书颁发机构（CA），提供免费 SSL 证书。它的目标是让所有网站都能轻松实现 HTTPS 加密，保障用户数据的安全。通过 Let’s Encrypt 可以为网站的主域名、子域名，甚至泛域名配置安全证书，而且过程完全自动化，不需要手动申请和管理证书，官方推荐使用 Certbot。

Certbot 安装

Linux 平台上可以使用 snap 或 pip 安装 Certbot，这里使用 Python + pip 的方式，参考安装流程。

1、首先安装 Python 环境。

Redis ziplist、quicklist 和 listpack

Mon, 03 Mar 2025 22:44:38 +0800

ziplist

为什么需要 ziplist？

由于 Redis 是一个内存型数据库，因此在使用相应的数据结构时需要1）节省内存空间，2）提高操作效率。传统的包含指向相邻节点指针的双向链表中在内存使用和操作效率上存在一些问题：

存储指针需要额外的内存空间，且该空间在指定硬件平台上是固定的。当存储的数据长度较小时，指针占用空间甚至会超过数据占用空间。
传统双向链表中相邻节点在内存中并不连续，这虽然利用了碎片化的内存空间，但是由于增加了一次额外的指针索引，遍历效率低。

ziplist 是 Redis 中设计的一种内存紧凑型的数据结构，可以用来代替传统的双向链表结构。ziplist 使用一块连续的内存空间，通过在每个节点中存储当前及前一个节点的长度来实现双向遍历，节省内存空间，操作效率高。

ziplist 是什么？

下面给出了压缩列表的结构示意图，包括 10byte 的表头元数据，若干个列表节点以及最后的 1byte 的结束标识符。

| zlbytes | zltail | zllen | entry1 | entry2 | ... | entryN | zlend |

# 各部分说明
zlbytes: 整个压缩列表占用的字节数，uint32_t(4byte)
zltail: 压缩列表表尾节点距离压缩列表的起始地址有多少字节，uint32_t(4byte)
zllen: 压缩列表包含的节点数，uint16_t(2byte)，当该属性值为 UINT16_MAX 时，真实节点数量需要遍历整个压缩列表才能得到
entry: 压缩列表节点
zlend: 用于标记压缩列表末端的特殊值(0xFF)，1byte

每个压缩列表的节点中存储的内容可以看作一个字节数组或者整数值，每个节点包含以下三部分内容：

| previous_entry_length | encoding | content |

# 各部分说明
previous_entry_length: 记录前一个节点的长度，长度为 1byte 或 5byte
    - 前一个节点长度小于 254 字节时，previous_entry_length 长度为 1 字节，记录前一个节点的长度
    - 前一个节点长度大于等于 254 字节时，previous_entry_length 长度为 5 字节，其中第一个字节设置为 0xFE，后面的四个字节用于记录前一个节点长度
encoding: 记录节点的 content 中所保存数据的类型和长度
    - 一字节(00开头)、两字节(01开头)或五字节(10开头)的表示字节数组编码，去除最高两位之后的其他位是字节数组长度
    - 一字节长(11开头)的表示整数编码，去除最高两位后的其他位可以用于标识整数的类型和位宽
content: 节点值，可以是一个字节数组或者整数值，由 encoding 属性决定

ziplist 有什么问题？

前面提到 ziplist 通过使用连续的内存块和精心设计的编码格式来保存列表数据，并实现双向检索的功能。但是，使用 ziplist 仍然存在一些缺点：

Nginx禁止使用IP直接访问服务器上相应端口

Sat, 11 May 2024 21:48:52 +0800

起因

我的服务器中部署了一个typecho博客和两个使用docker容器的服务，其中docker容器使用端口映射，将容器中的端口映射到宿主机上的端口实现访问。

一次偶然机会发现服务器上的服务可以通过IP+端口的方式直接访问，如果有未备案的域名解析到我们服务器的IP，可能会导致云服务器厂商关停我们的服务造成一些问题。因此，我们需要禁止通过IP+端口直接访问服务。

Nginx 配置

这里的三个服务通过nginx进行转发，对不同server_name的请求会直接转发到对应的服务进程。因此，这里有限考虑使用nginx配置来禁止IP+端口的访问。服务器上主要开放了两个端口，80和443，分别用于HTTP和HTTPS请求，在实际进行相应配置时二者也有所不同。

80 端口

对于80端口，我们在nginx.conf中添加如下配置。具体原理在于，当根据listen无法得到最佳匹配时，nginx会使用请求中的Host值匹配server_name，匹配顺序可以参考这篇博客。IP+端口进行请求时匹配到下面的server配置，直接返回403错误信息。

server {
    listen 80 default_server;
    server_name  _;    
    return 403;
}

443端口

由于使用了HTTPS协议，因此还需要禁止通过IP+443端口的访问方式。具体参考了下面的博客：

https://www.huixiangdou.cn/archives/nginx-jin-zhi-80-443-duan-kou

具体来说，Nginx 上对于 SSL 服务器在不配置证书的时候会出现协议错误，哪怕端口上配置了其他网站也会报错。因此，我们需要随便生成一个证书进行配置，生成 SSL 证书可以使用这个网站https://myssl.com/create_test_cert.html。在nginx.conf中添加如下配置：

server {
    listen 80 default;
    listen 443 default_server;
    #SSL-START SSL相关配置，请勿删除或修改下一行带注释的404规则
    #error_page 404/404.html;
    ssl_certificate /path/to/cert.pem;
    ssl_certificate_key /path/to/private.key;
    ssl_protocols TLSv1 TLSv1.1 TLSv1.2;
    ssl_ciphers ECDHE-RSA-AES128-GCM-SHA256:ECDHE:ECDH:AES:HIGH:!NULL:!aNULL:!MD5:!ADH:!RC4:!DH:!DHE;
    ssl_prefer_server_ciphers on;
    ssl_session_cache shared:SSL:10m;
    ssl_session_timeout 10m;
    error_page 497  https://$host$request_uri;
    #SSL-END
    server_name _;
    return 403;
}

配置完成后重载 Nginx 配置。

$ nginx -t
$ nginx -s reload

Docker容器问题

Docker容器通过端口映射实现服务的对外可用性，这里是通过-p host_port:container_port实现容器上的端口到宿主机上端口的映射。具体来说，以容器的80端口映射到宿主机的8080端口为例，docker容器运行时使用了-p 8080:80，Nginx中监听了80端口，并在对应域名访问时将请求转发到服务器的8080端口。

location / {
    proxy_pass http://host_ip:8080;
}

但是，在根据上面的配置禁止了直接使用IP+80/443端口访问的方式后，发现host_ip:8080仍然能够访问到docker容器中的服务。查询相关资料修改了iptables路由表和sfw防火墙规则后，仍然无法解决问题。防火墙上没有打开端口，但仍然可以访问。最后通过查找资料发现是docker自身的原因，下面是docker官方的介绍：

LeetCode刷题 - KMP算法

Sun, 04 Feb 2024 18:48:10 +0800

KMP算法是一种高效的字符串匹配算法，但是之前每次学过之后都会忘记，这次做一下总结加深印象，主要参考了以下链接。

https://programmercarl.com/0028.%E5%AE%9E%E7%8E%B0strStr.html

问题

给定一个字符串 $s$ (长度为N)和一个模式串 $t$ (长度为M)，如果 $s$ 中存在 $t$ ，那么返回模式串第一次出现的起始索引；如果不存在返回-1。对应Leetcode 28. 找出字符串中第一个匹配项的下标

KMP算法

KMP算法是由D.E.Knuth，J.H.Morris和V.R.Pratt同时发现的一种快速的字符串匹配算法，时间复杂度为 $O(M+N)$ 。KMP算法的核心思想是在字符串匹配失败时利用之前已经匹配的信息来做快速回退，避免从头再做匹配。KMP算法的核心函数是一个用于求解next数组的函数，next数组包含了模式串局部匹配的信息。

这里代码随想录中给出了关于next数组的详细解释。next数组对应自定义的前缀表，其中前缀表是一个和模式串长度相同的数组，前缀表第i个位置的值为[0,i]子字符串的最长相同前后缀的长度；

前缀是指不包含最后一个字符的所有以第一个字符开头的连续子串。后缀是指不包含第一个字符的所有以最后一个字符结尾的连续子串；
举例来说，“aab”的前缀有“a”和“aa”、后缀有“b”和“ab”，“aabaa”的最长相同前后缀长度为2，“aa”的最长相同前后缀长度为1。

以下图为例，假设文本串和模式串分别为aabaabaafa和aabaaf，前缀表如图中所示。那么在b和f不匹配时，此时寻找前缀表中前一位存储的值，查找得到值为2，该值的含义是“aabaa”的最长相同前后缀长度为2，即“aa”。此时我们可以不用从头开始重新匹配，文本串中的匹配指针可以不移动，将模式串中的匹配指针回退到索引2处重新开始匹配即可。

这里为什么可以不回退文本串的匹配指针？

因为这里通过回退j指针，找到了从文本串中该位置向前的最长相同前后缀，获得了类似下图的效果。

实际使用中常通过将前缀表统一减1得到next数组，那么如何计算next数组？

next数组的计算类似于移动模式串，在模式串和模式串之间做匹配，在移动的过程中计算next数组的值，next数组的计算代码如下所示：

void getNext(int* next, const string& s){
    int j = -1;
    next[0] = j;
    for(int i = 1; i < s.size(); i++) { // 注意i从1开始
        while (j >= 0 && s[i] != s[j + 1]) { // 前后缀不相同了
            j = next[j]; // 向前回退
        }
        if (s[i] == s[j + 1]) { // 找到相同的前后缀
            j++;
        }
        next[i] = j; // 将j（前缀的长度）赋给next[i]
    }
}

基于next数组进行文本串和模式串的匹配代码如下：

void match(string s, string t) {
    int j = -1;
    int next[t.size()];
    getNext(next, t);

    for (int i = 0; i < s.size(); i++) {
        while (j >= 0 && s[i] != t[j+1]) {
            j = next[j];
        }
        if (s[i] == s[j+1]) {
            j++;
        }
        if (j == (t.size() - 1)) {
          return i - t.size() + 1;
        }
    }
    return -1;
}

Transfer Server

Sat, 23 Dec 2023 23:17:56 +0800

站点迁移

之前使用的是云服务器是腾讯与的2核4G服务器，但是由于最开始购买时只买了一年，续费时价格太贵，因此转到阿里云，可以有四年每年99元的2核2G服务器可以白嫖~

迁移过程大概分为两步：站点数据迁移和站点备案迁移

数据迁移

博客迁移wordpress->typecho

原来的博客使用wordpress框架，但是wordpress框架功能齐全、有些臃肿，因此这里换成了更精简的typecho框架。

typecho安装参考了知乎博客https://zhuanlan.zhihu.com/p/34211709；
导出wordpress数据库并在新服务器中导入

mysql导入导出命令参考: https://www.runoob.com/w3cnote/linux-mysql-import-export-data.html；
先将原服务器上的wordpress数据库导出为*.sql文件，再导入到新服务器中；
这一步是为了方便下一步转换到typecho，因为这样可以直接访问本地数据库。

数据迁移到typecho 基于typecho插件：https://docs.typecho.org/plugins/wordpress-to-typecho
还原wordpress中的图片附件到typecho中

将WordPress的wp-content/uploads目录下的附件全部移动到Typecho的usr/uploads目录下，保持目录结构不变。
在mysql typecho对应数据库中执行以下代码以完成图片路径的替换：

 update typecho_contents set text=replace(text,'wp-content/uploads','usr/uploads')
 update typecho_contents set text=replace(text,'wordpree站点url','typecho站点url')

typecho使用数学公式使用插件：https://github.com/yuzhongzhibi/typecho_mathjax_plugin
typecho主题页面更改参考链接：https://www.skyqian.com/archives/typecho-pages.html

docker容器迁移

做法是现在新服务器上安装docker，然后迁移旧服务器上的docker挂载文件夹到新服务器相同位置，最后在新服务器启动容器。参考链接：https://zhuanlan.zhihu.com/p/643367054 这里我主要使用了两个容器用于存储电子书和笔记

Talebook：https://github.com/talebook/talebook
leanote: https://www.bilibili.com/read/cv23693842/

站点备案迁移

为了方便使用，计划将域名和服务器都转移到阿里云。因为服务器需要在所在服务商处备案，因此还需要再阿里云备案，主要参考了这篇博客：https://www.zuozuovera.com/posts/1644/。

算法学习-差分数组

Sat, 23 Dec 2023 23:05:16 +0800

差分数组

参考教程：https://wansuanfa.com/index.php/589
leetcode题目：1109. 航班预订统计

问题描述

给定一个数组，需要频繁地对某个区间内的元素做加减操作，并获取最后的操作结果。常规做法是每次都遍历整个区间然后修改区间内的元素，但是元素的访问需要时间、频繁访问元素会减慢程序的运行时间。因此，可以使用差分数组来进行优化。

一维差分数组定义

一维差分数组 $d[n]$ 定义为原始数组 $nums$ 相邻元素之间的差，即 $d[i]=nums[i]-nums[i-1]$ ，其中 $d[0]=nums[0]$ 。这样原数组就是差分数组的前缀和

nums[i] = \sum_{k=0}^i d[k].

由此，我们可以改进原来的区间操作，如对区间 $[a,b]$ 内每个元素加3，那么只需要在区间的两端进行操作即可，即

d[a] += 3, d[b+1] -= 3

证明

假设 $nums1$ 是修改后的数组， $d1$ 是修改后的差分数组，其中 $d1[a]=d[a]+3, d1[b+1]=d[b+1]-3$ .

hugo里面换行公式需要\\\\四个反斜杠

对于 $0\leq i \lt a$ , $nums1[i] = \sum_{k=0}^i d1[k] = \sum_{k=0}^i d[k] = nums[i]$ .
对于 $a\leq i \leq b$ , $\begin{aligned} nums1[i] & = \sum_{k=0}^i d1[k] \\\\ & = \sum_{k=0}^{a-1}d[k] + \sum_{k=a+1}^{b}d[k] + d[a] + 3 \\\\ & = \sum_{k=0}^i d[k] + 3 \\\\ & = nums[i]+3 \end{aligned}$
对于 $i \gt b$ , $\begin{align} nums1[i] &= \sum_{k=0}^i d1[k]\\\\ &= \sum_{k=0}^{a-1}d[k] + \sum_{k=a+1}^{b}d[k] + \sum_{k=b+1}^{i}d[k] + d[a] + 3 + d[b] - 3\\\\ &= \sum_{k=0}^i d[k] + 3 - 3\\\\ &= nums[i]. \end{align}$ 由此，可以证明只修改差分数组的两端即可以修改原数组的整个区间。

代码

class Solution {
public:
    vector<int> diff;
    vector<int> nums;

    void diffNums() {
        diff[0] = nums[0];
        for(int i = 1; i < nums.size(); ++i) {
            diff[i] = nums[i] - nums[i-1];
        }
    }

    void increment(int a, int b, int val) {
        diff[a] += val;
        if (b + 1 < diff.size())
            diff[b + 1] -= val;
    }

    void result() {
        nums[0] = diff[0];
        for (int i = 1; i < diff.size(); i++)
            nums[i] = diff[i] + nums[i - 1];
    }

    vector<int> corpFlightBookings(vector<vector<int>>& bookings, int n) {
        nums.resize(n, 0);
        diff.resize(n, 0);
        diffNums();
        for (int i = 0; i < bookings.size(); ++i) {
            increment(bookings[i][0]-1, bookings[i][1]-1, bookings[i][2]);
        }
        result();
        return nums;
    }
};

拓展 - 二维差分数组

二维差分数组可以在一维差分数组的基础上进行拓展，视为一个平面，定义如下

LeetCode刷题-二叉树遍历迭代法

Tue, 17 Oct 2023 20:15:23 +0800

LeetCode题目链接

二叉树的前序遍历：https://leetcode.cn/problems/binary-tree-preorder-traversal/ 二叉树的中序遍历：https://leetcode.cn/problems/binary-tree-inorder-traversal/ 二叉树的后序遍历：https://leetcode.cn/problems/binary-tree-postorder-traversal/

二叉树的遍历方法有两种，分别是递归法和迭代法；实际使用中由于系统调用栈有限制，使用递归法可能会导致栈溢出，这里记录三种遍历的迭代做法。最后，介绍二叉树层序遍历的两种方法。

迭代遍历法借助辅助栈实现，下面是二叉树节点的定义，使用链表实现。

 struct TreeNode {
     int val;
     TreeNode *left;
     TreeNode *right;
     TreeNode() : val(0), left(nullptr), right(nullptr) {}
     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 };

前序遍历

前序遍历的顺序是中左右，每次先处理中间节点，那么先将根节点入栈，然后将右孩子入栈，再将左孩子入栈。先右后左的原因是因为入栈顺序和处理顺序是相反的。前序遍历的处理代码如下：

class Solution {
public:
    vector<int> preorderTraversal(TreeNode* root) {
        vector<int> res;
        stack<TreeNode*> st;
        if (root == NULL) {
            return res;
        }

        st.push(root);
        while (!st.empty()) {
            TreeNode *cur = st.top();
            st.pop();
            res.push_back(cur->val);
            if (cur->right) st.push(cur->right);
            if (cur->left) st.push(cur->left);
        }

        return res;
    }
};

中序遍历

中序遍历处理顺序为左中右，先访问二叉树顶部的节点，随后逐层向下访问直到树最左侧的节点，再开始处理节点，这导致处理节点的顺序和访问节点的顺序不一致。中序遍历的迭代法如下所示：

LeetCode刷题 - 滑动窗口最大值

Tue, 17 Oct 2023 20:11:52 +0800

LeetCode刷题 - 滑动窗口最大值

参考链接:https://programmercarl.com/0239.%E6%BB%91%E5%8A%A8%E7%AA%97%E5%8F%A3%E6%9C%80%E5%A4%A7%E5%80%BC.html

leetcode题目链接：https://leetcode.cn/problems/sliding-window-maximum/

给你一个整数数组 nums，有一个大小为 k 的滑动窗口从数组的最左侧移动到数组的最右侧。你只可以看到在滑动窗口内的 k 个数字。滑动窗口每次只向右移动一位。

返回滑动窗口中的最大值。

示例 1：

输入：nums = [1,3,-1,-3,5,3,6,7], k = 3 输出：[3,3,5,5,6,7] 解释：滑动窗口的位置最大值

[1 3 -1] -3 5 3 6 7 3 1 [3 -1 -3] 5 3 6 7 3 1 3 [-1 -3 5] 3 6 7 5 1 3 -1 [-3 5 3] 6 7 5 1 3 -1 -3 [5 3 6] 7 6 1 3 -1 -3 5 [3 6 7] 7

LJson

Wed, 16 Aug 2023 10:42:01 +0800

LJSon

A C++ library for json parse/creation/update
package地址：https://github.com/lishengxie/LJson

开发原因

最近在复习C++相关的知识，想要通过一个项目来巩固C++和算法的一些相关知识，但是网上推荐的相关C++项目大多比较复杂，很难下手。刚好最近实验室项目中频繁使用json文件，想到是否可以使用C++来实现一个json的解析库，在github上搜索后看到了一些现有的json仓库，初步了解后开始进行实现。

参考仓库

https://github.com/510850111/cJSON/tree/master，在这个项目中学习了json对象的表示以及如何操作json对象；
https://github.com/ACking-you/MyUtil/tree/master/json-parser，在这个项目中学习了如何从json字符串中解析数据，服用了部分解析json字符串的代码；
https://github.com/nlohmann/json，著名的json处理库，从中学习了如何使用初始化列表来实现类Python的方式创建和更新json对象。

json文件格式

这里只做简单介绍，具体的格式可以参考json官网http://www.json.org。

json主要基于两种结构，分别是“键值对集合”和“值的有序列表”，前者可以看做字典或哈希表，后者可以看做数组。

对象是无序的键值对集合，一个对象被包含在{}中，每个键值对的格式为key:value，其中key是字符串，value可以是字符串、布尔类型(true/false)、null、数值(整数或浮点数)、对象、数组；键值对之间使用,分隔，对象应该使用key索引对应的值；
数组是值的有序集合，包含在[]中，值可以是前面提到的字符串、布尔类型(true/false)、null、数值(整数或浮点数)、对象、数组，值之间使用,分隔；

通过使用对象、数组以及支持两者之间的嵌套，json可以支持复杂的数据格式定义和传递。

使用数据结构表示json对象

前面提到了json文件的格式，一种很自然的表示json对象的方式应该是使用字典表示对象，字典的值本身也可以是一个json对象，有一些json解析库中使用了这种方式，可以参考Python中json库对json文件的读写。我们使用了另外一种方式，即使用树形结构来表示整个json对象，如下图所示：对应的C++定义如下，对象中的每个键值对以及数组中的每个值都使用一个JsonObject对象来表示，整个对象/数组的键值对/值使用双向链表进行表示，遍历整个双向链表即可以遍历整个json对象或数组。

enum JsonType {
    T_FALSE=0, T_TRUE, T_NULL, T_INT, T_FLOAT, T_STRING, T_ARRAY, T_OBJECT
};

class JsonObject {
    /* next和prev分别指向前一个对象和后一个对象 */
    JsonObject *next, *prev;
    /* Object和Array类型对象需要设置child指针 */
    JsonObject *child;
    /* Object的类型 */
    JsonType type;
    /* String对象的值 */
    char *valueString;
    /* 整数对象的值 */
    int valueInt;
    /* 浮点数的值 */
    double valueDouble;
    /* 键值对的键 */
    char *key;
}

以上图为例，假设有如下的json对象

内网离线服务器使用

Sat, 03 Jun 2023 20:34:46 +0800

最近在跑实验时，自己的电脑出现内存不够用的问题，想到在实验室的一台闲置的服务器上运行程序。但是该服务器只能通过内网连接，无法使用外网，因此这里记录了内网离线服务器使用的一些经历。可以考虑在服务器上安装docker，然后在自己电脑上配好环境后导出docker镜像到服务器上运行。这里没有使用docker环境，本地环境是WSL2-Ubuntu20.04。

程序运行环境配置

C++

针对C++程序，重新下载代码编译；

Python

重新配置Python环境主要经历了以下步骤：

下载miniconda安装程序并安装；
WSL2环境迁移到服务器中，这里选择直接打包WSL2下面的虚拟环境目录并到服务器相应目录下解压，参考了教程https://blog.csdn.net/qq_45893319/article/details/122226053;
直接打包的环境，无法使用pip的问题，可以通过修改pip文件解决，参考教程https://blog.csdn.net/qq_40933913/article/details/127907916
环境迁移后发现在迁移的环境中无法使用clear命令，原因是迁移过来的环境中clear文件有问题。解决方案如下：

在出错的环境下，输入which clear，然后将clear地址重命名，下次再clear时会生成新的。
```
mv /home/xxx/.conda/envs/yolox/bin/clear /home/xxx/.conda/envs/yolox/bin/clear_old
```

vscode连接服务器开发

参考教程https://blog.csdn.net/ffriend/article/details/126680223。由于服务器离线，使用vscode连接时无法在远程服务器上下载vscode-server，这里需要手动下载一下。步骤如下

查看本地vscode的commit id：帮助-关于，复制commit id
本地下载vscode-server

wget https://update.code.visualstudio.com/commit:${commit_id}/server-linux-x64/stable
# 注意把:${commit_id}替换成对应的Commit ID

复制到服务器并安装

rm ~/.vscode-server/bin/* -rf  #把$HOME/.vscode-server/bin下的内容删干净，防止出错
cd ~/.vscode-server/bin
tar -zxf vscode-server-linux-x64.tar.gz
mv vscode-server-linux-x64 ${commit_id} # 注意把:${commit_id}替换成对应的Commit ID

服务器安装screen应用

参考教程https://blog.csdn.net/Demo_Null/article/details/110873673，主要是编译安装screen和ncurses两个可执行程序，这里需要管理员权限，负责无法安装到默认的安装位置。

screen常用命令如下

1、启动共享窗口：screen -S 名称 2、查看当前所有共享会话：screen -ls 3、进入共享会话：screen -r 名称 4、退出共享会话：ctrl +a +d

建站过程

Sun, 30 Apr 2023 08:55:32 +0800

购买腾讯云服务器

购买腾讯云清量2核4G服务器直达链接

启动镜像

这里选择了Ubuntu server 20.04，启动镜像后设置远程登录(远程登录->密码/密钥登录->重置密码)，需要注意这里的用户需要系统中已经存在，默认已经存在一个用户ubuntu，这里我们直接使用该用户。配置好后可以本地使用Mobaxterm登录云服务器，将云服务器当作Ubuntu虚拟机使用。

搭建wordpress网站

网站搭建参考了博客https://blog.csdn.net/weixin_36338224/article/details/109105047。

主题替换

下载Kratos主题并上传替换原有主题，在外观里设置。

Markdown&Latex公式使用

安装WP Editor.md插件，在wordpress中使用markdown编辑。安装Simple MathJax插件，实现对latex公示的支持，需要注意的是这里行内公式使用\$...\$，例如$\sigma$，行间公式使用$$..$$，例如

\sigma

。

Windows常见问题记录

Sun, 30 Apr 2023 08:54:20 +0800

触摸板无法使用

在设置中选择“插入鼠标后禁用触摸板”选项后，将鼠标拔出后触摸板仍然无法使用，出现这种问题后

关闭“插入鼠标后禁用触摸板”选项，插入鼠标观察触摸板是否可以使用，如果不能使用那么触摸板可能损坏，需要进一步排查；如果可以使用，那么可能是因为设备管理器中出现了虚拟鼠标；
如果是第一步的第二种情况，需要在设备管理器中禁用第一个鼠标选项，如下图所示：

SystemC学习

Sun, 30 Apr 2023 08:52:48 +0800

视频教程

教程链接

创建模块

#include <systemc.h>

// SC_MODULE声明模块，and2对应模块名
SC_MODULE(and2){
	// sc_in声明输入端口，DT对应端口变量数据类型
	sc_in<DT> a;
	sc_in<DT> b;
	// 声明时钟信号
	sc_in<bool> clk;
	// sc_out声明输出端口
	sc_out<DT> f;

	void func() {
		// 输入端口读数据.read()
		// 输出端口写数据.write()
		f.write(a.read() & b.read());
	}
	
	// 模块构造函数
	SC_CTOR(and2){
		// 声明线程
		SC_METHOD(func);
		// 线程声明后紧接着声明敏感信号列表，以 << 号隔开
		// 声明a和b为敏感信号
		sensitive << a << b;
		// 声明clk的上升沿为敏感信号，下降沿为.neg()
		// sensitive << clk.pos();
	}
}

Threads

A function made to act like a hardware process

云服务器软件安装

Sun, 30 Apr 2023 08:51:16 +0800

Docker安装(Ubuntu 20.04)：参考知乎博客

更新软件包索引，并且安装必要的依赖软件

sudo apt update
sudo apt install apt-transport-https ca-certificates curl gnupg-agent software-properties-common

使用下面的 curl 导入源仓库的 GPG key：

curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add -

将 Docker APT 软件源添加到你的系统：

sudo add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable"

安装Docker a. 安装最新版本的Docker

sudo apt update
sudo apt install docker-ce docker-ce-cli containerd.io

b. 安装指定版本的docker

# 列出所有可用的docker版本
sudo apt update
apt list -a docker-ce
# 安装docker
sudo apt install docker-ce=<VERSION> docker-ce-cli=<VERSION> containerd.io

验证安装成功

sudo systemctl status docker
docker container run hello-world

Golang安装：参考腾讯云博客

常用资源汇总

Sun, 30 Apr 2023 08:49:48 +0800

python

pip国内镜像

# 清华镜像源
https://pypi.tuna.tsinghua.edu.cn/simple
# 豆瓣镜像源
http://pypi.douban.com/simple/
# 阿里云镜像源
http://mirrors.aliyun.com/pypi/simple/
# 中国科学技术大学镜像源
http://pypi.mirrors.ustc.edu.cn/simple/

使用方法为pip install package_name -i 镜像源

Ubuntu更换镜像源

如果Ubuntu原始速度还可以的话建议不要换源，常用的有阿里云镜像、清华镜像和搜狐镜像，这里是我使用的镜像，北京外国语大学镜像。

deb https://mirrors.bfsu.edu.cn/ubuntu/ focal main restricted universe multiverse
# deb-src https://mirrors.bfsu.edu.cn/ubuntu/ focal main restricted universe multiverse
deb https://mirrors.bfsu.edu.cn/ubuntu/ focal-updates main restricted universe multiverse
# deb-src https://mirrors.bfsu.edu.cn/ubuntu/ focal-updates main restricted universe multiverse
deb https://mirrors.bfsu.edu.cn/ubuntu/ focal-backports main restricted universe multiverse
# deb-src https://mirrors.bfsu.edu.cn/ubuntu/ focal-backports main restricted universe multiverse
deb https://mirrors.bfsu.edu.cn/ubuntu/ focal-security main restricted universe multiverse
# deb-src https://mirrors.bfsu.edu.cn/ubuntu/ focal-security main restricted universe multiverse

# 预发布软件源，不建议启用
# deb https://mirrors.bfsu.edu.cn/ubuntu/ focal-proposed main restricted universe multiverse
# deb-src https://mirrors.bfsu.edu.cn/ubuntu/ focal-proposed main restricted universe multiverse

Ubuntu换源的具体操作为

Linux常用命令记录

Sun, 30 Apr 2023 08:47:32 +0800

Vim

vim删除文件中的所有内容： ESC确保退出编辑模式，按下":“切换到命令模式然后输入%d并执行 vim删除单行内容：将光标移动到需要删除的行，ESC确保退出编辑模式，按两次d键。 vim删除多行内容：将光标移动到需要删除的第一行，ESC确保退出编辑模式。在dd命令前面加上要删除的行数。例如，如果要删除第4行以下的3行，请先移动至第四行，再按下3dd。 vim撤销&恢复：u是撤销刚才做的动作，ctrl+r 是恢复刚才撤销的动作。

文件操作

参考博客https://www.cnblogs.com/liaojie970/p/6746230.html

文件复制

命令格式：cp [-adfilprsu] 源文件(source) 目标文件(destination)
cp [option] source1 source2 source3 ... directory

参数说明：

-a:是指archive的意思，也说是指复制所有的目录
-d:若源文件为连接文件(link file)，则复制连接文件属性而非文件本身
-f:强制(force)，若有重复或其它疑问时，不会询问用户，而强制复制
-i:若目标文件(destination)已存在，在覆盖时会先询问是否真的操作
-l:建立硬连接(hard link)的连接文件，而非复制文件本身
-p:与文件的属性一起复制，而非使用默认属性
-r:递归复制，用于目录的复制操作
-s:复制成符号连接文件(symbolic link)，即“快捷方式”文件
-u:若目标文件比源文件旧，更新目标文件

如将/test1目录下的file1复制到/test3目录，并将文件名改为file2,可输入以下命令：

cp /test1/file1 /test3/file2

文件移动

命令格式：mv [-fiv] source destination

参数说明:

-f:force，强制直接移动而不询问
-i:若目标文件(destination)已经存在，就会询问是否覆盖
-u:若目标文件已经存在，且源文件比较新，才会更新

如将/test1目录下的file1移动到/test3 目录，并将文件名改为file2,可输入以下命令：

mv /test1/file1 /test3/file2

文件删除

命令格式：rm [fir] 文件或目录

参数说明：

-f:强制删除
-i:交互模式，在删除前询问用户是否操作
-r:递归删除，常用在目录的删除

如删除/test目录下的file1文件，可以输入以下命令：

rm -i /test/file1

Windows 常用命令

PowerShell创建新文件夹和新文件

mkdir 文件夹名称
new-item 文件名称.文件格式 -type file

多目标优化问题及两种常用解法

Sun, 30 Apr 2023 08:45:39 +0800

多目标优化问题

多目标优化（也称为多目标规划、向量优化、多标准优化、多属性优化或帕累托优化）是多标准决策制定的一个领域，涉及同时优化多个目标函数的数学优化问题，需要在权衡取舍的情况下在两个或多个相互冲突的目标之间做出最佳决策。(维基百科)

多目标优化问题中目标函数之间通常相互冲突，求解多目标优化问题通常希望找到可以很好地平衡不同优化目标的解，即帕累托最优解。

多目标优化问题的数学描述

\min_{x\in X} (f_1(x),f_2(x),\dots,f_k(x))

其中$k\geq 2$，$(f_1(x),f_2(x),\dots,f_k(x))$式决策函数集合。

帕累托最优

帕累托最优是指这样一种情况，没有可用的行动或分配可以使一个人过得更好而不会使另一个人过得更糟。多目标优化问题中我们希望找到的就是帕累托最优解，再由决策者决定具体使用那个解。帕累托最优解集指的是所有可行解中的不可支配解集，下面我们将介绍支配和不可支配解集的概念。

支配和不可支配解集

当解$x_1$和$x_2$满足以下两个条件时

对于所有的目标函数，$f_i(x_1)\leq f_i(x_2)$，其中$1\leq i \leq k$
至少由一个目标函数$f_i(x)$满足$f_i(x_1) < f_i(x_2)$，其中$1\leq i \leq k$ 我们称$x_1$支配$x_2$，如上图中$A$和$B$都支配$C$，但彼此之间不存在支配关系。

当一个解集中任何一个解都不能被该集合中其他解支配，那么就称该解集为不可支配解集。一组帕累托最优结果，如上图中红色的边界，称为帕累托前沿或帕累托边界。

求解多目标优化问题的方法主要分为两类，一种是将多目标优化问题转换成单目标优化问题，常用的方法是对目标函数值加权求和或保留一个目标函数、其余的目标函数被转化为限定条件。但是由于实际应用中目标函数的函数值范围不好确定，因此转换成单目标优化算法的效果常常不好。实际应用更加广泛的是另一种采用多目标的优化算法。

多目标粒子群算法MOPSO

多目标粒子群算法最早由Coello等人提出^[1]，算法的大致处理步骤如下所示：

和粒子群算法不同的是，这里添加了支配关系判断的步骤，同时选择全局最优解以及更新个体最优的步骤和粒子群算法也有所不同。此外，MOPSO还额外维护了精英解和解空间的网格，下面我们将分别加以介绍。

首先是支配关系的判断，根据第一部分中对于帕累托前沿和支配关系的介绍，我们知道多目标优化问题中解的优劣由支配关系来加以判断。

每次迭代开始时，我们需要从精英解集合中选择当前的全局最优解，精英解中包含的是不被其他解支配的解的集合，换言之，精英解包含的是目前获取到的帕累托前沿。选择全局最优解的步骤如下：

在解集空间中绘制网格，即根据当前的解集中不同目标函数的最大值和最小值，将空间均匀等分并给每个子空间添加索引，确定不同的解所对应的子空间。
对于包含解的子空间，判断每个子空间中存在的解个数$N_1,\cdots,N_k$，使用轮盘赌算法获取当前的全局最优解，轮盘赌的概率和解的个数呈反相关关系（让解稀疏的子空间拥有更大的被选中的概率，设法让解在帕累托前沿上分布更均匀）。

选择好当前的全局最优解后更新粒子的位置和速度，更新公式和粒子群算法一致。

v_i = w \times v_i + c_1\times rand() \times ((p_{best})_i-x_i) + c_2\times rand()\times (g_{best}-x_i)

粒子更新后会根据粒子当前解和局部最优解之间的支配关系更新粒子的局部最优解。在更新局部最优解之前，还可以采取类似于遗传算法的步骤，以一定的概率对粒子的当前解进行变异。

更新完局部最优解之后更新精英解集合，保留当前不被其他解支配的解，同时为了避免精英解过大，可以设置一个阈值来控制精英解集合中的解数目，多余的精英解被随机抛弃。

多目标遗传算法NSGA-II

多目标遗传算法NSGA-II由Deb等人提出^[2]，算法的大致处理步骤如下所示：相较于单目标进化算法添加了快速非支配排序和父代、子代合并操作增加种群多样性，此外从$rank_i$ 中取出一部分个体有两种方式、一种是拥挤距离排序、另一种是随机选择。下面我们将分别加以介绍。

对于当前已有的父代解和子代集合，融合两个集合产生当前的解集合，首先执行非支配排序，非支配排序的大致步骤为，先找出解集中的非支配边沿，将这部分的解的$rank$置为1；去掉这部分解，继续找出剩下的解集中的非支配边沿，将这部分的解的$rank$置为2，重复上述步骤知道遍历完所有的解。实际实现中需要记录每个解支配的解，方便后续的$rank$计算，具体可以参考后面的参考代码实现。

在当前解集合中选取下一轮迭代的父代解集合。需要注意的是对于固定大小的父代解集合，这里依次从$rank=1$的解开始加入，知道数量满足要求。最后可能需要从$rank=i$的解集合中选取一部分，此时有两种方式，一种是随机选取，一种是根据拥挤度距离排序后选取。拥挤度距离计算的示意图如下，拥挤度距离可以用来衡量当前解周围的解的密度，优先选择拥挤度距离大(解稀疏)的地方可以使得最后求得的帕累托前沿上解分布更均匀。

对当前的解执行交叉变异操作产生下一轮迭代的子代解，交叉变异操作可以有不同的实现。

代码实现

目标函数

# -*- coding : utf-8 -*-
from collections import defaultdict
import math
import numpy as np

def ZDT1(x):
    """
    测试函数——ZDT1
    :parameter
    :param x: 为 m 维向量，表示个体的具体解向量
    :return f: 为两个目标方向上的函数值
    """
    poplength = len(x)
    f = defaultdict(float)

    g = 1 + 9 * sum(x[1:poplength]) / (poplength - 1)
    f[1] = x[0]
    f[2] = g * (1 - pow(x[0] / g, 0.5))

    return f

def ZDT2(x):
    poplength = len(x)
    f = defaultdict(float)

    g = 1 + 9 * sum(x[1:poplength]) / (poplength - 1)
    f[1] = x[0]
    f[2] = g * (1 - (x[0] / g) ** 2)

    return f


def KUR(x):
    f = defaultdict(float)
    poplength = len(x)

    f[1] = 0
    for i in range(poplength - 1):
        f[1] = f[1] + (-10) * math.exp((-0.2) * (x[i] ** 2 + x[i+1] ** 2) ** 0.5)

    for i in range(poplength):
        f[2] = abs(x[i]) ** 0.8 + 5 * math.sin(x[i] ** 3)

    return f


# 轮盘赌函数
def RouletteWheelSelection(P):
    idx = np.argsort(P)
    val = np.sort(P)
    prob = [_/sum(P) for _ in val]  # 概率
    dprob = np.cumsum(prob)  # 累积概率
    seed = np.random.random()  # 随机数

    res = idx[(dprob>seed).tolist().index(True)]  # 选择
    return res

MOPSO

参考了Matlab实现

启发式优化算法学习-模拟退火

Sun, 30 Apr 2023 08:44:23 +0800

模拟退火算法(SA)

参考教程 https://blog.csdn.net/brilliantZC/article/details/124436967

模拟退火算法（Simulated Annealing，SA）是一种模拟物理退火过程而设计的优化算法。模拟退火算法采用类似于物理退火的过程。先在一个高温状态下（算法初始化随机解），然后逐渐退火，在每个温度下慢慢冷却，最终达到物理基态（相当于算法找到最优解）。模拟退火算法采用Metropolis准则，并用一组称为冷却进度表的参数控制算法的进程，使得算法在多项式时间里可以给出一个近似最优解。

SA算法运行流程

step1: 设定当前解（即为当前的最优解)：令$T =T_0$，即开始退火的初始温度，随机生成一个初始解$x_0$，并计算相应的目标函数值$E(x_0)$。 step2: 产生新解与当前解差值：根据当前解$x_i$进行扰动，产生一个新解$x_j$，计算相应的目标函数值$E(x_j)$，得到$\Delta E = E(x_j)-E(x_i)$。 step3: 判断新解是否被接受：若$\Delta E< 0$，则新解$x_j$被接受；若$\Delta E> 0 $，则新解$x_j$按概率$e^{\frac{-(E(x_j)-E(x_i))}{T_i}}$被接受，$T_i$为当前温度。 step4: 当新解被确定接受时，新解$x_j$被作为当前解。 step5: 循环以上四个步骤：在温度$T_i$下，重复$k$次的扰动和接受过程，接着执行下一步骤。 step6: 最后找到全局最优解：判断$T$是否已经达到终止温度$T_f$，是，则终止算法；否，则转到循环步骤继续执行。

SA算法求解映射问题

映射问题本质上可以看作一个序列的排序问题，使用SA算法求解时，需要关注的是如何产生新解，这里我们采用如下的方法：再序列中随机选取两个不重合的位置，将这两个位置中间的序列反转达到局部扰动的目的。

SA算法求解映射问题代码

# -*- coding: utf-8 -*-
# Lishengxie
# 2023-02-23
# Implementation of a Simulated Annealing algorithm for crossbar mapping/placing
# 参考链接: https://blog.csdn.net/weixin_58427214/article/details/125901431
# 参考链接: https://blog.csdn.net/brilliantZC/article/details/124436967

import numpy as np
import copy
import sys
import random

class SAPlacer:
    """
        SA algorithm
        -------------
        Class used to find the mapping from computing cores to routers on NoC which minizes the communication cost
    """
    def __init__(self, dim_x, dim_y, spike_table, L=200, K=0.95, S=0.04, T=100, T_threshold=0.01):
        """
            Initialization of PsoPlacer.
            Args:
                dim_x: int, the `x` dimension on NoC 
                dim_y: int, the `y` dimension on NoC 
                spike_table: 2D-array, the number of spikes between core `i` and core `j`
                L: int, 每个温度下的迭代次数
                K: float, 温度的衰减参数, T = K*T
                S: float, 步长因子
                T: float, 初始温度
                T_threshold: float, 终止温度
        """
        self.dim_x = dim_x
        self.dim_y = dim_y
        self.dim_size = dim_x * dim_y
        self.L = L
        self.K = K
        self.S = S
        self.T = T
        self.T_threshold = T_threshold
        if spike_table is not None:
            self.init_solution(spike_table)

    def init_solution(self, spike_table):
        """
            Init spike table, hop distance table and solution.
        """
        # init spike table
        self.spike_table = np.zeros((self.dim_size, self.dim_size))
        h, w = spike_table.shape
        for i in range(h):
            for j in range(w):
                self.spike_table[i,j] = spike_table[i,j]

        # init hop distance table
        self.hop_xy()

        # init solution
        self.pre_x = np.arange(self.dim_size)
        np.random.shuffle(self.pre_x)
        self.pre_bestx = self.pre_x
        self.pre_x = np.arange(self.dim_size)
        np.random.shuffle(self.pre_x)
        self.prex_cost = self.fitnessFuntcion(self.pre_x)
        self.bestx = self.pre_x
        self.bestx_cost = self.fitnessFuntcion(self.bestx)

    def hop_xy(self):
        """
            The hop distance between router `x` and `y` in the 2D-Mesh NoC using XY routing
        """
        self.hop_dist = np.zeros((self.dim_size, self.dim_size))
        for i in range(self.dim_size):
            for j in range(self.dim_size):
                self.hop_dist[i,j] = abs(i % self.dim_x - j % self.dim_x) \
                                + abs(i // self.dim_x - j // self.dim_x)
        
    def fitnessFuntcion(self, solution):
        """
            Compute the communication cost for each mapping solution
            Args:
                solution: List, a possible mapping solution
        """
        cost = 0
        for i in range(self.dim_size):
            for j in range(self.dim_size):
                cost +=  self.spike_table[i,j] * self.hop_dist[solution[i], solution[j]]
        return cost

    def place(self):
        """
            Execute the Simulated Annealing algorithm
        """
        P = 0
        next_x = np.arange(self.dim_size)
        np.random.shuffle(next_x)
        nextx_cost = self.fitnessFuntcion(next_x)

        while (self.T > self.T_threshold):
            self.T = self.K * self.T        # 降温
            # 当前温度T下迭代次数
            for i in range(self.L):
                # ====在此点附近随机选下一点=====
                # 选择两个随机位置, 将两个位置之间的数组进行翻转
                positions = np.random.choice(list(range(self.dim_size)), replace=False, size=2)
                x = min(positions[0], positions[1])
                y = max(positions[0], positions[1])
                mid_reversed = next_x[x:y+1][::-1]
                next_x[x:y+1] = mid_reversed
                
                if random.random() <= 0.0001:
                    np.random.shuffle(next_x)
                    
                nextx_cost = self.fitnessFuntcion(next_x)
                if nextx_cost < self.bestx_cost:
                    self.pre_bestx = self.bestx
                    self.bestx = next_x
                    self.bestx_cost = nextx_cost

                if nextx_cost < self.prex_cost:
                    self.pre_x = next_x
                    self.prex_cost = nextx_cost
                    P = P + 1
                else:
                    changer = -1 * (nextx_cost - self.prex_cost) / self.T
                    p1 = np.exp(changer)
                    if p1 > np.random.random():
                        self.pre_x = next_x
                        self.prex_cost = nextx_cost
                        P = P + 1

            print("Current T: {:.7f}, best cost: {}".format(self.T, self.bestx_cost))

        return self.bestx

启发式优化算法学习-PSO

Sun, 30 Apr 2023 08:42:37 +0800

粒子群算法(PSO)

参考教程：https://cloud.tencent.com/developer/article/1424756

粒子群算法是一种利用群体智能建立的一个简化模型，基于群体中个体对信息的共享使整个群体的运动趋向最优解。粒子群算法使用一群粒子，粒子拥有位置和速度两种属性，根据自身已经找到的最优解和参考整个共享于整个集群中找到的最优解去改变自己的飞行速度和位置。

粒子速度和位置

粒子群算法使用一定数量的粒子，粒子$i$在$N$维空间中的位置和速度表示为$x_i=(x_1,x_2,\cdots,x_N)$ 和 $v_i=(v_1,v_2,\cdots,v_N)$。每个粒子都有一个目标函数决定的适应值(fitness value)，并且知道自己到目前为止发现的最好位置(pbest)和现在的位置$x_i$。这个可以看作是粒子自己的飞行经验。除此之外，每个粒子还知道到目前为止整个群体中所有粒子发现的最好位置(gbest)(gbest是pbest中的最好值)，这个可以看作是粒子同伴的经验。粒子就是通过自己的经验和同伴中最好的经验来决定下一步的运动。

粒子速度和位置更新公式

粒子群算法会给每个粒子一个初始的随机解，并通过迭代寻找最优解，迭代规则如下图所示：迭代公式中的第一部分和第二部分分别反映了粒子对自身经验和群体经验的学习。基于上述公式还可以对当前的速度引入更新权重

PSO算法运行流程

1）初始化一群微粒(群体规模为N)，包括随机位置和速度； 2）评价每个微粒的适应度； 3）对每个微粒，将其适应值与其经过的最好位置pbest作比较，如果较好，则将其作为当前的最好位置pbest； 4）对每个微粒，将其适应值与其经过的最好位置gbest作比较，如果较好，则将其作为当前的最好位置gbest； 5）根据公式(2)、(3)调整微粒速度和位置； 6）未达到结束条件则转第2）步。迭代终止条件根据具体问题一般选为最大迭代次数Gk或(和)微粒群迄今为止搜索到的最优位置满足预定最小适应阈值。

PSO算法求解映射问题

映射问题本质上可以看作一个序列的排序问题，使用PSO算法求解映射问题时，粒子位置对应一个序列的排序。这里$pbest-x_i^{t-1}$对应将$x_i^{t-1}$转换成pbest所需要的交换序列，这里的迭代公式的含义变为对于原来的解序列$x_i^{t-1}$，

先按照$c_2$的概率使用$pbest-x_i^{t-1}$的交换序列对$x_i^{t-1}$进行交换获得$(x_i^{t-1})^{’}$，
再按照$c_3$的概率使用$gbest-(x_i^{t-1})^{’}$的交换序列对$(x_i^{t-1})^{’}$进行交换获得$x_i^{t}$.

PSO求解映射代码

# -*- coding: utf-8 -*-
# Lishengxie
# 2023-02-19
# Implementation of a PSO algorithm for crossbar mapping/placing

import numpy as np
import copy
import sys

class PsoPlacer:
    """
        PSO algorithm
        -------------
        Class used to find the mapping from computing cores to routers on NoC which minizes the communication cost
    """
    def __init__(self, dim_x, dim_y, spike_table, num_particle=50, s1=1.0, s2=0.04, s3=0.02):
        """
            Initialization of PsoPlacer.
            Args:
                dim_x: int, the `x` dimension on NoC 
                dim_y: int, the `y` dimension on NoC 
                spike_table: 2D-array, the number of spikes between core `i` and core `j`
                num_particle: int, number of particles in the PSO algorithm
        """
        self.dim_x = dim_x
        self.dim_y = dim_y
        self.dim_size = dim_x * dim_y
        self.num_particle = num_particle
        self.s1 = s1
        self.s2 = s2
        self.s3 = s3
        self.init_particle(spike_table)

    def init_particle(self, spike_table):
        """
            Init spike table, particles, local and global best solution
            Args:
                spike_table: 2D-array, the number of spikes between core `i` and core `j`
        """
        # init the spike table, adding `0`s if the dimension of `spike_table` not equal to `dim_size`
        self.spike_table = np.zeros((self.dim_size, self.dim_size))
        h, w = spike_table.shape
        for i in range(h):
            for j in range(w):
                self.spike_table[i,j] = spike_table[i,j]

        # init particle vectors with number of `num_particle`, each vector is a mappinng solution
        self.solution = np.zeros((self.num_particle, self.dim_size), dtype=np.int32)
        for i in range(self.num_particle):
            self.solution[i] = np.arange(self.dim_size)
            np.random.shuffle(self.solution[i])

        # init hop distance table
        self.hop_xy()

        # init the local/global best solution and their cost
        self.local_best_solution = copy.deepcopy(self.solution)
        self.local_best_cost = np.zeros((self.num_particle,))
        self.global_best_solution = np.arange(self.dim_size)
        self.global_best_cost = sys.maxsize
        for i in range(self.num_particle):
            self.local_best_cost[i] = self.fitnessFuntcion(self.local_best_solution[i])
            if self.local_best_cost[i] < self.global_best_cost:
                self.global_best_solution = self.local_best_solution[i]
                self.global_best_cost = self.local_best_cost[i]
        print("Init, gloabal best cost:{}".format(self.global_best_cost))


    def hop_xy(self):
        """
            The hop distance between router `x` and `y` in the 2D-Mesh NoC using XY routing
        """
        self.hop_dist = np.zeros((self.dim_size, self.dim_size))
        for i in range(self.dim_size):
            for j in range(self.dim_size):
                self.hop_dist[i,j] = abs(i % self.dim_x - j % self.dim_x) \
                                + abs(i // self.dim_x - j // self.dim_x)
        
    def fitnessFuntcion(self, solution):
        """
            Compute the communication cost for each mapping solution
            Args:
                solution: List, a possible mapping solution
        """
        cost = 0
        for i in range(self.dim_size):
            for j in range(self.dim_size):
                cost +=  self.spike_table[i,j] * self.hop_dist[solution[i], solution[j]]
        return cost
    
    def compute_swap_sequence(self, src_seq, dst_seq, seq_len):
        # TODO: Optimize this algorithm.
        """
            Find the swap sequence from source sequecne to destination sequence.
            Args:
                src_seq: List, the source sequence
                dst_seq: List, the destination sequence
                seq_len: int, the length of source and destination sequence
            Return:
                swap_sequence: the index of each point for `src_seq` in `dst_seq`
        """
        swap_seq = np.zeros((seq_len,))
        for i in range(seq_len):
            swap_seq[i] = np.where(dst_seq == src_seq[i])[0]
        return swap_seq

    def applySwap(self, swap_seq, src_seq, seq_len):
        """
            Apply swap sequence to the source sequence
            Args:
                src_seq: List, the source sequence
                swap_sequence: the index of each point for `src_seq` in `dst_seq`
                seq_len: int, the length of source and destination sequence
            Return:
                dst_seq: List, the destination sequence
        """
        dst_seq = np.zeros((seq_len,))
        for i in range(seq_len):
            dst_seq[swap_seq[i]] = src_seq[i]
        return dst_seq

    def place(self, num_iter=10):
        """
            Funciton to execute pso algorithm.
            Args:
                num_iter: int, max number of iterations to execute pso update
            Return:
                global best solution after `num_iter` iterations
        """
        for iter in range(num_iter):
            for i in range(self.num_particle):
                tmp_solution = copy.deepcopy(self.solution[i])
                if np.random.random() <= self.s2:
                    # print("local")
                    swap_seq_local = self.compute_swap_sequence(tmp_solution, self.local_best_solution[i], self.dim_size)
                    self.solution[i] = self.applySwap(self.solution[i], swap_seq_local, self.dim_size)
                if np.random.random() <= self.s3:
                    # print("global")
                    swap_seq_global = self.compute_swap_sequence(tmp_solution, self.global_best_solution, self.dim_size)
                    self.solution[i] = self.applySwap(self.solution[i], swap_seq_global, self.dim_size)

                if np.random.random() <= 0.0001:
                    np.random.shuffle(self.solution[i])

                cost = self.fitnessFuntcion(self.solution[i])
                if cost < self.local_best_cost[i]:
                    self.local_best_cost[i] = cost
                    self.local_best_solution[i] = copy.deepcopy(self.solution[i])

                if self.local_best_cost[i] < self.global_best_cost:
                    self.global_best_cost = self.local_best_cost[i]
                    self.global_best_solution = copy.deepcopy(self.local_best_solution[i])
            print("Iteration:{}, global best cost:{}".format(iter, self.global_best_cost))
        return self.global_best_solution

Gdb调试学习

Sun, 30 Apr 2023 08:40:25 +0800

前言

使用linux进行systemc的开发时经常出现core dump的文件，对于较大的项目vscode无法很快地进行debug，clion对makefile的支持不是很好，此时想到使用gdb进行调试并学习了一些基本的操作。以下的内容主要参考这篇博客和gdb debug的参考文档。

参考资料：

启动调试

GDB需要一个带有调试信息的可执行文件进行调试，因此编译过程中出现的错误无法使用GDB进行排除。通常对于C或者C++程序来说，在编译时加上-g参数可以保留调试信息，否则不能使用GDB进行调试。使用cmake时，可以在CMakeLists.txt文件中添加以下指令以支持GDB调试。

SET(CMAKE_BUILD_TYPE "Debug")
SET(CMAKE_CXX_FLAGS_DEBUG "$ENV{CXXFLAGS} -O0 -Wall -g2 -ggdb")
SET(CMAKE_CXX_FLAGS_RELEASE "$ENV{CXXFLAGS} -O3 -Wall")

如果程序不是自己编译的，那么如何判断文件中是否带有调试信息呢，这篇博客中给出了几种调试的方法。

使用gdb

$ gdb main
Reading symbols from main...

如果提示no debugging symbols found, 那么不可以使用gdb调试该可执行文件。 2. readelf

# main是可执行文件名称
$ readelf -S main | grep debug

file查看strip状况

$ file main

如果输出内容为xxx stripped, 那么说明该文件的调试信息已经被去除，不能使用gdb调试。但是not stripped的情况不能说明该文件可以被调试。

启动调试

无参数程序

$ gdb main
(gdb) run

输入run命令即可运行程序。

Makefile使用学习

Sun, 30 Apr 2023 08:37:37 +0800

参考教程

原文：https://makefiletutorial.com/ 中文翻译：https://makefiletutorial.vercel.app

Makefile常用内容

本文主要基于以上教程记录一些平时阅读Makefile可能会用到的信息。

Makefile基础使用

首先，Makefile用于帮助决定一个大型程序的哪些部分需要重新编译，如果有任何文件的依赖项发生改变，那么该文件将会重新编译。Makefile通常由一组规则组成，规则通常如下所示：

target: prerequisites
	command
	command
	command

target是文件名，以空格分隔，通常每个规则只有一个。
command通常是用于制作目标的一系列步骤，需要以制表符Tab而不是空格开头。
prerequisites也是文件名，称为依赖项，以空格分隔，在运行针对目标的命令之前，这些文件需要存在。

下面是一个Makefile的实例：

blah: blah.o
	gcc blah.o -o blah # Runs third

blah.o: blah.c
	gcc -c blah.c -o blah.o # Runs second

# Typically blah.c would already exist, but I want to limit any additional required files
blah.c:
	echo "int main() { return 0; }" > blah.c # Runs first

使用make时默认会执行第一个目标blah，或者可以指定目标进行生成make blah。上面的Makefile在执行make指令后按照一系列步骤进行调用：

Cmake 常用指令学习

Sun, 30 Apr 2023 08:36:41 +0800

参考教程

Cmake Cookbook:https://www.bookstack.cn/read/CMake-Cookbook/README.md
Cmake官方文档:https://cmake.org/cmake/help/latest/guide/tutorial/index.html
Cmake入门实战: https://www.hahack.com/codes/cmake/
CMake 生成静态库与动态库：https://blog.csdn.net/zhiyuan2021/article/details/129032343

Cmake介绍

Cmake是一种支持跨平台编译的工具，允许通过配置独立的配置文件CMakeList.txt来定制编译流程，随后在不同的平台上进一步生成本地的Makefile和工程文件(Linux平台的Makefile和Windows平台的Visual Studio工程等)。在linux平台下使用Cmake编译程序的主要流程是：

编写CMakeLists.txt；
执行cmake PATH生成Makefile；
执行make编译生成可执行程序或动态/静态链接库。

Cmake使用

基础案例

# CMake 最低版本号要求
cmake_minimum_required (VERSION 2.8)

# 项目信息
project (project_name)

# 指定生成目标
add_executable(project_name main.cc)

CMakeLists.txt的语法由命令、注释和空格组成，命令不区分大小写，#后面的内容是注释。命令由命令名称、小括号和参数组成，参数之间使用空格进行间隔。上面的示例中CmakeLists.txt中使用了几个常用的命令，依次是

cmake_minimum_required：指定运行当前配置文件需要的最低的Cmake版本；
project：指定项目名称
add_executable：将main.cc源文件编译成名为project_name的可执行文件。

实际使用中可能有多个源文件，逐个添加源文件是一件非常麻烦的事情，可以使用aux_source_directory命令来获取指定目录下的所有源文件，并将结果存到指定变量名中，使用示例如下：

# 查找当前目录下的所有源文件
# 并将名称保存到 DIR_SRCS 变量
aux_source_directory(. DIR_SRCS)

# 指定生成目标
add_executable(Demo ${DIR_SRCS})

Cmake生成动态和静态链接库

静态和动态链接库的主要目的是为了提供接口供其他程序调用，两者的主要区别在于：

静态链接库的拓展名通常为.a或.lib，在编译时会直接整合到目标程序中，编译成功的可执行文件可以独立运行（不再需要静态库）；
动态链接库的拓展名通常为.so或.dll，在编译时不会放到目标程序中，可执行文件无法离开动态链接库单独执行。

Cmake用于生成动态和静态链接库的命令为

# 动态链接库
add_library(project_name SHARED ${SRC_FILE})
# 静态链接库
add_library(project_name STATIC ${SRC_FILE})

Cmake引用外部库文件

Cmake中另外一个常用的使用场景是使用外部库，对于外部库，我们通常需要进行两步操作，即引入头文件和添加链接库，具体示例如下所示：

# 引入头文件所在路径
include_directories{include_path}
# 添加链接库
target_link_libraries(project_name lib_name)

其他常见的Cmkae命令

# 设置C++标准为C++14
set(CMAKE_CXX_STANDARD 14)

Snn & NoC 仿真器收集

Sun, 30 Apr 2023 08:33:39 +0800

NoC仿真器

NoC(Network on chip)是连接同构或者异构多核心的重要的系统互联结构，NoC仿真器提供了对NoC中多种性能指标的仿真。下面这篇博客中列出了常用的开源NoC仿真器，https://networkonchip.wordpress.com/2011/02/22/simulators/ ，目前了解到最常用的两种分别是

noxim，基于SystemC语言开发，修改和添加新功能较为灵活。

开源地址：https://github.com/davidepatti/noxim

booksim，基于C++语言开发，是 Principles and Practices of Interconnection Networks 这本书的配套教程。

开源地址：https://github.com/booksim/booksim，https://github.com/booksim/booksim2

SNN仿真器

SNN是第三代人工神经网络，基于脉冲传递数据和信息，由于SNN本身具有稀疏性（连接稀疏性和脉冲稀疏性），因此有许多神经形态硬件（Loihi、SpiNNaker、TianjiC、Darwin等）被开发出来用于SNN加速。这里主要列出一些在通用的CPU和GPU平台上进行SNN加速的一些SNN仿真器。

NEST，可以用于SNN网络信息处理，网络活动动态、学习和突触可塑性等

开源地址：https://github.com/nest/nest-simulator/

Brain2，时钟驱动的SNN仿真器

开源地址：https://github.com/brian-team/brian2

GeNN，GPU加速的SNN仿真器

开源地址：https://github.com/genn-team/genn

Carlsim，GPU加速的SNN仿真器

开源地址：https://github.com/UCI-CARL/CARLsim6

Auryn，RSNN仿真器

开源地址：https://github.com/fzenke/auryn

ANNarchy

开源地址：https://github.com/ANNarchy/ANNarchy

Spike， GPU加速的SNN仿真器

开源地址：https://github.com/nasiryahm/Spike

Spice，多GPU、时钟驱动的SNN仿真器

开源地址：https://github.com/denniskb/spice

Nengo，基于Python的神经网络仿真

开源地址：https://github.com/nengo/nengo

Brain2Loihi，基于brain2实现的Loihi模拟器

开源地址：https://github.com/sagacitysite/brian2_loihi

NeuroSync

开源地址：https://github.com/SNU-HPCS/NeuroSync

dynapse-simulator，Dynap-SE1神经形态硬件仿真器

开源地址：https://github.com/YigitDemirag/dynapse-simulator

待添加

Verilog Note

Sun, 30 Apr 2023 08:30:15 +0800

参考书籍：

《手把手教你学FPGA设计：基于大道至简的至简设计法》

百度网盘链接：https://pan.baidu.com/s/12knuxzb4Z6z_8gR-By-l-A 提取码：mwzd

自己实现的书中的模块和相应的testbench测试：https://github.com/lishengxie/verilog-learning.git

计数器

设计规则

计数器需要考虑三要素：初值、加一条件和结束值（通常依次考虑）；
计数初值必须为0；
使用某个计数值时必须同时满足加1条件；例如加1条件为add_cnt且add_cnt && cnt==4时表示计数到第五个，而add_cnt==0 && cnt==4不表示计数到第五个；
计数条件必须同时满足加一条件，且结束值必须是x-1的形式；
当从计数器取某个数时，assign形式必须为：(加一条件) && (cnt==计数值-1)；
结束后计数值需要回到0；
需要限定范围时，推荐使用>=和<两种符号，尽量不要使用大于或者小于等于两种符号；
计数器设计时，先写计数器的always段，条件用名字代替，随后使用assign语句依次写出加一条件和结束条件；由此可以得出计数器的模板写法如下所示

// 中文词语方便理解，实际使用需要更改为相应的变量名
always @(posedge clk or negedge rst_n) begin
    if(rst_n==1'b0)begin
        cnt <= 0;
    end 
    else if(加一条件)begin
        if(结束条件)
            cnt <= 0;
        else
            cnt <= cnt + 1;
    end
end
assign 加一条件 = xxxxxx;
assign 结束条件 = (加一条件) && (cnt==计数值-1);

加一条件必须与计数器严格对齐，其他信号一律向计数器对齐；例如，现在需要输出两个信号dout0和dout1，dout0在计数到6时拉高，dout1在计数到7时拉高，因此dout0变1的条件为add_cnt && cnt==6-1，dout1变1的条件有两种写法
- dout0 == 1
- add_cnt && cnt==7-1
第一种写法是间接向计数器对齐，是非常不好的方法，建议使用第二种直接向计数器对齐；
加一条件统一前缀为add_，结束条件统一前缀为end_；
暂不使用减1计数器。

状态机

设计规则

使用四段式写法第一段为同步时序的always模块，用于格式化描述次态迁移到现态寄存器；

always @(posedge clk or negedge rst_n) begin
	if(!rst_n) begin
		state_c <= IDLE;
	end
	else begin
		state_c <= state_n;
	end
end

第二段为组合逻辑的always块，用于描述状态转移条件判断，以三个状态的状态机IDLE->S1->S2->IDLE为例；

Gin框架学习

Sun, 30 Apr 2023 08:26:45 +0800

概述

Gin框架地址：https://github.com/gin-gonic/gin

参考文档： https://www.kancloud.cn/shuangdeyu/gin_book https://github.com/piexlmax/1010class

Gin服务入门

package main

import "github.com/gin-gonic/gin"

func main() {
	r := gin.Default()
	r.GET("/ping", func(c *gin.Context) {
		c.JSON(200, gin.H{
			"message": "pong",
		})
	})
	r.Run() // listen and serve on 0.0.0.0:8080
}

Gin获取Get/Post参数

获取Get参数

func main() {
	router := gin.Default()

	// 匹配的url格式:  /welcome?firstname=Jane&lastname=Doe
	router.GET("/welcome", func(c *gin.Context) {
		firstname := c.DefaultQuery("firstname", "Guest") // DefaultQuery可以在参数值不存在时使用传入的默认值
		lastname := c.Query("lastname") // 是 c.Request.URL.Query().Get("lastname") 的简写

		c.String(http.StatusOK, "Hello %s %s", firstname, lastname)
	})
	router.Run(":8080")
}

获取Post参数

func main() {
	router := gin.Default()

	router.POST("/form_post", func(c *gin.Context) {
		message := c.PostForm("message")
		nick := c.DefaultPostForm("nick", "anonymous") // 此方法可以设置默认值

		c.JSON(200, gin.H{
			"status":  "posted",
			"message": message,
			"nick":    nick,
		})
	})
	router.Run(":8080")
}

Get和Post参数混合使用

	router := gin.Default()

	router.POST("/post", func(c *gin.Context) {

		id := c.Query("id")
		page := c.DefaultQuery("page", "0")
		name := c.PostForm("name")
		message := c.PostForm("message")

		fmt.Printf("id: %s; page: %s; name: %s; message: %s", id, page, name, message)
	})
	router.Run(":8080")
}

请求示例：

Go Gin Chat

Sun, 30 Apr 2023 08:22:37 +0800

项目地址：https://github.com/hezhizheng/go-gin-chat

Gin框架学习

参考笔记

Websocket学习

Websocket连接是升级的HTTP连接，在连接被客户端或服务器终止之前一直存在，基于Websocket可以实现客户端和服务端之间的双工通信，而不需要对HTTP端口进行持续轮询，大大节省了网络资源开销。

go-gin-chat中基于gorilla/websocket实现websocket的使用，下面是该软件包使用的示例，可以参考博客。

// We'll need to define an Upgrader
// this will require a Read and Write buffer size
var upgrader = websocket.Upgrader{
    ReadBufferSize:  1024,
    WriteBufferSize: 1024,
}

func wsEndpoint(w http.ResponseWriter, r *http.Request) {
    upgrader.CheckOrigin = func(r *http.Request) bool { return true }

    // upgrade this connection to a WebSocket connection
    ws, err := upgrader.Upgrade(w, r, nil)
    if err != nil {
        log.Println(err)
    }

	// 向连接的客户端写入信息
    log.Println("Client Connected")
    err = ws.WriteMessage(1, []byte("Hi Client!"))
    if err != nil {
        log.Println(err)
    }
	
    // listen indefinitely for new messages coming
    // through on our WebSocket connection
    go reader(ws)
}

// define a reader which will listen for
// new messages being sent to our WebSocket
// endpoint
func reader(conn *websocket.Conn) {
    for {
    // read in a message
        messageType, p, err := conn.ReadMessage()
        if err != nil {
            log.Println(err)
            return
        }
    // print out that message for clarity
        fmt.Println(string(p))
        if err := conn.WriteMessage(messageType, p); err != nil {
            log.Println(err)
            return
        }
    }
}

Websocket心跳检测

参考博客 https://www.cnblogs.com/tugenhua0707/p/8648044.html

SNN映射论文阅读 Neu-NoC

Sun, 30 Apr 2023 00:19:30 +0800

Neu-NoC: A High-efﬁcient Interconnection Network for Accelerated Neuromorphic Systems

提出了一种环形+Mesh结合的NoC结构，同时基于该结构提出了相应的映射算法、广播协议和基于权重稀疏性的通信量减少方案，相较于现有的2D-Mesh的方法有效地减少了通信的延迟和能量消耗。

Motivation

相邻层之间通信频繁，导致NoC中大部分的通信量分布在较少的通信信道上；
全连接层中前一层的一个神经元给下一层的所有神经元发送的数据本质上是一样的，因此传输的数据包中有相当一部分是重复的数据。

Neu-NoC结构介绍

Mesh+ring结合，同一层中的神经元映射到一个ring中来减少数据的搬运，ring中提供两条信道，分别用于接收和发送数据以提高信息的传输速度；
ring中使用ring路由，根据上图c)可以看到ring路由包含相应的2选1多选器、缓存和打包解包模块，同时提供分配模块用于仲裁(例如，正在传输的包比刚输入的包优先级更高)

NN-aware Mapping

将神经元映射到具体的物理计算核心上，使得神经元之间的通信跳数最小
本质是贪婪算法，寻找局部最优的映射方案

packet广播

在packet的header中添加一段标志位用于支持广播协议，标志位长度和Mesh路由的总数目相同；如1->7->9->10中分别广播到9和10，因此将9和10的标志位置为1，经过9后，9的标志位被置为0随后继续传递给10；

稀疏感知的通信量减少

利用神经网络中特征图的稀疏性，提出了all-zero flit，该flit中使用特殊标志位，同时在payload中指出有多少个连续的全0包。根据这种方式将多个全0的数据包压缩成一个，由Mesh和ring之间的路由提供支持。

实验

针对全连接层
基于Booksim仿真器：https://github.com/booksim/booksim2
ring中的局部延迟和全局通信跳数随着同一个ring中支持的PE数量增加呈现出先增后减的趋势；
实验中发现通过将低于某个阈值的激活值置为0，提高特征图的稀疏性之后，精度不会受到严重的影响，因此可以在提高稀疏性和保持精度之间做一定的权衡；
提出的方法可以获得较好的性能，相较于普通的2D-Mesh的方法可以降低23.2%的包传输延迟和31.1%的能量消耗。

思考：

ring加Mesh结合的方法比较有特点；
能否直接在现有的2D-Mesh之间实现相应的映射方法，将同一层的神经元映射到相邻的PE上，但是相较于顺序方式需要一定的性能提升？
多播和0数据压缩的方式可以参考，尤其是对于SNN可以在时间维度上进行压缩，减少传输的延迟。

SNN映射论文阅读-SentryOS

Sun, 30 Apr 2023 00:13:55 +0800

SentryOS： Design of Many-Core Big Little µBrains for Energy-Efficient Embedded Neuromorphic Computing

开源地址： 暂无

使用芯片： µBrain

优化指标： 芯片使用面积和功耗

在uBrain神经形态核心上拓展实现的神经形态系统（基于分段总线）和映射框架（SentryOS）。

使用分段总线，实现核心之间的一对一互联（实际根据运行数据存在分时复用）；
基于异构大小核，大网络分割后的子网络规模不同，使用异构大小核来减少uBrain核心中的硬件空闲率

uBrain使用的三层全连接结构

异构大小核设计根据uBrain中使用的三层全连接结构，作者分析了LeNet、AlextNet、VGGNet、ResNet和DenseNet五种模型中L1和L2 neighbors 的数目，发现对于不同应用差别较大，因此使用异构的不同大小的uBrain核心可以提高硬件资源（神经元和突触连接）的利用率。
分段总线互联文中使用分段总线连接不同的uBrain核心来完成通信，相较于传统的共享式的总线结构，分段式总线结构可以价格总线分段，不同段之间可以并行通信，互不影响。为了实现同一时刻所有核心之间可以并行通信，需要多条并行总线，基于训练数据获取到同一时刻最大的并行通行量，从而可以确定所需要的最小的并行总线数目。
SentryOS设计

a. SentryC编译器：将大网络分割成多个可以映射到uBrain核心的子网络，具体的映射算法如下，主要分为四个步骤
1. 对于每个输出神经元，根据神经元到其的最长路径计算两者之间的距离；
2. 根据第一步算出的距离给神经元添加索引，需要确保所有子网络中的神经元具有连续索引（论文中的阐述）
3. 将所有距离小于2的神经元形成集合，$S_0 = {N_j | dist(N_j ) ≤ 2}$，产生一个子网络，剩下的神经元递归组成其他子网络，这一步中可能会插入权重为1的神经元（调整阈值每来一个脉冲就发放一个脉冲？）；
4. 融合两个子网络$S_i$ 和$S_j$ 当且仅当
  $Area(S_i,j) \lt Area(S_i) + Area(S_j)$
  
  $Power(S_i,j)\lt Power(S_i)+ Power(S_j)$
文中提到可以将SentryOS的方案扩展到基于crossbar的神经形态硬件上，即认为crossbar为两层全连接结构（uBrain是三层）

b. SentryRT运行时：类似于DFSynthesizer，使用Max-Plus Algebras的方式确定自网络之间的执行顺序，这篇文章在DFSynthesizer上进一步改善，一方面使用多流水线来执行一个网络，另一方面使用Batch依次运算多个输入图片提高吞吐量。
实验评估

a. 使用异构大小核设计可以提高突触等资源的利用率，降低能量消耗，提高吞吐量；

SNN映射论文阅读-NEUTRAMS

Sun, 30 Apr 2023 00:10:08 +0800

Neutrams: NEUTRAMS: Neural Network Transformation and Co-design under Neuromorphic Hardware Constraints

开源代码地址：https://github.com/hoangt/neutrams

使用芯片：TianJi，Prime

优化指标：Crossbar之间的脉冲通信量

图 1. NEUTRAMS提出的工具链的层级结构

实现步骤：

神经网络表示类似其他模拟器中常用的方式，将神经网络看成神经元分组和神经元分组之间的连接组成。神经元分组之间都认为使用全连接，不存在的边认为使用权重为0的虚拟边。
Training-based transformation(神经网络训练&神经元分组)

a. 使用BP算法训练神经网络

b. 连接稀疏化，通过交换矩阵的行或列来将连接矩阵转换为满足crossbar大小限制的多个子矩阵，并将其余连接权重置为0，目标是最大化剩余的原有连接的绝对值权重之和。

c. 权重量化，将原有的浮点数权重量化为低精度权重，同时使用BP算法微调模型(BP算法中仍然使用浮点数计算)。

d. 在原有的两层中间插入新的全连接层，对于大小为m和n的两个层之间的连接，插入$\frac{m+n}{2}$的全连接层，重新训练后减少准确度的损失。

e. 对于复杂的神经网络(非顺序连接的/循环的)：对于复杂的神经网络，可以通过图2所示的复制和合并的方式，逐层训练神经元分组之间的突触连接；对于循环神经网络，脉冲神经网络需要将循环连接暂时删除，然后记录循环连接中的信息，将上一时刻信息送入连接后神经元并保存当前时刻连接前神经元送入的信息。

图 2. 复杂神经网络训练

Mapping 使用Kernighan-Lin(KL)算法进行神经元子块到crossbar上的映射，目标是最小化crossbar之间的脉冲通信量。
Cycle-accurate simulator

实验

考察指标：错误率，能量消耗，芯片有效速度(反比于每个仿真周期内的芯片时钟周期数，芯片有效速度的最大值对应于超过该值部分脉冲无法在一个仿真周期内到达目标神经元)。
结论

a. 插入新的全连接层精度损失低于扩展crossbar规模，插入新的全连接层会增加能量损失、降低有效速度；

b. 基于已训练的前神经元节点训练后节点可以避免误差的积累；

c. 连接稀疏化对于精度影响较大，但是后续可以通过微调网络改善；

d. 部分神经元参数可以同步变大或减小，而不影响最终的输出；

e. 网络规模越大，芯片有效速度越小。

SNN映射论文阅读-PSOPART

Sat, 29 Apr 2023 22:14:32 +0800

图优化方法

PSOPART

Mapping of local and global synapses on spiking neuromorphic hardware

开源代码地址：https://github.com/Jinouwen/Mapping

优化指标：神经元分块之间的脉冲通信量

类脑芯片：CxQuad

基本步骤

使用Carlsim进行脉冲神经网络运行模拟，构建脉冲神经网络图结构；
使用PSO(Partial Swarm Optimization)算法进行脉冲神经网络的分割，产生符合硬件限制的子块，这一步中优化的指标为神经元分块之间的脉冲通信量。

图1. PSO算法执行流程

创新点 提出使用进化算法(PSO)用于脉冲神经网络分割。

问题没有考虑到神经元分块到crossbar的物理映射问题，优化算法映射时间过长。

SNN映射论文阅读-SpiNeMap

Sat, 29 Apr 2023 22:14:32 +0800

图优化方法

SpiNeMap

Mapping spiking neural networks to neuromorphic hardware.

开源代码地址：https://github.com/Jinouwen/SpiNeMap

优化指标：Global spikes，latency，energy consumptions

类脑芯片：DYNAP-SE

步骤分析:

SNN模拟与分析：使用SNN软件模拟器(CARLSim)提取经过训练的SNN网络的拓扑结构和神经元的行为，形成无向SNN图以及脉冲行为轨迹；
- 无向SNN图以神经元为节点、神经元与神经元之间的突触为边；
- 脉冲行为轨迹包含源神经元以及目的神经元的编号和激发时间
划分：随机无向SNN图划分为多个SNN子块，使用启发式算法Kernighan-Lin graph partitioning algorithm，通过在不同子块之间交换神经元优化SNN子块之间的脉冲通信量；
- 每个SNN子块中神经元数目不能超过单个crossbar所能容纳的神经元数
- 每个SNN子块只会被分配给一个crossbar
映射：使用启发式搜索算法（PSO，粒子群算法）找到一个最优的映射方案将SNN子块分配给目标硬件上的神经元核，最小化目标硬件上脉冲在crossbar之间传播的平均延迟和能量消耗(通过最小化脉冲传播的平均跳数实现)。基于拓展的Noxim平台（Noxim++）实现搜索算法中的指标函数计算。

创新点

将SNN网络的划分和SNN网络分块到物理硬件的映射一起考虑，形成完整的映射方案。

问题

没有提到神经元的扇入突触超过crossbar限制如何解决？

ISI distortion：inter-spike intervals失真，会引起模型精度的下降，定义为

I\_j^s\|\_{distortion}=I\_j^s|_{new}-I\_j^s = \delta\_j^s-\delta\_{j-1}^s

，其中 $\delta\_j^s$ 表示第j个脉冲在第s个突触上传播的延迟，当突触位于crossbar上时，可以认为 $I\_j^s\|\_{distortion}=0$ ，当突触映射到NoC上时， $I\_j^s\|\_{distortion}\neq 0$ 。当输入编码方案为速率编码时，ISI distortion可能没有影响，论文中提出了另一种直觉的spike disorder的指标

\sum\_{j=1}^{n\_i}[(F\_j^i-\hat{F}\_j^i)^2]/n\_i

， $F\_j^i$ 和 $\hat{F}\_j^i$ 分别表示神经元i中的第j个脉冲到达的频率。

My First Blog

Fri, 24 Feb 2023 14:43:42 +0800

This is the first blog for https://lishengxie.github.io.