projects / OpenSPARC-T2-SAM / blob
? search:
summary | tags | clone url | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Initial commit of OpenSPARC T2 architecture model.
[OpenSPARC-T2-SAM] / sam-t2 / sam / system / blaze / system.cc
// ========== Copyright Header Begin ==========================================
//
// OpenSPARC T2 Processor File: system.cc
// 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 (C) 2001, 2005 Sun Microsystems, Inc.
* All rights reserved.
*/
/* file layout, icqs:
* UICMDS (ie functions called by ui)
* DUMPRESTORE
* CPUACCESS (
* SYSCONF (legacy api, to be replace with real sysconf api soon...)
* HOSTCONFIG
*/
/* standard C includes */
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <synch.h>
#include <thread.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <sys/wait.h>
/* project includes */
#include "types.h"
#include "blaze_globals.h"
#include "system.h"
#include "ui.h"
#include "dr.h"
#include "system_impl.h"
#include "ui_utils.h"
#include "workerthread.h"
uint32_t boot_ctrl_id = 0;
uint32_t boot_target_id = 0;
uint32_t boot_part_id = 0;
uint32_t boot_disk_id = 0;
extern void term_console_destroy (); // defined in term.cc
// ========================== GLOBAL VARIABLES ================================
// BS flags. Majority of them are needed only within startp time
//
static bool_t ce_enable_flag = FALSE;
static bool_t scsi_disk_enable_flag = FALSE;
static bool_t scsi_boot_enable_flag = FALSE;
static bool_t fc_disk_enable_flag = FALSE;
static bool_t fc_boot_enable_flag = FALSE;
static bool_t mem_reserve_flag = TRUE;
SystemT the_sys = {0};
SystemT *psys = &the_sys;
uint64_t goodtrap_pc;
uint64_t badtrap_pc;
// The SAM UI is multi threaded; input can come from the user,
// the global time sync or a remote debugger for example. Every
// ui command needs to be executed whilst holding the lock. The
// ui_lock_held booleans is added to help in asserting this.
// The ui_cond variable is for synchronizing stop, see SYSTEM_wait_stop()
static mutex_t ui_lock;
static cond_t ui_cond;
static bool ui_lock_held;
// ============================================================================
//
// SYSTEM_open (like tracemod/mod_dlopen) is to look for files in the
// installation directory of blaze if the cwd doesn't work
//
// we don't search install dir if filename begins with '/'
// or './', but we do search install dir for '../' because
// "../lib/" or "../demo/" or "../etc/" are common
//
static char * blaze_exec_path = NULL;
FILE* SYSTEM_fopen (const char * filename, const char * flags)
{
FILE * fp;
fp = fopen (filename, flags);
if (!fp && blaze_exec_path && !(filename[0] == '/')
&& !(strncmp(filename, "../", 3) == 0)) {
char * temp = (char*) malloc (strlen (blaze_exec_path)
+ strlen (filename) + 1);
strcpy (temp, blaze_exec_path);
strcat (temp, filename);
fp = fopen (temp, flags);
}
return fp;
}
int SYSTEM_open (const char * filename, int oflag)
{
int fd;
fd = open (filename, oflag);
if (fd<0 && blaze_exec_path && !(filename[0] == '/')
&& !(strncmp(filename, "../", 3) == 0)) {
char * temp = (char*) malloc (strlen (blaze_exec_path)
+ strlen (filename) + 1);
strcpy (temp, blaze_exec_path);
strcat (temp, filename);
fd = open (temp, oflag);
}
return fd;
}
void init_SYSTEM_open ()
{
blaze_exec_path = strdup (getexecname ());
if (blaze_exec_path && strlen(blaze_exec_path) > 0) {
int i = strlen (blaze_exec_path) - 1;
while (i>0 && blaze_exec_path[i] != '/') --i;
blaze_exec_path[i+1] = '\0';
} else {
ui->verbose("getexecname = \"%s\"\n", blaze_exec_path);
ui->error("SAM cannot determine its own install dir path, "
"\"load <filename>\" cannot search install dir for files\n");
}
}
///////////////////////////////////////////////////////////
void SYSTEM_set_memreserve (bool_t flag)
{
mem_reserve_flag = flag;
}
bool_t SYSTEM_get_memreserve()
{
return mem_reserve_flag;
}
void SYSTEM_cycle_delay (uint32_t cpuid, uint32_t delay)
{
Vcpu *vcpu = get_vcpu(cpuid);
if (vcpu) {
vcpu->config.delay = delay;
} else {
ui->error("SYSTEM_cycle_delay: bad CPU id %d \n", cpuid);
}
}
int SYSTEM_in_execution_driven_mode()
{
return g_vcpu ? g_vcpu[0]->config.execution_driven : 0;
}
// must be called in response to a UI command, from the ui thread
void SYSTEM_enable_execution_driven_mode()
{
if (! IN_STOP_STATE(blaze_run_state))
{
ui->error("not in stop state \n");
return;
}
if (SYSTEM_in_execution_driven_mode())
{
ui->warning("enable_execution_driven_mode: exec-driven mode already enabled\n");
}
else
{
ui->output("enabling exec-driven mode. Setting numthreads to 1\n");
for(int i = 0; i <= g_vcpu_id_max; i++)
{
Vcpu *vcpu = get_vcpu(i);
if (!vcpu)
continue;
vcpu->config.execution_driven = 1;
}
the_arch.numthreads = 1;
cpu_enable_changed = 1;
}
} // void VCPU_Config::enable_execution_driven_mode()
void SYSTEM_disable_execution_driven_mode()
{
for(int i = 0; i <= g_vcpu_id_max; i++)
{
Vcpu *vcpu = get_vcpu(i);
if (!vcpu)
continue;
vcpu->config.execution_driven = 0;
}
cpu_enable_changed = 1;
} // void VCPU_Config::disable_execution_driven_mode()
cpuT *SYSTEM_cpu_by_sid(int n)
{
return get_vcpu(n);
}
void SYSTEM_unlock ()
{
}
void * SYSTEM_is_ready ()
{
return psys;
}
void SYSTEM_init(void)
{
BLAZE_STOP(blaze_run_state); // transition from INVALID to STOP !!!
mutex_init (&ui_lock, USYNC_THREAD, 0);
cond_init (&ui_cond, USYNC_THREAD, 0);
ui_lock_held = false;
}
void SYSTEM_lock_UI()
{
assert(!ui_lock_held);
mutex_lock (&ui_lock);
ui_lock_held = true;
}
void SYSTEM_unlock_UI()
{
assert(ui_lock_held);
ui_lock_held = false;
mutex_unlock(&ui_lock);
}
//////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////
//
// External interrupt delivery. This function is being called
// by SCHIZO as well as in other CPU (xcalls) in order to send INTR.
//
void SYSTEM_interrupt_by_sid(int dst_aid, int src_aid, intrT *intr)
{
Vcpu *vcpu = get_vcpu(dst_aid);
if(vcpu)
vcpu->interrupt ( intr );
}
static sint64_t system_intervalstart_usecs = 0;
static sint64_t system_intervallength_usecs = 0;
static sint64_t system_interval_sequencenum = 0;
bool SYSTEM_is_sync_on ()
{
if (IN_GTWAIT_STATE (blaze_run_state) || IN_GTSTEP_STATE (blaze_run_state))
return true;
return false;
}
void SYSTEM_mark_intervalstart (sint64_t usecs, uint64_t seqnum)
{
system_intervalstart_usecs = SYSTEM_get_global_time();
system_intervallength_usecs = usecs;
system_interval_sequencenum = seqnum;
}
void SYSTEM_mark_intervalstop ()
{
}
sint64_t SYSTEM_get_sequencenum ()
{
return system_interval_sequencenum;
}
int64_t SYSTEM_get_time (timewhence_t whence /*= TW_CURRENT*/)
{
if (whence == TW_CURRENT)
return SYSTEM_get_global_time();
else if (whence == TW_INTERVAL)
return SYSTEM_get_global_time() - system_intervalstart_usecs;
else if (whence == TW_MARK)
return system_intervalstart_usecs;
else if (whence == TW_LENGTH)
return system_intervallength_usecs;
return 0ull;
}
extern doneftn_t volatile wrkthdCBFunc;
extern void * volatile wrkthdCBArg;
extern sema_t wrkthdDONE;
static void check_mips_stickfreq()
{
// stickfreq not being set will cause kernel panic, so error anyway.
if (the_arch.stick_freq == 0){
ui->error("stickfreq not conf'ed. Add conf stickfreq <value> in rc file.\n");
exit(1);
}
if (the_arch.mips == 0) {
// if running from a checkpoint, then walk around
if (BLAZE_restore_from_checkpoint ()) {
// calculate the mips from the loopticks, stickincr
// recalculate to reflect changes in loopticks/stickincr/etc
the_arch.mips = ((the_arch.loopticks * the_arch.stick_freq )
/ the_arch.stickincr) / 1000000ULL;
the_arch.umips = the_arch.kmips = the_arch.mips;
}else{
ui->error("mips not conf'ed, exit. Add conf mips <value> in rc file.\n");
exit(1);
}
}
}
void SYSTEM_kick_usecs (int64_t nusecs)
{
if (cpu_enable_changed)
WorkerThread::create_worker_threads (SYSTEM_get_ncpu(),SYSTEM_get_cpus_per_thread(),\
SYSTEM_get_numthreads());
while (sema_trywait (&wrkthdDONE) == 0) ; // "sema_reset()"
check_mips_stickfreq();
if (SYSTEM_in_execution_driven_mode()) {
WorkerThread::kick_stepc(nusecs * (g_vcpu[0]->config.cpufreq / 1000000));
} else {
WorkerThread::kick_stept(nusecs);
}
}
void SYSTEM_kick_instrs (int64_t ninstrs)
{
if (cpu_enable_changed)
WorkerThread::create_worker_threads (SYSTEM_get_ncpu(),SYSTEM_get_cpus_per_thread(),\
SYSTEM_get_numthreads());
while (sema_trywait (&wrkthdDONE) == 0) ; // "sema_reset()"
check_mips_stickfreq();
WorkerThread::kick_stepi(ninstrs);
}
void SYSTEM_kick_cycles(int64_t ncycles)
{
if (cpu_enable_changed)
WorkerThread::create_worker_threads(SYSTEM_get_ncpu(), SYSTEM_get_cpus_per_thread(),
SYSTEM_get_numthreads());
while (sema_trywait (&wrkthdDONE) == 0) ; // "sema_reset()"
check_mips_stickfreq();
WorkerThread::kick_stepc(ncycles);
}
void
SYSTEM_kick_with_callback (int64_t nusecs, doneftn_t callback)
{
// only used by G-T-Sync, hence only a `usecs' version
wrkthdCBFunc = callback;
wrkthdCBArg = NULL;
SYSTEM_kick_usecs (nusecs);
}
// -------- Time and Events ---------------------------------------------------
// \___ microsecs.
void SYSTEM_register_event (
uint64_t stime,
EventFunc_T * callbackfunc, void * arg1, void * arg2,
UnloadFunc_T * unloadfunc,
const char * debugstring)
{
WorkerThread::registerEvent(stime, callbackfunc, arg1, arg2,
unloadfunc, debugstring);
}
int eventque_ui_cmds (void*, int argc, char **argv)
{
if (argc > 1 && strcmp (argv[1], "debug") == 0) {
if (argc > 2) {
EventQue::debug = strtol (argv[2], NULL, 0);
}
ui->verbose("events debug = %d\n", EventQue::debug);
return 1;
}
WorkerThread::doEventquePrint ();
return 1;
}
int64_t SYSTEM_get_ticks () // for perf_ui_cmd() only.!.
{
return WorkerThread::get_ticks();
}
uint64_t SYSTEM_get_globaltick_per_cpu () // for fc device, deprecated
{
return WorkerThread::get_ticks(); // also deprecated
}
uint64_t SYSTEM_get_global_time() // in MicroSecs, always !!!
{
return WorkerThread::get_time();
}
// ========================================================================== {
// UICMDS
//
// The routines below are being called in context of UI thread !!
//
/**********************************************************
* Blaze Run State Diagram for UI commands:
*
*
* "run"
* +--------+ "stepi" +--------+
* | |- - - - - - ->>| |
* | STOP | | RUN |
* | |<<- - - - - - -| |
* +--------+ "stop" +--------+
* | ^ CTRL-C
* | ^
* | |
* "syncOn"| |"syncOff"
* "resume"| |"stop", CTRL-C
* | |
* V |
* V |
* +--------+ "stept" +--------+
* | |- - - - - - ->>| |
* | GTWAIT | | GTSTEP |
* | |<<- - - - - - -| |
* +--------+ +--------+
*
*
* Note: we call device start/stop_action() when leaving/entering
* the STOP state, but not when cycling between the GT* states.
*
**********************************************************/
void SYSTEM_ss_register (ss_action stop, ss_action restart, void* d)
{
SS_entry *pentry = (SS_entry*) calloc (1, sizeof(SS_entry));
pentry->stop_action = stop;
pentry->start_action = restart;
pentry->client_data = d;
if (psys == NULL) {
ui->fatal("internal error (psys is not init yet)\n");
exit (1);
}
pentry->next = psys->ss_head;
psys->ss_head = pentry;
}
static void SYSTEM_device_stop_action()
{
for (SS_entry *pentry = psys->ss_head; pentry; pentry = pentry->next) {
if (pentry->stop_action)
pentry->stop_action (pentry->client_data);
}
}
static void SYSTEM_devices_start_action()
{
for (SS_entry *pentry = psys->ss_head; pentry; pentry = pentry->next) {
if (pentry->start_action)
pentry->start_action (pentry->client_data);
}
}
// put the cpu-sims into async run mode ----------------------------------
//
void SYSTEM_run_UI ()
{
assert(ui_lock_held);
if (! IN_STOP_STATE(blaze_run_state))
return;
BLAZE_RUN(blaze_run_state);
SYSTEM_kick_usecs (1ULL <<48/*infinity*/); // Start cpus
SYSTEM_devices_start_action();
}
// The stop, stepi, stepc, and syncoff all end with a call to
// SYSTEM_wait_stop() which will wait for the workerthread to
// finish and and then stop the rest.
static void SYSTEM_wait_stop()
{
static bool sema_wait_pending = false;
// Only one thread can be waiting in the semaphore for the
// worker threads to stop. So when a wait is pending then we
// just synchronize the return when stop really occurs.
if (sema_wait_pending)
{
while (sema_wait_pending)
cond_wait(&ui_cond,&ui_lock);
return;
}
sema_wait_pending = true;
// We know that we get here holding the ui_lock. We wait here
// for the worker threads to finish. While we wait we release
// the ui lock. If we don't release the lock then we have a
// potential deadlock situation where stop is holding the lock
// and a probe action is waiting for the lock - blocking the
// workerthread from stopping.
SYSTEM_unlock_UI();
sema_wait (&wrkthdDONE); // ------ wait for all to finish ------
SYSTEM_lock_UI();
sema_wait_pending = false;
cond_broadcast(&ui_cond);
// cpu threads stop first to make io stop safe logic easy
SYSTEM_device_stop_action();
BLAZE_CLEAR(blaze_stop_request); // Reset stop request if any pending
BLAZE_STOP(blaze_run_state); // Reset
update_remote_ui(); // signal stop to remote debug client
}
// stop the async run mode ----------------------------------
//
void SYSTEM_stop_UI ()
{
assert(ui_lock_held);
/* gtwait means we're already stopped !! */
if (IN_GTWAIT_STATE (blaze_run_state)) {
SYSTEM_device_stop_action();
BLAZE_STOP(blaze_run_state);
return;
}
if (IN_STOP_STATE (blaze_run_state))
return;
BLAZE_STOP(blaze_stop_request);
SYSTEM_wait_stop();
}
// run the cpu-sims synchronously (ui waits) --------------------------------
void SYSTEM_stepi_UI (int64_t ni)
{
assert(IN_STOP_STATE(blaze_run_state));
BLAZE_STEP(blaze_run_state);
SYSTEM_kick_instrs(ni);
SYSTEM_devices_start_action();
SYSTEM_wait_stop();
}
void SYSTEM_stepc_UI (int64_t nc)
{
assert(IN_STOP_STATE(blaze_run_state));
BLAZE_STEP(blaze_run_state);
SYSTEM_kick_cycles(nc);
SYSTEM_devices_start_action();
SYSTEM_wait_stop();
}
// -------------------- a Global-Time-Sync interval ---------------------
//
extern "C" {
static void SYSTEM_stept_callback (void * arg);
};
static doneftn_t stept_callback_ftn;
static void * stept_callback_arg;
void SYSTEM_stept_UI (int64_t usecs, int64_t seqnum, doneftn_t callback)
{
assert(ui_lock_held);
if (!IN_GTWAIT_STATE(blaze_run_state))
return;
SYSTEM_mark_intervalstart (usecs, seqnum); // MARK BEGIN <---
BLAZE_GTSTEP(blaze_run_state); // Set
stept_callback_ftn = callback;
stept_callback_arg = NULL;
SYSTEM_kick_with_callback (usecs, SYSTEM_stept_callback); // Start cpus
// N.B. `devices' are started at syncON, not here. // devices
}
extern "C" {
static void SYSTEM_stept_callback (void * /* arg */)
{
BLAZE_GTWAIT(blaze_run_state); // Reset
// N.B. `devices' are stopped at syncOFF, not here. // devices
SYSTEM_mark_intervalstop (); // MARK END <---
doneftn_t FTN = stept_callback_ftn;
if (FTN != NULL) {
stept_callback_ftn = NULL;
(*FTN) (stept_callback_arg);
}
}
};
// "sync on" ----------------------------------------------------------
//
void SYSTEM_syncon_UI ()
{
assert(ui_lock_held);
if (!IN_STOP_STATE(blaze_run_state))
return;
SYSTEM_devices_start_action();
BLAZE_GTWAIT(blaze_run_state);
}
// "sync off" ----------------------------------------------------------
//
void SYSTEM_syncoff_UI ()
{
assert(ui_lock_held);
if (!IN_SYNC_STATE(blaze_run_state))
return;
if (IN_GTSTEP_STATE(blaze_run_state)) {
BLAZE_STOP(blaze_stop_request); // Request halt
SYSTEM_wait_stop();
return;
}
assert(IN_GTWAIT_STATE(blaze_run_state));
SYSTEM_device_stop_action();
BLAZE_STOP(blaze_run_state); // Reset
}
// quit,exit,terminate,... ----------------------------------------------------
// this is being call from entirely too many places...
void quit_simulation ()
{
#ifdef V5_FAKEPROM
term_console_destroy ();
#endif
if ( mm1 != NULL )
delete mm1;
ui->output("quitting ...\n");
exit (0);
}
// devices/scsi_disk.cc should not be calling this...
void SYSTEM_quit ()
{
quit_simulation();
exit (0);
}
void SYSTEM_quit_UI ()
{
quit_simulation();
exit (0);
}
///////////////////////////////////////////////
void SYSTEM_ss_unregister (void *d)
{
if (psys) {
SS_entry *pentry = psys->ss_head;
SS_entry *prev = NULL;
while (pentry) {
if (pentry->client_data == d) {
if (prev)
prev->next = pentry->next;
else
psys->ss_head = pentry->next;
free(pentry);
pentry = psys->ss_head;
prev = NULL;
}
else {
prev = pentry;
pentry = pentry->next;
}
}
}
}
bool_t SYSTEM_is_stopped ()
{
return IN_STOP_STATE(blaze_run_state) ? TRUE : FALSE;
}
bool_t SYSTEM_is_running ()
{
return ANY_RUNNING_STATE(blaze_run_state) ? TRUE : FALSE;
}
bool_t SYSTEM_is_notready ()
{
return blaze_run_state == e_BLAZE_INVALID ? TRUE : FALSE;
}
// ========================================================================== }
// ========================================================================== {
// DUMPRESTORE
extern void write_scalar_64 (FILE *fp, const char * name, uint64_t v);
extern void write_scalar_32 (FILE *fp, const char * name, uint32_t v);
extern void write_string (FILE *fp, const char * name, char *s);
extern bool_t read_scalar_64 (FILE *fp, const char * name, uint64_t *v);
extern bool_t read_scalar_32 (FILE *fp, const char * name, uint32_t *v);
extern char* read_string (FILE *fp, const char * name, int , char *s);
extern char* read_string_2 (FILE *fp, const char * name, const char * alt_name, int , char *s);
void
SYSTEM_dump (FILE *fp)
{
write_scalar_64 (fp, "global_tick", global_tick);
write_scalar_32 (fp, "numcpus", the_arch.numcpus);
write_scalar_32 (fp, "nwins", the_arch.nwins);
write_scalar_64 (fp, "ramsize", the_arch.ramsize);
write_scalar_32 (fp, "tlbsize", the_arch.tlbsize);
write_scalar_32 (fp, "loopticks", the_arch.loopticks);
write_scalar_32 (fp, "loopticks_cp", the_arch.loopticks_cp);
write_scalar_32 (fp, "stickincr", the_arch.stickincr);
write_scalar_32 (fp, "cpus_per_thread", the_arch.cpus_per_thread);
write_scalar_64 (fp, "cpu_freq", the_arch.cpu_freq);
write_scalar_64 (fp, "stick_freq", the_arch.stick_freq);
write_scalar_32 (fp, "arch_flags", the_arch.arch_flags);
write_string (fp, "cputype", the_arch.mmutype);
write_string (fp, "platform", the_arch.platform);
write_scalar_32 (fp, "cpi", the_arch.cpi);
write_scalar_32 (fp, "boot_ctrl_id", boot_ctrl_id);
write_scalar_32 (fp, "boot_target_id", boot_target_id);
//write_scalar_32 (fp, "boot_disk_id", boot_disk_id);
write_scalar_32 (fp, "boot_part_id", boot_part_id);
write_scalar_32 (fp, "numNICs", the_arch.numNICs);
write_scalar_32 (fp, "numDCs", the_arch.numDCs); // number of disk controllers on pciA
write_scalar_64 (fp, "mips", the_arch.mips);
write_scalar_64 (fp, "umips", the_arch.umips);
write_scalar_64 (fp, "kmips", the_arch.kmips);
write_scalar_32 (fp, "roundrobin", the_arch.roundrobin);
WorkerThread::dump(fp);
}
bool_t
SYSTEM_restore (FILE *fp)
{
char line[1000], temp[1000];
do {
if (fgets (line, sizeof(line), fp) == NULL)
break;
else if (sscanf (line, "arch_flags %i", &the_arch.arch_flags) == 1) ;
else if (sscanf (line, "global_tick %lli", &global_tick) == 1) ;
else if (sscanf (line, "cpus_per_thread %i",&the_arch.cpus_per_thread)==1);
else if (sscanf (line, "numcpus %i", &the_arch.numcpus) == 1) ;
else if (sscanf (line, "nwins %i", &the_arch.nwins) == 1) ;
else if (sscanf (line, "ramsize %lli", &the_arch.ramsize) == 1) ;
else if (sscanf (line, "tlbsize %i", &the_arch.tlbsize) == 1) ;
else if (sscanf (line, "loopticks %i", &the_arch.loopticks) == 1) ;
else if (sscanf (line, "loopticks_cp %i", &the_arch.loopticks_cp)==1) ;
else if (sscanf (line, "stickincr %i", &the_arch.stickincr) == 1) ;
else if (sscanf (line, "cpu_freq %lli", &the_arch.cpu_freq) == 1) ;
else if (sscanf (line, "stick_freq %lli", &the_arch.stick_freq) == 1) ;
else if (sscanf (line, "cpi %i", &the_arch.cpi) == 1) ;
else if (sscanf (line, "mips %lli", &the_arch.mips) == 1) {
the_arch.umips = the_arch.kmips = the_arch.mips; }
else if (sscanf (line, "umips %lli", &the_arch.umips) == 1) ;
else if (sscanf (line, "kmips %lli", &the_arch.kmips) == 1) ;
else if (sscanf (line, "roundrobin %i", &the_arch.roundrobin) == 1) ;
else if (sscanf (line, "boot_ctrl_id %i", &boot_ctrl_id) == 1) ;
else if (sscanf (line, "boot_target_id %i", &boot_target_id) == 1) ;
else if (sscanf (line, "boot_part_id %i", &boot_part_id) == 1) ;
else if (sscanf (line, "numNICs %i", &the_arch.numNICs) == 1) ;
else if (sscanf (line, "numDCs %i", &the_arch.numDCs) == 1) ;
else if (sscanf (line, "platform %s", &temp[0]) == 1) {
the_arch.platform = strdup (temp); }
else if (sscanf (line, "cputype %s", &temp[0]) == 1) {
the_arch.mmutype = strdup (temp);
#ifdef CHPLUS
if (strcmp(the_arch.mmutype, "cheetah") == 0
|| strcmp(the_arch.mmutype, "spitfire") == 0)
ui->verbose("restore: mmutype %s NG. with CHPLUS \n",
the_arch.mmutype);
#elif CH
if (strcmp(the_arch.mmutype, "cheetahplus") == 0)
ui->verbose("restore: mmutype %s NG. with CH \n",
the_arch.mmutype);
#endif
}
else if (WorkerThread::restore(&line[0]) == 1) ;
else
ui->error("restore: unrecognized: %s\n", line);
} while (1) ;
if (restore_v4_dump() && the_arch.mips == 0) {
// need non-zero values for all of these v4 config values
//
if (the_arch.loopticks && the_arch.stickincr && the_arch.stick_freq) {
int64_t mips = (( (the_arch.stick_freq * the_arch.loopticks)
/ the_arch.stickincr) / 1000000LL);
the_arch.mips = mips;
the_arch.umips = mips;
the_arch.kmips = mips;
ui->verbose("mips computed from v4 stick_freq*loopticks/stickincr/1M"
" = %lld\n", the_arch.mips);
}
//
// hmmm, insufficient data, but this can't happen...?...
}
return TRUE;
}
// ========================================================================== {
// SYSCONF api routines
//
uint8_t SYSTEM_get_dc_num()
{
return (the_arch.numDCs);
}
uint8_t SYSTEM_get_nic_num()
{
return (the_arch.numNICs);
}
bool_t SYSTEM_chplus_mmu ()
{
#ifdef CHPLUS
return TRUE;
#else
return FALSE;
#endif
}
int SYSTEM_get_nwins()
{
return the_arch.nwins;
}
extern int get_wrdiskdelay();
int SYSTEM_get_wrdiskdelay()
{
return get_wrdiskdelay();
}
extern int get_diskdelay();
int SYSTEM_get_diskdelay()
{
return get_diskdelay();
}
int SYSTEM_get_loopticks ()
{
return the_arch.loopticks;
}
int SYSTEM_get_stickincr ()
{
return the_arch.stickincr;
}
uint64_t SYSTEM_get_stickfreq()
{
return the_arch.stick_freq;
}
uint64_t SYSTEM_get_cpufreq()
{
return the_arch.cpu_freq;
}
const char* SYSTEM_get_mmutypeS()
{
return the_arch.mmutype;
}
const char* SYSTEM_get_cputypeS()
{
return the_arch.mmutype;
}
int SYSTEM_get_tlbsize()
{
return the_arch.tlbsize;
}
const char* SYSTEM_get_infostr ()
{
return BLAZEVERSION_STRING;
}
char * SYSTEM_get_version ()
{
return (char*)BLAZEVERSION_STRING;
}
uint32_t SYSTEM_get_ncpu ()
{
return the_arch.numcpus;
}
uint32_t SYSTEM_get_ncores()
{
// this function is invoked in rs2blaze, do not remove it
// unless the caller in rs2blaze is modified accordingly.
if (the_arch.cmp_mode) {
return the_arch.numcores;
}
else {
ui->warning("SYSTEM_get_ncores call invalid unless in cmp_mode\n");
return 0;
//assert(0); // DEVENDRA commented this out
}
}
int SYSTEM_get_cpus_per_thread ()
{
return the_arch.cpus_per_thread;
}
int SYSTEM_get_numthreads ()
{
return the_arch.numthreads;
}
int SYSTEM_get_skipmp ()
{
return the_arch.skip_mp;
}
int SYSTEM_get_blockmp ()
{
return the_arch.block_mp;
}
bool_t SYSTEM_get_ce_enable_flag ()
{
return ce_enable_flag;
}
void SYSTEM_set_ce_enable_flag (bool_t flag)
{
ce_enable_flag = flag;
}
bool_t SYSTEM_get_scsi_disk_enable_flag ()
{
return scsi_disk_enable_flag;
}
void SYSTEM_set_scsi_disk_enable_flag (bool_t flag)
{
scsi_disk_enable_flag = flag;
}
bool_t SYSTEM_get_scsi_boot_enable_flag ()
{
return scsi_boot_enable_flag;
}
void SYSTEM_set_scsi_boot_enable_flag (bool_t flag)
{
scsi_boot_enable_flag = flag;
}
// to enable boot from any schizo and bus
void SYSTEM_set_boot_aid_bus(unsigned char aid, unsigned char bus)
{
scsi_boot_enable_flag += (bus << 7) | (aid << 4);
}
bool_t SYSTEM_get_fc_disk_enable_flag ()
{
return fc_disk_enable_flag;
}
void SYSTEM_set_fc_disk_enable_flag (bool_t flag)
{
fc_disk_enable_flag = flag;
}
bool_t SYSTEM_get_fc_boot_enable_flag ()
{
return fc_boot_enable_flag;
}
void SYSTEM_set_fc_boot_enable_flag (bool_t flag)
{
fc_boot_enable_flag = flag;
}
bool_t SYSTEM_is_serengeti()
{
if (the_arch.platform == NULL)
return FALSE;
if (strcmp (the_arch.platform, "SUNW,Sun-Fire") == NULL)
return TRUE;
else
return FALSE;
}
bool_t SYSTEM_is_480R()
{
if (the_arch.platform == NULL)
return FALSE;
if(strcmp (the_arch.platform, "SUNW,Sun-Fire-480R") == NULL)
return TRUE;
else
return FALSE;
}
// ========================================================================== }
// ============================================================================
//
// HOSTCONFIG property lookup table
//
// at the moment this is simply {"name", "value"} pairs, there is not yet
// any "name.subname.subsubname.etc..." convention,
//
// also note that the caller must ensure the strings are in stable memory,
// here we only save pointers...
//
#include <map> // Oh No Mr Bill,... STL ...!!!...
#if 1
class str_less : public std::binary_function<const char*A, const char*B, bool> {
public:
bool operator () (const char * A, const char * B) const {
return strcmp (A, B) < 0;
}
};
typedef std::map<const char *, const char *, str_less> Dictionary;
#else
class str_less : public std::binary_function <const char* _x, const char* _y, bool> {
public:
bool operator () (const char* _x, const char* _y) const {
return (strcmp (_x, _y) < 0);
}
};
typedef std::map<const char*, key, str_less> Dictionary;
#endif
Dictionary *hostconfig;
bool_t SYSTEM_isset_hostconfig (const char * configname)
{
if(!hostconfig){
hostconfig = new Dictionary;
}
return hostconfig->count(configname) != 0;
}
// returns config-value, given config-name, simple dictionary/map lookup.
const char * SYSTEM_get_hostconfig (const char * configname)
{
if(!hostconfig){
hostconfig = new Dictionary;
}
if (hostconfig->count (configname) != 0) {
return (*hostconfig)[ configname ];
} else
return NULL;
}
// used by ... to initially record the hostconfig info
void SYSTEM_set_hostconfig (const char * configname, const char * configvalue)
{
if(!hostconfig){
hostconfig = new Dictionary;
}
(*hostconfig)[ configname ] = configvalue;
}
// ... later ...
void SYSTEM_dump_hostconfig (FILE * f)
{
}
void SYSTEM_set_goodtrap_pc(uint64_t pc_va) {
goodtrap_pc = pc_va;
}
uint64_t SYSTEM_get_goodtrap_pc() {
return goodtrap_pc;
}
void SYSTEM_set_badtrap_pc(uint64_t pc_va) {
badtrap_pc = pc_va;
}
uint64_t SYSTEM_get_badtrap_pc() {
return badtrap_pc;
}
// used when restore from v4 and translate delaycount into usecs.
sint64_t SYSTEM_Sticks2usecs (sint64_t sticks)
{
/*
* Time is by definition equal to (sticks / stick_frequency).
*/
return (sint64_t)((double)sticks / ((double)SYSTEM_get_stickfreq()/1000000.0));
}
// used when restore from v4 and translate delaycount from cycles into usecs.
sint64_t SYSTEM_Ticks2usecs (sint64_t ticks)
{
/*
* Warning, ticks can be unreliable.
* Blaze re-computes ticks every time the user changes loopticks, or stickincr.
*/
return (sint64_t)((double)ticks
* ((double)SYSTEM_get_stickincr() / SYSTEM_get_loopticks())
/ ((double)SYSTEM_get_stickfreq() / 1000000.0));
}
/* -oOo-. */
Full OpenSPARC architecture tarball including simulator, hypervisor, and OBP.