MemoryError: stack overflow in python
MemoryError: stack overflow in python
这是 MIPS 单周期数据路径处理器的代码。它正在实现 IDEA 算法（ASM 代码）。我有很多函数调用，整个架构运行这个汇编 IDEA 代码 16 次。我收到此堆栈溢出错误。以前我遇到了递归深度错误，但使用 set.recusionlimit() 函数解决了这个问题。代码看起来没问题，但我不知道为什么它会给我一个 Stack overflow 错误。汇编代码在不同的汇编器中运行良好。
MemoryError: stack overflow
#===========================================================
#SingleCycle Datapath Processor running IDEA algorithm asm
#Sukrut Kelkar
#===========================================================
import sys
import os
def main():
global instrMem
global dataMem
global RegisterFile
global WD3
global Result
global A3
global RD3
global PC
global Branch
global zero
global Imm
global RD
global f
sys.setrecursionlimit(10000)
f=0
RD=0
Imm=0
zero=0
Branch=0
PC=-1
Result=0
WD3=0
A3=0
RD3=0
#Instruction Memory
instructM=open('instructionOpcodes_v1.txt','r')
instrMem = dict(enumerate(line.strip() for line in instructM))
print ('\ninstrMem: ',instrMem)
#Register files
RegisterFile = {k:0 for k in range(31)}
#Data Memory
dataM=open('keys.txt','r')
dataMem = dict(enumerate(line.strip() for line in dataM))
print ('\ndataMem: ',dataMem)
ProgramCounter()
def ProgramCounter():
global PC
PC=mux((Branch & zero),adderPC(PC),Imm)
A=PC
instrMemo(A)
#Instrction Memory Module
def instrMemo(A):
global Op
global funct
global RD
global A1
global A2
global Ard
global Imm
global instr
for i in instrMem:
if A==i:
RD=instrMem[i]
#scale_data= 16 ## equals to hexadecimal
instr=bin(int(RD, 16))[2:].zfill(32)
if int(instr,2)==1:
sys.exit("Its Done!!!")
Op=int(instr[0:6],2)#opcode
funct=int(instr[21:27],2)#funct
rt=instr[11:16]#A2 rt
rd=instr[16:21]# rd
rs=instr[6:11]#A1 rs
Imm=int(instr[16:32],2)#Immediate offset
#Imm=int(Im,2)
A1=int(rs,2)
A2=int(rt,2)
Ard=int(rd,2)
ControlU(Op,funct)
#Control Unit Module
def ControlU(Op,funct):
global RegWrite
global RegDst
global AluSrc
global Branch
global MemWrite
global MemtoReg
global AluCon
global ALUresult
global A3
#R-type Instructions
if Op==0:
RegWrite=1
RegDst=1
AluSrc=0
Branch=0
MemWrite=0
MemtoReg=0
if funct==0:
AluCon=0
elif funct==1:
AluCon=1
elif funct==2:
AluCon=2
elif funct==3:
AluCon=3
elif funct==4:
AluCon=4
elif funct==5:
AluCon=5
#Load Word
elif Op==2:
RegWrite=1
RegDst=0
AluSrc=1
Branch=0
MemWrite=0
MemtoReg=1
AluCon=0
#Load Imm
elif Op==1:
RegWrite=1
RegDst=0
AluSrc=1
Branch=0
MemWrite=0
MemtoReg=0
AluCon=0
#Store Word
elif Op==3:
RegWrite=0
RegDst=0
AluSrc=1
Branch=0
MemWrite=1
MemtoReg=0
AluCon=0
#Branch if equal
elif Op==5:
RegWrite=0
RegDst=0
AluSrc=0
Branch=1
MemWrite=0
MemtoReg=0
AluCon=1
#Add Imm
elif Op==9:
RegWrite=1
RegDst=0
AluSrc=1
Branch=0
MemWrite=0
MemtoReg=0
AluCon=0
#Branch if zero
elif Op==4:
RegWrite=0
RegDst=0
AluSrc=0
Branch=1
MemWrite=0
MemtoReg=0
AluCon=12
#Branch if greater than
elif Op==6:
RegWrite=0
RegDst=0
AluSrc=0
Branch=1
MemWrite=0
MemtoReg=0
AluCon=6
#Branch if less than
elif Op==7:
RegWrite=0
RegDst=0
AluSrc=0
Branch=1
MemWrite=0
MemtoReg=0
AluCon=7
#AddMod
elif Op==11:
RegWrite=1
RegDst=1
AluSrc=0
Branch=0
MemWrite=0
MemtoReg=0
AluCon=11
#MulMod
elif Op==10:
RegWrite=1
RegDst=1
AluSrc=0
Branch=0
MemWrite=0
MemtoReg=0
AluCon=10
A3=mux(RegDst,A2,Ard)
print ('A3: ',A3)
RegisterFiles(A1,A2)
#Register File Module
def RegisterFiles(A1,A2):
global RD1
global RD2
global SrcA
global SrcB
for i in RegisterFile:
if (A1==i):
RD1=RegisterFile[i]
for i in RegisterFile:
if (A2==i):
RD2=RegisterFile[i]
SrcB=mux(AluSrc,RD2,Imm)
SrcA=RD1
ALU_main(AluCon,SrcA,SrcB)
#Arithmetic Logic Unit ALU
def ALU_main(AluCon,inp1,inp2):
global ALUresult
global zero
if AluCon==0:#add
ALUresult=inp1+inp2
elif AluCon==1:#sub
ALUresult=inp1-inp2
elif AluCon==2:#mul
ALUresult=inp1*inp2
elif AluCon==3:#or
ALUresult=inp1 | inp2
elif AluCon==4:#and
ALUresult=inp1 & inp2
elif AluCon==5:#XOR
ALUresult=inp1 ^ inp2
elif AluCon==11:#AddMod
ALUresult=inp1+inp2
while ALUresult>65536:
ALUresult=ALUresult-65536
elif AluCon==10:#MulMod
if inp1==0:
inp1=65536
if inp2==0:
inp2=65536
#ALUresult=int(inp1,2)*int(inp2,2)
ALUresult=inp1*inp2
if ALUresult==65536:
ALUresult=0
while ALUresult>65537:
ALUresult=ALUresult-65537
elif AluCon==6:#BGT
if inp2>inp1:
ALUresult=0
else:
ALUresult=1
elif AluCon==7:#BLT
if inp2<inp1:
ALUresult=0
else:
ALUresult=1
elif AluCon==12:#BZ
if inp1==inp2:
ALUresult=0
else:
ALUresult=1
if ALUresult==0:
zero=1
else:
zero=0
dataMemo()
#Write
def RegisterFileWrite():
global WD3
Result=mux(MemtoReg,ALUresult,RD3)
WD3=Result
if RegWrite==1:
for i in RegisterFile:
if (A3==i):
RegisterFile[i]=WD3
final()
def dataMemo():
global RD3
global Result
WD=RD2
A4=ALUresult
if MemWrite==0:
for i in dataMem:
if A4==i:
RD3=int(dataMem[i],16)
else:
for i in dataMem:
if A4==i:
dataMem[i]=hex(WD)[2:]
os.system('cls')
RegisterFileWrite()
def mux(sel,firstinp,secondinp):
if sel==0:
out=firstinp
else:
out=secondinp
return(out)
def adderPC(inp):
addOut=inp+1
return(addOut)
def final():
global f
f+=1
print (f)
print ('\nPC: ',PC)
#if RegisterFile[24]>4:
print ('dataMem: ',dataMem)
#j=112
#while j<175:
if RegisterFile[24]==4:
print ('Instruction: ',instr)
print ('Op: ',Op)
print ('Funct: ',funct)
print ('Imm: ',Imm)
print ('SrcA: ',SrcA)
print ('SrcB: ',SrcB)
print ('ALUresult: ',ALUresult)
print ('zero: ',zero)
print ('RegisterFile: ',RegisterFile)
print(sys.getrecursionlimit())
#sys.exit("count is 4")
# final=dataMem[j]+dataMem[j+1]
# j=j+1
#print ('\nEncrypted Data: ',final)
ProgramCounter()
if __name__ == '__main__':
main()
您正在获取 Whosebug，因为您将递归限制设置得太高。 You can't set it as high as you like
sys.setrecursionlimit(limit) Set the maximum depth of the Python
interpreter stack to limit. This limit prevents infinite recursion
from causing an overflow of the C stack and crashing Python.
The highest possible limit is platform-dependent. A user may need to
set the limit higher when they have a program that requires deep
recursion and a platform that supports a higher limit. This should be
done with care, because a too-high limit can lead to a crash.
If the new limit is too low at the current recursion depth, a
RecursionError exception is raised.
Changed in version 3.5.1: A RecursionError exception is now raised if
the new limit is too low at the current recursion depth.
您真正的问题是您达到了递归限制。你为什么不直接 post 回溯？
您似乎在使用像 goto 这样的函数调用。 Python 不进行尾调用优化，因此该技术不起作用。
这是 MIPS 单周期数据路径处理器的代码。它正在实现 IDEA 算法（ASM 代码）。我有很多函数调用，整个架构运行这个汇编 IDEA 代码 16 次。我收到此堆栈溢出错误。以前我遇到了递归深度错误，但使用 set.recusionlimit() 函数解决了这个问题。代码看起来没问题，但我不知道为什么它会给我一个 Stack overflow 错误。汇编代码在不同的汇编器中运行良好。
MemoryError: stack overflow
#===========================================================
#SingleCycle Datapath Processor running IDEA algorithm asm
#Sukrut Kelkar
#===========================================================
import sys
import os
def main():
global instrMem
global dataMem
global RegisterFile
global WD3
global Result
global A3
global RD3
global PC
global Branch
global zero
global Imm
global RD
global f
sys.setrecursionlimit(10000)
f=0
RD=0
Imm=0
zero=0
Branch=0
PC=-1
Result=0
WD3=0
A3=0
RD3=0
#Instruction Memory
instructM=open('instructionOpcodes_v1.txt','r')
instrMem = dict(enumerate(line.strip() for line in instructM))
print ('\ninstrMem: ',instrMem)
#Register files
RegisterFile = {k:0 for k in range(31)}
#Data Memory
dataM=open('keys.txt','r')
dataMem = dict(enumerate(line.strip() for line in dataM))
print ('\ndataMem: ',dataMem)
ProgramCounter()
def ProgramCounter():
global PC
PC=mux((Branch & zero),adderPC(PC),Imm)
A=PC
instrMemo(A)
#Instrction Memory Module
def instrMemo(A):
global Op
global funct
global RD
global A1
global A2
global Ard
global Imm
global instr
for i in instrMem:
if A==i:
RD=instrMem[i]
#scale_data= 16 ## equals to hexadecimal
instr=bin(int(RD, 16))[2:].zfill(32)
if int(instr,2)==1:
sys.exit("Its Done!!!")
Op=int(instr[0:6],2)#opcode
funct=int(instr[21:27],2)#funct
rt=instr[11:16]#A2 rt
rd=instr[16:21]# rd
rs=instr[6:11]#A1 rs
Imm=int(instr[16:32],2)#Immediate offset
#Imm=int(Im,2)
A1=int(rs,2)
A2=int(rt,2)
Ard=int(rd,2)
ControlU(Op,funct)
#Control Unit Module
def ControlU(Op,funct):
global RegWrite
global RegDst
global AluSrc
global Branch
global MemWrite
global MemtoReg
global AluCon
global ALUresult
global A3
#R-type Instructions
if Op==0:
RegWrite=1
RegDst=1
AluSrc=0
Branch=0
MemWrite=0
MemtoReg=0
if funct==0:
AluCon=0
elif funct==1:
AluCon=1
elif funct==2:
AluCon=2
elif funct==3:
AluCon=3
elif funct==4:
AluCon=4
elif funct==5:
AluCon=5
#Load Word
elif Op==2:
RegWrite=1
RegDst=0
AluSrc=1
Branch=0
MemWrite=0
MemtoReg=1
AluCon=0
#Load Imm
elif Op==1:
RegWrite=1
RegDst=0
AluSrc=1
Branch=0
MemWrite=0
MemtoReg=0
AluCon=0
#Store Word
elif Op==3:
RegWrite=0
RegDst=0
AluSrc=1
Branch=0
MemWrite=1
MemtoReg=0
AluCon=0
#Branch if equal
elif Op==5:
RegWrite=0
RegDst=0
AluSrc=0
Branch=1
MemWrite=0
MemtoReg=0
AluCon=1
#Add Imm
elif Op==9:
RegWrite=1
RegDst=0
AluSrc=1
Branch=0
MemWrite=0
MemtoReg=0
AluCon=0
#Branch if zero
elif Op==4:
RegWrite=0
RegDst=0
AluSrc=0
Branch=1
MemWrite=0
MemtoReg=0
AluCon=12
#Branch if greater than
elif Op==6:
RegWrite=0
RegDst=0
AluSrc=0
Branch=1
MemWrite=0
MemtoReg=0
AluCon=6
#Branch if less than
elif Op==7:
RegWrite=0
RegDst=0
AluSrc=0
Branch=1
MemWrite=0
MemtoReg=0
AluCon=7
#AddMod
elif Op==11:
RegWrite=1
RegDst=1
AluSrc=0
Branch=0
MemWrite=0
MemtoReg=0
AluCon=11
#MulMod
elif Op==10:
RegWrite=1
RegDst=1
AluSrc=0
Branch=0
MemWrite=0
MemtoReg=0
AluCon=10
A3=mux(RegDst,A2,Ard)
print ('A3: ',A3)
RegisterFiles(A1,A2)
#Register File Module
def RegisterFiles(A1,A2):
global RD1
global RD2
global SrcA
global SrcB
for i in RegisterFile:
if (A1==i):
RD1=RegisterFile[i]
for i in RegisterFile:
if (A2==i):
RD2=RegisterFile[i]
SrcB=mux(AluSrc,RD2,Imm)
SrcA=RD1
ALU_main(AluCon,SrcA,SrcB)
#Arithmetic Logic Unit ALU
def ALU_main(AluCon,inp1,inp2):
global ALUresult
global zero
if AluCon==0:#add
ALUresult=inp1+inp2
elif AluCon==1:#sub
ALUresult=inp1-inp2
elif AluCon==2:#mul
ALUresult=inp1*inp2
elif AluCon==3:#or
ALUresult=inp1 | inp2
elif AluCon==4:#and
ALUresult=inp1 & inp2
elif AluCon==5:#XOR
ALUresult=inp1 ^ inp2
elif AluCon==11:#AddMod
ALUresult=inp1+inp2
while ALUresult>65536:
ALUresult=ALUresult-65536
elif AluCon==10:#MulMod
if inp1==0:
inp1=65536
if inp2==0:
inp2=65536
#ALUresult=int(inp1,2)*int(inp2,2)
ALUresult=inp1*inp2
if ALUresult==65536:
ALUresult=0
while ALUresult>65537:
ALUresult=ALUresult-65537
elif AluCon==6:#BGT
if inp2>inp1:
ALUresult=0
else:
ALUresult=1
elif AluCon==7:#BLT
if inp2<inp1:
ALUresult=0
else:
ALUresult=1
elif AluCon==12:#BZ
if inp1==inp2:
ALUresult=0
else:
ALUresult=1
if ALUresult==0:
zero=1
else:
zero=0
dataMemo()
#Write
def RegisterFileWrite():
global WD3
Result=mux(MemtoReg,ALUresult,RD3)
WD3=Result
if RegWrite==1:
for i in RegisterFile:
if (A3==i):
RegisterFile[i]=WD3
final()
def dataMemo():
global RD3
global Result
WD=RD2
A4=ALUresult
if MemWrite==0:
for i in dataMem:
if A4==i:
RD3=int(dataMem[i],16)
else:
for i in dataMem:
if A4==i:
dataMem[i]=hex(WD)[2:]
os.system('cls')
RegisterFileWrite()
def mux(sel,firstinp,secondinp):
if sel==0:
out=firstinp
else:
out=secondinp
return(out)
def adderPC(inp):
addOut=inp+1
return(addOut)
def final():
global f
f+=1
print (f)
print ('\nPC: ',PC)
#if RegisterFile[24]>4:
print ('dataMem: ',dataMem)
#j=112
#while j<175:
if RegisterFile[24]==4:
print ('Instruction: ',instr)
print ('Op: ',Op)
print ('Funct: ',funct)
print ('Imm: ',Imm)
print ('SrcA: ',SrcA)
print ('SrcB: ',SrcB)
print ('ALUresult: ',ALUresult)
print ('zero: ',zero)
print ('RegisterFile: ',RegisterFile)
print(sys.getrecursionlimit())
#sys.exit("count is 4")
# final=dataMem[j]+dataMem[j+1]
# j=j+1
#print ('\nEncrypted Data: ',final)
ProgramCounter()
if __name__ == '__main__':
main()
您正在获取 Whosebug，因为您将递归限制设置得太高。 You can't set it as high as you like
sys.setrecursionlimit(limit)Set the maximum depth of the Python interpreter stack to limit. This limit prevents infinite recursion from causing an overflow of the C stack and crashing Python.The highest possible limit is platform-dependent. A user may need to set the limit higher when they have a program that requires deep recursion and a platform that supports a higher limit. This should be done with care, because a too-high limit can lead to a crash.
If the new limit is too low at the current recursion depth, a RecursionError exception is raised.
Changed in version 3.5.1: A RecursionError exception is now raised if the new limit is too low at the current recursion depth.
您真正的问题是您达到了递归限制。你为什么不直接 post 回溯？
您似乎在使用像 goto 这样的函数调用。 Python 不进行尾调用优化，因此该技术不起作用。