1.基本异步处理电路
 
1.1电平同步
 
1.2脉冲同步
 
现将脉冲变成电平，同步之后再恢复，
 
1.下面是脉冲展电平的做法
 
 
2.下面是电平恢复脉冲
 
 
 
1.3异步fifo
 
1.4demux同步
 
DEBUX通过一个同步到目标时钟域的信号作为目标时钟域多比特数据更新的使能信号
 
2.Qualifier synchronization
 
 
其实和demux很相像，先选择一个qualif的singal做同步，同步到ck2之后，用该信号做其他数据的选通信号。
 
3.apb2apb的异步桥
 
apb的信号中只有psel和pready会做sync，其他都不直接sync
 
假设apb2apb的clk_1域为slave 端，需要同步到clk_2域master端
 
psel_s/penalbe_s/pwrite_s/paddr_s/pwdata_s 需要同步到clk_2
 
pready_m/prdata_m/pslverr_m需要同步到clk_1
 
3.1 使用异步fifo的同步形式
 
这种情况比较简单，但是资源占的较多
 
3.2Qualifier synchronization 策略
 
slave--->master过程如下:
 
1.将psel_s&(~penable_s)这样一个pulse signal 经过脉冲同步到clk_2，为pulse_d
 
2.用pulse_d拉高psel_m，用psel_m & penable_m & pready_m 拉低psel_m
 
3.用pulse_d_ff1拉高penable_m，用psel_m & penable_m & pready_m 拉低penable_m
 
4.pwrite_m/paddr_m/pwdata_m直接赋值
 
 
以上地方直接赋值也可以用psel_m做个mux
 
assign pwrite_m = psel_m & pwrite_s;
 
assign paddr_m = psel_m & paddr_s;
 
assign pwdata_m = psel_m & pwdata_s;
 
master--->slave过程如下：
 
1.将psel_m & penable_m & pready_m形成的pulse 信号同步到clk_1做pready_s
 
2.用psel_m & penable_m & pready_m对prdata_m在clk_2域锁存，锁存的信号直接作为clk_1的prdata_s
 
 
3.用psel_m & penable_m & pready_m对pslverr_m在clk_2域锁存，锁存的信号直接作为clk_1的pslverr_s(和prdata_s一样)
 
 
4.其他AXI/AHB的桥在异步处理上类似于apb2apb的异步桥

前言
因为本科毕业设计中要做一个分布式文件系统，其中一个模块需要实现文件IO。为了验证我对异步IO的理解，决定造一个异步文件IO的轮子。操作系统已经给出各种异步操作的API，如重叠IO, IOCP，kqueue，select，poll，epoll等机制，而且C++也有很多跨平台的异步IO库，如libevent，boost::asio等。我参考已有的实现来完善这个小系统的功能。
渣技术，渣代码，该日志也只是作为这个工程的记录，出现问题请各位指出。
概述
同步与异步：
　　同步：假如我想对一个文件（socket也同理）进行处理，那么一般的流程就是：
　　

 
1 fstream file;
2 file.open();
3 file.read();
4 //do something
5 file.close();

　　通常情况下，当这个线程运行到read（）时会被阻塞，直到文件读取完成。
　　异步：
　　还是上面的代码，我在read（）时通过操作系统或库提供的异步机制，告诉操作系统我想读一个文件，数据读完后执行某个功能；而当前线程在交代完操作系统该做什么工作之后，还可以做些别的事情（线程不必等待文件IO完成）。
线程池
　　为了避免IO阻塞线程导致程序无响应，完全可以为每一个文件操作创建一个线程，这样就可以同时处理多个文件了。但是创建线程，切换线程，销毁线程也是一笔资源开销，如果想重复使用已有的线程，就可以使用线程池。作为线程池，至少要提供创建线程和提交任务的功能，复杂一点可以智能控制线程池里的线程数量,还应该具有基本的负载均衡功能。这个文件系统中就会使用线程池。Windows API中的ThreadPool就很好用，但既然是造轮子，那么为了造轮子而造轮子也没什么关系，干脆就写个简单的线程池出来。
使用的库
　　这个模块只使用stl 和boost 两个库。
　　stl主要涉及容器和fstream。boost涉及到智能指针shared_ptr，线程同步shared_mutex,lock_guard, boost::filesystem中的path和一些文件操作，线程操作创建退出等。
 智能指针
　　自古以来内存管理都是C/C++中的重头戏，智能指针的功能就是分配出来的内存由库管理，如果某个智能指针指向的内存，通过其他的智能指针也能访问到（即有多个引用），那么该智能指针即时被销毁，指向的内存也不会销毁；只有这块内存没有引用，才会被库释放。
boost::filesystem
　　这个库提供了一些跨平台文件操作的API，如文件夹遍历，查看属性，删除文件等。path类可以记录跨平台的路径。
因为水平有限，这个模块基本不会出现跟模板有关的实现。（以后再说）
实现
源码：https://github.com/nemoofnemo/Cluster/tree/master/FileSystem
数据结构及定义
　　AsyncStatus是异步IO中需要实现的功能。像读，写，放弃异步操作，错误处理等。
　　ErrorCode会出现在回调函数中，表示之前异步读写的结果，如正在处理，出错，EOF等。
　　FS_Handle_ST：这个结构体对应一个文件路径。在系统中每个handle都是唯一的，系统有一个map，通过handle可以找到它对应的路径。
　　FS_AsyncHandle_ST:标识某个handle需要执行的任务，每个AsyncHandle都需要指定status即任务。一个handle可以有多个异步任务，但多个任务在系统中按照队列顺序执行。

 

  
 
 
 1     enum QueueOperation { PUSH_BACK, PUSH_FRONT };
 2     enum AsyncStatus { NONE, APPEND_WRITE, WRITE, READ, READ_ALL, ABORT, ERROR, EXIT };
 3     enum ErrorCode { DONE, PENDING, END_OF_FILE, OPEN_FAIL, BAD_STREAM, IO_FAIL, UNKNOWN_ERROR };        
 4 
 5     typedef uintmax_t FS_Handle;
 6     typedef uintmax_t FS_AsyncHandle;
 7 
 8     struct FS_AsyncHandle_ST {
 9         FS_Handle fileHandle = 0;
10         FS_AsyncHandle asyncHandle = 0;
11         AsyncStatus status = AsyncStatus::NONE;
12     };
13 
14     struct FS_Handle_ST {
15         FS_Handle handle = 0;
16         boost::filesystem::path fullPath;
17     };        
 

  
 

　　回调函数:异步操作完成之后要做什么。使用的时候把功能在派生类里实现，重载虚函数run就可以了。

 

  
 
 
 1     class FileSystemIOCallback {
 2     public:
 3         void operator=(const FileSystemIOCallback & cb) {
 4             //..
 5         }
 6 
 7         FileSystemIOCallback(const FileSystemIOCallback & cb) {
 8             //..
 9         }
10 
11         FileSystemIOCallback() {
12             //...
13         }
14 
15         virtual ~FileSystemIOCallback() {
16 
17         }
18 
19         virtual void run(const FS_AsyncHandle_ST & ast, ErrorCode e, void * data, uintmax_t count) {
20             //...
21         }
22     };
 

  
 

 功能概述
　　fstream中有一个非常有趣的函数，readsome（）方法，这个方法提出的目的是尽可能减少同步读取的阻塞时间。该方法会读取fstream内部缓冲区里的数据，读取的字节数取决于fstream内部缓冲区和作为参数传递给它的缓冲区的大小。举个例子，如果fstream缓冲区里只有10字节，我参数给出的缓冲区大小为100字节，不管这个文件后面还有没有数据，它只会去读10个字节。操作系统和函数库可能会使用由硬件引发的中断来读取数据，运行原理类似，但其具体实现未知，还要进一步了解。
　　既然IO操作要阻塞线程很长一段时间，那么就把IO操作扔给线程或纤程，主线程只负责提交任务。

 
同步复位、异步复位、异步复位同步释放、多时钟域复位桥电路和全局复位信号
 
复位
同步复位
异步复位
同步复位异步释放
以两级寄存器异步复位为例说明存在的问题
解决方法------异步复位同步释放
   
参考博客
  
复位电路设计
全局复位（GSR）
多时钟域复位桥电路
按键复位信号电路
  
常见的复位方式

 
复位
 
同步复位
 
1 module test
2 (
3  input clk,
4 input rst_n,
5 input data_in,
6 output reg out
7  );
8 always @ (posedge clk )
9          if(!rst_n) out <= 1'b0;
10          else out <= data_in;
11 endmodule
 

 优点：
 1.因为他只有在时钟有效电平到来时才有效，所以可以滤除高于时钟频率的毛刺。
 2.降低亚稳态出现的概率。（可以对rst信号先打一拍，然后在输入给rst_n，这样就可以降低亚稳态。）
 缺点：
 1.复位信号的有效时长必须大于时钟周期，才能真正被系统识别并完成复位任务。
 
2.倘若采用同步复位的话，综合器就会在寄存器的数据输入端口插入组合逻辑，这样就会耗费较多的逻辑资源。
 
异步复位
 
1 module test
2 (
3  input clk,
4  input rst_n,
5  input data_in,
6  output reg out
7  );
8  always @ (posedge clk or negedge rst_n)
9          if(!rst_n) out <= 1'b0;
10           else out <= data_in;
11  endmodule 
 

 优点
 大多数目标器件库的dff都有异步复位端口，因此采用异步复位可以节省资源。
 
缺点：
 1.在复位信号释放(release)的时候容易出现问题。具体就是说：倘若复位释放时恰恰在时钟有效沿附近，就很容易使寄存器输出出现亚稳态，从而导致亚稳态。
 
2.复位信号容易受到毛刺的影响。
 
同步复位异步释放
 
同步复位异步释放：既解决了同步复位的资源消耗问题，也解决了异步复位的亚稳态问题。其根本思想，也是将异步信号同步化。
 
以两级寄存器异步复位为例说明存在的问题
 
1 module test
2 (
3 input clk,
4 input rst_n,
5 input a,
6 output reg c
7  );
8  
9  reg b;
10 always @ (posedge clk or negedge rst_n)
11          if(!rst_n) b <= 1'b0;
12          else b <= a;
13         
14 always @ (posedge clk or negedge rst_n)
15          if(!rst_n) c <= 1'b0;
16          else c <= b;       
17 
18 endmodule 
 

 正常情况下，clk的上升沿c更新为b，b更新为a。一旦进入复位，b,c都清零；但是我们不能确定复位信号rst_n会在什么时候结束。如果结束于b_reg0和c_reg0的{launch edge –stup,launch edge+hold}时间只外，那么一切都会正常。但如果恰恰相反，会出现什么情况呢？ rst_n的上升变化出现在了clk上升的建立保持时间上，此时clk检测到的rst_n的状态就会是一个亚稳态（是0是1不确定）。从代码里我们看到如果此时b_reg0和c_reg0认为rst_n为0，那么依然保持复位清零，而如果认为rst_n为1，那么就跳出复位。因为此时的rst_n的不确定性，就可能出现4种情况，即b_reg0和c_reg0都复位或者都跳出复位，再或者一个复位一个跳出复位。那么后者就会造成了系统工作不同步的问题，在这个简单的两级异步复位实例中这种危害表现的并不明显，但是我们试想一个大的工程项目里众多的寄存器出现如此情况又会是如何一番景象呢？
 在大工程项目里，如果采用异步复位，那么当亚稳态来临时候，所有寄存器都会随机复位或者跳出复位，导致系统进入未知的或者错误的工作状态。
 
解决方法------异步复位同步释放
 
第一种方式：
 
 
1 module test
 2 (
 3 input clk,
 4 input rst_n,
 5 input a,
 6 output reg c
 7  );
 8  
 9 reg b,rst_nr;
10 always @ (posedge clk)
11          rst_nr <= rst_n;  
12             
13 always @ (posedge clk or negedge rst_nr)
14          if(!rst_nr) b <= 1'b0;
15          else b <= a; 
16             
17 always @ (posedge clk or negedge rst_nr)
18          if(!rst_nr) c <= 1'b0;
19          else c <= b; 
20             
21 endmodule 
 
将第一种方式的复位信号简化后则形成第二种方式。
 第二种方式：
 
1 module test
 2 (
 3  input clk,
 4  input rst_n,
 5  output reg rst_out
 6  );
 7  
 8 always @ (posedge clk,negedge rst_n)
 9     if(!rst_n)
10         rst_out<=1'b0;
11      else
12         rst_out<=1'b1;                        
13  endmodule 

 

 前两种方式都是属于异步复位同步释放，但是当出现一个毛刺信号时候，由于毛刺信号复位时间特别小，而信号变化需要一段时间，所以毛刺信号可能导致复位不彻底（即有些寄存器已经复位，有一些没有复位），系统出现错误的状态（即系统出现混乱），所以不可取。如果将该毛刺信号的复位延迟一个时钟周期，即系统检测到毛刺信号的下降沿后复位，等一个时钟后（即打一拍）再进行还原，可以有效避免这种情况出现。这就是我们所说的第三种方法。
 
 
第三种方式
 
module rst 
( 
  input clk, 
  input rst_n, 
  output reg rst_out 
); 
reg R1; 
    
always @ (posedge clk,negedge rst_n)
     if(!rst_n)
         begin
             R1 <= 1'b0;
             rst_out <= 1'b0;
         end
     else
         begin
             R1 <= 1'b1;
             rst_out <= R1;
        end
endmodule
 

 异步复位，同步释放的好处是：
 1.不要求复位信号必须大于一个时钟周期；
 2.因为释放过程和时钟同步，所以有效降低了亚稳态出现的概率。
 3.消除毛刺信号的影响。
 
参考博客
 
https://www.cnblogs.com/qiweiwang/archive/2010/11/25/1887888.html
 
复位电路设计
 
全局复位（GSR）
 
在很多FPGA中采用全局复位信号，即整个FPGA的所有触发器都使用同一个复位信号。所以GSR信号（全局复位信号）是一个高扇出的信号。
 
对于多数FPGA，均有专用的全局异步复位/置位资源（GSR，GlobalSetReset）。使用GSR资源，异步复位到达所有寄存器的偏斜最小。
 
多时钟域复位桥电路
 
每个时钟域都要有自己的复位信号，而且复位信号要与该时钟域的时钟同步。如下图所示，复位信号在进入每个时钟域前都先进行异步复位同步释放操作，使得复位信号和该时钟域的时钟同步。
 
 
按键复位信号电路
 
按键信号一般有抖动，所以在使用前需要消抖处理。
 这里有两种去抖动方案供大家参考：
 第一种：
 1.每隔20ms采集一次信号rst
 2.对rst信号打一拍，进行边沿检测。（这里需要对上升沿和下降沿都进行检测）
 如果检测到下降沿，则认为复位有效，系统进行复位。如果检测到上升沿，则认为复位释放。
 
//===========================================================================
// 采样按键值，20ms扫描一次,采样频率小于按键毛刺频率，相当于滤除掉了高频毛刺信号。
//===========================================================================
always @(posedge clk or negedge rst_n)     //检测时钟的上升沿和复位的下降沿
begin
   if(!rst_n)                //复位信号低有效
      count <= 20'd0;        //计数器清0
   else
      begin
         if(count ==20'd999_999)   //20ms扫描一次按键,20ms计数(50M/50-1=999_999)
            begin
               count <= 20'b0;     //计数器计到20ms，计数器清零
               key_scan <= key_in; //采样按键输入电平
            end
         else
            count <= count + 20'b1; //计数器加1
     end
end
//===========================================================================
// 按键信号锁存一个时钟节拍
//===========================================================================
reg [3:0] key_scan_r;
always @(posedge clk)
    key_scan_r <= key_scan;       
    
wire [3:0] flag_key = key_scan_r[3:0] & (~key_scan[3:0]);  //当检测到按键有下降沿变化时，代表该按键被按下，按键有效 

 
第二种方法：
 1.先进行上升沿检测
 2.检测到上升沿后，开始计数20ms，采集20ms后的复位信号rst1
 3.如果rst1为高电平且上升沿有效，则认为复位释放。
 同理复位有效也是这样处理。
 
 
 
常见的复位方式
 
为什么大多数电路上的复位信号都是低电平有效？
 
这是为了统一电路处理，使得上电复位过程和按键复位过程处理电路一致。一个板子在没有上电时候，各个管脚的信号可以认为是低电平的。并且电路上电和按键被按下时刻，数字电路的行为应该是一样的。而上电时刻，复位信号接一个高电平的模拟延时电路，从而保证时钟比复位信号早到（此时复位信号是低电平），如此芯片在工作开始前就复位了。
 
我们习惯上通常使用的复位有三种方式：
 
硬件开关：复位信号接一个拨码开关或按键，或者RC电路
 
电源芯片：上电时候电源芯片产生，可以长时间维持，直到稳定。
 
控制芯片：控制芯片产生复位脉冲。

同步方法
 
程序运行的时候，在调用其他方法的时候，会等待被调用的方法按顺序执行完，才会继续执行。非常符合开发思维，有序执行(这个意思是干啥都是一起干(不管多少程序)等最慢的或者最长的完成之后才可以统一完成(铁哥们)(括号内自我理解如果不对就别当回事))
 异步方法
 
在程序调用异步方法的时候，主程序不会等待方法执行完，而是主程序调用异步方法后直接继续运行，而异步方法会启动一个新线程来完成方法的计算。(异步相等于VIP干啥都是有特殊通道(括号内自我理解如果不对就别当回事))
 
异步编程
 
委托的异步调用
 
先根据比较耗时的功能方法声明对应的委托
给委托赋值，赋与这个耗时的功能函数
采用委托的BeginInvoke方法进行异步调用委托
 Invoke方法：类似于默认的方法调用，相当于直接使用()调用委托
 BeginInvoke方法：指采取异步调用委托
给BeginInvoke方法创建回调函数
 回调函数：回调函数是指，当前的正在执行的操作完成之后，立刻回调用的一个函数是回调函数
 BeginInvoke方法参数组成： 
  
第一组参数：委托所指向的方法对应的参数
AsyncCallback参数：与当前委托对应的回调函数
object参数：假如回调函数需要参数则由object参数提供
 BeginInvoke方法返回值为IAsyncResult，而委托的回调函数必须有一个参数为IAsyncResult类型
 
通过EndInvoke获取对应委托的BeginInvoke的执行结果
因为BeginInvoke相当于重新创建的线程进行异步调用方法函数，所以回调函数也是异步的线程的执行的，那么异步线程和程序主线程相当于阳关道和独木桥，
 因此如果使用Winform或WPF中的控件要考虑清楚：UI中的控件等都是Winform或WPF主线程中创建的，而异步线程无法直接使用
 设置CheckForIllegalCrossThreadCalls =false，这个属性是用来设置Winform或者WPF中的主线程不在做控件的跨线程检测
 
public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }
        private void button1_Click_1(object sender, EventArgs e)
        {
            int a = 0;
            //多线程编程
            //委托：ParameterizedThreadStart
            Thread objThread1 = new Thread(() =>
             {
                 for (int i = 0; i < 10; i++)
                 {
                     a += i;
                     //当 一个控件的InvokeRequired属性值为真时，说明有一个创建它以外的线程想访问它，此时它将会在内部调用new MethodInvoker(LoadGlobalImage)来完成下面的步骤，
                     if (label1.InvokeRequired)
                     {
                         //Invoke方法：类似于默认的方法调用，相当于直接使用()调用委托
                         label1.Invoke(new Action<string>(s =>
                         {
                             label1.Text = $"【{s}】";
                         }), a.ToString());
                     }
                     Thread.Sleep(500);
                 }
             });
            objThread1.IsBackground = true;//设置为后台线程
            objThread1.Start();//启动任务，将其调度到当前任务调度程序执行。
        }

        private void button2_Click(object sender, EventArgs e)
        {
            int a = 0;
            Thread objThread02 = new Thread(() =>
            {
                for (int i = 0; i < 100; i++)
                {
                    a += i;
                    if (label2.InvokeRequired)
                    {
                        label2.Invoke(new Action<int>(s =>
                        {
                            label2.Text = $"【{s}】";
                        }), a);
                        Thread.Sleep(200);
                    }
                }
            });
            objThread02.IsBackground = true;
            objThread02.Start();
        }
    }
 
异步编程总结
 
异步编程是建立在委托基础上的一种编程方法
异步调用的每个方法都是独立的线程执行。因此。本质上就是一种多线程程序，也可以说是一种简化版本的多线程技术
比较适合在后台运行较为耗时的简单任务，并且任务要求相互独立，任务中不应该有代码直接访问可视化控件
如果后台任务要求必须按照特定顺序执行，或者必须访问公共资源，则异步编程不适合，而直接使用多线程技术
 
多线程的异步
 
public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }
        private void button1_Click_1(object sender, EventArgs e)
        {
            int a = 0;
            //多线程编程
            //委托：ParameterizedThreadStart
            Thread objThread1 = new Thread(() =>
             {
                 for (int i = 0; i < 10; i++)
                 {
                     a += i;
                     //当 一个控件的InvokeRequired属性值为真时，说明有一个创建它以外的线程想访问它，此时它将会在内部调用new MethodInvoker(LoadGlobalImage)来完成下面的步骤，
                     if (label1.InvokeRequired)
                     {
                         //Invoke方法：类似于默认的方法调用，相当于直接使用()调用委托
                         label1.Invoke(new Action<string>(s =>
                         {
                             label1.Text = $"【{s}】";
                         }), a.ToString());
                     }
                     Thread.Sleep(500);
                 }
             });
            objThread1.IsBackground = true;//设置为后台线程
            objThread1.Start();//启动任务，将其调度到当前任务调度程序执行。
        }

        private void button2_Click(object sender, EventArgs e)
        {
            int a = 0;
            Thread objThread02 = new Thread(() =>
            {
                for (int i = 0; i < 100; i++)
                {
                    a += i;
                    if (label2.InvokeRequired)
                    {
                        label2.Invoke(new Action<int>(s =>
                        {
                            label2.Text = $"【{s}】";
                        }), a);
                        Thread.Sleep(200);
                    }
                }
            });
            objThread02.IsBackground = true;
            objThread02.Start();
        }
    }
 
后台线程
 
指的是程序中的一些功能不需要和一般线程同时执行，或者这些功能对于UI界面中显示方面要求不高，可以设置为后台线程
 
例如:VS工具中的，编译检测功能就是后台线程，当VS启动起来，除过前台线程给我们展示编辑菜单等界面，同时后台运行了检测程序
 句柄(Handle)
 
句柄是一个标识符，用于代表操作系统中的各种资源，比如各种窗体、GDI绘图对象、进程和线程对象、文件等都用句柄
 
句柄使用
 
即使进程退出，很多时候操作系统仍然保持进程句柄，操作系统句柄有限，使用用需要节省，比如打开文件后，使用完毕要及时关闭
句柄可以通过Process对象的Handle属性访问，比如进程退出的代码，时间等
 
总结：拥有图形界面的程序都有一个主窗体，这个窗体也对应有一个句柄。当窗体关闭时进程也关闭。主窗体一般由主线程负责创建