【计算机系统设计】实践笔记（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.mzph.cn/news/384641.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

【算法】学习笔记（2）：递归思想

【算法】学习笔记（2）：递归思想

0 回顾 之前的笔记&#xff08;0&#xff09;和笔记&#xff08;1&#xff09;&#xff0c;我们介绍了算法的基本含义&#xff0c;并且举了一些实例&#xff0c;同时理解了&#xff0c;算法就是人类在教计算机做事情&#xff01; 我们知道&#xff0c;算法就是解决问题的方案…
阅读更多...
【计算机系统设计】实践笔记（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…
阅读更多...
html css 学习笔记（1）背景相关

html css 学习笔记（1）背景相关

背景颜色 图片 插入图片img背景图片 背景图片 3. logo 4. 大图 5. 装饰性小图 便于控制位置&#xff01; 插入后会执行自动平铺&#xff0c;这与插入图片是不同的&#xff01; div{width: 600px;height: 300px;background-image: url(img/登录用户头像.png); }小结 盒子的第…
阅读更多...
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…
阅读更多...
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;大于等于其内部所有…
阅读更多...
Leetcode1512. 好数对的数目 抽出本质原型 利用范围条件

Leetcode1512. 好数对的数目 抽出本质原型 利用范围条件

解法1&#xff1a;暴力枚举 class Solution {public int numIdenticalPairs(int[] nums) {int count 0;for(int i 0;i < nums.length; i){for(int j i 1; j < nums.length; j){if(nums[i] nums[j])count;}}return count;} }没啥可说的&#xff0c;就是小学数学问题…
阅读更多...
leetcode面试题 10.01. 合并排序的数组

leetcode面试题 10.01. 合并排序的数组

直接排序 直接使用Java已有的方法进行排序&#xff0c;这一招…大意了&#xff01; 这题简单&#xff0c;就是个基本的排序&#xff0c;后面难题&#xff0c;可能这只是一小步&#xff0c;内个时候直接用排序算法比较合适&#xff0c;这个不合适。。 class Solution {public…
阅读更多...
IA-32 Architecture: the function of segment regitster(CS DS SS ES)

IA-32 Architecture: the function of segment regitster(CS DS SS ES)

对于IA-32架构&#xff0c;与8086不同&#xff0c;段寄存器不再是像以前一样&#xff0c;直接作为段基址&#xff0c;因为32位的寄存器直接就可以表示4GB大小&#xff0c;不需要再偏移&#xff0c;因此段寄存器的含义也发生了相应的变化。 在IA-32架构里&#xff0c;段寄存器是…
阅读更多...
x86异常处理与中断机制（1）概述中断的来源和处理方式

x86异常处理与中断机制（1）概述中断的来源和处理方式

参考《计算机组成》&#xff08;北京大学 MOOC&#xff09; 1 异常与中断的来源&#xff08;为什么需要中断&#xff09; 首先&#xff0c;说明一下异常和中断这两个概念。 它们两个唯一的区别&#xff0c;就是&#xff0c;没有什么区别。只是不同的地方不同的时间不同的人的…
阅读更多...
【C language】动态数组的创建和使用

【C language】动态数组的创建和使用

在C语言中&#xff0c;使用malloc函数创建动态数组&#xff0c;使用一个指针指向它&#xff0c;使用下标进行访问。 unsigned long *a (unsigned long *)malloc(2 * sizeof(int)); a[0] 1000; a[1] 2000; printf("%d %d\n", a[0], a[1]); free(a);上述例子&…
阅读更多...
x86异常处理与中断机制（2）中断向量表

x86异常处理与中断机制（2）中断向量表

补充&#xff1a;事件不仅包含中断和异常&#xff0c;还包含系统调用&#xff0c;这个属于用户主动请求的事件。 上一节&#xff0c;只有一个溢出异常&#xff0c;那么&#xff0c;如果很多异常、中断呢&#xff1f;&#xff08;中断向量表&#xff09; 另外&#xff0c;之前0…
阅读更多...
x86异常处理与中断机制（3）中断处理过程

x86异常处理与中断机制（3）中断处理过程

上一节讲完了根据中断类型号找中断服务程序的过程&#xff0c;现在着重说明一下更加完整的中断处理过程吧。 本节以8086时代的中断处理过程为例进行说明&#xff0c;主要分两大部分 硬件处理软件处理 需要注意&#xff0c;这不是绝对的&#xff0c;得看实际情况&#xff0c;…
阅读更多...
Linux 0.11 内核解析：中断相关（1）asm.s文件中断处理分析

Linux 0.11 内核解析：中断相关（1）asm.s文件中断处理分析

0 源代码 有两个版本的&#xff0c;一个是带中文注释&#xff0c;Intel格式的&#xff1b;一个是不带注释是AT&T格式的。 Linux 0.11 中文注释版 Linux 0.11 源码&#xff0c;基于《Linux内核完全注释》赵炯 1 asm.s 文件 我们先假设该文件处理的中断是无特权过渡的情况…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023