Subversion Repositories ao486

/*
 * Copyright (c) 2014, Aleksander Osman
 * All rights reserved.
 * 
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 * 
 * * Redistributions of source code must retain the above copyright notice, this
 *   list of conditions and the following disclaimer.
 * 
 * * Redistributions in binary form must reproduce the above copyright notice,
 *   this list of conditions and the following disclaimer in the documentation
 *   and/or other materials provided with the distribution.
 * 
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
 
package ao486.module.memory;
 
import java.io.File;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.LineNumberReader;
import java.io.OutputStream;
import java.math.BigInteger;
import java.util.LinkedList;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
 
public class Runner {
    Runner(File directory) {
        this.directory = directory;
    }
 
    long make_descriptor(long base, long limit) throws Exception {
 
        if(limit >= 0x100000L && (limit & 0xFFFL) != 0xFFFL) throw new Exception(String.format("Illegal limit: %x", limit));
 
        long g = 0;
        if(limit >= 0x100000L) {
            g = 1L << 55;
            limit = (limit >> 12) & 0xFFFFFL;
        }
//System.out.printf("CS BASE: %x, CS LIMIT: %x\n", base, limit);
        return (((base >> 24) & 0xFFL) << 56) | ((base & 0x00FFFFFFL) << 16) | g | (((limit >> 16) & 0xFL) << 48) | (limit & 0xFFFFL);
    }
 
    void ser_bool(StringBuilder buf, String name, boolean bool) {
        buf.append(name).append(": ");
        buf.append(bool? "1 " : "0 ");
        buf.append("\n");
    }
    void ser_long(StringBuilder buf, String name, long l) {
        buf.append(name).append(": ");
        buf.append(String.format("%x ", l));
        buf.append("\n");
    }
 
    boolean des_bool(String str) {
        return Long.parseLong(str) == 1;
    }
    long des_long(String str) {
        int first = Integer.valueOf(str.substring(0,1), 16);
        if(str.length() == 16 && first >= 8) {
            long val = Long.parseLong(String.format("%x", first-8) + str.substring(1), 16);
            val += Long.MIN_VALUE;
            return val;
        }
        return Long.parseLong(str, 16);
    }
    BigInteger des_BigInteger(String str) {
        return new BigInteger(str, 16);
    }
 
 
    void execute() throws Exception {
 
        Process p = null;
 
        try {
            ProcessBuilder pb = new ProcessBuilder("/opt/iverilog/bin/vvp", "tb_memory.vvp"); //, "-lxt2");
            pb.directory(directory);
            pb.redirectErrorStream(true);
 
            p = pb.start();
 
            InputStream in   = p.getInputStream();
            OutputStream out = p.getOutputStream();
 
            Output output = new Output();
            output_invalid = false;
 
            boolean started = false;
            int cycle = 0;
 
            LineNumberReader reader = new LineNumberReader(new InputStreamReader(in));
 
            while(true) {
                String line = reader.readLine();
                if(line == null) break;
 
                line = line.trim();
 
//System.out.println("line: " + line);
                if(line.startsWith("START")) {
                    started = true;
                    continue;
                }
 
                if(started == false) continue;
 
                if(line.endsWith("x")) {
                    output_invalid = true;
//System.out.println("line.endsWith: " + line);
                    continue;
                }
 
                if(line.equals("")) {
                    if(output_invalid && cycle >= 3) throw new Exception("Invalid output.");
 
                    if(output_invalid == false) {
                        for(Listener listener : listeners) listener.get_output(cycle, output);
                    }
 
                    cycle++;
 
                    output = new Output();
                    output_invalid = false;
 
                    continue;
                }
 
                Pattern pat = Pattern.compile("(\\w+?):\\s*([0-9a-fA-F]+)");
                Matcher mat = pat.matcher(line);
 
                boolean found = mat.find();
                if(found == false) throw new Exception("Invalid line: " + line);
 
                String s1 = mat.group(1);
                String s2 = mat.group(2);
 
                s1 = s1.trim();
                s2 = s2.trim();
 
                if(s1.equals("request")) {
                    Input input = new Input();
                    if(cycle == 0) input.rst_n = true;
                    if(cycle == 1) input.rst_n = false;
 
                    if(cycle >= 3) {
                        for(Listener listener : listeners) listener.set_input(cycle, input);
                    }
 
                    StringBuilder buf = new StringBuilder();
 
                    ser_bool(buf, "rst_n", input.rst_n);
 
                    ser_bool(buf, "read_do",        input.read_do);
                    ser_long(buf, "read_cpl",       input.read_cpl);
                    ser_long(buf, "read_address",   input.read_address);
                    ser_long(buf, "read_length",    input.read_length);
                    ser_bool(buf, "read_lock",      input.read_lock);
                    ser_bool(buf, "read_rmw",       input.read_rmw);
 
                    ser_bool(buf, "write_do",       input.write_do);
                    ser_long(buf, "write_cpl",      input.write_cpl);
                    ser_long(buf, "write_address",  input.write_address);
                    ser_long(buf, "write_length",   input.write_length);
                    ser_bool(buf, "write_lock",     input.write_lock);
                    ser_bool(buf, "write_rmw",      input.write_rmw);
                    ser_long(buf, "write_data",     input.write_data);
 
                    ser_bool(buf, "tlbcheck_do",            input.tlbcheck_do);
                    ser_long(buf, "tlbcheck_address",       input.tlbcheck_address);
                    ser_bool(buf, "tlbcheck_rw",            input.tlbcheck_rw);
 
                    ser_bool(buf, "tlbflushsingle_do",      input.tlbflushsingle_do);
                    ser_long(buf, "tlbflushsingle_address", input.tlbflushsingle_address);
 
                    ser_bool(buf, "tlbflushall_do",         input.tlbflushall_do);
 
                    ser_bool(buf, "invdcode_do",            input.invdcode_do);
                    ser_bool(buf, "invddata_do",            input.invddata_do);
                    ser_bool(buf, "wbinvddata_do",          input.wbinvddata_do);
 
                    ser_long(buf, "prefetch_cpl",           input.cpl);
                    ser_long(buf, "prefetch_eip",           input.eip);
                    ser_long(buf, "cs_cache",               make_descriptor(input.cs_base, input.cs_limit));
 
                    ser_bool(buf, "prefetchfifo_accept_do", input.prefetchfifo_accept_do);
 
                    ser_bool(buf, "cr0_pg",             input.cr0_pg);
                    ser_bool(buf, "cr0_wp",             input.cr0_wp);
                    ser_bool(buf, "cr0_am",             input.cr0_am);
                    ser_bool(buf, "cr0_cd",             input.cr0_cd);
                    ser_bool(buf, "cr0_nw",             input.cr0_nw);
 
                    ser_bool(buf, "acflag",             input.acflag);
 
                    ser_long(buf, "cr3",                (input.cr3_base & 0xFFFFF000) | (input.cr3_pcd? 1<<4 : 0) | (input.cr3_pwt? 1<<3 : 0));
 
                    ser_bool(buf, "pipeline_after_read_empty",      input.pipeline_after_read_empty);
                    ser_bool(buf, "pipeline_after_prefetch_empty",  input.pipeline_after_prefetch_empty);
 
                    ser_bool(buf, "pr_reset",           input.pr_reset);
                    ser_bool(buf, "rd_reset",           input.rd_reset);
                    ser_bool(buf, "exe_reset",          input.exe_reset);
                    ser_bool(buf, "wr_reset",           input.wr_reset);
 
                    ser_bool(buf, "avm_waitrequest",   input.avm_waitrequest);
                    ser_bool(buf, "avm_readdatavalid", input.avm_readdatavalid);
                    ser_long(buf, "avm_readdata",      input.avm_readdata);
 
                    if(input.finished)  buf.append("quit: 0\n");
                    else                buf.append("continue: 0\n");
 
//System.out.println("Send: " + buf.toString());
                    out.write(buf.toString().getBytes());
                    out.flush();
 
                    continue;
                }
 
                switch(s1) {
                    case "time": break;
 
                    case "read_done":                   output.read_done                = des_bool(s2); break;
                    case "read_page_fault":             output.read_page_fault          = des_bool(s2); break;
                    case "read_ac_fault":               output.read_ac_fault            = des_bool(s2); break;
                    case "read_data":                   output.read_data                = des_long(s2); break;
 
                    case "write_done":                  output.write_done               = des_bool(s2); break;
                    case "write_page_fault":            output.write_page_fault         = des_bool(s2); break;
                    case "write_ac_fault":              output.write_ac_fault           = des_bool(s2); break;
 
                    case "tlbcheck_done":               output.tlbcheck_done            = des_bool(s2); break;
                    case "tlbcheck_page_fault":         output.tlbcheck_page_fault      = des_bool(s2); break;
 
                    case "tlbflushsingle_done":         output.tlbflushsingle_done      = des_bool(s2); break;
 
                    case "invdcode_done":               output.invdcode_done            = des_bool(s2); break;
                    case "invddata_done":               output.invddata_done            = des_bool(s2); break;
                    case "wbinvddata_done":             output.wbinvddata_done          = des_bool(s2); break;
 
                    case "prefetchfifo_accept_data":    output.prefetchfifo_accept_data = des_BigInteger(s2); break;
                    case "prefetchfifo_accept_empty":   output.prefetchfifo_accept_empty= des_bool(s2); break;
 
                    case "tlb_code_pf_cr2":             output.tlb_code_pf_cr2          = des_long(s2); break;
                    case "tlb_code_pf_error_code":      output.tlb_code_pf_error_code   = des_long(s2); break;
 
                    case "tlb_check_pf_cr2":            output.tlb_check_pf_cr2         = des_long(s2); break;
                    case "tlb_check_pf_error_code":     output.tlb_check_pf_error_code  = des_long(s2); break;
 
                    case "tlb_write_pf_cr2":            output.tlb_write_pf_cr2         = des_long(s2); break;
                    case "tlb_write_pf_error_code":     output.tlb_write_pf_error_code  = des_long(s2); break;
 
                    case "tlb_read_pf_cr2":             output.tlb_read_pf_cr2          = des_long(s2); break;
                    case "tlb_read_pf_error_code":      output.tlb_read_pf_error_code   = des_long(s2); break; 
 
                    case "avm_address":                 output.avm_address              = des_long(s2); break;
                    case "avm_writedata":               output.avm_writedata            = des_long(s2); break;
                    case "avm_byteenable":              output.avm_byteenable           = des_long(s2); break;
                    case "avm_burstcount":              output.avm_burstcount           = des_long(s2); break;
                    case "avm_write":                   output.avm_write                = des_bool(s2); break;
                    case "avm_read":                    output.avm_read                 = des_bool(s2); break;
 
                    default: throw new Exception("Unknown line: " + line);
                }
 
            }
            int result = p.waitFor();
 
            System.out.println("[Runner] Run result: " + result);
        }
        finally {
            if(p != null) p.destroy();
        }
    }
 
    boolean output_invalid;
    LinkedList<Listener> listeners;
    File directory;
}