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的异步桥

同步复位、异步复位、异步复位同步释放、多时钟域复位桥电路和全局复位信号
复位
同步复位
异步复位
同步复位异步释放
以两级寄存器异步复位为例说明存在的问题
解决方法------异步复位同步释放
参考博客
复位电路设计
全局复位（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电路
电源芯片：上电时候电源芯片产生，可以长时间维持，直到稳定。
控制芯片：控制芯片产生复位脉冲。

五花八门的日志框架

门面 slf4j  common-log

实现 jul log4j logback 等

 

解决jar包中应用的日志框架各不相同，使用适配器和桥接器可以很好的解决

桥接器命名规范一般是  实现类-over/to-门面 （eg： log4j-over-slf4j）

桥接器实现原理- 已上面jar包为例，桥接器重写了log4j，类名功能都一样，但是实现了slf接口。引入桥接器 排除实现 完美替代log4j的类。

 

常用SLF4J

不同的框架变成slf4，别的门面通过桥接到slf4j



 

说下我之前遇到的真实问题，线上qps到了20k左右 大量的日志导致了服务抖动，优化了如下配置

discardThreshold  剩余容量导致了这个值 丢弃日志

queuqSize 同步队列的长度

nevermoreBlock 使用非阻塞方法 offer 默认put

 

参考了大佬的文章，写的超赞

https://time.geekbang.org/column/article/220307

1.异步操作过程实例：
A.开启一个线程一直执行耗时操作
B.通过每隔多长多件轮询线程是否实行完毕，thread.isCompleted()
C.执行完毕后，通过回调函数返回真实信息
一个调用者在调用耗时操作,不能立即返回数据时,先返回一个取货凭证.然后在过一断时间后
凭取货凭证来获取真正的数据.
所以连结调用者和真实数据之间的桥梁是取货凭证.我们先来看它的实现:
public class FutureTicket{
private Object data = null;
private boolean completed = false;
public synchronized void makeRealData(){
if(this.complited) return;
//获取数据的耗时操作.这里用Sleep代替
try{
Thread.sleep(10000);
}catch(Throwable t){}
this.data = "返回的数据内容";
this.completed = true;
notifyAll();
}
public synchronized Object getData(){
while(!this.completed)){
try{
wait();
}catch(Throwable t){}
}
return this.data;
}
public boolean isCompleted(){
return this.completed;
}
}
为了简单化说明(不把它们的关系开得复杂),这里用Objectb代替了真实数据.而真实的实现中
我们应该把makeData放在一个真实数据的类中,然后提供一个方法返回真实数据.这样对于真实
数据的处理和取货凭证解耦.
对于这个取货凭证,调用者的如何调用是异步调用的关键:
publc class Requester{
public FutureTicket request(){
final FutureTicket ft = new FutureTicket();
//在新线程中调用耗时操作
new Thread(){
public void run(){
ft.makeRealData();
}
}.start();
return ft;
}
}
在新线程中启动耗时操作后,不等待线程的完成立即返回提货单.
然后调用者可以根据ft.isCompleted()来调用getData()获取真实数据.
当然对ft.isCompleted()测试可以按规定时间间隔轮巡(极低级的方案),也可以
在条件不满足时wait(),然后等待makeData的notifyAll();这样你就完成了一个
用JAVA模拟的异步操作.
改进:
但这样的调用对于调用者来说仍然要继续控制线程操作.如果调用者是一个资深的
程序员,这当然没有问题.但假如我们把对直接数据的处理委托给取货凭证来做.调用
者直接规定对数据的操作,然后由取货凭证来调用规定的操作,这对于调用者是一个很
好的解脱:
interface ProcessData{
public void process(Onject data);
}
public MyProcessData{
public void process(Object data){
//你不管什么时候起初数据data被获取了.
//你只要规定如果获取到数据了如何处理
System.out.println(data.toString() + "处理完成...........");
//insert into dataBase?
}
}
取货凭证在接收调用者请求获取数据时,要知道对获取的数据如何处理的方法:
public class FutureTicket{
private Object data = null;
private boolean completed = false;
private ProcessData pd;
public FutureTicket(ProcessData pd){
this.pd = pd;
}
public synchronized void makeRealData(ProcessData pd){
if(this.complited) return;
//获取数据的耗时操作.这里用Sleep代替
try{
Thread.sleep(10000);
}catch(Throwable t){}
this.data = "返回的数据内容";
this.completed = true;
notifyAll();
}
public synchronized void putData(){
while(!this.completed)){
try{
wait();
}catch(Throwable t){}
}
//return this.data;
//不用返回了,直接处理
this.pd.process(this.data);
// alert(?);
}
//这个方法也可以不要了.
public boolean isCompleted(){
return this.completed;
}
}
调用:
final FutureTicket ft = new FutureTicket(new ProcessData());
//在新线程中调用耗时操作
new Thread(){
public void run(){
ft.makeRealData();
}
}.start();
ft.putData();
OK,你现在可以抽烟,喝酒,泡妞.ft会为你完成所有的工作.