Subversion Repositories aor3000

/*

 * This file is subject to the terms and conditions of the BSD License. See

 * the file "LICENSE" in the main directory of this archive for more details.

 *

 * Copyright (C) 2014 Aleksander Osman

 */

#include <cstdio>

#include <cstdlib>

#include <cstring>

#include <sys/mman.h>

#include <sys/types.h>

#include <sys/stat.h>

#include <sys/wait.h>

#include <fcntl.h>

#include <signal.h>

#include <unistd.h>

#include "shared_mem.h"

#include "tests.h"

//------------------------------------------------------------------------------

volatile shared_mem_t *shared_ptr = NULL;

//------------------------------------------------------------------------------

//------------------------------------------------------------------------------

//------------------------------------------------------------------------------

tst_t tst_instr_fetch_tlb_invalid_exc = { .init = NULL                      };

tst_t tst_arith_logic_till_exc        = { .init = arith_logic_till_exc_init };

tst_t tst_exception_till_exc          = { .init = exception_till_exc_init   };

tst_t tst_tlb_commands_till_exc       = { .init = tlb_commands_till_exc_init};

tst_t tst_branch_till_exc             = { .init = branch_till_exc_init      };

tst_t tst_data_till_exc               = { .init = data_till_exc_init        };

tst_t tst_interrupt_till_exc          = { .init = interrupt_till_exc_init   };

tst_t tst_tlb_fetch_till_exc          = { .init = tlb_fetch_till_exc_init   };

tst_t tst_tlb_data_till_exc           = { .init = tlb_data_till_exc_init    };

//------------------------------------------------------------------------------

tst_t *tst_current = &tst_tlb_data_till_exc;

//------------------------------------------------------------------------------

//------------------------------------------------------------------------------

//------------------------------------------------------------------------------

bool is_diff(volatile report_t *vmips, volatile report_t *ao) {

    char buf[65536];

    memset(buf, 0, sizeof(buf));

    char *ptr = buf;

    bool diff;

    bool show = false;

    ptr += sprintf(ptr, "name               |d| vmips     | ao       \n");

    ptr += sprintf(ptr, "------------------------------------------\n");

    diff = vmips->counter != ao->counter; show = show || diff;

    ptr += sprintf(ptr, "counter            |%c| %08x | %08x \n", (diff)? '*' : ' ', vmips->counter, ao->counter);

    diff = vmips->exception != ao->exception; show = show || diff;

    ptr += sprintf(ptr, "exception          |%c| %08x | %08x \n", (diff)? '*' : ' ', vmips->exception, ao->exception);

    for(int i=1; i<32; i++) {

        diff = vmips->state.reg[i-1] != ao->state.reg[i-1]; show = show || diff;

        ptr += sprintf(ptr, "reg[%02d]            |%c| %08x | %08x \n", i, (diff)? '*' : ' ', vmips->state.reg[i-1], ao->state.reg[i-1]);

    }

    diff = vmips->state.pc != ao->state.pc; show = show || diff;

    ptr += sprintf(ptr, "pc                 |%c| %08x | %08x \n", (diff)? '*' : ' ', vmips->state.pc, ao->state.pc);

    //not comapred: diff = vmips->state.lo != ao->state.lo; show = show || diff;

    //not comapred: ptr += sprintf(ptr, "lo                 |%c| %08x | %08x \n", (diff)? '*' : ' ', vmips->state.lo, ao->state.lo);

    //not comapred: diff = vmips->state.hi != ao->state.hi; show = show || diff;

    //not comapred: ptr += sprintf(ptr, "hi                 |%c| %08x | %08x \n", (diff)? '*' : ' ', vmips->state.hi, ao->state.hi);

    diff = vmips->state.index_p != ao->state.index_p; show = show || diff;

    ptr += sprintf(ptr, "index_p            |%c| %01x        | %01x        \n", (diff)? '*' : ' ', vmips->state.index_p, ao->state.index_p);

    diff = vmips->state.index_index != ao->state.index_index; show = show || diff;

    ptr += sprintf(ptr, "index_index        |%c| %02x       | %02x       \n", (diff)? '*' : ' ', vmips->state.index_index, ao->state.index_index);

    diff = vmips->state.random != ao->state.random; show = show || diff;

    ptr += sprintf(ptr, "random             |%c| %02x       | %02x       \n", (diff)? '*' : ' ', vmips->state.random, ao->state.random);

    diff = vmips->state.entrylo_pfn != ao->state.entrylo_pfn; show = show || diff;

    ptr += sprintf(ptr, "entrylo_pfn        |%c| %05x    | %05x    \n", (diff)? '*' : ' ', vmips->state.entrylo_pfn, ao->state.entrylo_pfn);

    diff = vmips->state.entrylo_n != ao->state.entrylo_n; show = show || diff;

    ptr += sprintf(ptr, "entrylo_n          |%c| %01x        | %01x        \n", (diff)? '*' : ' ', vmips->state.entrylo_n, ao->state.entrylo_n);

    diff = vmips->state.entrylo_d != ao->state.entrylo_d; show = show || diff;

    ptr += sprintf(ptr, "entrylo_d          |%c| %01x        | %01x        \n", (diff)? '*' : ' ', vmips->state.entrylo_d, ao->state.entrylo_d);

    diff = vmips->state.entrylo_v != ao->state.entrylo_v; show = show || diff;

    ptr += sprintf(ptr, "entrylo_v          |%c| %01x        | %01x        \n", (diff)? '*' : ' ', vmips->state.entrylo_v, ao->state.entrylo_v);

    diff = vmips->state.entrylo_g != ao->state.entrylo_g; show = show || diff;

    ptr += sprintf(ptr, "entrylo_g          |%c| %01x        | %01x        \n", (diff)? '*' : ' ', vmips->state.entrylo_g, ao->state.entrylo_g);

    diff = vmips->state.context_ptebase != ao->state.context_ptebase; show = show || diff;

    ptr += sprintf(ptr, "context_ptebase    |%c| %03x      | %03x      \n", (diff)? '*' : ' ', vmips->state.context_ptebase, ao->state.context_ptebase);

    diff = vmips->state.context_badvpn != ao->state.context_badvpn; show = show || diff;

    ptr += sprintf(ptr, "context_badvpn     |%c| %05x    | %05x    \n", (diff)? '*' : ' ', vmips->state.context_badvpn, ao->state.context_badvpn);

    diff = vmips->state.bad_vaddr != ao->state.bad_vaddr; show = show || diff;

    ptr += sprintf(ptr, "bad_vaddr          |%c| %08x | %08x \n", (diff)? '*' : ' ', vmips->state.bad_vaddr, ao->state.bad_vaddr);

    diff = vmips->state.entryhi_vpn != ao->state.entryhi_vpn; show = show || diff;

    ptr += sprintf(ptr, "entryhi_vpn        |%c| %05x    | %05x    \n", (diff)? '*' : ' ', vmips->state.entryhi_vpn, ao->state.entryhi_vpn);

    diff = vmips->state.entryhi_asid != ao->state.entryhi_asid; show = show || diff;

    ptr += sprintf(ptr, "entryhi_asid       |%c| %02x       | %02x       \n", (diff)? '*' : ' ', vmips->state.entryhi_asid, ao->state.entryhi_asid);

    diff = vmips->state.sr_cp_usable != ao->state.sr_cp_usable; show = show || diff;

    ptr += sprintf(ptr, "sr_cp_usable       |%c| %01x        | %01x        \n", (diff)? '*' : ' ', vmips->state.sr_cp_usable, ao->state.sr_cp_usable);

    diff = vmips->state.sr_rev_endian != ao->state.sr_rev_endian; show = show || diff;

    ptr += sprintf(ptr, "sr_rev_endian      |%c| %01x        | %01x        \n", (diff)? '*' : ' ', vmips->state.sr_rev_endian, ao->state.sr_rev_endian);

    diff = vmips->state.sr_bootstrap_vec != ao->state.sr_bootstrap_vec; show = show || diff;

    ptr += sprintf(ptr, "sr_bootstrap_vec   |%c| %01x        | %01x        \n", (diff)? '*' : ' ', vmips->state.sr_bootstrap_vec, ao->state.sr_bootstrap_vec);

    diff = vmips->state.sr_tlb_shutdown != ao->state.sr_tlb_shutdown; show = show || diff;

    ptr += sprintf(ptr, "sr_tlb_shutdown    |%c| %01x        | %01x        \n", (diff)? '*' : ' ', vmips->state.sr_tlb_shutdown, ao->state.sr_tlb_shutdown);

    diff = vmips->state.sr_parity_err != ao->state.sr_parity_err; show = show || diff;

    ptr += sprintf(ptr, "sr_parity_err      |%c| %01x        | %01x        \n", (diff)? '*' : ' ', vmips->state.sr_parity_err, ao->state.sr_parity_err);

    diff = vmips->state.sr_cache_miss != ao->state.sr_cache_miss; show = show || diff;

    ptr += sprintf(ptr, "sr_cache_miss      |%c| %01x        | %01x        \n", (diff)? '*' : ' ', vmips->state.sr_cache_miss, ao->state.sr_cache_miss);

    diff = vmips->state.sr_parity_zero != ao->state.sr_parity_zero; show = show || diff;

    ptr += sprintf(ptr, "sr_parity_zero     |%c| %01x        | %01x        \n", (diff)? '*' : ' ', vmips->state.sr_parity_zero, ao->state.sr_parity_zero);

    diff = vmips->state.sr_switch_cache != ao->state.sr_switch_cache; show = show || diff;

    ptr += sprintf(ptr, "sr_switch_cache    |%c| %01x        | %01x        \n", (diff)? '*' : ' ', vmips->state.sr_switch_cache, ao->state.sr_switch_cache);

    diff = vmips->state.sr_isolate_cache != ao->state.sr_isolate_cache; show = show || diff;

    ptr += sprintf(ptr, "sr_isolate_cache   |%c| %01x        | %01x        \n", (diff)? '*' : ' ', vmips->state.sr_isolate_cache, ao->state.sr_isolate_cache);

    diff = vmips->state.sr_irq_mask != ao->state.sr_irq_mask; show = show || diff;

    ptr += sprintf(ptr, "sr_irq_mask        |%c| %02x       | %02x       \n", (diff)? '*' : ' ', vmips->state.sr_irq_mask, ao->state.sr_irq_mask);

    diff = vmips->state.sr_ku_ie != ao->state.sr_ku_ie; show = show || diff;

    ptr += sprintf(ptr, "sr_ku_ie           |%c| %02x       | %02x       \n", (diff)? '*' : ' ', vmips->state.sr_ku_ie, ao->state.sr_ku_ie);

    diff = vmips->state.cause_branch_delay != ao->state.cause_branch_delay; show = show || diff;

    ptr += sprintf(ptr, "cause_branch_delay |%c| %01x        | %01x        \n", (diff)? '*' : ' ', vmips->state.cause_branch_delay, ao->state.cause_branch_delay);

    diff = vmips->state.cause_cp_error != ao->state.cause_cp_error; show = show || diff;

    ptr += sprintf(ptr, "cause_cp_error     |%c| %01x        | %01x        \n", (diff)? '*' : ' ', vmips->state.cause_cp_error, ao->state.cause_cp_error);

    diff = vmips->state.cause_irq_pending != ao->state.cause_irq_pending; show = show || diff;

    ptr += sprintf(ptr, "cause_irq_pending  |%c| %01x        | %01x        \n", (diff)? '*' : ' ', vmips->state.cause_irq_pending, ao->state.cause_irq_pending);

    diff = vmips->state.cause_exc_code != ao->state.cause_exc_code; show = show || diff;

    ptr += sprintf(ptr, "cause_exc_code     |%c| %02x       | %02x       \n", (diff)? '*' : ' ', vmips->state.cause_exc_code, ao->state.cause_exc_code);

    diff = vmips->state.epc != ao->state.epc; show = show || diff;

    ptr += sprintf(ptr, "epc                |%c| %08x | %08x \n", (diff)? '*' : ' ', vmips->state.epc, ao->state.epc);

    for(int i=0; i<64; i++) {

        diff = vmips->state.tlb[i].vpn != ao->state.tlb[i].vpn; show = show || diff;

        ptr += sprintf(ptr, "tlb[%02d].vpn        |%c| %05x    | %05x    \n", i, (diff)? '*' : ' ', vmips->state.tlb[i].vpn, ao->state.tlb[i].vpn);

        diff = vmips->state.tlb[i].asid != ao->state.tlb[i].asid; show = show || diff;

        ptr += sprintf(ptr, "tlb[%02d].asid       |%c| %02x       | %02x       \n", i, (diff)? '*' : ' ', vmips->state.tlb[i].asid, ao->state.tlb[i].asid);

        diff = vmips->state.tlb[i].pfn != ao->state.tlb[i].pfn; show = show || diff;

        ptr += sprintf(ptr, "tlb[%02d].pfn        |%c| %05x    | %05x    \n", i, (diff)? '*' : ' ', vmips->state.tlb[i].pfn, ao->state.tlb[i].pfn);

        diff = vmips->state.tlb[i].n != ao->state.tlb[i].n; show = show || diff;

        ptr += sprintf(ptr, "tlb[%02d].n          |%c| %01x        | %01x        \n", i, (diff)? '*' : ' ', vmips->state.tlb[i].n, ao->state.tlb[i].n);

        diff = vmips->state.tlb[i].d != ao->state.tlb[i].d; show = show || diff;

        ptr += sprintf(ptr, "tlb[%02d].d          |%c| %01x        | %01x        \n", i, (diff)? '*' : ' ', vmips->state.tlb[i].d, ao->state.tlb[i].d);

        diff = vmips->state.tlb[i].v != ao->state.tlb[i].v; show = show || diff;

        ptr += sprintf(ptr, "tlb[%02d].v          |%c| %01x        | %01x        \n", i, (diff)? '*' : ' ', vmips->state.tlb[i].v, ao->state.tlb[i].v);

        diff = vmips->state.tlb[i].g != ao->state.tlb[i].g; show = show || diff;

        ptr += sprintf(ptr, "tlb[%02d].g          |%c| %01x        | %01x        \n", i, (diff)? '*' : ' ', vmips->state.tlb[i].g, ao->state.tlb[i].g);

    }

    if(show) {

        printf("%s", buf);

        return true;

    }

    return false;

}

//------------------------------------------------------------------------------

//------------------------------------------------------------------------------

int main(int argc, char **argv) {

    int int_ret;

    //open file with truncate

    FILE *fp = fopen("shared_mem.dat", "wb");

    if(fp == NULL) {

        perror("Can not truncate file shared_mem.dat");

        return -1;

    }

    uint8 *buf = new uint8[sizeof(shared_mem_t)];

    memset(buf, 0, sizeof(shared_mem_t));

    int_ret = fwrite(buf, sizeof(shared_mem_t), 1, fp);

    delete buf;

    if(int_ret != 1) {

        perror("Can not zero-fill file shared_mem.dat");

        fclose(fp);

        return -2;

    }

    fclose(fp);

    //--------------------------------------------------------------------------

    //map shared memory

    int fd = open("./shared_mem.dat", O_RDWR, S_IRUSR | S_IWUSR);

    if(fd == -1) {

        perror("open() failed for shared_mem.dat");

        return -3;

    }

    shared_ptr = (shared_mem_t *)mmap(NULL, sizeof(shared_mem_t), PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);

    if(shared_ptr == MAP_FAILED) {

        perror("mmap() failed");

        close(fd);

        return -4;

    }

    //--------------------------------------------------------------------------

    srand(0);

    while(true) {

        //----------------------------------------------------------------------

        memset((void *)shared_ptr, 0, sizeof(shared_mem_t));

        //---------------------------------------------------------------------- run init function

        if(tst_current->init != NULL) tst_current->init(tst_current, (shared_mem_t *)shared_ptr);

        //----------------------------------------------------------------------

        pid_t proc_vmips = fork();

        if(proc_vmips == 0) {

            system("cd ./../vmips && ./main_tester > ./vmips_output.txt");

            return 0;

        }

        pid_t proc_ao = fork();

        if(proc_ao == 0) {

            system("cd ./../aoR3000 && ./obj_dir/VaoR3000 > ./ao_output.txt");

            return 0;

        }

        //----------------------------------------------------------------------

        printf("Waiting for init of vmips..."); fflush(stdout);

        shared_ptr->proc_vmips.initialize_do = true;

        while(shared_ptr->proc_vmips.initialize_do) usleep(1);

        printf("done\n");

        printf("Waiting for init of aoR3000...");  fflush(stdout);

        shared_ptr->proc_ao.initialize_do = true;

        while(shared_ptr->proc_ao.initialize_do) usleep(1);

        printf("done\n");

        while(true) {

            if(shared_ptr->proc_vmips.report_do && shared_ptr->proc_ao.report_do) {

                bool diff = is_diff(&(shared_ptr->proc_vmips.report), &(shared_ptr->proc_ao.report));

                if(diff) {

                    printf("\nTEST FAILED. DIFF.\n");

                    shared_ptr->test_finished = true;

                    return -1;

                }

                if(shared_ptr->proc_vmips.report.exception == 1 && shared_ptr->proc_ao.report.exception == 1) {

                    printf("\nTEST OK.\n");

                    shared_ptr->test_finished = true;

                    break;

                }

                shared_ptr->proc_vmips.report_do = shared_ptr->proc_ao.report_do = false;

                printf("check ok\n");

            }

            while(shared_ptr->proc_vmips.write_do || shared_ptr->proc_ao.write_do) {

                if(shared_ptr->proc_vmips.write_do && shared_ptr->proc_ao.write_do) {

                    if( shared_ptr->proc_vmips.write_address    == shared_ptr->proc_ao.write_address &&

                        shared_ptr->proc_vmips.write_byteenable == shared_ptr->proc_ao.write_byteenable &&

                        shared_ptr->proc_vmips.write_data       == shared_ptr->proc_ao.write_data)

                    {

                        printf("write: %08x %01x %08x\n", shared_ptr->proc_vmips.write_address, shared_ptr->proc_vmips.write_byteenable, shared_ptr->proc_vmips.write_data);

                        uint32 byteena = shared_ptr->proc_vmips.write_byteenable;

                        uint32 value   = shared_ptr->proc_vmips.write_data;

                        for(uint32 i=0; i<4; i++) {

                            if(byteena & 1) shared_ptr->mem.bytes[shared_ptr->proc_vmips.write_address + i] = value & 0xFF;

                            value >>= 8;

                            byteena >>= 1;

                        }

                        shared_ptr->proc_vmips.write_do = false;

                        shared_ptr->proc_ao.write_do    = false;

                    }

                    else {

                        printf("vmips: %08x %01x %08x\n", shared_ptr->proc_vmips.write_address, shared_ptr->proc_vmips.write_byteenable, shared_ptr->proc_vmips.write_data);

                        printf("ao:    %08x %01x %08x\n", shared_ptr->proc_ao.write_address,    shared_ptr->proc_ao.write_byteenable,    shared_ptr->proc_ao.write_data);

                        printf("\nTEST FAILED. MEM WRITE DIFF.\n");

                        shared_ptr->test_finished = true;

                        return -1;

                    }

                }

            }

        }

        //---------------------------------------------------------------------- wait for process end

        waitpid(proc_vmips, NULL, 0);

        waitpid(proc_ao, NULL, 0);

    }

    return 0;

}

//------------------------------------------------------------------------------