static void read_cpu_tjmax(void *magic)
{
UInt32 number = get_cpu_number();
if (number < kCPUSensorsMaxCpus) {
cpu_tjmax[number] = (rdmsr64(MSR_IA32_TEMP_TARGET) >> 16) & 0xFF;
}
/**
* @brief Initialise the hashtable.
*
* Allocate the hash table entries and initialise the hash masks.
*
* @param hash_table Hash table to setup.
* @param size Requested size for the hash table in number of entries.
*/
void hash_init(HashTable *hash_table, const unsigned long long size)
{
int i, n_way;
for (n_way = 1; n_way < HASH_N_WAY; n_way <<= 1);
assert(hash_table != NULL);
assert((n_way & -n_way) == n_way);
info("< init hashtable of %llu entries>\n", size);
if (hash_table->hash != NULL) free(hash_table->memory);
hash_table->memory = malloc((size + n_way + 1) * sizeof (Hash));
if (hash_table->memory == NULL) {
fatal_error("hash_init: cannot allocate the hash table\n");
}
if (HASH_ALIGNED) {
const size_t alignment = n_way * sizeof (Hash) - 1;
hash_table->hash = (Hash*) (((size_t) hash_table->memory + alignment) & ~alignment);
hash_table->hash_mask = size - n_way;
} else {
hash_table->hash = (Hash*) hash_table->memory;
hash_table->hash_mask = size - 1;
}
hash_cleanup(hash_table);
hash_table->n_lock = 256 * MAX(get_cpu_number(), 1);
hash_table->lock_mask = hash_table->n_lock - 1;
hash_table->n_lock += n_way + 1;
hash_table->lock = (HashLock*) malloc(hash_table->n_lock * sizeof (HashLock));
for (i = 0; i < hash_table->n_lock; ++i) spin_init(hash_table->lock + i);
}
static inline void read_cpu_thermal(void *magic)
{
UInt32 number = get_cpu_number();
if (number < kCPUSensorsMaxCpus) {
UInt64 msr = rdmsr64(MSR_IA32_THERM_STS);
if (msr & 0x80000000) {
cpu_thermal[number] = (msr >> 16) & 0x7F;
cpu_thermal_updated[number] = true;
}
inline void read_cpu_thermal(void* cpu_index)
{
UInt8 * cpn = (UInt8 *)cpu_index;
*cpn = get_cpu_number();
if(*cpn < kCPUSensorsMaxCpus) {
UInt64 msr = rdmsr64(MSR_IA32_THERM_STS);
if (msr & 0x80000000) cpu_thermal[*cpn] = (msr >> 16) & 0x7F;
}
/**
* current_cpu_datap
*
* Return the current processor PCB.
*/
cpu_data_t* current_cpu_datap(void)
{
int smp_number = get_cpu_number();
cpu_data_t* current_cpu_data;
if(smp_number == 0)
return &cpu_data_master;
current_cpu_data = cpu_datap(smp_number);
if(!current_cpu_data) {
panic("cpu_data for slot %d is not available yet\n", smp_number);
}
return current_cpu_data;
}
void
lapic_shutdown(void)
{
uint32_t lo;
uint32_t hi;
uint32_t value;
/* Shutdown if local APIC was enabled by OS */
if (lapic_os_enabled == FALSE)
return;
mp_disable_preemption();
/* ExtINT: masked */
if (get_cpu_number() == master_cpu) {
value = LAPIC_READ(LVT_LINT0);
value |= LAPIC_LVT_MASKED;
LAPIC_WRITE(LVT_LINT0, value);
}
/* Error: masked */
LAPIC_WRITE(LVT_ERROR, LAPIC_READ(LVT_ERROR) | LAPIC_LVT_MASKED);
/* Timer: masked */
LAPIC_WRITE(LVT_TIMER, LAPIC_READ(LVT_TIMER) | LAPIC_LVT_MASKED);
/* Perfmon: masked */
LAPIC_WRITE(LVT_PERFCNT, LAPIC_READ(LVT_PERFCNT) | LAPIC_LVT_MASKED);
/* APIC software disabled */
LAPIC_WRITE(SVR, LAPIC_READ(SVR) & ~LAPIC_SVR_ENABLE);
/* Bypass the APIC completely and update cpu features */
rdmsr(MSR_IA32_APIC_BASE, lo, hi);
lo &= ~MSR_IA32_APIC_BASE_ENABLE;
wrmsr(MSR_IA32_APIC_BASE, lo, hi);
cpuid_set_info();
mp_enable_preemption();
}
void
lapic_configure(void)
{
int value;
if (lapic_error_time_threshold == 0 && cpu_number() == 0) {
nanoseconds_to_absolutetime(NSEC_PER_SEC >> 2, &lapic_error_time_threshold);
if (!PE_parse_boot_argn("lapic_dont_panic", &lapic_dont_panic, sizeof(lapic_dont_panic))) {
lapic_dont_panic = FALSE;
}
}
/* Set flat delivery model, logical processor id */
LAPIC_WRITE(DFR, LAPIC_DFR_FLAT);
LAPIC_WRITE(LDR, (get_cpu_number()) << LAPIC_LDR_SHIFT);
/* Accept all */
LAPIC_WRITE(TPR, 0);
LAPIC_WRITE(SVR, LAPIC_VECTOR(SPURIOUS) | LAPIC_SVR_ENABLE);
/* ExtINT */
if (get_cpu_number() == master_cpu) {
value = LAPIC_READ(LVT_LINT0);
value &= ~LAPIC_LVT_MASKED;
value |= LAPIC_LVT_DM_EXTINT;
LAPIC_WRITE(LVT_LINT0, value);
}
/* Timer: unmasked, one-shot */
/**
* @brief edax main function.
*
* Do a global initialization and choose a User Interface protocol.
*
* @param argc Number of arguments.
* @param argv Command line arguments.
*/
int main(int argc, char **argv)
{
UI *ui;
int i, r, level = 0, size = 8;
char *problem_file = NULL;
char *wthor_file = NULL;
char *count_type = NULL;
int n_bench = 0;
// options.n_task default to system cpu number
options.n_task = get_cpu_number();
// options from edax.ini
options_parse("edax.ini");
// allocate ui
ui = (UI*) malloc(sizeof *ui);
if (ui == NULL) fatal_error("Cannot allocate a user interface.\n");
ui->type = UI_EDAX;
ui->init = ui_init_edax;
ui->free = ui_free_edax;
ui->loop = ui_loop_edax;
// parse arguments
for (i = 1; i < argc; i++) {
char *arg = argv[i];
while (*arg == '-') ++arg;
if (strcmp(arg, "v") == 0 || strcmp(arg, "version") == 0) version();
else if (ui_switch(ui, arg)) ;
else if ((r = (options_read(arg, argv[i + 1]))) > 0) i += r - 1;
else if (strcmp(arg, "solve") == 0 && argv[i + 1]) problem_file = argv[++i];
else if (strcmp(arg, "wtest") == 0 && argv[i + 1]) wthor_file = argv[++i];
else if (strcmp(arg, "bench") == 0 && argv[i + 1]) n_bench = atoi(argv[++i]);
else if (strcmp(arg, "count") == 0 && argv[i + 1]) {
count_type = argv[++i];
if (argv[i + 1]) level = string_to_int(argv[++i], 0);
if (argv[i + 1] && strcmp(argv[i + 1], "6x6") == 0) {
size = 6;
++i;
}
}
else usage();
}
options_bound();
// initialize
edge_stability_init();
hash_code_init();
hash_move_init();
statistics_init();
eval_open(options.eval_file);
search_global_init();
// solver & tester
if (problem_file || wthor_file || n_bench) {
Search search[1];
search_init(search);
search->options.header = " depth|score| time | nodes (N) | N/s | principal variation";
search->options.separator = "------+-----+--------------+-------------+----------+---------------------";
if (options.verbosity) version();
if (problem_file) obf_test(search, problem_file, NULL);
if (wthor_file) wthor_test(wthor_file, search);
if (n_bench) obf_speed(search, n_bench);
search_free(search);
} else if (count_type){
Board board[1];
board_init(board);
if (strcmp(count_type, "games") == 0) quick_count_games(board, level, size);
else if (strcmp(count_type, "positions") == 0) count_positions(board, level, size);
else if (strcmp(count_type, "shapes") == 0) count_shapes(board, level, size);
} else if (ui->type == UI_CASSIO) {
engine_loop();
// other protocols
} else {
ui_event_init(ui);
ui->init(ui);
ui->loop(ui);
if (ui->free) ui->free(ui);
ui_event_free(ui);
}
// display statistics
statistics_print(stdout);
// free;
eval_close();
options_free();
free(ui);
return 0;
}
