Architecture Lab：Part C【流水线通用原理/Y86-64的流水线实现/实现IIADDQ指令】

news2024/11/20 17:39:41

目录

任务描述

知识回顾

流水线通用原理

Y86-64流水线实现（PIPE-与PIPE）

开始实验

IIADDQ指令的添加

优化 ncopy.ys

仅用第四章知识，CEP=11.55

8x1展开，CPE=9.35

8x1展开+2x1展开+消除气泡，CPE=8.10 

流水线化通过让不同的阶段并行操作，改进了系统的吞吐量性能。

在任意一个给定的时刻，多条指令被不同的阶段处理。在引入这种并行性的过程中，我们必须非常小心，以提供与程序的顺序执行相同的程序级行为。通过重新调整SEQ各个部分的顺序，引入流水线，我们得到SEQ+,接着添加流水线寄存器，创建出 PIPE-流水线。

然后，添加了转发逻辑，加速了将结果从一条指令发送到另一条指令，从而提高了流水线的性能。有几种特殊情况需要额外的流水线控制逻辑来暂停或取消一些流水线阶段。

任务描述

Your task in Part C is to modify ncopy.ys and pipe-full.hcl with the goal of making ncopy.ys
run as fast as possible.

翻译过来就是：

第一步，首先要把 pipe-full.hcl 中加入 iaddq 指令。

第二步，优化 ncopy.ys ，使CEP降到7.5

知识回顾

流水线通用原理

就像下图流水线图上方指明的那样，流水线阶段之间的指令转移是由时钟信号来控制的。每隔120ps, 信号从0上升至1,开始下一组流水线阶段的计算。

 时间=239时，是时钟上升沿到来的前一刻，此时组合逻辑A已经完成了指令I2（蓝色），正在等待寄存器打入脉冲（即时间=240时的上升沿）。同理，组合逻辑B已经完成了指令I1（深灰色），正在等待寄存器打入脉冲（即时间=240时的上升沿）。

 时间=241时，是时钟上升沿到来之后，指令I2（蓝色）的结果刚刚打入寄存器。指令I1（深灰色）的结果也刚刚打入寄存器。

 时间=300时，是时钟上升沿到来之后，指令I2（蓝色）正在组合逻辑B中进行计算。指令I1（深灰色）正在组合逻辑C中进行计算。新加入的指令I3（浅灰色）正在组合逻辑A中进行计算。

Y86-64流水线实现（PIPE-与PIPE）

首先，对顺序的SEQ处理器做一点小的改动，将 PC的计算挪到第一阶段（取指）。原因：方便流水线源源不断的给出新指令。

然后，在各个阶段之间加上流水线寄存器。

开始实验

IIADDQ指令的添加

IIADDQ指令的添加与Part B一样。唯一要注意的是记得改条件码（set_cc）。

char simname[] = "Y86-64 Processor: pipe-full.hcl";
#include <stdio.h>
#include "isa.h"
#include "pipeline.h"
#include "stages.h"
#include "sim.h"
int sim_main(int argc, char *argv[]);
int main(int argc, char *argv[]){return sim_main(argc,argv);}
long long gen_f_pc()
{
    return ((((ex_mem_curr->icode) == (I_JMP)) & !(ex_mem_curr->takebranch)
        ) ? (ex_mem_curr->vala) : ((mem_wb_curr->icode) == (I_RET)) ? 
      (mem_wb_curr->valm) : (pc_curr->pc));
}

long long gen_f_icode()
{
    return ((imem_error) ? (I_NOP) : (imem_icode));
}

long long gen_f_ifun()
{
    return ((imem_error) ? (F_NONE) : (imem_ifun));
}

long long gen_instr_valid()
{
    return ((if_id_next->icode) == (I_NOP) || (if_id_next->icode) == 
      (I_HALT) || (if_id_next->icode) == (I_RRMOVQ) || (if_id_next->icode)
       == (I_IRMOVQ) || (if_id_next->icode) == (I_RMMOVQ) || 
      (if_id_next->icode) == (I_MRMOVQ) || (if_id_next->icode) == (I_ALU)
       || (if_id_next->icode) == (I_JMP) || (if_id_next->icode) == (I_CALL)
       || (if_id_next->icode) == (I_RET) || (if_id_next->icode) == 
      (I_PUSHQ) || (if_id_next->icode) == (I_POPQ) || (if_id_next->icode)
       == (I_IADDQ));
}

long long gen_f_stat()
{
    return ((imem_error) ? (STAT_ADR) : !(instr_valid) ? (STAT_INS) : (
        (if_id_next->icode) == (I_HALT)) ? (STAT_HLT) : (STAT_AOK));
}

long long gen_need_regids()
{
    return ((if_id_next->icode) == (I_RRMOVQ) || (if_id_next->icode) == 
      (I_ALU) || (if_id_next->icode) == (I_PUSHQ) || (if_id_next->icode)
       == (I_POPQ) || (if_id_next->icode) == (I_IRMOVQ) || 
      (if_id_next->icode) == (I_RMMOVQ) || (if_id_next->icode) == 
      (I_MRMOVQ) || (if_id_next->icode) == (I_IADDQ));
}

long long gen_need_valC()
{
    return ((if_id_next->icode) == (I_IRMOVQ) || (if_id_next->icode) == 
      (I_RMMOVQ) || (if_id_next->icode) == (I_MRMOVQ) || 
      (if_id_next->icode) == (I_JMP) || (if_id_next->icode) == (I_CALL) || 
      (if_id_next->icode) == (I_IADDQ));
}

long long gen_f_predPC()
{
    return (((if_id_next->icode) == (I_JMP) || (if_id_next->icode) == 
        (I_CALL)) ? (if_id_next->valc) : (if_id_next->valp));
}

long long gen_d_srcA()
{
    return (((if_id_curr->icode) == (I_RRMOVQ) || (if_id_curr->icode) == 
        (I_RMMOVQ) || (if_id_curr->icode) == (I_ALU) || (if_id_curr->icode)
         == (I_PUSHQ)) ? (if_id_curr->ra) : ((if_id_curr->icode) == 
        (I_POPQ) || (if_id_curr->icode) == (I_RET)) ? (REG_RSP) : 
      (REG_NONE));
}

long long gen_d_srcB()
{
    return (((if_id_curr->icode) == (I_ALU) || (if_id_curr->icode) == 
        (I_RMMOVQ) || (if_id_curr->icode) == (I_MRMOVQ) || 
        (if_id_curr->icode) == (I_IADDQ)) ? (if_id_curr->rb) : (
        (if_id_curr->icode) == (I_PUSHQ) || (if_id_curr->icode) == (I_POPQ)
         || (if_id_curr->icode) == (I_CALL) || (if_id_curr->icode) == 
        (I_RET)) ? (REG_RSP) : (REG_NONE));
}

long long gen_d_dstE()
{
    return (((if_id_curr->icode) == (I_RRMOVQ) || (if_id_curr->icode) == 
        (I_IRMOVQ) || (if_id_curr->icode) == (I_ALU) || (if_id_curr->icode)
         == (I_IADDQ)) ? (if_id_curr->rb) : ((if_id_curr->icode) == 
        (I_PUSHQ) || (if_id_curr->icode) == (I_POPQ) || (if_id_curr->icode)
         == (I_CALL) || (if_id_curr->icode) == (I_RET)) ? (REG_RSP) : 
      (REG_NONE));
}

long long gen_d_dstM()
{
    return (((if_id_curr->icode) == (I_MRMOVQ) || (if_id_curr->icode) == 
        (I_POPQ)) ? (if_id_curr->ra) : (REG_NONE));
}

long long gen_d_valA()
{
    return (((if_id_curr->icode) == (I_CALL) || (if_id_curr->icode) == 
        (I_JMP)) ? (if_id_curr->valp) : ((id_ex_next->srca) == 
        (ex_mem_next->deste)) ? (ex_mem_next->vale) : ((id_ex_next->srca)
         == (ex_mem_curr->destm)) ? (mem_wb_next->valm) : (
        (id_ex_next->srca) == (ex_mem_curr->deste)) ? (ex_mem_curr->vale)
       : ((id_ex_next->srca) == (mem_wb_curr->destm)) ? (mem_wb_curr->valm)
       : ((id_ex_next->srca) == (mem_wb_curr->deste)) ? (mem_wb_curr->vale)
       : (d_regvala));
}

long long gen_d_valB()
{
    return (((id_ex_next->srcb) == (ex_mem_next->deste)) ? 
      (ex_mem_next->vale) : ((id_ex_next->srcb) == (ex_mem_curr->destm)) ? 
      (mem_wb_next->valm) : ((id_ex_next->srcb) == (ex_mem_curr->deste)) ? 
      (ex_mem_curr->vale) : ((id_ex_next->srcb) == (mem_wb_curr->destm)) ? 
      (mem_wb_curr->valm) : ((id_ex_next->srcb) == (mem_wb_curr->deste)) ? 
      (mem_wb_curr->vale) : (d_regvalb));
}

long long gen_aluA()
{
    return (((id_ex_curr->icode) == (I_RRMOVQ) || (id_ex_curr->icode) == 
        (I_ALU)) ? (id_ex_curr->vala) : ((id_ex_curr->icode) == (I_IRMOVQ)
         || (id_ex_curr->icode) == (I_RMMOVQ) || (id_ex_curr->icode) == 
        (I_MRMOVQ) || (id_ex_curr->icode) == (I_IADDQ)) ? 
      (id_ex_curr->valc) : ((id_ex_curr->icode) == (I_CALL) || 
        (id_ex_curr->icode) == (I_PUSHQ)) ? -8 : ((id_ex_curr->icode) == 
        (I_RET) || (id_ex_curr->icode) == (I_POPQ)) ? 8 : 0);
}

long long gen_aluB()
{
    return (((id_ex_curr->icode) == (I_RMMOVQ) || (id_ex_curr->icode) == 
        (I_MRMOVQ) || (id_ex_curr->icode) == (I_ALU) || (id_ex_curr->icode)
         == (I_CALL) || (id_ex_curr->icode) == (I_PUSHQ) || 
        (id_ex_curr->icode) == (I_RET) || (id_ex_curr->icode) == (I_POPQ)
         || (id_ex_curr->icode) == (I_IADDQ)) ? (id_ex_curr->valb) : (
        (id_ex_curr->icode) == (I_RRMOVQ) || (id_ex_curr->icode) == 
        (I_IRMOVQ)) ? 0 : 0);
}

long long gen_alufun()
{
    return (((id_ex_curr->icode) == (I_ALU)) ? (id_ex_curr->ifun) : (A_ADD)
      );
}

long long gen_set_cc()
{
    return (((((id_ex_curr->icode) == (I_ALU)) & !((mem_wb_next->status)
             == (STAT_ADR) || (mem_wb_next->status) == (STAT_INS) || 
            (mem_wb_next->status) == (STAT_HLT))) & !((mem_wb_curr->status)
           == (STAT_ADR) || (mem_wb_curr->status) == (STAT_INS) || 
          (mem_wb_curr->status) == (STAT_HLT))) | ((id_ex_curr->icode) == 
        (I_IADDQ)));
}

long long gen_e_valA()
{
    return (id_ex_curr->vala);
}

long long gen_e_dstE()
{
    return ((((id_ex_curr->icode) == (I_RRMOVQ)) & !
        (ex_mem_next->takebranch)) ? (REG_NONE) : (id_ex_curr->deste));
}

long long gen_mem_addr()
{
    return (((ex_mem_curr->icode) == (I_RMMOVQ) || (ex_mem_curr->icode) == 
        (I_PUSHQ) || (ex_mem_curr->icode) == (I_CALL) || 
        (ex_mem_curr->icode) == (I_MRMOVQ)) ? (ex_mem_curr->vale) : (
        (ex_mem_curr->icode) == (I_POPQ) || (ex_mem_curr->icode) == (I_RET)
        ) ? (ex_mem_curr->vala) : 0);
}

long long gen_mem_read()
{
    return ((ex_mem_curr->icode) == (I_MRMOVQ) || (ex_mem_curr->icode) == 
      (I_POPQ) || (ex_mem_curr->icode) == (I_RET));
}

long long gen_mem_write()
{
    return ((ex_mem_curr->icode) == (I_RMMOVQ) || (ex_mem_curr->icode) == 
      (I_PUSHQ) || (ex_mem_curr->icode) == (I_CALL));
}

long long gen_m_stat()
{
    return ((dmem_error) ? (STAT_ADR) : (ex_mem_curr->status));
}

long long gen_w_dstE()
{
    return (mem_wb_curr->deste);
}

long long gen_w_valE()
{
    return (mem_wb_curr->vale);
}

long long gen_w_dstM()
{
    return (mem_wb_curr->destm);
}

long long gen_w_valM()
{
    return (mem_wb_curr->valm);
}

long long gen_Stat()
{
    return (((mem_wb_curr->status) == (STAT_BUB)) ? (STAT_AOK) : 
      (mem_wb_curr->status));
}

long long gen_F_bubble()
{
    return 0;
}

long long gen_F_stall()
{
    return ((((id_ex_curr->icode) == (I_MRMOVQ) || (id_ex_curr->icode) == 
          (I_POPQ)) & ((id_ex_curr->destm) == (id_ex_next->srca) || 
          (id_ex_curr->destm) == (id_ex_next->srcb))) | ((I_RET) == 
        (if_id_curr->icode) || (I_RET) == (id_ex_curr->icode) || (I_RET)
         == (ex_mem_curr->icode)));
}

long long gen_D_stall()
{
    return (((id_ex_curr->icode) == (I_MRMOVQ) || (id_ex_curr->icode) == 
        (I_POPQ)) & ((id_ex_curr->destm) == (id_ex_next->srca) || 
        (id_ex_curr->destm) == (id_ex_next->srcb)));
}

long long gen_D_bubble()
{
    return ((((id_ex_curr->icode) == (I_JMP)) & !(ex_mem_next->takebranch))
       | (!(((id_ex_curr->icode) == (I_MRMOVQ) || (id_ex_curr->icode) == 
            (I_POPQ)) & ((id_ex_curr->destm) == (id_ex_next->srca) || 
            (id_ex_curr->destm) == (id_ex_next->srcb))) & ((I_RET) == 
          (if_id_curr->icode) || (I_RET) == (id_ex_curr->icode) || (I_RET)
           == (ex_mem_curr->icode))));
}

long long gen_E_stall()
{
    return 0;
}

long long gen_E_bubble()
{
    return ((((id_ex_curr->icode) == (I_JMP)) & !(ex_mem_next->takebranch))
       | (((id_ex_curr->icode) == (I_MRMOVQ) || (id_ex_curr->icode) == 
          (I_POPQ)) & ((id_ex_curr->destm) == (id_ex_next->srca) || 
          (id_ex_curr->destm) == (id_ex_next->srcb))));
}

long long gen_M_stall()
{
    return 0;
}

long long gen_M_bubble()
{
    return (((mem_wb_next->status) == (STAT_ADR) || (mem_wb_next->status)
         == (STAT_INS) || (mem_wb_next->status) == (STAT_HLT)) | (
        (mem_wb_curr->status) == (STAT_ADR) || (mem_wb_curr->status) == 
        (STAT_INS) || (mem_wb_curr->status) == (STAT_HLT)));
}

long long gen_W_stall()
{
    return ((mem_wb_curr->status) == (STAT_ADR) || (mem_wb_curr->status)
       == (STAT_INS) || (mem_wb_curr->status) == (STAT_HLT));
}

long long gen_W_bubble()
{
    return 0;
}

改完之后，在pipe目录下：

make clean

make VERSION=full

然后测试：

./psim -t ../y86-code/asumi.yo
cd ../ptest; make SIM=../pipe/psim
cd ../ptest; make SIM=../pipe/psim TFLAGS=-i

发现都过了，那么IIADDQ指令就添加对了。接下来优化 ncopy.ys

优化 ncopy.ys

先从ptest目录回到pipe目录，测试一下基准程序：

cd ../pipe

 ./correctness.pl（测试正确性）

./benchmark.pl（给出得分）

基准程序，CEP=15.18

现在进行一些优化。

仅用第四章知识，CEP=11.55

1. 29行移到33行的位置，去掉原本的第33行。（效果：CPE降1）

2. 使用iaddq指令替换所有的addq指令

3. 把25行跳转改为传送？

        不行

        原因是，原句含义为“如果R[%r10]>0，那么R[%rax]++”。改为“%r11赋值为1，测试%r10，如果≤0，将立即数0传送给%r11，addq %r11，%rax，将r11恢复为立即数1以备下次循环使用”，测试结果是，跳转改为传送，可将CEP降低0.44，但“将r11恢复为立即数1以备下次循环使用”又将CEP提高了1.

4. 第20行，由于跳转策略，所以默认给它Loop（效果：CPE降0.14）

至此，用我们在第四章学到的知识，CEP=11.55，代码如下：

# You can modify this portion
	xorq %rax,%rax		# count = 0;
	andq %rdx,%rdx		# len <= 0?
	jg Loop		        # if so, goto Done:
	ret
	
Loop:	mrmovq (%rdi), %r10	# read val from src...
	rmmovq %r10, (%rsi)	# ...and store it to dst
	andq %r10, %r10		# val <= 0?
	jle NoAdd1
	iaddq $1, %rax

NoAdd1:	
	iaddq $8, %rdi		# src++
	iaddq $8, %rsi		# dst++
	iaddq $-1, %rdx		# length--
	jg Loop			    # if so, goto Loop:

 

然后用第五章的循环展开方法继续优化。

8x1展开，CPE=9.35
# You can modify this portion
	xorq %rax,%rax		    # count = 0;
	andq %rdx, %rdx
	jg Judge
	ret
	
Judge:	
	iaddq $-8, %rdx
	jge Loop6
	iaddq $8, %rdx

Loop1:
	mrmovq (%rdi), %r10	    # read val from src...
	rmmovq %r10, (%rsi)	    # ...and store it to dst
	andq %r10, %r10		    # val <= 0?
	jle NoAdd
	iaddq $1, %rax
NoAdd:
	iaddq $8, %rdi
	iaddq $8, %rsi
	iaddq $-1, %rdx
	jg Loop1		
	ret
	
Loop6:	
	mrmovq (%rdi), %r10	    # read val from src...
	rmmovq %r10, (%rsi)	    # ...and store it to dst
	andq %r10, %r10		    # val <= 0?
	jle NoAdd1
	iaddq $1, %rax
NoAdd1:	
	mrmovq 8(%rdi), %r10	# read val from src...
	rmmovq %r10, 8(%rsi)	# ...and store it to dst
	andq %r10, %r10 	    # val <= 0?
	jle NoAdd2
	iaddq $1, %rax
NoAdd2:	
	mrmovq 16(%rdi), %r10	# read val from src...
	rmmovq %r10, 16(%rsi)	# ...and store it to dst
	andq %r10, %r10		    # val <= 0?
	jle NoAdd3
	iaddq $1, %rax
NoAdd3:	
	mrmovq 24(%rdi), %r10	# read val from src...
	rmmovq %r10, 24(%rsi)	# ...and store it to dst
	andq %r10, %r10		    # val <= 0?
	jle NoAdd4
	iaddq $1, %rax
NoAdd4:	
	mrmovq 32(%rdi), %r10	# read val from src...
	rmmovq %r10, 32(%rsi)	# ...and store it to dst
	andq %r10, %r10		    # val <= 0?
	jle NoAdd5
	iaddq $1, %rax
NoAdd5:	
	mrmovq 40(%rdi), %r10	# read val from src...
	rmmovq %r10, 40(%rsi)	# ...and store it to dst
	andq %r10, %r10		    # val <= 0?
	jle NoAdd6
	iaddq $1, %rax
NoAdd6:	
	mrmovq 48(%rdi), %r10	# read val from src...
	rmmovq %r10, 48(%rsi)	# ...and store it to dst
	andq %r10, %r10		    # val <= 0?
	jle NoAdd7
	iaddq $1, %rax
NoAdd7:	
	mrmovq 56(%rdi), %r10	# read val from src...
	rmmovq %r10, 56(%rsi)	# ...and store it to dst
	andq %r10, %r10		    # val <= 0?
	jle NoAdd8
	iaddq $1, %rax
NoAdd8:	
	iaddq $64, %rdi
	iaddq $64, %rsi
	andq %rdx, %rdx
	jg Judge

8x1展开+2x1展开+消除气泡，CPE=8.10 
# You can modify this portion
	#xorq %rax,%rax		# count = 0;
	andq %rdx, %rdx
	jg Judge
	ret
	
Unfold8:	
	mrmovq (%rdi), %r10	# read val from src...
	mrmovq 8(%rdi), %r11	# read val from src...
	mrmovq 16(%rdi), %r12	# read val from src...
	mrmovq 24(%rdi), %r13	# read val from src...
	rmmovq %r10, (%rsi)	# ...and store it to dst
	rmmovq %r11, 8(%rsi)	# ...and store it to dst
	rmmovq %r12, 16(%rsi)	# ...and store it to dst
	rmmovq %r13, 24(%rsi)	# ...and store it to dst
	andq %r10, %r10		# val <= 0?
	jle NoAdd1
	iaddq $1, %rax
NoAdd1:	
	andq %r11, %r11 	# val <= 0?
	jle NoAdd2
	iaddq $1, %rax
NoAdd2:	
	andq %r12, %r12		# val <= 0?
	jle NoAdd3
	iaddq $1, %rax
NoAdd3:	
	andq %r13, %r13		# val <= 0?
	jle NoAdd4
	iaddq $1, %rax
NoAdd4:	
	mrmovq 32(%rdi), %r10	# read val from src...
	mrmovq 40(%rdi), %r11	# read val from src...
	mrmovq 48(%rdi), %r12	# read val from src...
	mrmovq 56(%rdi), %r13	# read val from src...
	rmmovq %r10, 32(%rsi)	# ...and store it to dst
	rmmovq %r11, 40(%rsi)	# ...and store it to dst
	rmmovq %r12, 48(%rsi)	# ...and store it to dst
	rmmovq %r13, 56(%rsi)	# ...and store it to dst
	
	andq %r10, %r10		# val <= 0?
	jle NoAdd5
	iaddq $1, %rax
NoAdd5:	
	andq %r11, %r11 	# val <= 0?
	jle NoAdd6
	iaddq $1, %rax
NoAdd6:	
	andq %r12, %r12		# val <= 0?
	jle NoAdd7
	iaddq $1, %rax
NoAdd7:	
	andq %r13, %r13 	# val <= 0?
	jle NoAdd8
	iaddq $1, %rax
NoAdd8:	
	iaddq $64, %rdi
	iaddq $64, %rsi
	andq %rdx, %rdx
	jg Judge
	ret
	
Judge:	
	iaddq $-8, %rdx
	jge Unfold8
	iaddq $8, %rdx
Judge2:
	iaddq $-2, %rdx
	jge Unfold2
	iaddq $2, %rdx
	
SingleLoop:
	mrmovq (%rdi), %r10	# read val from src...
	rmmovq %r10, (%rsi)	# ...and store it to dst
	andq %r10, %r10		# val <= 0?
	jle Done
	iaddq $1, %rax
	ret
	
Unfold2:
	mrmovq (%rdi), %r10	# read val from src...
	mrmovq 8(%rdi), %r11	# read val from src...
	rmmovq %r10, (%rsi)	# ...and store it to dst
	rmmovq %r11, 8(%rsi)	# ...and store it to dst
	andq %r10, %r10		# val <= 0?
	jle Noadd1
	iaddq $1, %rax
Noadd1:	
	andq %r11, %r11 	# val <= 0?
	jle Noadd2
	iaddq $1, %rax

Noadd2:	
	iaddq $16, %rdi
	iaddq $16, %rsi
	andq %rdx, %rdx
	jg Judge2

参考

CSAPP | Lab4-Architecture Lab 深入解析 - 知乎 (zhihu.com)

[读书笔记]CSAPP：ArchLab - 知乎 (zhihu.com)

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1434475.html

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

相关文章

在VM虚拟机上搭建MariaDB数据库服务器

在VM虚拟机上搭建MariaDB数据库服务器

例题&#xff1a;搭建MariaDB数据库服务器&#xff0c;并实现主主复制。 1.在二台服务器中分别MariaDB安装。 2.在二台服务器中分别配置my.cnf文件&#xff0c;开启log_bin。 3.在二台服务器中分别创建专用于数据库同步的用户replication_user&#xff0c;并授权SLAVE。&#x…
阅读更多...
【DDD】学习笔记-数据分析模型

【DDD】学习笔记-数据分析模型

在 Eric Evans 提出领域驱动设计之前&#xff0c;对企业系统的分析设计多数采用数据模型驱动设计。如前所述&#xff0c;这种数据模型驱动设计就是站在数据的建模视角&#xff0c;逐步开展分析、设计与实现的建模过程。通过对数据的正确建模&#xff0c;设计人员就可以根据模型…
阅读更多...
【INTEL（ALTERA）】为什么在编译 HDMI 英特尔® FPGA IP设计示例 VHDL 变体时看到错误 （13879）？

【INTEL（ALTERA）】为什么在编译 HDMI 英特尔® FPGA IP设计示例 VHDL 变体时看到错误 （13879）？

说明 由于英特尔 Quartus Prime Pro Edition 软件版本 23.2 存在一个问题&#xff0c;您在编译 HDMI 英特尔 FPGA IP设计示例的 VHDL 变体时可能会看到以下错误&#xff1a; 错误 &#xff08;13879&#xff09;&#xff1a; VHDL 绑定指示 hdmi_rx_ram_1port_intel_mce_2010…
阅读更多...
Java设计模式大全：23种常见的设计模式详解（一）

Java设计模式大全：23种常见的设计模式详解（一）

本系列文章简介&#xff1a; 设计模式是在软件开发过程中&#xff0c;经过实践和总结得到的一套解决特定问题的可复用的模板。它是一种在特定情境中经过验证的经验和技巧的集合&#xff0c;可以帮助开发人员设计出高效、可维护、可扩展和可复用的软件系统。设计模式提供了一种在…
阅读更多...
缩略图保持加密（TPE）论文

缩略图保持加密（TPE）论文

文献： R.Zhao,Y.Zhang,Y.Nan,W.Wen,X.Chai,andR. Lan, “Primitively visually meaningful image encryption: A new paradigm,” Inf. Sci. (Ny), Vol. 613, pp. 628–48, 2022. DOI: 10.1016/j.ins.2022.08.027. (1) 第1行：原始图像 第2行：加密图像 加密的目标： 原始…
阅读更多...
synchronized内部工作原理

synchronized内部工作原理

作者简介&#xff1a; zoro-1&#xff0c;目前大二&#xff0c;正在学习Java&#xff0c;数据结构&#xff0c;javaee等 作者主页&#xff1a; zoro-1的主页 欢迎大家点赞 &#x1f44d; 收藏 ⭐ 加关注哦&#xff01;&#x1f496;&#x1f496; synchronized内部工作原理 syn…
阅读更多...
运维监控之MySQL死锁查询及监控

运维监控之MySQL死锁查询及监控

死锁是指两个或两个以上的事务在执行过程中&#xff0c;因争夺资源而造成的一种相互等待的现象&#xff0c;若无外力作用&#xff0c;它们都将无法推进下去&#xff0c;此时称系统处于死锁状态或系统产生了死锁。 为了监控MySQL的死锁情况&#xff0c;可以使用以下方法&#xf…
阅读更多...
【论文解读】Point Transformer

【论文解读】Point Transformer

Point Tranformer 摘要引言方法实验结论 摘要 自注意网络已经彻底改变了自然语言处理&#xff0c;并在图像分析任务&#xff08;如图像分类和对象检测&#xff09;方面取得了令人印象深刻的进展。受这一成功的启发&#xff0c;我们研究了自注意网络在三维点云处理中的应用。我…
阅读更多...
流浪动物救助|基于Springboot的流浪动物救助平台设计与实现(源码+数据库+文档)

流浪动物救助|基于Springboot的流浪动物救助平台设计与实现(源码+数据库+文档)

流浪动物救助平台目录 目录 基于Springboot的流浪动物救助平台设计与实现 一、前言 二、系统功能设计 三、系统实现 1、用户信息管理 2、动物信息管理 3、商品评论管理 4、公告信息管理 四、数据库设计 1、实体ER图 五、核心代码 六、论文参考 七、最新计算机毕设…
阅读更多...
常用Hallmark及KEGG、GO基因查询

常用Hallmark及KEGG、GO基因查询

文献&#xff1a;The Molecular Signatures Database (MSigDB) hallmark gene set collection - PMC (nih.gov) GSEA | MSigDB | Browse Human Gene Sets (gsea-msigdb.org)通过msigdb数据库可以查看各个Hallmark、KEGG、GO具体包含的基因细节。 Hallmark nameProcess categor…
阅读更多...
python中的三种程序控制结构-顺序结构、分支结构、循环结构

python中的三种程序控制结构-顺序结构、分支结构、循环结构

程序控制结构 一、顺序结构二、分支结构三、循环结构条件循环-while遍历循环-for循环控制-break、continue 一、顺序结构 顺序结构是指程序在执行时按照代码的顺序逐一执行&#xff0c;每一行代码只执行一次&#xff0c;然后依次执行下一行代码。顺序结构是程序最基本的执行方式…
阅读更多...
springboot果蔬配送商城

springboot果蔬配送商城

技术架构&#xff1a; java mysql bootstrap jquery mybatis springboot 有需要该项目的小伙伴可以私信我你的Q。 功能介绍&#xff1a; 系统基于Java技术进行开发&#xff0c;后台数据库使用MySQL&#xff0c;在Windows环境下使用idea开发工具进行开发&#xff0c;主…
阅读更多...
异地办公必不可缺的远程控制软件，原理到底是什么?

异地办公必不可缺的远程控制软件，原理到底是什么?

目录 引言远程桌面连接软件的作用与重要性 基本概念与架构客户端-服务器模型网络通信协议 核心技术组件图形界面捕获与传输输入转发会话管理 性能优化策略带宽优化延迟优化 引言 远程桌面连接软件的作用与重要性 在当今这个高度数字化和网络化的时代&#xff0c;远程桌面连接软…
阅读更多...
基于springboot智慧养老平台源码和论文

基于springboot智慧养老平台源码和论文

首先,论文一开始便是清楚的论述了系统的研究内容。其次,剖析系统需求分析,弄明白“做什么”,分析包括业务分析和业务流程的分析以及用例分析,更进一步明确系统的需求。然后在明白了系统的需求基础上需要进一步地设计系统,主要包罗软件架构模式、整体功能模块、数据库设计。本项…
阅读更多...
Yarn常见问题处理

Yarn常见问题处理

任务出现container OOM异常导致作业失败 原因 Container内存不足或者作业数据倾斜 解决方案 检查Container相关参数，判断是否设置过小（低于4GB）。如果Container小于4GB，优先考虑调大当前作业container大小，如果是Tez任务，还需要同步调整以下参数 # tez container size…
阅读更多...
教你一招如何半小时把C语言的 scanf printf sscanf sprintf fscanf fprintf wscanf wprintf 玩出花来

教你一招如何半小时把C语言的 scanf printf sscanf sprintf fscanf fprintf wscanf wprintf 玩出花来

本篇会加入个人的所谓‘鱼式疯言’ ❤️❤️❤️鱼式疯言:❤️❤️❤️此疯言非彼疯言 而是理解过并总结出来通俗易懂的大白话, 我会尽可能的在每个概念后插入鱼式疯言,帮助大家理解的. &#x1f92d;&#x1f92d;&#x1f92d;可能说的不是那么严谨.但小编初心是能让更多人能…
阅读更多...
FPGA模块——FIFO

FPGA模块——FIFO

界面1 2. 3. 4.
阅读更多...
SpringBoot注解--04--@Repository 和@Mapper的区别

SpringBoot注解--04--@Repository 和@Mapper的区别

提示&#xff1a;文章写完后&#xff0c;目录可以自动生成&#xff0c;如何生成可参考右边的帮助文档 文章目录 1.Repository的作用1.1 含义1.2 Repository与Service和Component有什么区别&#xff1f;1.3 使用场景单独使用Repository&#xff0c;需要配合使用MapperScannerCon…
阅读更多...
微信小程序的图片色彩分析，窃取网络图片的主色调

微信小程序的图片色彩分析，窃取网络图片的主色调

1、安装 Mini App Color Thief 包 包括下载包&#xff0c;简单使用都有&#xff0c;之前写了&#xff0c;这里就不写了 网址&#xff1a;微信小程序的图片色彩分析&#xff0c;窃取主色调&#xff0c;调色板-CSDN博客 2、 问题和解决方案 问题&#xff1a;由于我们的窃取图片的…
阅读更多...
【ArcGIS微课1000例】0102：面状要素空洞填充

【ArcGIS微课1000例】0102：面状要素空洞填充

文章目录 一、实验描述二、实验数据三、实验步骤1. 手动补全空洞2. 批量补全空洞四、注意事项一、实验描述 在对地理数据进行编辑时，时常会遇到面数据中存在个别或大量的空洞，考虑实际情况中空洞的数量多少、分布情况，填充空洞区域可以采用逐个填充的方式，也可以采用快速大…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023