Abacus Pipeline Conflict Analysis

This tool analyzes the data conflicts of a given Abacus program for a specified processor pipeline. In the Abacus assembler program you can specify the pipeline of the processor using the parameters shown in the example program below. Abacus is a processor that has been designed in the Embedded Systems Group of the University of Kaiserslautern (more about Abacus). See also

reference card for Abacus instructions
options for the Abacus simulator

// -----------------------------------------------------------------------------
// The following Abacus program computes the innner product of the vectors
// a=(1,3,...,2N-1) and b=(2,4,...,2N) for some parameter N. These vectors are
// first generated and are stored in memory, where vector a will start at
// address 0 and vector b will start at address N. After the vectors have been
// generated, their inner product is computed and will be finally available in
// register $7.
// -----------------------------------------------------------------------------
// parameters for processor pipeline
// -----------------------------------------------------------------------------
#const SingleCycle    no  // whether everything is done in one stage
#const PipeFetch       1  // pipeline stage where next program counter is set
#const PipeDecode      2  // pipeline stage where operand registers are read
#const PipeExecute     3  // pipeline stage where ALU results are produced
#const PipeMemAcs      4  // pipeline stage where Load results are produced
#const PipeRegWrite    5  // pipeline stage where registers are written
#const RegBypass     yes  // whether register reads yield current writes
#const Forwarding     no  // whether forwarding from PipeExecute and PipeMemAcs
#const BranchInDecode no  // immediately write new PC in PipeDecode for Branches
// -----------------------------------------------------------------------------
// program parameters to be used for better readability
// -----------------------------------------------------------------------------
#const N 20             // length of the vectors

// -----------------------------------------------------------------------------
// first, generate the argument vectors in memory
// -----------------------------------------------------------------------------
    mov $0,0        // Reg[0] := 0
    mov $1,N        // Reg[1] := N
    mov $2,0        // Reg[2] := 0   (loop variable)
    mov $3,1        // Reg[3] := 1   (elements of a)
    mov $4,2        // Reg[4] := 2   (elements of b)
l1: st $3,$0,$2     // Mem[Reg[2]+0] := Reg[3]
    st $4,$1,$2     // Mem[Reg[2]+N] := Reg[4]
    addi $2,$2,1    // Reg[2] := Reg[2] + 1
    addi $3,$3,2    // Reg[3] := Reg[3] + 2
    addi $4,$4,2    // Reg[4] := Reg[4] + 2
    slt $5,$2,$1    // Reg[5] := Reg[2] < Reg[1]
    bnz $5,l1       // if Reg[5]!=0 goto l1
    sync
// -----------------------------------------------------------------------------
// compute the inner product of the generated vectors
// -----------------------------------------------------------------------------
    mov $2,0        // Reg[2] := 0           (loop variable)
    mov $7,0        // Reg[7] := 0           (preliminary inner product)
l2: ld $3,$0,$2     // Reg[3] := Mem[Reg[2]+0]   (enumerates elements of a)
    ld $4,$1,$2     // Reg[4] := Mem[Reg[2]+N]   (enumerates elements of b)
    mulu $6,$3,$4   // Reg[6] := Reg[3] * Reg[4]
    addu $7,$7,$6   // Reg[7] := Reg[7] + Reg[6]
    addi $2,$2,1    // Reg[2] := Reg[2] + 1
    slt $5,$2,$1    // Reg[5] := Reg[2] < Reg[1]
    bnz $5,l2       // if Reg[5]!=0 goto l2
    sync
// -----------------------------------------------------------------------------

Fachbereich Informatik

Embedded Systems Group (ES)

Abacus Pipeline Conflict Analysis