ivannosys3/src/IntermediaryCode/Allocation.java

/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */
package IntermediaryCode;

import Processors.Ocorrence;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;

/**
 *
 * @author Eugenio
 */
public class Allocation {

    protected static int registerCount = 32;
    protected int lastLine = 0;
    protected HashMap<String, Ocorrence> vars;
//    HashMap<String, HashMap<Integer, Integer>> vars;
    HashMap<String, ArrayList<ArrayList<Integer>>> intervals;
    protected static ArrayList<String> labels;
    protected ArrayList<Boolean> registers;
    protected HashMap<String, Integer> assigns;
    protected HashMap<String, String> regAssigns;
    protected Integer swapRegister;
    protected Integer currentRegister;
    protected ArrayList<Integer> interval;

    public Allocation(int sizeOfBlock, HashMap<String, Ocorrence> varOcorrences) {
        vars = varOcorrences;
        lastLine = sizeOfBlock;
        intervals = new HashMap<>();
        labels = new ArrayList<>();
        registers = new ArrayList<>();
        assigns = new HashMap<>();
        regAssigns = new HashMap<>();

        initRegisters();
    }

    @Override
    public String toString() {
        return "Allocation:\n"
                + "Registers\n" + registers.toString()
                + "\nAssigns\n" + assigns.toString()
                + "\nReg->Var\n" + regAssigns.toString();
    }

    public static String reg2Str(int reg) {
        return labels.get(reg);
    }

    public static int reg2Int(String regis) {
        return labels.indexOf(regis);
    }

    public void put(int line, String var, int reg) {
//        System.out.println("Put:" + var + ":" + line + ":" + reg);
        assigns.put(var + "." + line, reg);
        regAssigns.put(reg + "." + line, var);
//        System.out.println("assigns:" + assigns + ":" + regAssigns);
    }

    public void remove(int line, String var, int reg) {
        assigns.remove(var + "." + line);
        regAssigns.remove(reg + "." + line);
    }

    public String get(int line, String var) {
        String key = var + "." + line;
        if (assigns.containsKey(key)) {
            return reg2Str(assigns.get(key));
        }
        return "undefined";
    }

    public String var(int line, String reg) {
        String key = reg + "." + line;
        if (regAssigns.containsKey(key)) {
            return regAssigns.get(key);
        }
        return "undefined";
    }

    public void register(int line, String var) throws Exception {
        if (!var.matches("^_.*")) {
            return;
        }
//        System.out.println("Register:" + line + ":" + var);

        Integer reg;
        /*Se não existe um registrador associado a variavel retorna*/
        if (!alive(line, var)) {

            /*Tenta alocar um registrador para variavel*/
            reg = assign(line, var);

            /*Se não existem registradores disponiveis executa a troca*/
            if (reg == null) {
                reg = swap(line, var);

            }
            /*Atribui o registrador ao intervalo atual*/
            interval.set(2, reg);

        } else {
            /* atribui o registrador do intervalo*/
            reg = interval.get(2);
        }

        System.out.println("put_register:" + line + ":" + var + ":" + reg);

        put(line, var, reg);
    }

    protected ArrayList<Integer> newInterval(int line, String var) {
        interval = new ArrayList<>();

        interval.add(line);//inicio do intervalo
        interval.add(vars.get(var).last());//fim do intervalo
        interval.add(-1);//não possui registrador

        intervals.get(var).add(interval);

        return interval;
    }

    /**
     * Verifica se a variavel possui um registrador associado na a um intervalo
     *
     * @param line
     * @param var
     * @return
     * @throws java.lang.Exception
     */
    public boolean alive(int line, String var) throws Exception {
//        return !dead(line, var);
//        return vars.get(var).last() >= line;
        interval = interval(line, var);
        return interval.get(2) >= 0;
    }

    protected boolean dead(int line, String var) throws Exception {
        if (!vars.containsKey(var)) {
            throw new Exception("Var '" + var + "' not found!");
        }
        return vars.get(var).last() < line;
    }

    protected ArrayList<ArrayList<Integer>> intervals(int line, int regb, int rege) {

        for (Map.Entry<String, ArrayList<ArrayList<Integer>>> entry : intervals.entrySet()) {
            String string = entry.getKey();
//            Ocorrence ocorrence = entry.getValue();

        }

        return null;
    }

    protected ArrayList<Integer> interval(int line, String var) {

        if (!intervals.containsKey(var)) {
            intervals.put(var, new ArrayList<ArrayList<Integer>>());
            return newInterval(line, var);
        }
        /*Verifica se o intervalo existe*/
        ArrayList<ArrayList<Integer>> itens = intervals.get(var);
        ArrayList<Integer> i;
        for (int count = itens.size() - 1; count >= 0; count--) {
            i = itens.get(count);

            if (line >= i.get(0) && line <= i.get(1)) {
                return i;
            }
        }


        /*Cria o intervalo caso não exista */
        return newInterval(line, var);

    }

    protected int coust(int line, String var) throws Exception {
        if (!vars.containsKey(var)) {
            throw new Exception("[Coust] Var '" + var + "' not found!");
        }
        return vars.get(var).nextOcorrenceAfter(line);
    }

    protected Integer swap(int line, String var) throws Exception {
//        int[] result = {0, -1};

//        Integer reg =  free(regType(var), true, line);
//
//        if (reg != null) {
//            result[0] = 1;
//            result[1] = reg;
//        }
        return free(regType(var), true, line, var);
        /*Verifica se existe alguma variavel que não possui mais ocorrencia apos a linha atual.
         * Retorno é um vetor de inteiros. o primeiro indice indica se encontrou ou não e o segundo 
         * é o valor do registrador.
         */ //        int[] result = ;
        //        Integer reg = null;
        //        if (result[0] == 0) {
        //            /*Se não encontrou um registrador disponivel forca a troca*/
        //            reg = swapRegister;
        //        } else {
        //            reg = result[1];
        //        }
    }

    protected Integer assign(int line, String var) throws Exception {
        return free(regType(var), false, line, var);
    }

    protected Integer free(String base, boolean recicle, int line, String var) throws Exception {
        int start, end;

        switch (base) {
            case "v":
                start = 2;
                end = 3;
                break;
            case "a":
                start = 4;
                end = 7;
                break;
            case "s":
                start = 16;
                end = 23;
                break;
            case "k":
                start = 26;
                end = 27;
                break;
            case "t":
                Integer result = free(8, 15, recicle, line, var);
                if (result == null) {
                    result = free(24, 25, recicle, line, var);
                }
                return result;

            default:
                throw new Exception("Register type " + base + " not defined!");
        }

        return free(start, end, recicle, line, var);
    }

    protected Integer recicle(int begin, int end, int line, String var) throws Exception {
        int[] result = {0, 0};
        int limit = 0, coust;
        return 1;

//        ArrayList<Integer> lowCoust;
//
////        for (int reg = begin; reg <= end; reg++) {
//        try {
//
//            for (ArrayList<Integer> interval : intervals(line, begin, end)) {
//
//            }
//
//        } catch (DeadInterval e) {
//            return e.getRegister();
//        }
////
////            if (dead(line, var)) {
////                return interval.get(2);
////            }
//
////            var = regAssigns.get(reg + "." + line);
////
////            
////
////            coust = coust(line, var);
////
////            if (coust > limit) {
////                limit = coust;
////                swapRegister = reg;
////            }
    }

    protected Integer free(int begin, int end, boolean recicle, int line, String var) throws Exception {

        if (recicle) {
            return recicle(begin, end, line, var);
        }

        for (int i = begin; i <= end; i++) {
            if (!registers.get(i)) {
                registers.set(i, true);
                return i;
            }
        }

        return null;
    }

    protected String regType(String var) throws Exception {
        var = var.replace("*", "")
                .replace("&", "")
                .substring(0, 2);

        switch (var) {
            case "_T":
            case "_C":
                return "t";
            case "_I":
            case "_V":
            case "_P":
            case "_Y":
            case "_X":
            case "_G":
                return "s";
            case "_A":
                return "a";
        }
        throw new Exception("Invalid label '" + var + "'!");
    }

    protected void initRegisters() {
        for (int i = 0; i < registerCount; i++) {
            registers.add(false);
        }
        //Zero
        labels.add("zero");
        //Assembler
        labels.add("$at");
        //Returns
        labels.add("$v0");
        labels.add("$v1");
        //Arguments
        labels.add("$a0");
        labels.add("$a1");
        labels.add("$a2");
        labels.add("$a3");
        //Temporary
        labels.add("$t0");
        labels.add("$t1");
        labels.add("$t2");
        labels.add("$t3");
        labels.add("$t4");
        labels.add("$t5");
        labels.add("$t6");
        labels.add("$t7");
        //Saved
        labels.add("$s0");
        labels.add("$s1");
        labels.add("$s2");
        labels.add("$s3");
        labels.add("$s4");
        labels.add("$s5");
        labels.add("$s6");
        labels.add("$s7");
        //Temporary
        labels.add("$t8");
        labels.add("$t9");
        //Kernel
        labels.add("$k0");
        labels.add("$k1");
        //Stack control
        labels.add("$gp");
        labels.add("$sp");
        labels.add("$fp");
        //Return address
        labels.add("$ra");
    }

}