legion/src/simcore/control.c

/*
* ========== Copyright Header Begin ==========================================
*
* OpenSPARC T2 Processor File: control.c
* Copyright (c) 2006 Sun Microsystems, Inc.  All Rights Reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES.
*
* The above named program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public
* License version 2 as published by the Free Software Foundation.
*
* The above named program is distributed in the hope that it will be
* useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public
* License along with this work; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
*
* ========== Copyright Header End ============================================
*/
/*
 * Copyright 2006 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */
#pragma ident   "@(#)control.c  1.34    06/10/24 SMI"

#include <stdlib.h>
#include <pthread.h>
#include <errno.h>
#include <unistd.h>

#include "basics.h"
#include "options.h"
#include "fatal.h"
#include "allocate.h"
#include "simcore.h"
#include "config.h"
#include "createthr.h"
#include "xicache.h"
#include "barrier.h"
#include "callback.h"
#include "breakpoint.h"

/*
 * This file contains the control and execution infrastructure for the
 * simulator.
 *
 * Legion is multi-threaded to achieve high performance including a single
 * control thread and along with a number of exec-threads.  The exact
 * number of exec-threads being determined by the -t command line parameter
 * or the number of simulated CPUs.
 */

        /*
         * List of all the scheduler threads the simulator uses
         * for execution.
         */

LIST_DEF(exec_thread_list, exec_thread_t);
static int nexec_threads;

simcpu_list_t simcpu_list;

barrier_t stop_barrier;
barrier_t run_barrier;
barrier_busy_t sync_busy_barrier;

simstatus_t      simstatus;

void init_simstatus(void)
{
        simstatus.sp.mode = false;
        simstatus.sp.poweron = false;
        simstatus.running = false;
        simstatus.initialized = false;
}

simcpu_t *sim_cpu_alloc(
                config_proc_t *cfp,
                void *specificp)
{
        simcpu_t *sp;
        int gid;


        gid = simcpu_list.count;
        sp = LIST_ADD(simcpu_list, simcpu_t);
        sp->gid = gid;

        sp->state_bits = 0;

        sp->attention = 0;

#if ERROR_INJECTION
        sp->error_enabled = false;
        sp->error_check = false;
        sp->error_priv = NULL;
        sp->errorp = Xcalloc(1, error_t);
        sp->errorp->errlistp = NULL;
#endif

        sp->nextp = (simcpu_t *)0;

         /* Pointer to the exec_thread this simcpu is on */
        sp->etp = (exec_thread_t *)0;

        /* Head of the list of simcpus for each exec_thread */
        sp->headp = (simcpu_t *)0;

        sp->decodemep = NULL;
        sp->xic_miss = NULL;
        sp->xic_miss_addrp = NULL;
        sp->config_procp = cfp;
        sp->specificp = specificp;

#if ERROR_TRAP_GEN /* { */
        sp->error_cycle = UINT64_MAX;
        sp->error_pending = false;
        sp->error_cycle_reached = false;
        sp->eep = NULL;
#endif /* ERROR_TRAP_GEN } */

        sp->cycle = 0LL;
        sp->cycle_quantum_start = sp->cycle;
        cycle_target_off(sp);
        sp->total_instr = 0LL;

        /*
         * More misc stuff ..
         * flush the xdcache, but the support functions
         * need to be supplied by the caller
         */
        xdcache_flush(sp);
        sp->xdc.miss = NULL;

        /*
         * clear the breakpoint cache for this cpu
         */
        sp->bp_infop = NULL;

        return (sp);
}

static void *exec_thread_init(void *argp)
{
        exec_thread_t *etp = (exec_thread_t *)argp;

        /* wait until we start running */

        barrier_wait(&run_barrier);


        /*
         * All threads are now running, including the ctrl-thread.
         *
         * We call into exec_loop(), passing it the first simcpu in
         * the list to start the execution. The exec_loop will take
         * care of switching all simcpus in it's list to ensure that
         * they all make equal progress.
         */
        DBGEXECLOOP(lprintf(etp->id,
                        "exec_thread%d calling exec_loop for simcpu%d "
                        "nsimcpus=%d\n",
                        etp->id, etp->allp->gid, etp->nsimcpus););

        ASSERT(etp->allp != NULL);
        if (etp->allp->config_procp->proc_typep->debug_hookp != NULL)
                exec_loop_dh(etp);
        else
                exec_loop(etp);

        /* We never return to here */
        return ((void*)0);
}

static void exec_thread_alloc(void)
{
        exec_thread_t   *etp;
        pthread_t       id;
        int             i, n, r, etidx;
        simcpu_t        *prev_sp = NULL;
        static int      simidx = 0;

        etidx = exec_thread_list.count;
        etp = LIST_ADD(exec_thread_list, exec_thread_t);
        etp->id = etidx;

        /*
         * We need to figure out how many simcpus this
         * etp needs to have assigned.
         */
        n = simcpu_list.count / nexec_threads;
        r = simcpu_list.count % nexec_threads;

        if (etp->id < r)
                n += 1;

        /* create a liked list of simcpus for each exec_thread */
        for (i = 0; i < n; i++) {
                if (simidx < simcpu_list.count) {
                        simcpu_t *sp = LIST_ENTRY(simcpu_list, simidx);

                        /*
                         * Save pointer of first simcpu (head) into etp
                         */
                        if (etp->allp == NULL)
                                etp->allp = sp;

                        /*
                         * Update the nextp in the previous simcpu of this
                         * list
                         */
                        if (prev_sp != NULL)
                                prev_sp->nextp = sp;

                        /* so all simcpus can find the head of the list */
                        sp->headp = etp->allp;

                        /* so all simcpus can find the exec_thread */
                        sp->etp = etp;

                        prev_sp = sp;
                        etp->nsimcpus++;
                        simidx++;
                } else {
                        printf("\nERROR:: exec_thread_alloc: "
                            "simidx < simcpu_list.count (0x%x < 0x%x)",
                            simidx, simcpu_list.count);
                        fatal("DIE");
                }
        }

                /* create the execution thread */
        create_thread(exec_thread_init, (void *)etp, &id);
}

static void *ctrl_thread_main(void *argp)
{
        simcpu_t *sp;
        int i, j;

        for (;;) {
                while (!simstatus.running) {
                        /*
                         * spin until it's time to go.  this is useful when
                         * we're not auto-starting.
                         */
                }

                /* pre-exec setup */
                for (i = 0; i < simcpu_list.count; i++) {
                        sp = LIST_ENTRY(simcpu_list, i);
                        sp->config_procp->proc_typep->exec_setup(sp);
                }

                /*
                 * after the run barrier everyone, including the
                 * exec-threads are running
                 */

                barrier_wait(&run_barrier);

                /*
                 * now that everybody's running, now wait for everyone to
                 * stop again
                 */

                barrier_wait(&stop_barrier);

                /* we've come to a "stop" */

                ASSERT(!simstatus.running);

                /*
                 * the exec-threads should be waiting (at the run_barrier)
                 * until we start running again.  meanwhile process the
                 * stopped callbacks
                 */

                /* post-exec cleanup */
                for (i = 0; i < simcpu_list.count; i++) {
                        sp = LIST_ENTRY(simcpu_list, i);
                        sp->config_procp->proc_typep->exec_cleanup(sp);
                }

                /* we're stopped, call stop callbacks */
                callback_fire(CB_Stop);

                /* if we've hit a breakpoint, call breakpoint callbacks */
                if (breakpoint_any_reached()) {
                        callback_fire(CB_Breakpoint);
                }
        }
}

static void ctrl_thread_alloc(void)
{
        pthread_t id;

        create_thread(ctrl_thread_main, NULL, &id);
}

/*
 * support functions for finding devices etc
 */
config_addr_t *
find_domain_address(domain_t *domainp, tpaddr_t pa)
{
        config_addr_t   *addrp;

        for (addrp = domainp->address.listp;
             addrp != NULL && addrp->baseaddr <= pa; addrp = addrp->nextp) {
                if ((addrp->baseaddr <= pa) && (addrp->topaddr > pa)) {
                        return (addrp); /* bingo */
                }
        }
        return (NULL);
}


/*
 * The function below should never be called because the cycle_target
 * it relates to should never match the execution counter
 * If such a match occurs, we ensure an error is reported and the
 * simulator stops.
 */
void
simcore_cycle_match_error(simcpu_t *sp)
{
        fatal("Illegal cycle match error");
}

void
cycle_target_off(simcpu_t *sp)
{
        sp->cycle_target = UINT64_MAX;

        sp->cycle_target_match = simcore_cycle_match_error;
}


#if !defined(NDEBUG)    /* { */

        /*
         * Used in various control interfaces around the simulator to
         * modify the debug modes
         */
void
simcore_update_debug_bits(uint64_t newval)
{
        int i;

        if (debug_bits == newval) {
                return;
        }

        lprintf(-1, "debug_bits 0x%llx -> 0x%llx\n", debug_bits, newval);

        /* FIXME: Kludge - clobber the decodes incase we turned tracing on ! */

        if ((debug_bits & (DBG_EL | DBG_EL_MIN)) == 0 &&
            (newval & (DBG_EL | DBG_EL_MIN)) != 0) {
                for (i = 0; i < simcpu_list.count; i++) {
                        simcpu_t *sp = LIST_ENTRY(simcpu_list, i);

                        sp->xicache_instn_flush_pending = true;
                        set_sync_pending(sp);
                }
        }
        /* end of Kludge */

        debug_bits = newval;
}
#endif          /* } */

void
init_threads(void)
{
        int i;

        callback_init();

        nexec_threads = (options.threads > simcpu_list.count)
                ? simcpu_list.count : options.threads;
        /*
         * Default behavior for quantum is divide DFT_EXEC_QUANTUM
         * by the maximum number of CPUs on an exec thread.
         */
        if (options.quantum == 0) {
                options.quantum = (DFT_EXEC_QUANTUM * nexec_threads) /
                    simcpu_list.count;
        }
        PRINTF(("Using %d execution thread(s) quantum=%u\n", nexec_threads,
            options.quantum));

        barrier_init(&stop_barrier, nexec_threads + 1);
        barrier_init(&run_barrier, nexec_threads + 1);
        barrier_busy_init(&sync_busy_barrier, nexec_threads);

        ctrl_thread_alloc();

        for (i = 0; i < nexec_threads; i++) {
                exec_thread_alloc();
        }
}

void
simcore_start(void)
{
        /*
         * Once we get here, legion has completed all initialization
         * and is about to jump to the first instruction. Anything
         * that was waiting on the initialization to complete can
         * start now.
         */
        simstatus.initialized = true;

        /*
         * If running in service processor mode, we want to wait
         * here until the service processor tells us to start.
         * Each processor can determine how the SP signals the
         * simulation to start, but once the signal is received,
         * setting simstatus.sp.poweron to true will cause the
         * simulator to start running.
         */
        if (simstatus.sp.mode) {
                printf("\nWaiting on Serivce Processor POWERON interrupt\n");
                while (simstatus.sp.poweron != true) {
                        sleep(1);
                }
                printf("\nReceived Serivce Processor POWERON interrupt\n");
        }

        /*
         * signal to all exec threads that it's ok to start
         * executing instructions.
         */
        simstatus.running = true;
}

void
simcore_stop(void)
{
        if (simstatus.running) {
                int i;

                simstatus.running = false;

                for (i = 0; i < simcpu_list.count; i++) {
                        simcpu_t *sp = LIST_ENTRY(simcpu_list, i);

                        set_sync_pending(sp);
                }
        }
}

static void simcore_cpu_state_updated(simcpu_t *sp)
{
        if (DISABLED(sp) || PARKED(sp))
                set_sync_pending(sp);
}

void
simcore_cpu_enable(simcpu_t *sp)
{
        ASSERT(DISABLED(sp));
        CLR_DISABLED(sp);

        simcore_cpu_state_updated(sp);
}

void
simcore_cpu_state_unpark(simcpu_t *sp)
{
        ASSERT(PARKED(sp));
        CLR_PARKED(sp);

        simcore_cpu_state_updated(sp);
}

void
simcore_cpu_disable(simcpu_t *sp)
{
        ASSERT(!DISABLED(sp));
        SET_DISABLED(sp);

        simcore_cpu_state_updated(sp);
}

void
simcore_cpu_state_park(simcpu_t *sp)
{
        ASSERT(!PARKED(sp));
        SET_PARKED(sp);

        simcore_cpu_state_updated(sp);
}