【計算機系統設計】實踐筆記（4）改進數據通路：第一類I型指令分析與實現

0 回顧

之前，我們完成了17條R型指令的設計，接下來，我們逐步完成I型指令的設計。

1 核心思想：增量思維 & 復用思維 & 學會選擇 & 分治思想

增量思維

我們從無到有，構建了支持R型指令的CPU，接下來還會完成I型指令，J型指令，這樣，單周期CPU就完成了，之后，我們會將其改進為多周期CPU，也會改進為五級流水線CPU，之后可能需要提升性能，增加串口；將內存移出去，增加內存控制器；增加指令Cache和數據Cache……讓我們慢慢啟程吧！

復用思維 & 學會選擇

人生皆選擇，CPU也一樣，同樣的一個功能，復用同一個器件，輸入卻可能不同，而控制器就幫其做出選擇，配合多路選擇器完成這個選擇！

分治思想

我們每一次，都是完成一類指令，我們將一類具備共同特征的指令抽出來，一起來完成它，提高效率！

2 第一類I型指令

在這里插入圖片描述這些指令，是R型指令的立即數操作。

I-類型oprsrtimmediate
addi001000rsrtimmediate
addiu001001rsrtimmediate
andi001100rsrtimmediate
ori001101rsrtimmediate
xori001110rsrtimmediate
lui00111100000rtimmediate
slti001010rsrtimmediate
sltiu001011rsrtimmediate

它們共同的操作都是 rt <- rs op imm

特別的，lui比較特殊，直接將imm移動到32位高16位，低16位補0.

另外，16位的imm需要擴展，可能是0擴展也可能是符號擴展，根據不同的指令進行不同判斷即可。

然后，我們看看這些操作需要增加的器件和控制信號，再進行設計即可，這個過程已經做了好多遍了，這里可以直接加速完成，不再細說了。

在這里插入圖片描述
這里，還需要一個額外的控制信號，表明是0擴展還是符號擴展，我們使用Zero_sign_ex

  • 0：0擴展
  • 1：符號擴展

還有Lui信號，表明是lui指令，輸入到ALU。
在這里插入圖片描述
這是新的數據通路，我們在設計的時候

  1. 將imm，ALUSrc，Zero_sign_ex集成到ALU中
  2. 將RegDst集成到Reg Files中

3 設計

3.1 控制器

特別注意RegDst 信號

  • 0：rt I類指令
  • 1：rd R類指令
instructionopALUopRegWriteSftmdJrnLuiRegDstALUSrcZero_sign_ex
addi00100000001000011
addiu00100100011000011
andi00110001001000010
ori00110101011000010
xori00111001101000010
lui00111111011001010
slti00101010001000011
sltiu00101110011000010
`timescale 1ns / 1ps
//
// Company:
// Engineer:
//
// Create Date: 2020/11/14 22:30:48
// Design Name:
// Module Name: control_1
// Project Name:
// Target Devices:
// Tool Versions:
// Description:
//
// Dependencies:
//
// Revision:
// Revision 0.01 - File Created
// Additional Comments:
//
//module control_1(input [5:0] op,input [5:0] func,output reg RegWrite,output reg Sftmd,    // indicate the instruction is sll/srl/sraoutput reg [3:0] ALUop,output reg Jrn,   // jr instructionoutput reg Lui,   // lui instructionoutput reg RegDst,output reg ALUSrc,output reg Zero_sign_ex);always @(*)
begincase(op)6'b000000:   R-type begincase (func)6'b100000:  // addbeginRegWrite <= 1;Sftmd <= 0;ALUop <= 4'b0000;Jrn <= 0;Lui <= 0;RegDst <= 1;ALUSrc <= 0;Zero_sign_ex <= 0;end6'b100001:  // addubeginRegWrite <= 1;Sftmd <= 0;ALUop <= 4'b0001;Jrn <= 0;Lui <= 0;RegDst <= 1;ALUSrc <= 0;Zero_sign_ex <= 0;end6'b100010:  // subbeginRegWrite <= 1;Sftmd <= 0;ALUop <= 4'b0010;Jrn <= 0;Lui <= 0;RegDst <= 1;ALUSrc <= 0;Zero_sign_ex <= 0;end6'b100011:  // sububeginRegWrite <= 1;Sftmd <= 0;ALUop <= 4'b0011;Jrn <= 0;Lui <= 0;RegDst <= 1;ALUSrc <= 0;Zero_sign_ex <= 0;end6'b100100:  // andbeginRegWrite <= 1;Sftmd <= 0;ALUop <= 4'b0100;Jrn <= 0;Lui <= 0;RegDst <= 1;ALUSrc <= 0;Zero_sign_ex <= 0;end6'b100101:  // orbeginRegWrite <= 1;Sftmd <= 0;ALUop <= 4'b0101;Jrn <= 0;Lui <= 0;RegDst <= 1;ALUSrc <= 0;Zero_sign_ex <= 0;end6'b100110:  // xorbeginRegWrite <= 1;Sftmd <= 0;ALUop <= 4'b0110;Jrn <= 0;Lui <= 0;RegDst <= 1;ALUSrc <= 0;Zero_sign_ex <= 0;end6'b100111:  // norbeginRegWrite <= 1;Sftmd <= 0;ALUop <= 4'b0111;Jrn <= 0;Lui <= 0;RegDst <= 1;ALUSrc <= 0;Zero_sign_ex <= 0;end6'b101010:  // sltbeginRegWrite <= 1;Sftmd <= 0;ALUop <= 4'b1000;Jrn <= 0;Lui <= 0;RegDst <= 1;ALUSrc <= 0;Zero_sign_ex <= 0;end6'b101011:  // sltubeginRegWrite <= 1;Sftmd <= 0;ALUop <= 4'b1001;Jrn <= 0;Lui <= 0;RegDst <= 1;ALUSrc <= 0;Zero_sign_ex <= 0;end6'b000100:  // sllvbeginRegWrite <= 1;Sftmd <= 0;ALUop <= 4'b1010;Jrn <= 0;Lui <= 0;RegDst <= 1;ALUSrc <= 0;Zero_sign_ex <= 0;end6'b000110:  // srlvbeginRegWrite <= 1;Sftmd <= 0;ALUop <= 4'b1011;Jrn <= 0;Lui <= 0;RegDst <= 1;ALUSrc <= 0;Zero_sign_ex <= 0;end6'b000111:  // sravbeginRegWrite <= 1;Sftmd <= 0;ALUop <= 4'b1100;Jrn <= 0;Lui <= 0;RegDst <= 1;ALUSrc <= 0;Zero_sign_ex <= 0;end6'b000000:  // sllbeginRegWrite <= 1;Sftmd <= 1;ALUop <= 4'b1010;Jrn <= 0;Lui <= 0;RegDst <= 1;ALUSrc <= 0;Zero_sign_ex <= 0;end6'b000010:  // srlbeginRegWrite <= 1;Sftmd <= 1;ALUop <= 4'b1011;Jrn <= 0;Lui <= 0;RegDst <= 1;ALUSrc <= 0;Zero_sign_ex <= 0;end6'b000011:  // srabeginRegWrite <= 1;Sftmd <= 1;ALUop <= 4'b1100;Jrn <= 0;Lui <= 0;RegDst <= 1;ALUSrc <= 0;Zero_sign_ex <= 0;end6'b001000:  // jrbeginRegWrite <= 0;Sftmd <= 0;ALUop <= 4'b1111;Jrn <= 1;Lui <= 0;RegDst <= 1;ALUSrc <= 0;Zero_sign_ex <= 0;enddefault:beginRegWrite <= 0;Sftmd <= 0;ALUop <= 4'b1111;Jrn <= 0;Lui <= 0;RegDst <= 1;ALUSrc <= 0;Zero_sign_ex <= 0;endendcaseend/*************** I-type ***************/6'b001000:  // addibeginALUop <= 4'b0000;RegWrite <= 1;Sftmd <= 0;Jrn <= 0;Lui <= 0;RegDst <= 0;ALUSrc <= 1;Zero_sign_ex <= 1;end6'b001001:  // addiubeginALUop <= 4'b0001;RegWrite <= 1;Sftmd <= 0;Jrn <= 0;Lui <= 0;RegDst <= 0;ALUSrc <= 1;Zero_sign_ex <= 1;end6'b001100:  // andibeginALUop <= 4'b0100;RegWrite <= 1;Sftmd <= 0;Jrn <= 0;Lui <= 0;RegDst <= 0;ALUSrc <= 1;Zero_sign_ex <= 0;end6'b001101:  // oribeginALUop <= 4'b0101;RegWrite <= 1;Sftmd <= 0;Jrn <= 0;Lui <= 0;RegDst <= 0;ALUSrc <= 1;Zero_sign_ex <= 0;end6'b001110:  // xoribeginALUop <= 4'b0110;RegWrite <= 1;Sftmd <= 0;Jrn <= 0;Lui <= 0;RegDst <= 0;ALUSrc <= 1;Zero_sign_ex <= 0;end6'b001111:  // lui  note beginALUop <= 4'b1101;RegWrite <= 1;Sftmd <= 0;Jrn <= 0;Lui <= 1;RegDst <= 0;ALUSrc <= 1;Zero_sign_ex <= 0;end6'b001010:  // sltibeginALUop <= 4'b1000;RegWrite <= 1;Sftmd <= 0;Jrn <= 0;Lui <= 0;RegDst <= 0;ALUSrc <= 1;Zero_sign_ex <= 1;end6'b001011:  // sltiubeginALUop <= 4'b1001;RegWrite <= 1;Sftmd <= 0;Jrn <= 0;Lui <= 0;RegDst <= 0;ALUSrc <= 1;Zero_sign_ex <= 0;enddefault:beginRegWrite <= 0;Sftmd <= 0;ALUop <= 4'b1111;Jrn <= 0;Lui <= 0;RegDst <= 0;ALUSrc <= 0;Zero_sign_ex <= 0;endendcase
endendmodule

3.2 ALU

`timescale 1ns / 1ps
//
// Company:
// Engineer:
//
// Create Date: 2020/11/14 22:30:23
// Design Name:
// Module Name: ALU_1
// Project Name:
// Target Devices:
// Tool Versions:
// Description:
//
// Dependencies:
//
// Revision:
// Revision 0.01 - File Created
// Additional Comments:
//
//module ALU_1(// datainput [31:0] A,input [31:0] B,input [4:0] shamt,// controlinput [3:0] ALUop,input Sftmd, // shift instruction control/*** I-type ***/input [15:0] imm, // data// controlinput Lui,           // 1:lui instructioninput ALUSrc,        // 1:imm calculateinput Zero_sign_ex,  // 0:zero extension; 1:sign extensionoutput reg [31:0] ALUresult);// convert A and B to signed numbers
wire signed [31:0] A_signed = A;
wire signed [31:0] B_signed;
wire signed [31:0] B_signed_origin = B; // for sra instruction// for shift instructions
// select data: if (Sftmd == 1) input shamt else input rs
wire [31:0] A_or_Shift = (Sftmd == 0) ? A : {27'b0,shamt};/*** I-type: data select ***/// immediate data extension and select
wire [31:0] zero_imm_ex = {16'b0,imm};
wire [31:0] sign_imm_ex = (imm[15] == 1)? {16'hffff,imm}: {16'b0,imm}; // NOTE: 16'b1 is incorrect
wire [31:0] imm_input = (Zero_sign_ex == 0)? zero_imm_ex: sign_imm_ex;// R[rt] or imm extension
wire [31:0] B_select = (ALUSrc == 0)? B: imm_input;
assign B_signed = B_select;/* calculate */
always @(*)
begincase (ALUop)4'b0000:    // add addibeginALUresult <= A + B_select;end4'b0001:    // addu addiubeginALUresult <= A + B_select;end4'b0010:    // subbeginALUresult <= A - B;end4'b0011:    // sububeginALUresult <= A - B;end4'b0100:    // and andibeginALUresult <= A & B_select;end4'b0101:    // or oribeginALUresult <= A | B_select;end4'b0110:    // xor xoribeginALUresult <= A ^ B_select;end4'b0111:    // nor noribeginALUresult <= ~(A | B_select);end4'b1000:    // slt slti // note:********signed********//beginif(A_signed < B_signed)ALUresult <= 1;elseALUresult <= 0;end4'b1001:    // sltu sltiubeginif(A < B_select)ALUresult <= 1;elseALUresult <= 0;end4'b1010:    // sllv 10  /*** note: not B_select ***/beginALUresult <= B << A_or_Shift;    // NOTE: not A << B!end4'b1011:    // srlvbeginALUresult <= B >> A_or_Shift;    // NOTE: not A >> B!end4'b1100:    // srav // note: ******signed*******//beginALUresult <= B_signed_origin >>> A_or_Shift;    // NOTE: not A_signed >> B!end4'b1101: // luibeginALUresult <= (Lui == 1)? {imm,16'b0}: 0;enddefault:beginALUresult <= 0;endendcase
endendmodule

3.3 Reg Files

`timescale 1ns / 1ps
//
// Company:
// Engineer:
//
// Create Date: 2020/11/14 22:31:09
// Design Name:
// Module Name: reg_files_1
// Project Name:
// Target Devices:
// Tool Versions:
// Description:
//
// Dependencies:
//
// Revision:
// Revision 0.01 - File Created
// Additional Comments:
//
//module reg_files_1(input clk,input rst_n,/*** read port 1 ***/input [4:0] rA,      // rs fieldoutput reg [31:0] A,/*** read port 2 ***/input [4:0] rB,      // rtoutput reg [31:0] B,/*** write port ***/input [4:0] rW,          // rdinput [31:0] writeData,  // datainput RegWrite,          // if RegWrite == 1,you can write data to reg files/*** I-type input control ***/input RegDst // 1: R-type destination is rd; 0: I-type dst is rt);// reg files
reg [31:0] register [0:31];
integer i;
initial
beginfor (i = 0;i < 32;i = i + 1)begin// 為了方便初步測試 ///register[i] <= i;// register[i] <= 0;end
end/******* write operation *******/
wire [4:0] rW_select;
assign rW_select = (RegDst == 1)? rW: rB;always @(posedge clk) // sequential logic
beginif(rst_n == 0)  // reset is invalidbeginif((RegWrite == 1'b1) && (rW_select != 5'b0))  // write is valid and address is not equal zerobeginregister[rW_select] <= writeData;endelse;endelse;
end/******* rA read operation *******/
always @(*) // combinational logic
beginif(rst_n == 1)beginA <= 32'b0;endelse if(rA == 5'b0)beginA <= 32'b0;endelsebeginA <= register[rA];end
end/******* rB read operation *******/
always @(*) // combinational logic
beginif(rst_n == 1)beginB <= 32'b0;endelse if(rB == 5'b0) // $zerobeginB <= 32'b0;endelsebeginB <= register[rB];end
endendmodule

注意事項：需要16位1的寫法是16'h_FFFF，不是16'b1，缺少的項會被自動補0！如果需要16位0，只需要16'b0即可。

3.4 datapath

`timescale 1ns / 1ps
//
// Company:
// Engineer:
//
// Create Date: 2020/11/27 11:41:34
// Design Name:
// Module Name: datapath_1
// Project Name:
// Target Devices:
// Tool Versions:
// Description: 僅僅實現了幾個簡單的R類指令的最簡單的數據通路，不與外界交互
//
// Dependencies:
//
// Revision:
// Revision 0.01 - File Created
// Additional Comments:
//
//module datapath_1(input clk,input rst_n,output [31:0] result // 測試syntheses，沒有輸出的模塊是恐怖的);/******** PC ********/// pc_1 Inputs
wire  Jrn;
wire  [31:0]  JrPC;// pc_1 Outputs
wire  [31:0]  pcOld;pc_1  u_pc_1 (.clk                     ( clk     ),.rst_n                   ( rst_n   ),.pcOrigin                ( pcOld   ),.JrPC                    ( JrPC    ),.Jrn                     ( Jrn     ),.pcOld                   ( pcOld   ));///
/******** Instruction ROM ********/
///// blk_mem_gen_0 Inputs
// wire  [13:0]  addra  = pcOld[15:2];// blk_mem_gen_0 Outputs // instructions
wire  [31:0]  instruction;blk_mem_gen_0  u_blk_mem_gen_0 (.clka                    ( clk    ),.addra                   ( pcOld[15:2]   ),.douta                   ( instruction   ));/
/******** Reg Files ********/
/// reg_files_1 Inputs
wire  [31:0]  ALUresult;/// wire   [4:0]  rA = instruction[25:21];
/// wire   [4:0]  rB = instruction[20:16];
/// wire   [4:0]  rW = instruction[15:11];
/// wire   [31:0]  writeData = ALUresult;
wire   RegWrite;
wire   RegDst_in;// reg_files_1 Outputs
wire  [31:0]  A;    // rs
wire  [31:0]  B;    // rt
assign JrPC = A;reg_files_1  u_reg_files_1 (.clk                     ( clk         ),.rst_n                   ( rst_n       ),.rA                      ( instruction[25:21]          ),.rB                      ( instruction[20:16]          ),.rW                      ( instruction[15:11]          ),.writeData               ( ALUresult   ),.RegWrite                ( RegWrite    ),.RegDst                  ( RegDst_in   ),.A                       ( A           ),.B                       ( B           ));///
/******** ALU ********/
///// ALU_1 Inputs
// wire   [31:0]  A;
// wire   [31:0]  B;
wire   [3:0]  ALUop;
wire   Sftmd;wire   [15:0] imm = instruction[15:0];
wire Lui_in;
wire ALUSrc_in;
wire Zero_sign_ex_in;// ALU_1 Outputs
// wire  [31:0]  ALUresult = writeData; // Note：Error！ALU_1  u_ALU_1 (.A                       ( A           ),.B                       ( B           ),.shamt                   ( instruction[10:6]),.ALUop                   ( ALUop       ),.Sftmd                   ( Sftmd       ),/** I-type **/.imm                     ( imm              ),.Lui                     ( Lui_in           ),.ALUSrc                  ( ALUSrc_in        ),.Zero_sign_ex            ( Zero_sign_ex_in  ),.ALUresult               ( ALUresult   ));/
/******** controler ********/
/// control_1 Inputs
// wire   [5:0]  op = instruction[31:26];
// wire   [5:0]  func = instruction[5:0];// control_1 Outputs
// wire  RegWrite
// wire  [3:0]  ALUop;
wire Lui;
wire RegDst;
wire ALUSrc;
wire Zero_sign_ex;assign RegDst_in = RegDst; // Send to Reg Files
// send to ALU
assign Lui_in = Lui;
assign ALUSrc_in = ALUSrc;
assign Zero_sign_ex_in = Zero_sign_ex;control_1  u_control_1 (.op                      ( instruction[31:26]         ),.func                    ( instruction[5:0]       ),.RegWrite                ( RegWrite   ),.Sftmd                   ( Sftmd      ),.ALUop                   ( ALUop      ),.Jrn                     ( Jrn        ),// I type.Lui                     ( Lui        ),.RegDst                  ( RegDst     ),.ALUSrc                  ( ALUSrc     ),.Zero_sign_ex            ( Zero_sign_ex ));assign result = ALUresult;endmodule

4 測試

注意，以前完成的指令依然要測試，因為你不知道你改完之后，是不是把以前對的改錯了。

nop
add $1,$2,$3	# $1 = 2 + 3 = 5
addu $2,$4,$1	# $2 = 4 + 5 = 9
sub $4,$2,$1	# $4 = 9 - 5 = 4
subu $5,$4,$3	# $5 = 4 - 3 = 1and $6,$7,$8	# $6 = 0111 and 1000 = 0
or $7,$6,$8		# $7 = 0 or 1000 = 8
xor $7,$6,$8	# $7 = 0000 xor 1000 = 1000 = 8
nor $8,$7,$6	# $8 = not (1000 or 0) = 11111111111110111slt $10,$11,$12	# $10 = 11 < 12 = 1		# 應該用負數驗證，以后再說
sltu $10,$12,$11	# $10 = 12 > 11 = 0# sllv $12,$5,$13	# $12 = 1101 << 1 = 1101_0 = 1A	【注意此處的倒置問題！ sllv rd,rt,rs】
# srlv $12,$5,$13	# $12 = 1101 >> 1 = 110 = 6
# srav $14,$5,$15	# $14 = 1111 >>> 1 = 111  = 7 應該用負數驗證，以后再說# 上面3條是錯誤的！我們應該改的不是使用，而是內部運算邏輯
# 對于使用者來說，邏輯就是 $13 << $5
# 而實際的編碼是 rt = $13，rs = $5，這與一般的指令不一樣
# 因此，我們在ALU運算中 rt--B，rs--A，應該是 【B << A】，而不是 A >> B。
sllv $12,$13,$5	# $12 = 1101 << 1 = 1101_0 = 1A	
srlv $12,$13,$5	# $12 = 1101 >> 1 = 110 = 6
srav $14,$15,$5	# $14 = 1111 >>> 1 = 111  = 7 應該用負數驗證，以后再說sll $16,$17,2	# $16 = 1_0001 << 2 = 100_0100 = 44	
srl $16,$18,2	# $16 = 1_0010 >> 2 = 0100 = 4
sra $16,$19,2	# 應該用負數驗證，以后再說 $16 = 4################ I type test #################
addi $17,$7,-1	# $17 = 8 - 1 = 7  測試符號擴展
addiu $17,$7,-2 # $17 = 8 - 2 = 6
andi  $17,$8,1  # $17 = 1	測試zero extension
ori $17,$8,0	# $17 = ffff_fff7 = ffff_fff7
xori $17,$8,15	# $17 = ffff_fff7 xor 0000_000f = ffff_fff8 lui $17,100	# $17 = 前16位是64_后16位是0jr $16	# PC = 4

編碼

memory_initialization_radix = 16;
memory_initialization_vector =
00000000,
00430820,
00811021,
00412022,
00832823,
00e83024,
00c83825,
00c83826,
00e64027,
016c502a,
018b502b,
00ad6004,
00ad6006,
00af7007,
00118080,
00128082,
00138083,
20f1ffff,
24f1fffe,
31110001,
35110000,
3911000f,
3c110064,
02000008;

行為仿真測試成功。

本文來自互聯網用戶投稿，該文觀點僅代表作者本人，不代表本站立場。本站僅提供信息存儲空間服務，不擁有所有權，不承擔相關法律責任。
如若轉載，請注明出處：http://www.pswp.cn/news/384641.shtml
繁體地址，請注明出處：http://hk.pswp.cn/news/384641.shtml
英文地址，請注明出處：http://en.pswp.cn/news/384641.shtml

如若內容造成侵權/違法違規/事實不符，請聯系多彩編程網進行投訴反饋email:809451989@qq.com，一經查實，立即刪除！

相關文章

【算法】學習筆記（1）：算法就是人類去教會計算機的方法

【算法】學習筆記（1）：算法就是人類去教會計算機的方法

人生處處皆算法&#xff0c;算法是解決問題之道。 對于計算機科學中的算法&#xff0c;我更喜歡將其理解為利用人類思維之一&#xff1a;計算機思維&#xff0c;去解決一些人類不擅長的問題&#xff0c;比如大量重復運算&#xff0c;然后&#xff0c;人類使用計算機編程語言去…
閱讀更多...
【算法】學習筆記（2）：遞歸思想

【算法】學習筆記（2）：遞歸思想

0 回顧 之前的筆記&#xff08;0&#xff09;和筆記&#xff08;1&#xff09;&#xff0c;我們介紹了算法的基本含義&#xff0c;并且舉了一些實例&#xff0c;同時理解了&#xff0c;算法就是人類在教計算機做事情&#xff01; 我們知道&#xff0c;算法就是解決問題的方案…
閱讀更多...
【計算機系統設計】實踐筆記（5）插敘：內外有別之CPU和Memory

【計算機系統設計】實踐筆記（5）插敘：內外有別之CPU和Memory

區分CPU的內外 首先明確&#xff0c;內存&#xff0c;不在CPU內&#xff0c;我們的CPU是會有數據和指令端口的&#xff0c;然后去訪問內存和外設。 而CPU設計&#xff0c;我們所說的單周期&#xff0c;多周期和流水線&#xff0c;描述的都是CPU&#xff0c;而不是Memory&…
閱讀更多...
【計算機系統設計】實踐筆記（5）改進數據通路：beq和bne指令分析與實現

【計算機系統設計】實踐筆記（5）改進數據通路：beq和bne指令分析與實現

接下來的分析和實踐非常粗糙&#xff0c;因為跟之前一樣的分析流程&#xff0c;不再多說了&#xff0c;如果前面真的掌握&#xff0c;這里不看也罷。 分析 先看beq指令。 ALU輸入的是rs和rt&#xff0c;不輸入imm&#xff0c;進行subu操作&#xff0c;判斷是否為zero&#x…
閱讀更多...
【算法】學習筆記（4）：分治思想 歸并排序

【算法】學習筆記（4）：分治思想 歸并排序

分治思想&#xff0c;分治策略&#xff0c;自古有之&#xff0c;與人類生活息息相關&#xff0c;其本質是將大問題拆解為小問題&#xff0c;小問題轉換為已知解的問題&#xff0c;進而求解。 軍隊管理&#xff0c;國家分級治理…… 大規模數據排序&#xff0c;例如10000000000…
閱讀更多...
【算法】學習筆記（5）：快速排序

【算法】學習筆記（5）：快速排序

注意一個C的坑 sizeof()這個函數靜態數組可以求長度&#xff0c;動態new出來的數組不行&#xff0c;因為針對的是指針……&#xff0c;不過既然的動態數組了&#xff0c;其長度本身必然是一個變量了&#xff0c;你沒有必要這么求長度。 下面看快速排序的代碼。 #include <…
閱讀更多...
【計算機系統設計】實踐筆記（6）改進數據通路：lw和sw指令

【計算機系統設計】實踐筆記（6）改進數據通路：lw和sw指令

不想多說了……前面的鋪墊足夠了&#xff0c;剩下的自己做做應該也會了&#xff0c;如果遇到問題&#xff0c;就搜一下自己查閱就好。 這篇水過&#xff0c;沒有太多技術點。 唯一注意的是&#xff0c;引入的RAM和ROM的clk觸發問題&#xff0c;可能引起時序問題&#xff0c;等…
閱讀更多...
html css 核心設計理念

html css 核心設計理念

分開看&#xff01; 從不同視角&#xff0c;獨立地去看某一部分內容&#xff0c;使用聚焦視角&#xff0c;進行獨立操作和批量操作。
閱讀更多...
html css 學習筆記（1）背景相關

html css 學習筆記（1）背景相關

背景顏色 圖片 插入圖片img背景圖片 背景圖片 3. logo 4. 大圖 5. 裝飾性小圖 便于控制位置&#xff01; 插入后會執行自動平鋪&#xff0c;這與插入圖片是不同的&#xff01; div{width: 600px;height: 300px;background-image: url(img/登錄用戶頭像.png); }小結 盒子的第…
閱讀更多...
html css a標簽的應用

html css a標簽的應用

作為普通鏈接轉換為行內塊元素 轉換為行內塊元素之后&#xff0c;就可以給其各種塊行為&#xff0c;加背景&#xff0c;加背景圖片&#xff0c;設置寬高&#xff0c;內外邊距…… 塊行為可以的&#xff0c;它都行&#xff0c;唯一的區別&#xff0c;它這個盒子是個鏈接&#…
閱讀更多...
GitHub回滾

GitHub回滾

不要直接退回到很久前的歷史版本&#xff0c;這很可能引起文件沖突&#xff0c;可以一步步回滾&#xff0c;先回滾最近的&#xff0c;從近到遠一步步滾到目標。
閱讀更多...
2020-12-15 CPU設計復盤

2020-12-15 CPU設計復盤

SOC修改 將之前完成的31條指令單周期CPU進行了重構&#xff0c;將其分開&#xff0c;實現了內外有別&#xff0c;將CPU、指令ROM和數據RAM。 這樣&#xff0c;以后為其增加接口外設&#xff0c;總線控制&#xff0c;才更加清晰&#xff0c;這是進一步封裝和抽象。 MARS大坑 …
閱讀更多...
Tomcat 學習筆記（0）

Tomcat 學習筆記（0）

JavaWeb 用Java寫的程序&#xff0c;可以在瀏覽器運行。 Request & Responce Web資源 Web服務器 我們在自己的主機啟動Tomcat服務器&#xff0c;然后運行它&#xff0c;就能夠通過主機訪問這個服務器&#xff0c;這個服務器能夠運行我們的程序。 部署Web工程 法1 將web…
閱讀更多...
計算機系統 學習筆記（0）南京大學（一）第一周

計算機系統 學習筆記（0）南京大學（一）第一周

課程&#xff1a;計算機系統基礎 核心理念&#xff1a;人類世界與計算機世界的異同 人類世界 直觀感受數學 計算機世界 與數學不同&#xff0c;存儲首先&#xff0c;各層次與現實世界不同 我們關注點是差異點&#xff01; 一樣的你就不用關心了&#xff0c;關心差異&#…
閱讀更多...
x86架構下 CF與OF標志位 帶符號和無符號運算 詳解

x86架構下 CF與OF標志位 帶符號和無符號運算 詳解

針對能夠影響OF和CF標志位的指令&#xff0c;一般來說是涉及到數據運算的指令&#xff0c;這里使用add舉例&#xff0c;即不區分有無符號的加法指令&#xff0c;參與運算的數據&#xff0c;從二進制層級去考慮。 CF標志位 對于CF&#xff0c;它是carry flag&#xff0c;進位標…
閱讀更多...
tmux學習筆記

tmux學習筆記

參考學習鏈接 我們需要理解幾個重要的概念 session 回話window 窗口pane 窗格 window 我們打開的一個terminal就是一個window. 而打開的這個window&#xff0c;也就是打開了一個session&#xff0c;打開window&#xff0c;session開始&#xff1b;關閉window&#xff0c;se…
閱讀更多...
安裝win10和Linux雙系統的個人經驗

安裝win10和Linux雙系統的個人經驗

使用easy uefi誤刪除win10引導文件 這個時候&#xff0c;網上教程有各種方式&#xff0c;我直接使用了一種最簡單的&#xff0c;這個方法網上都沒有提到過。 注意&#xff1a;發現引導文件刪了&#xff0c;千萬不要關機&#xff0c;否則再想開機恐怕只能重裝系統了。 我們直…
閱讀更多...
Linux的ext4文件系統學習筆記

Linux的ext4文件系統學習筆記

補充&#xff1a;設備獨立性 Linux中&#xff0c;設備驅動以文件形式表示&#xff0c;用戶操作邏輯設備就是操作文件&#xff0c;而不是具體的物理設備&#xff0c;也就是說&#xff0c;用戶操作的是功能&#xff0c;是黑箱&#xff0c;而不是真正的實體。 APP操作的都是邏輯…
閱讀更多...
html基礎元素案例筆記（1）

html基礎元素案例筆記（1）

這是代碼 <!DOCTYPE html> <html><head><meta charset"utf-8"><title>CSS FlexBox test</title><link rel"stylesheet" type"text/css" href"./css/index.css"></head><body>…
閱讀更多...
C語言中的struct和union區別

C語言中的struct和union區別

參考&#xff1a;Difference between Structure and Union in C 二者區別 struct 這里不做詳細說明&#xff0c;因為參考鏈接中都寫明了。只做一些重點強調。 struct中聲明的變量&#xff0c;在分配空間的時候&#xff0c;struct結構空間大小&#xff0c;大于等于其內部所有…
閱讀更多...
最新文章

Copyright @ 2022~2023