URL https://opencores.org/ocsvn/mytwoqcache/mytwoqcache/trunk

Subversion Repositories mytwoqcache

[/] [mytwoqcache/] [trunk/] [2QCache.vhd] - Blame information for rev 14

Go to most recent revision | Details | Compare with Previous | View Log


----------------------------------------------------------------------------------
-- Company: 
-- Engineer: 
-- 
-- Create Date:    07:41:47 12/14/2010 
-- Design Name: 
-- Module Name:    Cache - Rtl 
-- Project Name: 
-- Target Devices: 
-- Tool versions: 
-- Description: 
--
-- Dependencies: 
--
-- Revision: 
-- Revision 0.01 - File Created
-- Additional Comments: 
--
----------------------------------------------------------------------------------
library IEEE, work;
use IEEE.std_logic_1164.all;
use IEEE.std_logic_arith.all;
use work.global.all;
 
---- Uncomment the following library declaration if instantiating
---- any Xilinx primitives in this code.
--library UNISIM;
--use UNISIM.VComponents.all;
 
entity Cache is
  generic( constant blocksizeld: integer := 11;
                          constant ldways: integer := 1;
                          constant ldCachedWords: integer := 2);
  port( nReset: in std_ulogic;                                          -- System reset active low
        Clock: in std_ulogic;                                           -- System Clock
                  AddressIn: in std_ulogic_vector(RAMrange'high + 1 downto 0);    -- Address of memory fetch
                  DataIn: in std_ulogic_vector( 31 downto 0);                     -- Data to write
             IOCode: in std_ulogic_vector(2 downto 0);                                           -- operation
                                                                                  -- Bit
                                                                                                                                                                                                --  2    0 read
                                                                                                                                                                                                --       1 write
                                                                                                                                                                                                -- 1 0   11 word
                                                                                                                                                                                                --       10 halfword
                                                                                                                                                                                                --       01 single byte
                                                                                                                                                                                                --       00 no operation
                  DataOut: out std_ulogic_vector( 31 downto 0);                   -- Data read
                  done: out std_ulogic;
                  -- memory interface
                  AddressOut: out std_ulogic_vector(RAMrange'high downto 0);        -- memory address
                  DataBlockIn: in std_ulogic_vector( 2 ** ldCachedWords * 32 - 1 downto 0);   -- data from memory
                  reads: out std_ulogic;                                                      -- read memory
                  DataBlockOut: out std_ulogic_vector( 2 ** ldCachedWords * 32 - 1 downto 0); -- data to memory
                  Mask: out std_ulogic_vector( 2 ** ldCachedWords * 4 - 1 downto 0);          -- enables for each byte active low
                  writes: out std_ulogic;                                                     -- write memory
                  ack: in std_ulogic                                                          -- acknowledge from memory
                );
end Cache;
 
architecture Rtl of Cache is
constant ways: integer := 2 ** ldways;
constant ldram: integer := blocksizeld + ldways - 1;
constant ldqueuelength: integer := ldram;
 
type IOType is ( Start, busy);
type tType is ( inittag, startt, startt1, tagtest, tagwait, stateget, stateget1, finish, finished);
type rType is ( raminit, ramstart, ramstart1, ramcheck, ramcheck1, ramcheck2, ramread, ramread1, ramupdate,
                ramupdate1, ramupdate2, ramupdate3, ramflush, ramflush1, ramwait, ramwait1, ramclean, ramclean1);
type fType is ( queuestart, queuewait, queuewaitAm1, queuewaitAm2, queuewaitA11, queuewaitA12, queueelim);
subtype myint is natural range 15 downto 0;
type TagRAMType is record
  cacheAddr: std_ulogic_vector( ldram - 1 downto 0);
  cacheValid: std_ulogic;
  Tag: std_ulogic_vector( RAMrange'high downto 2 + ldCachedWords + blocksizeld);
  TagValid: std_ulogic;
end record;
type WordType is record
  Word: std_ulogic_vector(31 downto 0);
  Modified: std_ulogic_vector( 3 downto 0);
end record;
type WordArray is array ( 2 ** ldCachedWords - 1 downto 0) of WordType;
type CacheType is record
  Words: WordArray;
  FiFoaddr: std_ulogic_vector( ldqueuelength - 1 downto 0);
  Am: std_ulogic;                                                        -- redifined and renamed
end record;
type FiFoType is record
  Word: std_ulogic_vector( blocksizeld - 1 downto 0);
  way: std_ulogic_vector( ldways downto 0);
  valid: std_ulogic;
end record;
 
type TagRAMarray is array ( ways - 1 downto 0) of TagRAMType;
type TagBuffer is array ( ways - 1 downto 0) of std_ulogic_vector( RAMrange'high - ldCachedWords - blocksizeld - 2 + ldram + 2 downto 0);
type TagFile is array ( 2 ** blocksizeld - 1 downto 0) of std_ulogic_vector( RAMrange'high - ldCachedWords - blocksizeld - 2 + ldram + 2 downto 0);
type TagFiles is array ( ways - 1 downto 0) of TagFile;
 
type RAMFile is array ( 2 ** ldram - 1 downto 0) of std_ulogic_vector( 35 downto 0);
type RAMFiles is array ( 2 ** ldCachedWords - 1 downto 0) of RAMFile;
type RAMBuffer is array ( 2 ** ldCachedWords - 1 downto 0) of std_ulogic_vector( 35 downto 0);
type AFile is array ( 2 ** ldram - 1 downto 0) of std_ulogic_vector( ldqueuelength downto 0); -- redimensioned
 
type myarrayf is array ( 2 ** ldram - 1 downto 0) of std_ulogic_vector( ldram - 1 downto 0);
type myarrayA is array ( 2 ** ldram - 1 downto 0) of std_ulogic_vector( blocksizeld + ldways + 1 downto 0);
 
signal RAMs: RAMFiles;
signal Ax: AFile;
signal tagRAM: TagFiles;
signal tagdummy, tagBuff, TagRAMIn, TagRAMOut: TagRAMarray;
signal RecBuff, CacheIn, CacheOut: CacheType;
signal blockIn, blockOut: WordArray;
signal DataInh: std_ulogic_vector( 31 downto 0);
signal A1In, A1Out, AmIn, AmOut: FiFoType;
signal putA1, removeA1, getA1, emptyA1, fullA1: std_ulogic;
signal putAm, removeAm, getAm, emptyAm, fullAm: std_ulogic;
signal A1Inaddr, A1Outaddr, AmInaddr, AmOutaddr: std_ulogic_vector( ldqueuelength - 1 downto 0);
signal emptyf, getf, putf: std_ulogic;
signal cindex, FreeOut, FreeIn: std_ulogic_vector( ldram - 1 downto 0);
signal ramf: myarrayf;
signal counterf: unsigned( ldram downto 0);
signal firstf, lastf: unsigned( ldram - 1 downto 0);
signal newFiFoAddr: std_ulogic_vector( ldqueuelength - 1 downto 0);
signal newAm: std_ulogic;  -- redifined and renamed
signal initcount: unsigned( blocksizeld - 1 downto 0);
signal initcount1: unsigned( ldram - 1 downto 0);
signal ramA1: myarrayA;
signal counterA1: unsigned( ldqueuelength downto 0);
signal firstA1, lastA1: unsigned( ldqueuelength - 1 downto 0);
signal ramAm: myarrayA;
signal counterAm: unsigned( ldqueuelength downto 0);
signal firstAm, lastAm: unsigned( ldqueuelength - 1 downto 0);
 
signal AddressInh: std_ulogic_vector( AddressIn'high -1 downto 0);
signal IOCodeh: std_ulogic_vector( IOCode'range);
signal toFlush, AddressInt: std_ulogic_vector( 2 + ldCachedWords + blocksizeld - 1 downto 2 + ldCachedWords);
signal found, free, elim, del: myint;
signal stateIO: IOType;
signal statetag: tType;
signal stateram: rType;
signal statequeue: fType;
signal enableram, enablequeue, queuedone, readsh, writesh, doneh, preempted,
       interrupt, readb, writeb, writec, writet, accdone, accqueue, accinterrupt, serviced, oldint: std_ulogic;
 
begin
 
 
 
  blockIO: process( nReset, Clock, readb, writeb) is
  variable s: std_ulogic;
  begin
    if nReset /= '1' then
           writesh <= '0';
                readsh <= '0';
                stateIO <= start;
    elsif rising_edge(Clock) then
           case stateIO is
                when start =>
                  if readb = '1' then
                         Mask <= ( others => '1');
                         readsh <= '1';
                    stateIO <= busy;
                  elsif writeb = '1' then
                    s := '0';
 
                    for i in blockOut'range loop
                      DataBlockOut( ( i + 1) * 32 - 1 downto i * 32) <= blockOut( i).word;
                           Mask( ( i + 1) * 4 - 1 downto i * 4) <= not blockOut( i).Modified;
                                s := s or blockOut( i).Modified(0) or blockOut( i).Modified(1) or
                                          blockOut( i).Modified(2) or blockOut( i).Modified(3);
                         end loop;
 
                         writesh <= s;
 
                         if s = '1' then
                      stateIO <= busy;
                         end if;
                  end if;
                when busy =>
                  if ack = '1' then
                    stateIO <= start;
 
                    if readsh = '1' then
                           for i in blockIn'range loop
                        blockIn( i).word <= DataBlockIn( ( i + 1) * 32 - 1 downto i * 32);
                                  blockIn( i).Modified <= ( others => '0');
                                end loop;
                    end if;
 
                    readsh <= '0';
                    writesh <= '0';
                  end if;
                end case;
         end if;
  end process blockIO;
 
  writes <= writesh;
  reads <= readsh;
 
  tagrams: process ( nReset, Clock) is
  variable a, b, d: myint;
  variable DataInTag, DataOutTag: TagBuffer;
  begin
  if rising_edge(Clock) then
    if nReset /= '1' then
           statetag <= inittag;
                writet <= '0';
                enableram <= '0';
           oldint <= '0';
                found <= 15;
                free <= 15;
                done <= '0'; -- NEW
                initcount <= ( others => '0');
                AddressInt <= ( others => '0');
                IOCodeh <= ( others => '0');
                AddressInh <= ( others => '0');
         else
 
         oldint <= interrupt;
           case statetag is
                  when inittag =>
                    for i in tagRAMIn'range loop
                           tagRAMIn(i).tagValid <= '0';
                           tagRAMIn(i).tag <= ( others => '0');
                           tagRAMIn(i).cacheValid <= '0';
                           tagRAMIn(i).cacheAddr <= ( others => '0');
                         end loop;
                         AddressInt <= std_ulogic_vector(initcount);
                         initcount <= initcount + 1;
                         if unsigned( not AddressInt) = 0 then
                      statetag <= startt;
                           writet <= '0';
                         else
                           writet <= '1';
                         end if;
                  when startt =>
                    if IOCode( 1 downto 0) /= "00" and AddressIn( AddressIn'high) = '0' then
                      -- request encountered
                                AddressInh <= AddressIn(AddressInh'range);
                                IOCodeh <= IOCode;
                      AddressInt <= AddressIn( AddressInt'range);
                                DataInh <= DataIn;
                      statetag <= startt1;
                    end if;
                  when startt1 =>
                    statetag <= tagtest;
                  when tagtest =>
          a := 15;
                    b := 15;
 
               for i in 0 to TagRAMarray'high loop
                      if tagRAMOut( i).tagValid = '1' then
                   if AddressInh(tagRAMout( i).tag'range) = tagRAMout( i).tag then
                          a := i; -- present
                                  end if;
                      else
                             b := i; -- free entry
                      end if;
               end loop;
 
                    found <= a;
                    free <= b;
 
                    if stateram = ramstart then
                      enableram <= '1';
                      statetag <= tagwait;
                         end if;
                  when tagwait =>
                    writet <= '0';
 
                    if interrupt = '1' and oldint = '0' then
                      enableram <= '0';
                           AddressInt <= toFlush;
                                statetag <= stateget;
                         elsif queuedone = '1' then
                      enableram <= '0';
                           statetag <= finish;
                         end if;
                  when stateget =>
                         statetag <= stateget1;
                  when stateget1 =>
                    enableram <= '1';
                         tagDummy <= tagRAMOut;
 
                         for i in tagRAMIn'range loop
                           if del = i then
                        tagRAMIn( i).tagvalid <= '0';
                             tagRAMIn( i).cacheValid <= '0';
                             tagRAMIn( i).tag <= ( others => '0');
                             tagRAMIn( i).cacheAddr <= ( others => '0');
                                  writet <= '1';
                           else
                             tagRAMIn( i) <= tagRAMOut( i);
                           end if;
                         end loop;
 
                         statetag <= tagwait;
                  when finish =>
                    if doneh = '1' then
                           tagRAMIn <= tagBuff;
                                writet <= '1';
                      AddressInt <= AddressInh( AddressInt'range);
                                done <= '1';
                      statetag <= finished;
                    end if;
                  when finished => -- NEW
                    writet <= '0';
                    done <= '0';
                    statetag <= startt;
                end case;
 
         for i in tagRAM'range loop
      DataInTag( i) := TagRAMIn( i).TagValid & TagRAMIn( i).Tag & TagRAMIn( i).cacheValid & TagRAMIn( i).cacheAddr;
 
           if writet = '1' then
                  tagRAM(i)(to_integer( AddressInt)) <= DataInTag( i);
                else
                  DataOutTag( i) := tagRAM(i)(to_integer( AddressInt));
 
             TagRAMOut( i).cacheAddr <= DataOutTag( i)( ldram - 1 downto 0);
             TagRAMOut( i).cacheValid <= DataOutTag( i)( ldram);
             TagRAMOut( i).Tag <= DataOutTag( i)( DataOutTag( 0)'high - 1 downto ldram + 1);
             TagRAMOut( i).TagValid <= DataOutTag( i)( DataOutTag( 0)'high);
                end if;
         end loop;
         end if;
  end if;
  end Process tagrams;
 
  dataram: process (nReset, Clock, enableram) is
  variable en, acc, hi: std_ulogic;
  variable f, g: std_ulogic_vector( CacheIn.FiFoAddr'length downto 0);
  variable a, b: RAMBuffer;
  variable index, index1: integer;
 
  variable address: std_ulogic_vector( ldram - 1 downto 0);
  variable uaddress: unsigned( ldram - 1 downto 0);
  variable datum:  std_ulogic_vector( FreeIn'range);
  variable w: std_ulogic;
  begin
  if rising_edge(Clock) then
    if nReset /= '1' then
           enablequeue <= '0';
           stateram <= raminit;
                writec <= '0';
                writeb <= '0';
                readb <= '0';
                getf <= '0';
                putf <= '0'; -- NEW inserted
                doneh <= '0';
                elim <= 15;
                accinterrupt <= '0';
                accqueue <= '0';
                initcount1 <= ( others => '0');
                FreeIn <= ( others => '0');
                firstf <= ( others => '0');
                lastf <= ( others => '0');
                counterf <= ( others => '0');
         else
           hi := accinterrupt or (interrupt and not oldint);
                acc := accqueue or queuedone;
                en := enablequeue and not acc;
 
                if ldCachedWords = 0 then
                  index := 0;
                else
                  index := to_integer( AddressInh( ldCachedWords + 1 downto 2));
                end if;
 
           case stateram is
                  when raminit =>
                         FreeIn <= std_ulogic_vector( initcount1);
          initcount1    <= initcount1 + 1;
 
                         if unsigned( not FreeIn) = 0 then
                           stateram <= ramstart;
                           putf <= '0';
                         else
                           putf <= '1';
                         end if;
                  when ramstart =>
                    if enableram = '1' then -- UPDATE
                           tagBuff <= tagRAMOut;
                                elim <= 15;
                                stateram <= ramstart1;
                         end if;
                  when ramstart1 =>
                    if enableram = '1' then
                                if found /= 15 then
                                  cindex <= tagBuff( found).cacheAddr;
                                  stateram <= ramupdate;
                                elsif free /= 15 then
                                  en := '1';
                                  stateram <= ramwait;
                                else
                                  elim <= 0;
                                  stateram <= ramcheck;
                                end if;
                         end if;
                  when ramcheck =>
                         cindex <= tagBuff( elim).cacheAddr;
                    stateram <= ramcheck1;
                  when ramcheck1 =>
                    stateram <= ramcheck2;
                  when ramcheck2 =>
                    if cacheOut.Am = '0' or elim = ways - 1 then
                           RecBuff <= cacheOut;
                                en := '1';
                      stateram <= ramwait;
                         else
                           elim <= elim + 1;
                      stateram <= ramcheck;
                         end if;
                  when ramupdate =>
                    stateram <= ramupdate1;
                  when ramupdate1 =>
                    cacheIn <= cacheOut;
                         blockOut <= cacheOut.Words;
                         RecBuff <= cacheOut;
                         en := '1';
                         stateram <= ramwait;
                  when ramwait =>
                         doneh <= '0';
 
                    if hi = '1' then
                                stateram <= ramwait1;
                         elsif acc = '1' then
                           if found /= 15 then
                                  cindex <= tagBuff( found).cacheAddr;
                                  cacheIn <= RecBuff;
                                  blockOut <= RecBuff.Words;
                                  stateram <= ramupdate2;
                                elsif free /= 15 then
                                  cindex <= FreeOut;
                                  tagBuff( free).cacheAddr <= FreeOut;
                                  tagBuff( free).cacheValid <= '1';
                                  tagBuff( free).tag <= AddressInh( tagBuff( free).tag'range);
                                  tagBuff( free).tagValid <= '1';
                                  getf <= '1';
                                  if IOCodeh = "111" and ldCachedWords = 0 then
                                    stateram <= ramupdate2;
                                  else
                                    readb <= '1';
                               AddressOut <= AddressInh( AddressOut'range);
                                    stateram <= ramread;
                                  end if;
                                else
                                  cindex <= tagBuff( elim).cacheAddr;
                                  cacheIn <= RecBuff;
                                  blockOut <= RecBuff.Words;
                                  AddressOut <= tagBuff( elim).tag & AddressInh( AddressInt'range) & ( ldCachedWords + 1 downto 0 => '0');
                        writeb <= '1';
                                  stateram <= ramflush;
                                end if;
                         end if;
                  when ramwait1 =>
                         if del /= 15 and enableram = '1' then
                           if toflush = AddressInh( toflush'range) then -- inserted, tagline could match flushing tagline !!!!
                        tagBuff( del).tagvalid <= '0';
                             tagBuff( del).cacheValid <= '0';
                             tagBuff( del).tag <= ( others => '0');
                             tagBuff( del).cacheAddr <= ( others => '0');
                                end if;
                           cindex <= tagdummy( del).cacheAddr;
                                FreeIn <= tagdummy( del).cacheAddr;
                                putf <= tagdummy( del).cacheValid;
                           stateram <= ramclean;
                         end if;
                  when ramread =>
                    readb <= '0';
                         getf <= '0';
                    stateram <= ramread1;
                  when ramread1 =>
                    if readsh = '0' then
                           for i in blockIn'range loop
                                  cacheIn.Words( i) <= blockIn( i);
                                end loop;
                      stateram <= ramupdate2;
                         end if;
                  when ramupdate2 =>
                    if IOCodeh(2) = '1' then
                           if IOCodeh(1) = '1' then
                                  If IOCodeh(0) = '1' then
                                    cacheIn.Words( index).Word <= DataInh;
                                         cacheIn.Words( index).Modified <= "1111";
                                  elsif AddressInh(1) = '1' then
                                    cacheIn.Words( index).Word( 31 downto 16) <= DataInh( 15 downto 0);
                                         cacheIn.Words( index).Modified( 3 downto 2) <= "11";
                                  else
                                    cacheIn.Words( index).Word( 15 downto 0) <= DataInh( 15 downto 0);
                                         cacheIn.Words( index).Modified( 1 downto 0) <= "11";
                                  end if;
                                else
                                  if AddressInh(1) = '0' then
                                    if AddressInh(0) = '0' then
                                           cacheIn.Words( index).Word( 7 downto 0) <= DataInh( 7 downto 0);
                                                cacheIn.Words( index).Modified(0) <= '1';
                                    else
                                           cacheIn.Words( index).Word( 15 downto 8) <= DataInh( 7 downto 0);
                                                cacheIn.Words( index).Modified(1) <= '1';
                                         end if;
                                  else
                                    if AddressInh(0) = '0' then
                                           cacheIn.Words( index).Word( 23 downto 16) <= DataInh( 7 downto 0);
                                                cacheIn.Words( index).Modified(2) <= '1';
                                    else
                                           cacheIn.Words( index).Word( 31 downto 24) <= DataInh( 7 downto 0);
                                                cacheIn.Words( index).Modified(3) <= '1';
                                         end if;
                                  end if;
                                end if;
                         else
                           DataOut <= cacheIn.Words( index).Word;
                         end if;
 
                         cacheIn.FiFoAddr <= newFiFoAddr;
                         cacheIn.Am <= newAm;
 
                         getf <= '0';
                         writec <= '1';
                         doneh <= '1';
 
                         stateram <= ramupdate3;
                  when ramupdate3 =>
                    hi := '0';
                         acc := '0';
                         en := '0';
                         writec <= '0';
                    doneh <= '0';
                         stateram <= ramstart;
                  when ramclean =>
                    putf <= '0';
                    stateram <= ramclean1;
                  when ramclean1 =>
                         if del /= 15 then
                           blockOut <= cacheOut.words;
                                writeb <= tagdummy( del).tagValid;
                                AddressOut <= tagdummy( del).tag & toFlush & ( ldCachedWords + 1 downto 0 => '0');
                           stateram <= ramflush;
                         end if;
                  when ramflush =>
                    writeb <= '0';
                         for i in blockIn'range loop
                      cacheIn.Words( i).Word <= ( others => '0');
                           cacheIn.Words( i).Modified <= ( others => '0');
                         end loop;
 
                         stateram <= ramflush1;
                  when ramflush1 =>
                         if writesh = '0' then
                           if del /= 15 and hi = '1' then
                                  hi := '0';
                             stateram <= ramwait;
                                else
                                  tagBuff( elim).tag <= AddressInh( tagBuff( elim).tag'range);
                                  tagBuff( elim).tagValid <= '1';
                                  if IOCodeh = "111" and ldCachedWords = 0 then
                                    stateram <= ramupdate2;
                                  else
                                    readb <= '1';
                                    AddressOut <= AddressInh( AddressOut'range);
                                    stateram <= ramread;
                                  end if;
                                end if;
                         end if;
                end case;
 
                accinterrupt <= hi;
                enablequeue <= en;
                accqueue <= acc;
 
         f := CacheIn.Am & CacheIn.FiFoAddr;
         if writec = '1' then
           Ax( to_integer( cindex)) <= f;
         else
           g := Ax( to_integer( cindex));
                CacheOut.FiFoAddr <= g( g'high - 1 downto g'low);
                CacheOut.Am <= g( g'high);
         end if;
 
         for i in RAMBuffer'range loop
           a( i) := CacheIn.Words( i).Modified & CacheIn.Words( i).Word;
                if writec = '1' then
                  RAMs( i)( to_integer( cindex)) <= a( i);
                else
                  b( i) := RAMs( i)( to_integer( cindex));
                  CacheOut.Words( i).Word <= b( i)( 31 downto 0);
                  CacheOut.Words( i).Modified <= b( i)( 35 downto 32);
                end if;
         end loop;
 
         if putf = '1' then
           address := std_ulogic_vector( firstf);
                datum := FreeIn;
                firstf <= firstf + 1;
                counterf <= counterf + 1;
                w := '1';
         else
           uaddress := lastf;
           if getf = '1' and counterf /= 0 then
             counterf <= counterf - 1;
                  uaddress := uaddress + 1;
           end if;
                lastf <= uaddress;
                address := std_ulogic_vector( uaddress);
                w := '0';
         end if;
 
         if w = '1' then
           ramf( to_integer( address)) <= datum;
         else
           FreeOut <= ramf( to_integer( address));
         end if;
 
         end if;
  end if;
  end process dataram;
 
  emptyf <= '1' when counterf = 0 else '0';
 
  queues: process( nReset, Clock, enablequeue) is
  variable acc, hi: std_ulogic;
  variable A1OutBuff, AmOutBuff: std_ulogic_vector( blocksizeld + ldways + 1 downto 0);
  variable addressA1: std_ulogic_vector( ldqueuelength - 1 downto 0);
  variable diff, uaddressA1: unsigned( ldqueuelength - 1 downto 0);
  variable datumA1:  std_ulogic_vector( A1OutBuff'range);
  variable wA1: std_ulogic;
  variable addressAm: std_ulogic_vector( ldqueuelength - 1 downto 0);
  variable uaddressAm: unsigned( ldqueuelength - 1 downto 0);
  variable datumAm:  std_ulogic_vector( AmOutBuff'range);
  variable wAm: std_ulogic;
  begin
  if rising_edge(Clock) then
    if nReset /= '1' then
                del <= 15;
           statequeue <= queuestart;
           queuedone <= '0';
                interrupt <= '0';
                accdone <= '0';
                preempted <= '0';
                firstA1 <= ( others => '0');
                A1Outaddr <= ( others => '0');
                lastA1 <= ( others => '0');
                counterA1 <= ( others => '0');
                firstAm <= ( others => '0');
                AmOutaddr <= ( others => '0');
                lastAm <= ( others => '0');
                counterAm <= ( others => '0');
                getA1 <= '0'; -- NEW
                getAm <= '0'; -- NEW
                removeA1 <= '0'; -- NEW
                removeAm <= '0'; -- NEW
                putA1 <= '0'; -- NEW
                putAm <= '0'; -- NEW
           serviced <= '0';
         else
           hi := interrupt;
                acc := accdone or doneh;
 
                diff := firstA1 - unsigned( RecBuff.FiFoAddr);
 
           case statequeue is
                  when queuestart =>
                         getA1 <= '0';
 
                    if enablequeue = '1' then
                           if found /= 15 then
                                  if RecBuff.Am = '1' or                                -- in Am
                                    ( RecBuff.Am = '0' and diff( diff'high) = '0') then -- in lower half of A1
                                    queuedone <= '1';
                                         newFiFoAddr <= RecBuff.FiFoAddr;
                                         newAm <= RecBuff.Am;
                               statequeue <= queuewait;
                                  elsif fullAm = '1' then
                                    -- Am full
                                         if AmOut.valid = '1' then
                                           del <= to_integer( AmOut.way);
                                                toFlush <= AmOut.word;
                                                getAm <= '1';
                                           hi := '1';
                                           statequeue <= queuewait;
                                         end if;
                                  else
                                    AmIn.word <= AddressInh( 2 + ldCachedWords + blocksizeld - 1 downto 2 + ldCachedWords);
                                         AmIn.way <= std_ulogic_vector(to_unsigned( found, ldways + 1));
                                         AmIn.valid <= '1';
                                         putAm <= '1';
                                         A1Inaddr <= RecBuff.FiFoAddr;
                                         removeA1 <= '1';
                                         statequeue <= queuewaitAm1;
                                  end if;
                                elsif free /= 15 then
                                  if fullA1 = '1' or (emptyf = '1' and emptyA1 = '0' and serviced = '0') then
                                    -- remove last entry from A1
                                         if A1Out.valid = '1' then
                                           del <= to_integer( A1Out.way);
                                           toFlush <= A1Out.word;
                                           getA1 <= '1';
                                           hi := '1';
                              serviced <= '1';
                                           statequeue <= queuewait;
                                         end if;
                                  elsif fullAm = '1' and emptyf = '1' and serviced = '0' then
                                    -- remove last entry from Am
                                         if AmOut.valid = '1' then
                                           del <= to_integer( AmOut.way);
                                           toFlush <= AmOut.word;
                                           getAm <= '1';
                                           hi := '1';
                              serviced <= '1';
                                           statequeue <= queuewait;
                                         end if;
                                  else
                                    A1In.word <= AddressInh( 2 + ldCachedWords + blocksizeld - 1 downto 2 + ldCachedWords);
                                         A1In.way <= std_ulogic_vector(to_unsigned( free, ldways + 1));
                                         A1In.valid <= '1';
                                         putA1 <= '1';
                            serviced <= '0';
                                         statequeue <= queuewaitA11;
                                  end if;
                                elsif elim /= 15 then
                                  if fullA1 = '1' then
                                    if A1Out.valid = '1' then
                                           if not ( to_integer( A1Out.way) = elim and
                                                        A1Out.word = AddressInh( 2 + ldCachedWords + blocksizeld - 1 downto 2 + ldCachedWords)) then
                                             del <= to_integer( A1Out.way);
                                             toFlush <= A1Out.word;
                                             statequeue <= queueelim;
                                           end if;
 
                                           getA1 <= '1';
                                         end if;
                                  else
                            if getA1 = '1' then
                              preempted <= '1';
                            end if;
                                         getA1 <= '0'; -- NEW, inserted the only bug!!!!!!!!!!!!!!
                                    A1In.word <= AddressInh( 2 + ldCachedWords + blocksizeld - 1 downto 2 + ldCachedWords);
                                         A1In.way <= std_ulogic_vector(to_unsigned( elim, ldways + 1));
                                         A1In.valid <= '1';
                                         putA1 <= '1';
                                         statequeue <= queueelim;
                                  end if;
                                end if;
                         end if;
                  when queuewait =>
                         removeA1 <= '0';
                         removeAm <= '0';
                    getAm <= '0';
                    getA1 <= '0';
                         queuedone <= '0';
 
             if hi = '1' then
                   hi := '0';
                           statequeue <= queuestart;
               elsif acc = '1' then
                           acc := '0';
                                del <= 15;
                           statequeue <= queuestart;
                         end if;
                  when queuewaitAm1 =>
                    putAm <= '0';
                         removeA1 <= '0';
                         statequeue <= queuewaitAm2;
                  when queuewaitAm2 =>
                         newFiFoAddr <= AmOutAddr;
                         newAm <= '1';
                         queuedone <= '1';
                         statequeue <= queuewait;
                  when queuewaitA11 =>
                    putA1 <= '0';
                         statequeue <= queuewaitA12;
                  when queuewaitA12 =>
                         newFiFoAddr <= A1OutAddr;
                         newAm <= '0';
                         removeA1 <= '0';
                         removeAm <= '0';
                         queuedone <= '1';
                    preempted <= '0';
                         statequeue <= queuewait;
                  when queueelim =>
                    putA1 <= '0';
                         getA1 <= '0';
 
                         if RecBuff.Am = '1' and preempted = '0' then
                           AmInAddr <= RecBuff.FiFoAddr;
                           removeAm <= '1';
                         elsif preempted = '0' then
                           A1InAddr <= RecBuff.FiFoAddr;
                           removeA1 <= '1';
                         end if;
 
                         if getA1 = '1' then
                           hi := '1';
                                preempted <= '1';
                           statequeue <= queuewait;
                         else
                           statequeue <= queuewaitA12;
                         end if;
                end case;
 
                interrupt <= hi;
                accdone <= acc;
 
         if putA1 = '1' or removeA1 = '1' then
           if removeA1 = '0' then
             addressA1 := std_ulogic_vector( firstA1);
                  datumA1 := A1In.valid & A1In.way & A1In.Word;
                  firstA1 <= firstA1 + 1;
                  counterA1 <= counterA1 + 1;
                  A1Outaddr <= std_ulogic_vector( firstA1);
                else
                  addressA1 := A1Inaddr( addressA1'range);
                  datumA1 := ( others => '0');
                end if;
                wA1 := '1';
         else
           uaddressA1 := lastA1;
           if (getA1 = '1' or A1Out.valid = '0') and counterA1 /= 0 then
             counterA1 <= counterA1 - 1;
             uaddressA1 := uaddressA1 + 1;
           end if;
           lastA1 <= uaddressA1;
           addressA1 := std_ulogic_vector( uaddressA1);
           wA1 := '0';
         end if;
 
         if wA1 = '1' then
           ramA1( to_integer( addressA1)) <= datumA1;
         else
           A1OutBuff := ramA1( to_integer( addressA1));
 
      A1Out.Word <= A1OutBuff( blocksizeld - 1 downto 0);
      A1Out.way <= A1OutBuff( blocksizeld + ldways downto blocksizeld);
                A1Out.valid <= A1OutBuff( blocksizeld + ldways + 1);
         end if;
 
         if putAm = '1' or removeAm = '1' then
           if removeAm = '0' then
             addressAm := std_ulogic_vector( firstAm);
                  datumAm := AmIn.valid & AmIn.way & AmIn.Word;
                  firstAm <= firstAm + 1;
                  counterAm <= counterAm + 1;
                  AmOutaddr <= std_ulogic_vector( firstAm);
                else
                  addressAm := AmInaddr( addressAm'range);
                  datumAm := ( others => '0');
                end if;
                wAm := '1';
         else
           uaddressAm := lastAm;
           if (getAm = '1' or AmOut.valid = '0') and counterAm /= 0 then
             counterAm <= counterAm - 1;
             uaddressAm := uaddressAm + 1;
           end if;
           lastAm <= uaddressAm;
           addressAm := std_ulogic_vector( uaddressAm);
           wAm := '0';
         end if;
 
         if wAm = '1' then
           ramAm( to_integer( addressAm)) <= datumAm;
         else
           AmOutBuff := ramAm( to_integer( addressAm));
 
      AmOut.Word <= AmOutBuff( blocksizeld - 1 downto 0);
      AmOut.way <= AmOutBuff( blocksizeld + ldways downto blocksizeld);
                AmOut.valid <= AmOutBuff( blocksizeld + ldways + 1);
         end if;
         end if;
  end if;
  end process queues;
 
  fullA1 <= counterA1( counterA1'high);
  emptyA1 <= '1' when counterA1 = 0 else '0';
 
  fullAm <= counterAm( counterAm'high);
  emptyAm <= '1' when counterAm = 0 else '0';
 
end Rtl;
 

Line No.	Rev	Author	Line
1	11	gerhardhoh	`----------------------------------------------------------------------------------`
2			`-- Company:`
3			`-- Engineer:`
4			`--`
5			`-- Create Date: 07:41:47 12/14/2010`
6			`-- Design Name:`
7			`-- Module Name: Cache - Rtl`
8			`-- Project Name:`
9			`-- Target Devices:`
10			`-- Tool versions:`
11			`-- Description:`
12			`--`
13			`-- Dependencies:`
14			`--`
15			`-- Revision:`
16			`-- Revision 0.01 - File Created`
17			`-- Additional Comments:`
18			`--`
19			`----------------------------------------------------------------------------------`
20			`library IEEE, work;`
21			`use IEEE.std_logic_1164.all;`
22			`use IEEE.std_logic_arith.all;`
23			`use work.global.all;`
24
25			`---- Uncomment the following library declaration if instantiating`
26			`---- any Xilinx primitives in this code.`
27			`--library UNISIM;`
28			`--use UNISIM.VComponents.all;`
29
30			`entity Cache is`
31			`generic( constant blocksizeld: integer := 11;`
32			`constant ldways: integer := 1;`
33			`constant ldCachedWords: integer := 2);`
34			`port( nReset: in std_ulogic; -- System reset active low`
35			`Clock: in std_ulogic; -- System Clock`
36	10	gerhardhoh	`AddressIn: in std_ulogic_vector(RAMrange'high + 1 downto 0); -- Address of memory fetch`
37	11	gerhardhoh	`DataIn: in std_ulogic_vector( 31 downto 0); -- Data to write`
38			`IOCode: in std_ulogic_vector(2 downto 0); -- operation`
39	10	gerhardhoh	`-- Bit`
40			`-- 2 0 read`
41			`-- 1 write`
42			`-- 1 0 11 word`
43			`-- 10 halfword`
44			`-- 01 single byte`
45	11	gerhardhoh	`-- 00 no operation`
46			`DataOut: out std_ulogic_vector( 31 downto 0); -- Data read`
47	10	gerhardhoh	`done: out std_ulogic;`
48	11	gerhardhoh	`-- memory interface`
49			`AddressOut: out std_ulogic_vector(RAMrange'high downto 0); -- memory address`
50			`DataBlockIn: in std_ulogic_vector( 2 ** ldCachedWords * 32 - 1 downto 0); -- data from memory`
51			`reads: out std_ulogic; -- read memory`
52			`DataBlockOut: out std_ulogic_vector( 2 ** ldCachedWords * 32 - 1 downto 0); -- data to memory`
53			`Mask: out std_ulogic_vector( 2 ** ldCachedWords * 4 - 1 downto 0); -- enables for each byte active low`
54	10	gerhardhoh	`writes: out std_ulogic; -- write memory`
55	11	gerhardhoh	`ack: in std_ulogic -- acknowledge from memory`
56			`);`
57			`end Cache;`
58
59	10	gerhardhoh	`architecture Rtl of Cache is`
60			`constant ways: integer := 2 ** ldways;`
61			`constant ldram: integer := blocksizeld + ldways - 1;`
62			`constant ldqueuelength: integer := ldram;`
63
64	11	gerhardhoh	`type IOType is ( Start, busy);`
65			`type tType is ( inittag, startt, startt1, tagtest, tagwait, stateget, stateget1, finish, finished);`
66	10	gerhardhoh	`type rType is ( raminit, ramstart, ramstart1, ramcheck, ramcheck1, ramcheck2, ramread, ramread1, ramupdate,`
67	11	gerhardhoh	`ramupdate1, ramupdate2, ramupdate3, ramflush, ramflush1, ramwait, ramwait1, ramclean, ramclean1);`
68			`type fType is ( queuestart, queuewait, queuewaitAm1, queuewaitAm2, queuewaitA11, queuewaitA12, queueelim);`
69			`subtype myint is natural range 15 downto 0;`
70			`type TagRAMType is record`
71			`cacheAddr: std_ulogic_vector( ldram - 1 downto 0);`
72			`cacheValid: std_ulogic;`
73			`Tag: std_ulogic_vector( RAMrange'high downto 2 + ldCachedWords + blocksizeld);`
74			`TagValid: std_ulogic;`
75	10	gerhardhoh	`end record;`
76			`type WordType is record`
77	11	gerhardhoh	`Word: std_ulogic_vector(31 downto 0);`
78	10	gerhardhoh	`Modified: std_ulogic_vector( 3 downto 0);`
79			`end record;`
80	11	gerhardhoh	`type WordArray is array ( 2 ** ldCachedWords - 1 downto 0) of WordType;`
81			`type CacheType is record`
82	10	gerhardhoh	`Words: WordArray;`
83			`FiFoaddr: std_ulogic_vector( ldqueuelength - 1 downto 0);`
84	11	gerhardhoh	`Am: std_ulogic; -- redifined and renamed`
85			`end record;`
86	10	gerhardhoh	`type FiFoType is record`
87			`Word: std_ulogic_vector( blocksizeld - 1 downto 0);`
88			`way: std_ulogic_vector( ldways downto 0);`
89			`valid: std_ulogic;`
90			`end record;`
91
92			`type TagRAMarray is array ( ways - 1 downto 0) of TagRAMType;`
93			`type TagBuffer is array ( ways - 1 downto 0) of std_ulogic_vector( RAMrange'high - ldCachedWords - blocksizeld - 2 + ldram + 2 downto 0);`
94			`type TagFile is array ( 2 ** blocksizeld - 1 downto 0) of std_ulogic_vector( RAMrange'high - ldCachedWords - blocksizeld - 2 + ldram + 2 downto 0);`
95			`type TagFiles is array ( ways - 1 downto 0) of TagFile;`
96
97			`type RAMFile is array ( 2 ** ldram - 1 downto 0) of std_ulogic_vector( 35 downto 0);`
98			`type RAMFiles is array ( 2 ** ldCachedWords - 1 downto 0) of RAMFile;`
99			`type RAMBuffer is array ( 2 ** ldCachedWords - 1 downto 0) of std_ulogic_vector( 35 downto 0);`
100	11	gerhardhoh	`type AFile is array ( 2 ** ldram - 1 downto 0) of std_ulogic_vector( ldqueuelength downto 0); -- redimensioned`
101	10	gerhardhoh
102			`type myarrayf is array ( 2 ** ldram - 1 downto 0) of std_ulogic_vector( ldram - 1 downto 0);`
103			`type myarrayA is array ( 2 ** ldram - 1 downto 0) of std_ulogic_vector( blocksizeld + ldways + 1 downto 0);`
104
105			`signal RAMs: RAMFiles;`
106			`signal Ax: AFile;`
107	11	gerhardhoh	`signal tagRAM: TagFiles;`
108	10	gerhardhoh	`signal tagdummy, tagBuff, TagRAMIn, TagRAMOut: TagRAMarray;`
109			`signal RecBuff, CacheIn, CacheOut: CacheType;`
110			`signal blockIn, blockOut: WordArray;`
111			`signal DataInh: std_ulogic_vector( 31 downto 0);`
112			`signal A1In, A1Out, AmIn, AmOut: FiFoType;`
113			`signal putA1, removeA1, getA1, emptyA1, fullA1: std_ulogic;`
114			`signal putAm, removeAm, getAm, emptyAm, fullAm: std_ulogic;`
115			`signal A1Inaddr, A1Outaddr, AmInaddr, AmOutaddr: std_ulogic_vector( ldqueuelength - 1 downto 0);`
116			`signal emptyf, getf, putf: std_ulogic;`
117	11	gerhardhoh	`signal cindex, FreeOut, FreeIn: std_ulogic_vector( ldram - 1 downto 0);`
118			`signal ramf: myarrayf;`
119			`signal counterf: unsigned( ldram downto 0);`
120	10	gerhardhoh	`signal firstf, lastf: unsigned( ldram - 1 downto 0);`
121			`signal newFiFoAddr: std_ulogic_vector( ldqueuelength - 1 downto 0);`
122	11	gerhardhoh	`signal newAm: std_ulogic; -- redifined and renamed`
123	10	gerhardhoh	`signal initcount: unsigned( blocksizeld - 1 downto 0);`
124			`signal initcount1: unsigned( ldram - 1 downto 0);`
125	11	gerhardhoh	`signal ramA1: myarrayA;`
126			`signal counterA1: unsigned( ldqueuelength downto 0);`
127			`signal firstA1, lastA1: unsigned( ldqueuelength - 1 downto 0);`
128			`signal ramAm: myarrayA;`
129			`signal counterAm: unsigned( ldqueuelength downto 0);`
130			`signal firstAm, lastAm: unsigned( ldqueuelength - 1 downto 0);`
131	10	gerhardhoh
132			`signal AddressInh: std_ulogic_vector( AddressIn'high -1 downto 0);`
133	11	gerhardhoh	`signal IOCodeh: std_ulogic_vector( IOCode'range);`
134			`signal toFlush, AddressInt: std_ulogic_vector( 2 + ldCachedWords + blocksizeld - 1 downto 2 + ldCachedWords);`
135			`signal found, free, elim, del: myint;`
136	10	gerhardhoh	`signal stateIO: IOType;`
137			`signal statetag: tType;`
138			`signal stateram: rType;`
139			`signal statequeue: fType;`
140			`signal enableram, enablequeue, queuedone, readsh, writesh, doneh, preempted,`
141	13	gerhardhoh	`interrupt, readb, writeb, writec, writet, accdone, accqueue, accinterrupt, serviced, oldint: std_ulogic;`
142	11	gerhardhoh
143			`begin`
144	10	gerhardhoh
145	11	gerhardhoh
146
147	10	gerhardhoh	`blockIO: process( nReset, Clock, readb, writeb) is`
148			`variable s: std_ulogic;`
149			`begin`
150			`if nReset /= '1' then`
151			`writesh <= '0';`
152			`readsh <= '0';`
153			`stateIO <= start;`
154			`elsif rising_edge(Clock) then`
155			`case stateIO is`
156			`when start =>`
157			`if readb = '1' then`
158			`Mask <= ( others => '1');`
159			`readsh <= '1';`
160			`stateIO <= busy;`
161			`elsif writeb = '1' then`
162			`s := '0';`
163
164			`for i in blockOut'range loop`
165			`DataBlockOut( ( i + 1) * 32 - 1 downto i * 32) <= blockOut( i).word;`
166			`Mask( ( i + 1) * 4 - 1 downto i * 4) <= not blockOut( i).Modified;`
167			`s := s or blockOut( i).Modified(0) or blockOut( i).Modified(1) or`
168			`blockOut( i).Modified(2) or blockOut( i).Modified(3);`
169			`end loop;`
170
171			`writesh <= s;`
172
173			`if s = '1' then`
174			`stateIO <= busy;`
175			`end if;`
176			`end if;`
177			`when busy =>`
178			`if ack = '1' then`
179			`stateIO <= start;`
180
181			`if readsh = '1' then`
182			`for i in blockIn'range loop`
183			`blockIn( i).word <= DataBlockIn( ( i + 1) * 32 - 1 downto i * 32);`
184			`blockIn( i).Modified <= ( others => '0');`
185			`end loop;`
186			`end if;`
187
188			`readsh <= '0';`
189			`writesh <= '0';`
190			`end if;`
191			`end case;`
192			`end if;`
193			`end process blockIO;`
194
195			`writes <= writesh;`
196			`reads <= readsh;`
197
198			`tagrams: process ( nReset, Clock) is`
199			`variable a, b, d: myint;`
200	11	gerhardhoh	`variable DataInTag, DataOutTag: TagBuffer;`
201	10	gerhardhoh	`begin`
202			`if rising_edge(Clock) then`
203			`if nReset /= '1' then`
204			`statetag <= inittag;`
205			`writet <= '0';`
206			`enableram <= '0';`
207	13	gerhardhoh	`oldint <= '0';`
208	10	gerhardhoh	`found <= 15;`
209			`free <= 15;`
210			`done <= '0'; -- NEW`
211			`initcount <= ( others => '0');`
212			`AddressInt <= ( others => '0');`
213			`IOCodeh <= ( others => '0');`
214			`AddressInh <= ( others => '0');`
215			`else`
216
217	13	gerhardhoh	`oldint <= interrupt;`
218	10	gerhardhoh	`case statetag is`
219			`when inittag =>`
220			`for i in tagRAMIn'range loop`
221			`tagRAMIn(i).tagValid <= '0';`
222			`tagRAMIn(i).tag <= ( others => '0');`
223			`tagRAMIn(i).cacheValid <= '0';`
224			`tagRAMIn(i).cacheAddr <= ( others => '0');`
225			`end loop;`
226			`AddressInt <= std_ulogic_vector(initcount);`
227			`initcount <= initcount + 1;`
228			`if unsigned( not AddressInt) = 0 then`
229			`statetag <= startt;`
230			`writet <= '0';`
231			`else`
232			`writet <= '1';`
233			`end if;`
234			`when startt =>`
235			`if IOCode( 1 downto 0) /= "00" and AddressIn( AddressIn'high) = '0' then`
236			`-- request encountered`
237			`AddressInh <= AddressIn(AddressInh'range);`
238	11	gerhardhoh	`IOCodeh <= IOCode;`
239	10	gerhardhoh	`AddressInt <= AddressIn( AddressInt'range);`
240			`DataInh <= DataIn;`
241			`statetag <= startt1;`
242			`end if;`
243			`when startt1 =>`
244			`statetag <= tagtest;`
245			`when tagtest =>`
246	11	gerhardhoh	`a := 15;`
247	10	gerhardhoh	`b := 15;`
248	11	gerhardhoh
249			`for i in 0 to TagRAMarray'high loop`
250			`if tagRAMOut( i).tagValid = '1' then`
251			`if AddressInh(tagRAMout( i).tag'range) = tagRAMout( i).tag then`
252	10	gerhardhoh	`a := i; -- present`
253	11	gerhardhoh	`end if;`
254			`else`
255			`b := i; -- free entry`
256			`end if;`
257			`end loop;`
258	10	gerhardhoh
259	11	gerhardhoh	`found <= a;`
260			`free <= b;`
261
262	10	gerhardhoh	`if stateram = ramstart then`
263			`enableram <= '1';`
264			`statetag <= tagwait;`
265			`end if;`
266			`when tagwait =>`
267			`writet <= '0';`
268
269	13	gerhardhoh	`if interrupt = '1' and oldint = '0' then`
270	10	gerhardhoh	`enableram <= '0';`
271			`AddressInt <= toFlush;`
272			`statetag <= stateget;`
273			`elsif queuedone = '1' then`
274			`enableram <= '0';`
275			`statetag <= finish;`
276			`end if;`
277			`when stateget =>`
278			`statetag <= stateget1;`
279			`when stateget1 =>`
280			`enableram <= '1';`
281			`tagDummy <= tagRAMOut;`
282
283			`for i in tagRAMIn'range loop`
284			`if del = i then`
285			`tagRAMIn( i).tagvalid <= '0';`
286			`tagRAMIn( i).cacheValid <= '0';`
287			`tagRAMIn( i).tag <= ( others => '0');`
288			`tagRAMIn( i).cacheAddr <= ( others => '0');`
289			`writet <= '1';`
290			`else`
291			`tagRAMIn( i) <= tagRAMOut( i);`
292			`end if;`
293			`end loop;`
294
295			`statetag <= tagwait;`
296			`when finish =>`
297			`if doneh = '1' then`
298			`tagRAMIn <= tagBuff;`
299			`writet <= '1';`
300			`AddressInt <= AddressInh( AddressInt'range);`
301			`done <= '1';`
302			`statetag <= finished;`
303			`end if;`
304			`when finished => -- NEW`
305			`writet <= '0';`
306			`done <= '0';`
307			`statetag <= startt;`
308			`end case;`
309
310			`for i in tagRAM'range loop`
311			`DataInTag( i) := TagRAMIn( i).TagValid & TagRAMIn( i).Tag & TagRAMIn( i).cacheValid & TagRAMIn( i).cacheAddr;`
312
313			`if writet = '1' then`
314			`tagRAM(i)(to_integer( AddressInt)) <= DataInTag( i);`
315			`else`
316			`DataOutTag( i) := tagRAM(i)(to_integer( AddressInt));`
317
318			`TagRAMOut( i).cacheAddr <= DataOutTag( i)( ldram - 1 downto 0);`
319			`TagRAMOut( i).cacheValid <= DataOutTag( i)( ldram);`
320			`TagRAMOut( i).Tag <= DataOutTag( i)( DataOutTag( 0)'high - 1 downto ldram + 1);`
321			`TagRAMOut( i).TagValid <= DataOutTag( i)( DataOutTag( 0)'high);`
322			`end if;`
323			`end loop;`
324			`end if;`
325			`end if;`
326			`end Process tagrams;`
327
328			`dataram: process (nReset, Clock, enableram) is`
329			`variable en, acc, hi: std_ulogic;`
330			`variable f, g: std_ulogic_vector( CacheIn.FiFoAddr'length downto 0);`
331			`variable a, b: RAMBuffer;`
332			`variable index, index1: integer;`
333
334	11	gerhardhoh	`variable address: std_ulogic_vector( ldram - 1 downto 0);`
335			`variable uaddress: unsigned( ldram - 1 downto 0);`
336	10	gerhardhoh	`variable datum: std_ulogic_vector( FreeIn'range);`
337	11	gerhardhoh	`variable w: std_ulogic;`
338	10	gerhardhoh	`begin`
339			`if rising_edge(Clock) then`
340			`if nReset /= '1' then`
341			`enablequeue <= '0';`
342			`stateram <= raminit;`
343			`writec <= '0';`
344			`writeb <= '0';`
345			`readb <= '0';`
346			`getf <= '0';`
347			`putf <= '0'; -- NEW inserted`
348			`doneh <= '0';`
349			`elim <= 15;`
350			`accinterrupt <= '0';`
351			`accqueue <= '0';`
352			`initcount1 <= ( others => '0');`
353			`FreeIn <= ( others => '0');`
354	11	gerhardhoh	`firstf <= ( others => '0');`
355			`lastf <= ( others => '0');`
356			`counterf <= ( others => '0');`
357	10	gerhardhoh	`else`
358	13	gerhardhoh	`hi := accinterrupt or (interrupt and not oldint);`
359	10	gerhardhoh	`acc := accqueue or queuedone;`
360	13	gerhardhoh	`en := enablequeue and not acc;`
361	10	gerhardhoh
362			`if ldCachedWords = 0 then`
363			`index := 0;`
364			`else`
365			`index := to_integer( AddressInh( ldCachedWords + 1 downto 2));`
366			`end if;`
367
368			`case stateram is`
369			`when raminit =>`
370			`FreeIn <= std_ulogic_vector( initcount1);`
371			`initcount1 <= initcount1 + 1;`
372
373			`if unsigned( not FreeIn) = 0 then`
374			`stateram <= ramstart;`
375			`putf <= '0';`
376			`else`
377			`putf <= '1';`
378			`end if;`
379			`when ramstart =>`
380			`if enableram = '1' then -- UPDATE`
381			`tagBuff <= tagRAMOut;`
382			`elim <= 15;`
383			`stateram <= ramstart1;`
384	11	gerhardhoh	`end if;`
385	10	gerhardhoh	`when ramstart1 =>`
386			`if enableram = '1' then`
387			`if found /= 15 then`
388			`cindex <= tagBuff( found).cacheAddr;`
389			`stateram <= ramupdate;`
390			`elsif free /= 15 then`
391			`en := '1';`
392			`stateram <= ramwait;`
393			`else`
394			`elim <= 0;`
395			`stateram <= ramcheck;`
396			`end if;`
397			`end if;`
398			`when ramcheck =>`
399			`cindex <= tagBuff( elim).cacheAddr;`
400			`stateram <= ramcheck1;`
401			`when ramcheck1 =>`
402			`stateram <= ramcheck2;`
403			`when ramcheck2 =>`
404			`if cacheOut.Am = '0' or elim = ways - 1 then`
405			`RecBuff <= cacheOut;`
406			`en := '1';`
407			`stateram <= ramwait;`
408			`else`
409			`elim <= elim + 1;`
410			`stateram <= ramcheck;`
411			`end if;`
412			`when ramupdate =>`
413			`stateram <= ramupdate1;`
414			`when ramupdate1 =>`
415			`cacheIn <= cacheOut;`
416			`blockOut <= cacheOut.Words;`
417			`RecBuff <= cacheOut;`
418			`en := '1';`
419			`stateram <= ramwait;`
420			`when ramwait =>`
421			`doneh <= '0';`
422
423			`if hi = '1' then`
424			`stateram <= ramwait1;`
425			`elsif acc = '1' then`
426			`if found /= 15 then`
427			`cindex <= tagBuff( found).cacheAddr;`
428			`cacheIn <= RecBuff;`
429			`blockOut <= RecBuff.Words;`
430			`stateram <= ramupdate2;`
431			`elsif free /= 15 then`
432			`cindex <= FreeOut;`
433			`tagBuff( free).cacheAddr <= FreeOut;`
434			`tagBuff( free).cacheValid <= '1';`
435			`tagBuff( free).tag <= AddressInh( tagBuff( free).tag'range);`
436			`tagBuff( free).tagValid <= '1';`
437			`getf <= '1';`
438			`if IOCodeh = "111" and ldCachedWords = 0 then`
439			`stateram <= ramupdate2;`
440			`else`
441			`readb <= '1';`
442			`AddressOut <= AddressInh( AddressOut'range);`
443			`stateram <= ramread;`
444			`end if;`
445			`else`
446			`cindex <= tagBuff( elim).cacheAddr;`
447			`cacheIn <= RecBuff;`
448			`blockOut <= RecBuff.Words;`
449			`AddressOut <= tagBuff( elim).tag & AddressInh( AddressInt'range) & ( ldCachedWords + 1 downto 0 => '0');`
450			`writeb <= '1';`
451			`stateram <= ramflush;`
452			`end if;`
453			`end if;`
454			`when ramwait1 =>`
455			`if del /= 15 and enableram = '1' then`
456	11	gerhardhoh	`if toflush = AddressInh( toflush'range) then -- inserted, tagline could match flushing tagline !!!!`
457	10	gerhardhoh	`tagBuff( del).tagvalid <= '0';`
458			`tagBuff( del).cacheValid <= '0';`
459			`tagBuff( del).tag <= ( others => '0');`
460			`tagBuff( del).cacheAddr <= ( others => '0');`
461			`end if;`
462			`cindex <= tagdummy( del).cacheAddr;`
463			`FreeIn <= tagdummy( del).cacheAddr;`
464			`putf <= tagdummy( del).cacheValid;`
465			`stateram <= ramclean;`
466			`end if;`
467			`when ramread =>`
468			`readb <= '0';`
469			`getf <= '0';`
470			`stateram <= ramread1;`
471			`when ramread1 =>`
472			`if readsh = '0' then`
473			`for i in blockIn'range loop`
474			`cacheIn.Words( i) <= blockIn( i);`
475			`end loop;`
476			`stateram <= ramupdate2;`
477			`end if;`
478			`when ramupdate2 =>`
479			`if IOCodeh(2) = '1' then`
480			`if IOCodeh(1) = '1' then`
481			`If IOCodeh(0) = '1' then`
482			`cacheIn.Words( index).Word <= DataInh;`
483			`cacheIn.Words( index).Modified <= "1111";`
484			`elsif AddressInh(1) = '1' then`
485			`cacheIn.Words( index).Word( 31 downto 16) <= DataInh( 15 downto 0);`
486			`cacheIn.Words( index).Modified( 3 downto 2) <= "11";`
487			`else`
488			`cacheIn.Words( index).Word( 15 downto 0) <= DataInh( 15 downto 0);`
489			`cacheIn.Words( index).Modified( 1 downto 0) <= "11";`
490			`end if;`
491			`else`
492			`if AddressInh(1) = '0' then`
493			`if AddressInh(0) = '0' then`
494			`cacheIn.Words( index).Word( 7 downto 0) <= DataInh( 7 downto 0);`
495			`cacheIn.Words( index).Modified(0) <= '1';`
496			`else`
497			`cacheIn.Words( index).Word( 15 downto 8) <= DataInh( 7 downto 0);`
498			`cacheIn.Words( index).Modified(1) <= '1';`
499			`end if;`
500			`else`

Browse

Tools

Subversion Repositories mytwoqcache

[/] [mytwoqcache/] [trunk/] [2QCache.vhd] - Blame information for rev 14