캐스케이드 2 비트 비교기를 사용하는 2n 비트 비교기 구현

Question

지금까지 2 비트 비교기에 대한이 코드를 사용했습니다.

module twobitcomparator(xgtyin,xety,xltyin,x1,x0,y1,y0,xgty,xety,xlty); 
//I/O 
output xgty, xety, xlty; //xgty - x>y, xlty - x<y, xety - x=y 
input x1, x0, y1, y0, xgtyin, xetyin, xltyin; 

//specify circuit behavior 
assign r = (xgyin); 
assign s = (xlyin); 
assign t = (xetyin);//not sure if I need an xetyin 

assign a = (x1&~y1); 
assign b = (x1&x0&~y0); 
assign c = (x0&~y1&~y0); 
assign xgty = (a|b|c|r);//X>Y 

assign d = (~x0&~y0); 
assign e = (x0&y0); 
assign f = (x1&y1); 
assign g = (~x1&~y1); 
assign xety = ((d|e)&(f|g));//X=Y 

assign h = (~x1&~x0&y0); 
assign i = (~x1&y1); 
assign j = (~x0&y1&y0); 
assign xlty = (h|i|j|s);//X<Y 

endmodule 

이 모양이 좋습니까? 나는 그것을 위해 테스트 벤치를 작성하고 파도를 바라 보았고 결과물은 입력에 대해 정확했지만 가장 효율적인 방법인지는 확실치 않습니다.

계단식의 경우, 최상위 비트 비교기의 결과 (불균형 인 경우)가 나머지 비교기를 통해 전송되어야하며 최종 결과가된다는 것을 알고 있습니다. 그것들이 동일하다면, 가장 높은 비트 비교기를 찾아야 만합니다. 여기서는 불평등이 있고, 제가 언급 한 것처럼 계단식으로 연결될 필요가 있습니다.

내가 캐스 캐 이드를 사용하는 데 어려움을 겪었으므로 Verilog에 익숙하지 않은데 어떻게 각 비교기의 결과를 다음 단계로 가져 오는지 실마리가 없습니다. 여기 내 시도입니다.

module ncompare#(parameter n = 2)(input [2*n-1:0] xgyin, xlyin, 
input [2*n-1:0] x1, x0, y1, y0, 
output [2*n-1:0] xgy, xey, xly, 
output xqyout); 
wire xqyin; 
assign xqyin = 1'b0; 

twobitcomparator s1(.xgyin(xgyin[xqyin]), .xlyin(xlyin[xqyin]), 
.x1(x1[2*n-1]), .x0(x0[2*n-2]), .y1(y1[2*n-1]), .y0(y0[2*n-2]), 
.xgy(xgy[ripple0]), .xey(xey[ripple1]), .xly(xly[ripple2])); 

twobitcomparator s0(.xgyin(xgyin[ripple0]), .xlyin(xlyin[ripple2]), 
.x1(x1[1]), .x0(x0[0]), .y1(y1[1]), .y0(y0[0]), 
.xgy(xgy[ripple3]), .xey(xey[ripple4]), .xly(xly[ripple5])); 

endmodule 

는 나는 내가 어떤 매개 변수 N을 위해 일해야하기 때문에 생성 문을 사용할 필요가 있다고 생각하지만 난 어떻게 만 검토 한 모든 예는 하나 개의 출력 및 I이 있기 때문에 생성 사용하는 단서가 없다 3 개가 있습니다 (다음 비교기의 입력입니다!)

모든 도움에 감사드립니다! I 대신 개별 비트들로 처리하는 버스로서 두 비트 입력을 처리 한

module twobitcomparator(xgtyin,xltyin,x,y,xgty,xlty,xety); 

    output xgty, xety, xlty;   
    input xgtyin, xltyin; 
    input [1:0] x,y; 

    assign xgty = xgtyin | (~xltyin & ((x[1] > y[1]) | ((x[1] == y[1]) & (x[0] > y[0])))); 
    assign xlty = xltyin | (~xgtyin & ((x[1] < y[1]) | ((x[1] == y[1]) & (x[0] < y[0])))); 

    assign xety = ~(xlty | xgty); 

endmodule 

로

Answer 1

2 비트 비교기 모듈을 쓸 수있다 (Verilog를 사용하면 해당 할 수 있음). 귀하의 코드에 존재하는 수많은 중간 결과를 정리했습니다. 이렇게하면 모든 임시 배선을 추적 할 필요가 없으므로 코드를 더 쉽게 이해할 수 있습니다.

그런 다음이 모듈을 EDA 놀이터에서 Icarus Verilog를 사용하여 시뮬레이션했습니다. 링크는 여기 https://www.edaplayground.com/x/5KRL

이러한 twobitcomparator를 사용하는 4 비트 비교기는 다음과 같이 작성할 수 있습니다. https://www.edaplayground.com/x/2fbr 파형에

module twoN_bitcomparator #(
    parameter N = 2 
)(
    input xgtyin, 
    input xltyin, 
    input [(2*N-1):0]x, 
    input [(2*N-1):0]y, 
    output xgty, 
    output xlty, 
    output xety 
); 

    wire [N:0] xgty_w,xlty_w,xety_w; 

    assign xgty_w[N] = xgtyin; 
    assign xlty_w[N] = xltyin; 

    generate 
    genvar i; 
    for (i=0;i<=(N-1);i=i+1) 
     begin:TWOBITGEN 
     twobitcomparator u_1 (
      .xgtyin(xgty_w[i+1]), 
      .xltyin(xlty_w[i+1]), 
      .x(x[(2*i+1) : (2*i)]), 
      .y(y[(2*i+1) : (2*i)]), 
      .xgty(xgty_w[i]), 
      .xlty(xlty_w[i]), 
      .xety(xety_w[i]) 
     ); 
     end 
    endgenerate 

    assign xgty = xgty_w[0]; 
    assign xlty = xlty_w[0]; 
    assign xety = xety_w[0]; 

endmodule 

이 일반화 모듈의 시뮬레이션은 다음과 같은 EDA 놀이터 가능으로 작은 테스트 벤치도이기

module fourbitcomparator(xgtyin,xltyin,x,y,xgty,xlty,xety); 
    output xgty, xety, xlty;   
    input xgtyin, xltyin; 
    input [3:0] x,y; 

    wire xgty_1,xlty_1,xety_1; 

    twobitcomparator u_1 (
    .xgtyin(xgtyin), 
    .xltyin(xltyin), 
    .x(x[3:2]), 
    .y(y[3:2]), 
    .xgty(xgty_1), 
    .xlty(xlty_1), 
    .xety(xety_1) 
); 

    twobitcomparator u_0 (
    .xgtyin(xgty_1), 
    .xltyin(xlty_1), 
    .x(x[1:0]), 
    .y(y[1:0]), 
    .xgty(xgty), 
    .xlty(xlty), 
    .xety(xety) 
); 

endmodule 

마지막 twobitcomparators을 사용하여 2n 개의 비트 비교기는 일반화 될 수있다 이용 가능 : https://www.edaplayground.com/w/x/27X