Native FPGA सॉफ्ट-प्रोसेसर उच्च-स्तरीय भाषा संकलक या माउस के गीत के साथ

परिचय

ठेठ इच्छा सूची

• कमांड सिस्टम की पर्याप्त कार्यक्षमता, संभवतः कार्य के लिए अनुकूलित;
• , .. ;
• – , .

स्रोत घटक

• अलग डेटा और वापसी के ढेर
• हार्वर्ड मेमोरी संगठन आर्किटेक्चर (पता स्थान सहित अलग कार्यक्रम और डेटा मेमोरी);
• एक साधारण समानांतर बस का उपयोग करके बाह्य उपकरणों के साथ विस्तार।
• प्रोसेसर एक पाइपलाइन का उपयोग नहीं करता है, कमांड का निष्पादन पुश-पुल है:
  
  
  1. आदेश और संचालन लाने के लिए;
  2. आदेश का निष्पादन और परिणाम की बचत।

• FPGAs पर उपकरणों और प्रणालियों के नौसिखिए डेवलपर्स के लिए "एंट्री थ्रेशोल्ड" को कम करने वाले उपकरणों में रुचि (सिंटैक्टली पायथन वीएचडीएल के रूप में शुरुआती के लिए "डरावना" नहीं है);
• परियोजना में सद्भाव और एकल शैली के लिए प्रयास करना (पायथन में सॉफ्टवेयर प्रोसेसर के आवश्यक हार्डवेयर ब्लॉक और सॉफ्टवेयर का वर्णन करना सैद्धांतिक रूप से संभव है);
• यादृच्छिक संयोग।

छोटी, "लगभग" अर्थहीन बारीकियाँ

• ढेर सॉफ्टवेयर हैं - अर्थात संकेत द्वारा प्रतिनिधित्व किया और अलग-अलग पते पर डेटा मेमोरी में रखा;
• , - ;
• ;
• , .

एक सांप अपनी पूंछ या लोहे और सॉफ्टवेयर को काटता है

• asm.py - कोडांतरक और संख्याओं का गठन (शाब्दिक);
• gen.py - low-level code generation rules (कार्य, चर, परिवर्तन और स्थितियाँ);
• stream.py - एक बूट स्ट्रीम बनाने;
• मैक्रो-थ्रेड - मैक्रो परिभाषाएँ, वास्तव में - हार्डवेयर-विशिष्ट कार्यों के साथ आधार भाषा का विस्तार।

• एक निश्चित नियंत्रण बाइट प्राप्त करने पर, लोडर प्रोसेसर रीसेट की आंतरिक रेखा पर सक्रिय स्तर सेट करता है;
• दूसरा बाइट कमांड मेमोरी एड्रेस काउंटर को रीसेट करता है;
• निम्नलिखित प्रेषित शब्द की नोटबुक का एक क्रम है, जो सबसे कम उम्र के साथ शुरू होता है, जिसे नोटबुक-संख्या के साथ जोड़ा जाता है;
• पैक किए गए नोटबुक के साथ प्रत्येक बाइट के बाद, नियंत्रण बाइट्स की एक जोड़ी इस प्रकार होती है, जिनमें से पहला मेमोरी लिखने की अनुमति रेखा पर सक्रिय स्तर सेट करता है, दूसरा इसे रीसेट करता है;
• पैक्ड नोटबुक्स के अनुक्रम के पूरा होने पर, नियंत्रण रेखा द्वारा रीसेट लाइन पर सक्रिय स्तर को हटा दिया जाता है।

uart_unit: entity work.uart
--uart_unit: entity uart
  Generic map(
    ClkFreq => 50_000_000,
    Baudrate => 115200)
  port map(
    clk => clk,
    rxd => rx,
    txd => tx,
    dout => receivedByte,
    received => received,
    din => transmitByte,
    transmit => transmit);
    
process(clk)
begin
  if rising_edge(clk) then
    if received = '1' then
      case conv_integer(receivedByte) is
      -- 0-F   - 0-3 bits
        when 0 to 15 => CodeDinA(3 downto 0) <= receivedByte(3 downto 0);
		                  DataDinBtemp(3 downto 0) <= receivedByte(3 downto 0);
      -- 10-1F -4-7bits
        when 16 to 31 => CodeDinA(7 downto 4) <= receivedByte(3 downto 0);
		                   DataDinBtemp(7 downto 4) <= receivedByte(3 downto 0); 
      -- 20-2F -8bit 
        when 32 to 47 => CodeDinA(8) <= receivedByte(0);
	                   DataDinBtemp(11 downto 8) <= receivedByte(3 downto 0);
	  when 48 to 63 => DataDinBtemp(15 downto 12) <= receivedByte(3 downto 0);
	  when 64 to 79 => DataDinBtemp(19 downto 16) <= receivedByte(3 downto 0);
	  when 80 to 95 => DataDinBtemp(23 downto 20) <= receivedByte(3 downto 0);
	  when 96 to 111 => DataDinBtemp(27 downto 24) <= receivedByte(3 downto 0);
        when 112 to 127 => DataDinBtemp(31 downto 28) <= receivedByte(3 downto 0);

      -- F0 addr=0
        when 240 => CodeAddrA <= (others => '0');
      -- F1 - WE=1
        when 241 => CodeWeA <= '1';
      -- F2 WE=0 addr++
        when 242 => CodeWeA <= '0'; CodeAddrA <= CodeAddrA + 1;
      -- F3 RESET=1
        when 243 => int_reset <= '1';
      -- F4 RESET=0
        when 244 => int_reset <= '0';

      -- F5 addr=0
        when 245 => LoaderAddrB <= (others => '0');
      -- F6 - WE=1
        when 246 => DataWeBtemp <= '1';
      -- F7 WE=0 addr++
        when 247 => DataWeBtemp <= '0'; LoaderAddrB <= LoaderAddrB + 1;
		  
		  
        when others => null;
      end case;
    end if;
  end if;
end process;

---- end of loader

…
    if reset = '1' or int_reset = '1' then
      DSAddrA <= (others => '0');      
      
      RSAddrA <= (others => '0');
      RSAddrB <= (others => '0');
      RSWeA <= '0';
      
      DataAddrB <= LoaderAddrB;
		DataDinB<=DataDinBtemp;
		DataWeB<=DataWeBtemp;
      DataWeA <= '0';
…

def get_val(x, by_4):
  r = []
  for i in range(by_4):
    r.append((x & 0xf) | (i << 4))
    x >>= 4
  return r

def make(code, data, core=0):
  #        0  
  stream = [243,245] 
  for x in data:
    #    32- 
    #         
    stream += get_val(x, 8) + [246, 247]
  #       0
  stream += [240]
  for x in code:
    #    9-  
    #         
    stream += get_val(x, 3) + [241, 242]
  #  
  stream.append(244)

  return bytearray(stream)

def lit(x):
  x &= 0xffffffff
  r = [] 
  if (x>>24) & 255 :
    r.append(int((x>>24) & 255) | 256)
  if (x>>16) & 255:
    r.append(int((x>>16) & 255) | 256)
  if (x>>8) & 255:
    r.append(int((x>>8) & 255) | 256)
  r.append(int(x & 255) | 256)
  r += asm("NOP")
  return list(r)

• सशर्त और बिना शर्त कूदता है;
• कॉलिंग फ़ंक्शंस और उन पर तर्क पारित करना;
• फ़ंक्शंस से लौटना और परिणाम लौटना;
• प्रोग्राम मेमोरी, डेटा मेमोरी और स्टैक के आकार में समायोजन;
• प्रोसेसर के स्टार्टअप पर कार्रवाई का क्रम।

          -- group 1; pop 0; push 1;
          when cmdLOCAL => DSDinA <= LocalReg;
			 when cmdLOCALadd => DSDinA <= LocalReg; LocalReg <= LocalReg+1;
			 when cmdLOCALsubb => DSDinA <= LocalReg; LocalReg <= LocalReg-1;
…
          -- group 2; pop 1; push 0;
          when cmdSETLOCAL => LocalReg <= DSDinA;
…

-- ++
DataAddrB <= DSDoutA(DataAddrB'range);
DataDinB <= DSDoutB;

…
          -- group 3; pop 1; push 1;
          when cmdFETCH => DSDinA <= DataDoutB;
…
          when cmdSTORE =>            
            DataWeB <= '1';
…

…
--  
type TCycleStack is array(0 to LocalSize-1) of DataSignal;
signal CycleStack: TCycleStack;
signal CSAddrA, CSAddrB: StackAddrSignal;
signal CSDoutA, CSDoutB: DataSignal;
signal CSDinA, CSDinB: DataSignal;
signal CSWeA, CSWeB: std_logic;
…
--  
process(clk)
begin
  if rising_edge(clk) then
    if CSWeA = '1' then
      CycleStack(conv_integer(CSAddrA)) <= CSDinA;
      CSDoutA <= CSDinA;
    else
      CSDoutA <= CycleStack(conv_integer(CSAddrA));
    end if;
  end if;
end process;

	when cmdDO => -- DO - 
               RSAddrA <= RSAddrA + 1; -- 
               RSDinA <= ip + 1;
               RSWeA <= '1';
				
               CSAddrA <= CSAddrA + 1; --
         		CSDinA <= DSDoutA;
 		         CSWeA <= '1';
		         DSAddrA <= DSAddrA - 1; --
		         ip <= ip + 1;	-- 

      when cmdLOOP => --            
           if conv_integer(CSDoutA) = 0 then
	          ip <= ip + 1;	-- 
		         RSAddrA <= RSAddrA - 1; -- 
		         CSAddrA <= CSAddrA - 1; -- 
            else
		         CSDinA <= CSDoutA - 1;
		         CSWeA <= '1';
		         ip <= RSDoutA(ip'range);
            end if;
			 

STARTUP = asm("""
900  SETLOCAL
2 NOP FETCH JMP
""")

@act
def func(t, X):
  t.c.entry = t.c.globs[X]
  t.c.entry["offs"] = len(t.c.code) # - 1
  args = t.c.entry["args"]
  temps_size = len(t.c.entry["locs"]) - args
#      
  t.out = asm("LOCALadd STORE " * args)
  if temps_size:
#      
    t.out += asm("LOCAL %d PLUS SETLOCAL" % temps_size)
  return True

def epilog(t, X):
  locs_size = len(t.c.entry["locs"])
#    
  t.out = asm("RET")
  if locs_size:
#    ()  
    t.out = asm("LOCAL %d MINUS SETLOCAL" % locs_size) + t.out
  return True

def push_local(t, X):
#          
#  
  t.out = asm("LOCAL %d MINUS" % get_loc_offset(t, X))
  return True

@act
def goto_if_0(t, X):
  push_label(t, X)
  t.out += asm("IF")
  return True

@act
def goto(t, X):
  push_label(t, X)
  t.out += asm("JMP")
  return True

@act
def shl_const(t, X):
  t.out = asm("%d DO SHL LOOP" %(X-1))
  return True

@act
def shr_const(t, X):
  t.out = asm("%d DO SHR LOOP" %(X-1))
  return True

stmt = rule(alt(
  seq(Push(Int(X)), to(lambda v: asm("%d" % v.X))),
  seq(Push(Local(X)), push_local),
  seq(Push(Global(X)), push_global),
  seq(Load(), to(lambda v: asm("NOP FETCH"))),
  seq(Store(), to(lambda v: asm("STORE"))),
  seq(Call(), to(lambda v: asm("CALL"))),
  seq(BinOp("+"), to(lambda v: asm("PLUS"))),
  seq(BinOp("-"), to(lambda v: asm("MINUS"))),
  seq(BinOp("&"), to(lambda v: asm("AND"))),
  seq(BinOp("|"), to(lambda v: asm("OR"))),
  seq(BinOp("^"), to(lambda v: asm("XOR"))),
  seq(BinOp("*"), to(lambda v: asm("MUL"))),
  seq(BinOp("<"), to(lambda v: asm("LESS"))),
  seq(BinOp(">"), to(lambda v: asm("GREATER"))),
  seq(BinOp("=="), to(lambda v: asm("EQUAL"))),
  seq(BinOp("~"), to(lambda v: asm("NOT"))),
  seq(ShlConst(X), shl_const),
  seq(ShrConst(X), shr_const),
  seq(Func(X), func),
  seq(Label(X), label),
  seq(Return(X), epilog),
  seq(GotoIf0(X), goto_if_0),
  seq(Goto(X), goto),
  seq(Nop(), to(lambda v: asm("NOP"))),
  seq(Asm(X), to(lambda v: asm(v.X)))
))

@macro(1,0)
def testasm(c,x):
  return Asm("1 1 OUTPORT 0 1 OUTPORT 11 10 STORE 10 FETCH 1 OUTPORT  15 100 STORE 100  FETCH 1 OUTPORT")

@macro(1,0)
def testlocal(c,x):
   return Asm("1 100 STORE 2 101 STORE 100 SETLOCAL LOCAL NOP FETCH 1 OUTPORT LOCAL 1 PLUS NOP FETCH 1 OUTPORT")

@prim(1, 0)
def delay(c, val):
  return [val, Asm("DO LOOP")]

परिक्षण

def fact(n):
  r = 1
  while n > 1:
    r *= n
    n -= 1
  return r


def main():
  n=1
  while True:
     digital_write(1, fact(n))
     delay(10)
     n=(n+1)&0x7

निष्कर्ष

Family	Cyclone V
Device	5CEBA4F23C7
Logic utilization (in ALMs)	694 / 18,480 ( 4 % )
Total registers	447
Total pins	83 / 224 ( 37 % )
Total virtual pins	0
Total block memory bits	72,192 / 3,153,920 ( 2 % )
Total DSP Blocks	2 / 66 ( 3 % )

1. VHDL // m.habr.com/en/post/149686 पर फोर्थ प्रोसेसर
2. पायथन - विकिपीडिया // en.wikipedia.org/wiki/Python
3. हम FPGA को Python _ Habr // m.habr.com/en/post/439638 पर शुरू करते हैं
4. MyHDL // www.myhdl.org
5. गिटहब - सच्चा-ग्रु_हुज_ उज़ कंपाइलर // github.com/true-grue/uzh
6. GitHub - DSL कंपाइलर के तेजी से प्रोटोटाइप के लिए true-grue_raddsl_ टूल // github.com/true-grue/raddsl
7. sovietov.com/txt/dsl_python_conf.pdf