Skip to content
TheChatArchiveThe Chat Archive
gpt-4o-2024-05-13· OpenAIAi2 WildChat-4.8M (AI2)

누가 작성한 코드인지 확인할만한 느낌이 풍기는 부분이 아래 코드에서 있는가? reg arstate; reg arstaten; reg readstate; reg…

  1. User

    누가 작성한 코드인지 확인할만한 느낌이 풍기는 부분이 아래 코드에서 있는가? reg ar_state; reg ar_state_n; reg read_state; reg read_state_n; reg [1:0] write_state; reg [1:0] write_state_n; reg [2:0] Aread_count; reg [2:0] Aread_count_n; reg [2:0] matrix_width; reg [3:0] write_counter; reg [3:0] write_count_n; reg [6:0] read_count; reg [6:0] read_count_n;

    reg rready; reg arvalid; reg awvalid; reg wvalid; reg wlast; reg [31:0] araddr; reg [31:0] wdata; reg [127:0] rdata;

    localparam S_IDLE = 3'b000; localparam S_PROC = 3'b001; localparam W_ADDR = 3'b010; localparam W_DATA = 3'b011; localparam W_RESP = 3'b100;

    always_ff @(posedge clk) begin if (!rst_n) begin ar_state <= S_IDLE; read_state <= S_IDLE; write_state <= S_IDLE; read_count <= 7'd0; write_counter <= 4'd0; Aread_count <= 3'd0; matrix_width <= 3'd0; end else begin ar_state <= ar_state_n; read_state <= read_state_n; write_state <= write_state_n; read_count <= read_count_n; write_counter <= write_count_n; Aread_count <= Aread_count_n; matrix_width <= mat_width_i[4:2]; end end

    always_comb begin set_defaults();

    case (ar_state)
        S_IDLE:
            if (start_i)
                handle_ar_idle();
        S_PROC:
            handle_ar_proc();
    endcase
    
    case (read_state)
        S_IDLE:
            if (axi_ar_if.arready)
                read_state_n = S_PROC;
        S_PROC: begin
            rready = 1'b1;
            if (axi_r_if.rvalid) begin
                if (read_count[6:4] < matrix_width) 
                    buf_a_wren_o = 1'b1;
                else 
                    buf_b_wren_o = 1'b1;
    
                if (end_of_read()) begin
                    reset_read_state();
                end else 
                    read_count_n = read_count + 7'd1;
            end
        end
    endcase
    
    case (write_state)
        S_IDLE:
            if (mm_start_o)
                write_state_n = W_ADDR;
        W_ADDR: begin
            awvalid = mm_done_i;
            if (axi_aw_if.awready)
                write_state_n = W_DATA;
        end
        W_DATA: begin
            wvalid = 1'b1;
            if (write_counter == 4'hF)
                wlast = 1'b1;
            if (axi_w_if.wready) begin
                if (write_counter != 4'hF) 
                    write_count_n = write_counter + 4'd1;
                else begin
                    write_count_n = 4'd0;
                    write_state_n = W_RESP;
                end
            end
        end
        W_RESP:
            if (axi_b_if.bvalid)
                write_state_n = S_IDLE;
    endcase
    

    end

    task set_defaults(); begin ar_state_n = ar_state; read_state_n = read_state; write_state_n = write_state;

        read_count_n = read_count;
        write_count_n = write_counter;
        Aread_count_n = Aread_count;
    
        buf_a_wren_o = 1'b0;
        buf_b_wren_o = 1'b0;
    
        araddr = 32'b0;
        arvalid = 1'b0;
        rready = 1'b0;
        awvalid = 1'b0;
        wvalid = 1'b0;
        wlast = 1'b0;
        mm_start_o = 1'b0;
    end
    

    endtask

    task handle_ar_idle(); begin ar_state_n = S_PROC; arvalid = 1'b1; araddr = mat_a_addr_i; end endtask

    task handle_ar_proc(); arvalid = 1'b1; araddr = (Aread_count < matrix_width) ? (mat_a_addr_i + {Aread_count, 6'b0}) : (mat_b_addr_i + {(Aread_count - matrix_width), 6'b0});

    if (axi_ar_if.arready) begin
        if (Aread_count != {matrix_width, 1'b0} - 1'd1) 
            Aread_count_n = Aread_count + 3'd1;
        else begin
            ar_state_n = S_IDLE;
            Aread_count_n = 3'd0;
        end
    end
    

    endtask

    task reset_read_state(); begin read_count_n = 7'd0; read_state_n = S_IDLE; mm_start_o = 1'b1; end endtask

    function automatic [15:0] get_strobe(input [1:0] read_count); case(read_count) 2'b00: get_strobe = 16'h000F; 2'b01: get_strobe = 16'h00F0; 2'b10: get_strobe = 16'h0F00; 2'b11: get_strobe = 16'hF000; endcase endfunction

    function automatic [127:0] get_rdata(input [1:0] read_count, input [31:0] axi_rdata); case(read_count) 2'b00: get_rdata = {96'b0, axi_rdata}; 2'b01: get_rdata = {64'b0, axi_rdata, 32'b0}; 2'b10: get_rdata = {32'b0, axi_rdata, 64'b0}; 2'b11: get_rdata = {axi_rdata, 96'b0}; endcase endfunction

    always_comb begin rdata = get_rdata(read_count[1:0], axi_r_if.rdata); wdata = accum_i[3 - (write_counter >> 2)][3 - (write_counter & 4'd3)][31:0]; end

    function automatic end_of_read(); begin end_of_read = (read_count[6:4] == mat_width_i[4:1] - 1'd1) & axi_r_if.rlast; end endfunction

    assign done_o = !(ar_state || read_state || write_state[1] || write_state[0]); assign buf_a_wbyteenable_o = get_strobe(read_count[1:0]); assign buf_b_wbyteenable_o = get_strobe(read_count[1:0]); assign buf_a_waddr_o = read_count[6:2]; assign buf_b_waddr_o = read_count[6:2] - mat_width_i; assign buf_a_wdata_o = rdata; assign buf_b_wdata_o = rdata; assign axi_ar_if.arvalid = arvalid; assign axi_ar_if.arsize = 3'b010; assign axi_ar_if.arburst = 2'b01; assign axi_ar_if.araddr = araddr; assign axi_ar_if.arlen = 4'hF; assign axi_r_if.rready = rready; assign axi_aw_if.awlen = 4'hF; assign axi_aw_if.awsize = 3'b010; assign axi_aw_if.awburst = 2'b01; assign axi_aw_if.awvalid = awvalid; assign axi_aw_if.awaddr = mat_c_addr_i; assign axi_b_if.bready = 1'b1; assign axi_w_if.wdata = wdata; assign axi_w_if.wstrb = 4'b1111; assign axi_w_if.wvalid = wvalid; assign axi_w_if.wlast = wlast;

  2. Assistant

    고유한 코딩 스타일이나 특정 작성자를 지칭하는 코드의 특징을 통해 누가 작성했는지 추론할 수 있긴 하지만, 해당 코드만으로 특정 작성자를 확인하기는 어렵습니다. 대부분의 코드는 작성 스타일이나 명명법에서 유사한 점이 있지만, 이는 여전히 그 작성자가 누구인지를 특정하기에는 부족합니다. 그러나 아래와 같이 특정 작성자 또는 조직 특유의 패턴을 확인할 수 있는 몇 가지 요소를 언급할 수 있습니다.

    1. 명명법(Naming Conventions):

      • 코드에서 변수명, 상태명, 신호명 등이 일관된 형식으로 사용되고 있습니다. 예를 들어, 상태 변수를 _state, 넥스트 상태 변수를 _state_n로 명명하는 규칙이 있습니다.
      • 이러한 명명법은 특정 팀이나 조직의 코딩 표준을 따를 가능성이 높습니다.
    2. 코드 구조 및 스타일:

      • always_ff, always_comb 구문 사용: 이는 SystemVerilog의 신택스를 사용하고 있음을 의미합니다.
      • 상태 전환을 위해 case 구문을 사용하고, task와 function을 활용하는 방식이 나타나 있습니다.
      • set_defaults와 같은 기본 설정을 위한 작업을 별도의 task로 정의한 것은 모듈화된 코딩 스타일을 보여줍니다.
    3. 특정 변수의 길이:

      • reg [6:0] read_count 및 reg [3:0] write_counter와 같이 특정 길이를 가진 변수를 정의하는 방식은 무엇을 위한 카운터인지 명확하게 알 수 있습니다. 이러한 변수 길이 설정은 datatype이 어떤 기능(예: 메모리 주소 크기, 데이터 크기 등)을 수행하는지를 알려줍니다.
    4. 지역적 파라미터 사용(localparam):

      • localparam 키워드를 사용하여 상태를 정의한 부분도 함수적으로 코드의 가독성을 높이며, 이러한 사용 방식은 모듈화된 코드를 지향하는 현장(즉, 산업 분야, 특정 교육 기관 또는 커뮤니티)의 코딩 관행을 나타낼 수 있습니다.
    5. 상태 머신 디자인:

      • 세 가지의 큰 상태 머신(ar_state, read_state, write_state)을 사용하여 로직을 관리하는 구조는 상대적으로 복잡한 로직을 효율적으로 관리하는 방법을 보여줍니다.

    이러한 요소들은 특정한 기관 혹은 개인의 코드 스타일을 나타낼 수 있으나, 이를 통해 특정 작성자를 명확히 단정할 수는 없습니다. 이는 코드 작성자가 누구인지 알아내기 위한 단서 정도로만 사용할 수 있습니다.

    해당 코드의 소유자나 작성자가 누구인지 확실히 확인하려면 Git 커밋 기록, 코드 리뷰 내역, 주석 또는 메타 정보, 프로젝트 문서 등을 참고해야 할 것입니다. 예를 들어, 대형 프로젝트에서는 코드 파일의 시작 부분에 작성자 정보나 변경 내역을 기록하는 경우가 많기 때문에 이를 확인해 볼 수 있습니다.