ivannosys3/src/samples/program_jun_lu.go

// Aplica o back-end do juninho
@target          : mipsjun
// Especifica o tipo de metodo empregado para salvar o resultado da compilação
//@export          : MultCoreJun
@export          : simulation

// Diretorio onde o resultado da compilação será gravado
@outputDirectory : `C:\Users\EUGENIO CARVALHO\Desktop\tmp\lu`

// Quantidade de palavras de um bloco 32 palavras de 4bytes
@cacheBlockSize: `32`

/**
    Profile de compilacao do back-end
    O formato da string é um json que descreve um array de definições de cada core
    {
        "stackBaseAddress"   : 5888,     -> endereço da base da pilha do core em questão
        "initFunction": "multiplica(0)", -> define a main de cada core. aceita ate 4 parametros com valores de constantes
        "id": "core0"                    -> label que define o codigo de cada core
    },

    Se "stackBaseAddress" não for definido o compilador irá inferir o valor iniciando do ultimo endereço da memoria    
*/

@profile: `[
    {
        "id"               : "core0",
        "initFunction"     : "bitCount(0)",
        "filename"         : "%s_core_0.txt"
    },
    {
        "id"               : "core1",
        "initFunction"     : "bitCount(18750)",
        "filename"         : "%s_core_1.txt"
    },
    {
        "id"               : "core2",
        "initFunction"     : "bitCount(37500)",
        "filename"         : "%s_core_2.txt"
    },
    {
        "id"               : "core3",
        "initFunction"     : "bitCount(56250)",
        "filename"         : "%s_core_3.txt"
    }
]`

package main;


const (
    SIZE         = 20
    INITIAL_LINE = 0
    END_LINE     = 5
)

var (
    M [SIZE][SIZE]int32
    L [SIZE][SIZE]int32
    lock bool
    i int32
    j int32
    k int32
    aux_div int32
    res_div int32
    aux_mkk int32
)

func preenche(){
    if lock {return}

    lock = true
    /* Inicializa matrizes */
    for i = 0; i < SIZE; i++ {
        for j = 0; j < SIZE; j++{
            if i == j {
                M[i][j] = 1
            }else{
                M[i][j] = 1 + (i*SIZE) + j
            }
            L[i][j] = 0
        }
    }
    lock = false
}
func lu(){
    
    //for ;lock;  {}

    /* 4. ITERATIONS LOOP */
    for k=INITIAL_LINE; k<SIZE-1; k++ {
 
    /* 4.1. PROCESS ROWS IN PARALLEL, DISTRIBUTE WITH nthreads STRIDE */
        for i=k+1; i<END_LINE; i++ {
            /* 4.1.1. COMPUTE L COLUMN */
//            L[i][k] = M[i][k] / M[k][k];  //Era DIV, mas usava BREAK e daria trabalho fazer
            aux_div = M[i][k]
            aux_mkk = M[k][k]
            res_div = 0
             
            if aux_div < 0 {
                aux_div = aux_div * -1
            }
 
            if aux_mkk < 0 {
                aux_mkk = aux_mkk * -1
            }
 
            for aux_div - aux_mkk >= 0 {
                aux_div -= aux_mkk
                res_div++
            }
            
            L[i][k] = res_div
            /* 4.1.2. COMPUTE M ROW ELEMENTS */
            for j=k+1; j<SIZE; j++ {
                M[i][j] = M[i][j] - L[i][k] * M[k][j]
            }
        }
/* 4.2. END ITERATIONS LOOP */
    }   
}

func main(){
    zomba := 10
    lu()
}