From 242ea71ee6bb59c868783bd615ff18b9fc490f3e Mon Sep 17 00:00:00 2001 From: Rodrigo Arias Date: Wed, 1 Feb 2023 12:18:40 +0100 Subject: [PATCH] Remove old nanos6.c and ovni.c --- src/emu/nanos6.c | 658 ----------------------------------------------- src/emu/ovni.c | 620 -------------------------------------------- 2 files changed, 1278 deletions(-) delete mode 100644 src/emu/nanos6.c delete mode 100644 src/emu/ovni.c diff --git a/src/emu/nanos6.c b/src/emu/nanos6.c deleted file mode 100644 index 031e411..0000000 --- a/src/emu/nanos6.c +++ /dev/null @@ -1,658 +0,0 @@ -/* Copyright (c) 2022-2023 Barcelona Supercomputing Center (BSC) - * SPDX-License-Identifier: GPL-3.0-or-later */ - -#include "uthash.h" -#include "utlist.h" - -#include "chan.h" -#include "emu.h" -#include "task.h" -#include "ovni.h" -#include "prv.h" - -void -hook_init_nanos6(struct ovni_emu *emu) -{ - int64_t *clock = &emu->delta_time; - FILE *prv_th = emu->prv_thread; - FILE *prv_cpu = emu->prv_cpu; - - /* Init the channels in all threads */ - for (size_t i = 0; i < emu->total_nthreads; i++) { - struct ovni_ethread *th = emu->global_thread[i]; - int row = th->gindex + 1; - - struct ovni_chan **uth = &emu->th_chan; - - chan_th_init(th, uth, CHAN_NANOS6_TASKID, CHAN_TRACK_TH_RUNNING, 0, 0, 1, row, prv_th, clock); - chan_th_init(th, uth, CHAN_NANOS6_TYPE, CHAN_TRACK_TH_RUNNING, 0, 0, 1, row, prv_th, clock); - chan_th_init(th, uth, CHAN_NANOS6_SUBSYSTEM, CHAN_TRACK_TH_ACTIVE, 0, 0, 1, row, prv_th, clock); - chan_th_init(th, uth, CHAN_NANOS6_RANK, CHAN_TRACK_TH_RUNNING, 0, 0, 1, row, prv_th, clock); - chan_th_init(th, uth, CHAN_NANOS6_THREAD, CHAN_TRACK_NONE, 0, 1, 1, row, prv_th, clock); - } - - /* Init the Nanos6 channels in all cpus */ - for (size_t i = 0; i < emu->total_ncpus; i++) { - struct ovni_cpu *cpu = emu->global_cpu[i]; - int row = cpu->gindex + 1; - struct ovni_chan **ucpu = &emu->cpu_chan; - - chan_cpu_init(cpu, ucpu, CHAN_NANOS6_TASKID, CHAN_TRACK_TH_RUNNING, 0, 0, 1, row, prv_cpu, clock); - chan_cpu_init(cpu, ucpu, CHAN_NANOS6_TYPE, CHAN_TRACK_TH_RUNNING, 0, 0, 1, row, prv_cpu, clock); - chan_cpu_init(cpu, ucpu, CHAN_NANOS6_SUBSYSTEM, CHAN_TRACK_TH_RUNNING, 0, 0, 1, row, prv_cpu, clock); - chan_cpu_init(cpu, ucpu, CHAN_NANOS6_RANK, CHAN_TRACK_TH_RUNNING, 0, 0, 1, row, prv_cpu, clock); - chan_cpu_init(cpu, ucpu, CHAN_NANOS6_THREAD, CHAN_TRACK_TH_RUNNING, 0, 0, 1, row, prv_cpu, clock); - } - - /* Init task stack */ - for (size_t i = 0; i < emu->total_nthreads; i++) { - struct ovni_ethread *th = emu->global_thread[i]; - th->nanos6_task_stack.thread = th; - } -} - -/* --------------------------- pre ------------------------------- */ - -static void -chan_task_stopped(struct ovni_emu *emu) -{ - struct ovni_ethread *th = emu->cur_thread; - - chan_set(&th->chan[CHAN_NANOS6_TASKID], 0); - chan_set(&th->chan[CHAN_NANOS6_TYPE], 0); - - if (emu->cur_loom->rank_enabled) - chan_set(&th->chan[CHAN_NANOS6_RANK], 0); -} - -static void -chan_task_running(struct ovni_emu *emu, struct task *task) -{ - struct ovni_ethread *th = emu->cur_thread; - struct ovni_eproc *proc = emu->cur_proc; - - if (task->id == 0) - edie(emu, "task id cannot be 0\n"); - - if (task->type->gid == 0) - edie(emu, "task type gid cannot be 0\n"); - - if (proc->appid <= 0) - edie(emu, "app id must be positive\n"); - - chan_set(&th->chan[CHAN_NANOS6_TASKID], task->id); - chan_set(&th->chan[CHAN_NANOS6_TYPE], task->type->gid); - - if (emu->cur_loom->rank_enabled) - chan_set(&th->chan[CHAN_NANOS6_RANK], proc->rank + 1); -} - -static void -chan_task_switch(struct ovni_emu *emu, - struct task *prev, struct task *next) -{ - struct ovni_ethread *th = emu->cur_thread; - - if (!prev || !next) - edie(emu, "cannot switch to or from a NULL task\n"); - - if (prev == next) - edie(emu, "cannot switch to the same task\n"); - - if (next->id == 0) - edie(emu, "next task id cannot be 0\n"); - - if (next->type->gid == 0) - edie(emu, "next task type id cannot be 0\n"); - - if (prev->thread != next->thread) - edie(emu, "cannot switch to a task of another thread\n"); - - /* No need to change the rank as we will switch to tasks from - * same thread */ - chan_set(&th->chan[CHAN_NANOS6_TASKID], next->id); - - /* FIXME: We should emit a PRV event even if we are switching to - * the same type event, to mark the end of the current task. For - * now we only emit a new type if we switch to a type with a - * different gid. */ - if (prev->type->gid != next->type->gid) - chan_set(&th->chan[CHAN_NANOS6_TYPE], next->type->gid); -} - -static void -update_task_state(struct ovni_emu *emu) -{ - if (ovni_payload_size(emu->cur_ev) < 4) - edie(emu, "missing task id in payload\n"); - - uint32_t task_id = emu->cur_ev->payload.u32[0]; - - struct ovni_ethread *th = emu->cur_thread; - struct ovni_eproc *proc = emu->cur_proc; - - struct task_info *info = &proc->nanos6_task_info; - struct task_stack *stack = &th->nanos6_task_stack; - - struct task *task = task_find(info->tasks, task_id); - - if (task == NULL) - edie(emu, "cannot find task with id %u\n", task_id); - - switch (emu->cur_ev->header.value) { - case 'x': - task_execute(emu, stack, task); - break; - case 'e': - task_end(emu, stack, task); - break; - case 'p': - task_pause(emu, stack, task); - break; - case 'r': - task_resume(emu, stack, task); - break; - default: - edie(emu, "unexpected Nanos6 task event\n"); - } -} - -static char -expand_transition_value(struct ovni_emu *emu, int was_running, int runs_now) -{ - char tr = emu->cur_ev->header.value; - - /* Ensure we don't clobber the value */ - if (tr == 'X' || tr == 'E') - edie(emu, "unexpected event value %c\n", tr); - - /* Modify the event value to detect nested transitions */ - if (tr == 'x' && was_running) - tr = 'X'; /* Execute a new nested task */ - else if (tr == 'e' && runs_now) - tr = 'E'; /* End a nested task */ - - return tr; -} - -static void -update_task_channels(struct ovni_emu *emu, - char tr, struct task *prev, struct task *next) -{ - switch (tr) { - case 'x': - case 'r': - chan_task_running(emu, next); - break; - case 'e': - case 'p': - chan_task_stopped(emu); - break; - /* Additional nested transitions */ - case 'X': - case 'E': - chan_task_switch(emu, prev, next); - break; - default: - edie(emu, "unexpected transition value %c\n", tr); - } -} - -static void -enforce_task_rules(struct ovni_emu *emu, - char tr, struct task *prev, struct task *next) - -{ - UNUSED(prev); - - /* If a task has just entered the running state, it must show - * the running task body subsystem */ - if (tr == 'x' || tr == 'X') { - if (next->state != TASK_ST_RUNNING) - edie(emu, "a Nanos6 task starts running but not in the running state\n"); - - struct ovni_ethread *th = emu->cur_thread; - struct ovni_chan *sschan = &th->chan[CHAN_NANOS6_SUBSYSTEM]; - int st = chan_get_st(sschan); - - if (st != 0 && st != ST_NANOS6_TASK_BODY) - edie(emu, "a Nanos6 task starts running but not in the \"running body\" subsystem state\n"); - } -} - -static void -update_task(struct ovni_emu *emu) -{ - struct ovni_ethread *th = emu->cur_thread; - struct task_stack *stack = &th->nanos6_task_stack; - - struct task *prev = task_get_running(stack); - - /* Update the emulator state, but don't modify the channels */ - update_task_state(emu); - - struct task *next = task_get_running(stack); - - int was_running = (prev != NULL); - int runs_now = (next != NULL); - char tr = expand_transition_value(emu, was_running, runs_now); - - /* Update the task related channels now */ - update_task_channels(emu, tr, prev, next); - - enforce_task_rules(emu, tr, prev, next); -} - -static void -create_task(struct ovni_emu *emu) -{ - if (ovni_payload_size(emu->cur_ev) != 8) - edie(emu, "cannot create task: unexpected payload size\n"); - - uint32_t task_id = emu->cur_ev->payload.u32[0]; - uint32_t type_id = emu->cur_ev->payload.u32[1]; - - struct task_info *info = &emu->cur_proc->nanos6_task_info; - - task_create(emu, info, type_id, task_id); -} - -static void -pre_task(struct ovni_emu *emu) -{ - switch (emu->cur_ev->header.value) { - case 'c': - create_task(emu); - break; - case 'x': - case 'e': - case 'r': - case 'p': /* Wet floor */ - update_task(emu); - break; - default: - edie(emu, "unexpected Nanos6 task event value\n"); - } -} - -static void -pre_type(struct ovni_emu *emu) -{ - uint8_t value = emu->cur_ev->header.value; - - if (value != 'c') - edie(emu, "unexpected event value %c\n", value); - - if ((emu->cur_ev->header.flags & OVNI_EV_JUMBO) == 0) - edie(emu, "expecting a jumbo event\n"); - - uint8_t *data = &emu->cur_ev->payload.jumbo.data[0]; - uint32_t typeid = *(uint32_t *) data; - data += 4; - - const char *label = (const char *) data; - - struct ovni_eproc *proc = emu->cur_proc; - - task_type_create(&proc->nanos6_task_info, typeid, label); -} - -static void -pre_deps(struct ovni_emu *emu) -{ - struct ovni_ethread *th = emu->cur_thread; - struct ovni_chan *chan_th = &th->chan[CHAN_NANOS6_SUBSYSTEM]; - - switch (emu->cur_ev->header.value) { - case 'r': - chan_push(chan_th, ST_NANOS6_DEP_REG); - break; - case 'R': - chan_pop(chan_th, ST_NANOS6_DEP_REG); - break; - case 'u': - chan_push(chan_th, ST_NANOS6_DEP_UNREG); - break; - case 'U': - chan_pop(chan_th, ST_NANOS6_DEP_UNREG); - break; - default: - edie(emu, "unknown Nanos6 dependency event\n"); - } -} - -static void -pre_blocking(struct ovni_emu *emu) -{ - struct ovni_ethread *th = emu->cur_thread; - struct ovni_chan *chan_th = &th->chan[CHAN_NANOS6_SUBSYSTEM]; - - switch (emu->cur_ev->header.value) { - case 'b': - chan_push(chan_th, ST_NANOS6_BLK_BLOCKING); - break; - case 'B': - chan_pop(chan_th, ST_NANOS6_BLK_BLOCKING); - break; - case 'u': - chan_push(chan_th, ST_NANOS6_BLK_UNBLOCKING); - break; - case 'U': - chan_pop(chan_th, ST_NANOS6_BLK_UNBLOCKING); - break; - case 'w': - chan_push(chan_th, ST_NANOS6_BLK_TASKWAIT); - break; - case 'W': - chan_pop(chan_th, ST_NANOS6_BLK_TASKWAIT); - break; - case 'f': - chan_push(chan_th, ST_NANOS6_BLK_WAITFOR); - break; - case 'F': - chan_pop(chan_th, ST_NANOS6_BLK_WAITFOR); - break; - default: - edie(emu, "unknown Nanos6 blocking event\n"); - } -} - -static void -pre_worker(struct ovni_emu *emu) -{ - struct ovni_ethread *th = emu->cur_thread; - struct ovni_chan *chan_th = &th->chan[CHAN_NANOS6_SUBSYSTEM]; - - switch (emu->cur_ev->header.value) { - case '[': - chan_push(chan_th, ST_NANOS6_WORKER_LOOP); - break; - case ']': - chan_pop(chan_th, ST_NANOS6_WORKER_LOOP); - break; - case 't': - chan_push(chan_th, ST_NANOS6_HANDLING_TASK); - break; - case 'T': - chan_pop(chan_th, ST_NANOS6_HANDLING_TASK); - break; - case 'w': - chan_push(chan_th, ST_NANOS6_SWITCH_TO); - break; - case 'W': - chan_pop(chan_th, ST_NANOS6_SWITCH_TO); - break; - case 'm': - chan_push(chan_th, ST_NANOS6_MIGRATE); - break; - case 'M': - chan_pop(chan_th, ST_NANOS6_MIGRATE); - break; - case 's': - chan_push(chan_th, ST_NANOS6_SUSPEND); - break; - case 'S': - chan_pop(chan_th, ST_NANOS6_SUSPEND); - break; - case 'r': - chan_push(chan_th, ST_NANOS6_RESUME); - break; - case 'R': - chan_pop(chan_th, ST_NANOS6_RESUME); - break; - case '*': - chan_ev(chan_th, EV_NANOS6_SIGNAL); - break; - default: - edie(emu, "unknown Nanos6 worker event\n"); - } -} - -static void -pre_memory(struct ovni_emu *emu) -{ - struct ovni_ethread *th = emu->cur_thread; - struct ovni_chan *chan_th = &th->chan[CHAN_NANOS6_SUBSYSTEM]; - - switch (emu->cur_ev->header.value) { - case 'a': - chan_push(chan_th, ST_NANOS6_ALLOCATING); - break; - case 'A': - chan_pop(chan_th, ST_NANOS6_ALLOCATING); - break; - case 'f': - chan_push(chan_th, ST_NANOS6_FREEING); - break; - case 'F': - chan_pop(chan_th, ST_NANOS6_FREEING); - break; - default: - edie(emu, "unknown Nanos6 memory event\n"); - } -} - -static void -pre_sched(struct ovni_emu *emu) -{ - struct ovni_ethread *th = emu->cur_thread; - struct ovni_chan *chan_th = &th->chan[CHAN_NANOS6_SUBSYSTEM]; - - switch (emu->cur_ev->header.value) { - case '[': - chan_push(chan_th, ST_NANOS6_SCHED_SERVING); - break; - case ']': - chan_pop(chan_th, ST_NANOS6_SCHED_SERVING); - break; - case 'a': - chan_push(chan_th, ST_NANOS6_SCHED_ADDING); - break; - case 'A': - chan_pop(chan_th, ST_NANOS6_SCHED_ADDING); - break; - case 'p': - chan_push(chan_th, ST_NANOS6_SCHED_PROCESSING); - break; - case 'P': - chan_pop(chan_th, ST_NANOS6_SCHED_PROCESSING); - break; - case '@': - chan_ev(chan_th, EV_NANOS6_SCHED_SELF); - break; - case 'r': - chan_ev(chan_th, EV_NANOS6_SCHED_RECV); - break; - case 's': - chan_ev(chan_th, EV_NANOS6_SCHED_SEND); - break; - default: - edie(emu, "unknown Nanos6 scheduler event\n"); - } -} - -static void -pre_thread(struct ovni_emu *emu) -{ - struct ovni_ethread *th = emu->cur_thread; - struct ovni_chan *chan_th = &th->chan[CHAN_NANOS6_THREAD]; - - switch (emu->cur_ev->header.value) { - case 'e': - chan_push(chan_th, ST_NANOS6_TH_EXTERNAL); - break; - case 'E': - chan_pop(chan_th, ST_NANOS6_TH_EXTERNAL); - break; - case 'w': - chan_push(chan_th, ST_NANOS6_TH_WORKER); - break; - case 'W': - chan_pop(chan_th, ST_NANOS6_TH_WORKER); - break; - case 'l': - chan_push(chan_th, ST_NANOS6_TH_LEADER); - break; - case 'L': - chan_pop(chan_th, ST_NANOS6_TH_LEADER); - break; - case 'm': - chan_push(chan_th, ST_NANOS6_TH_MAIN); - break; - case 'M': - chan_pop(chan_th, ST_NANOS6_TH_MAIN); - break; - default: - edie(emu, "unknown Nanos6 thread type event\n"); - } -} - -static void -pre_ss(struct ovni_emu *emu, int st) -{ - struct ovni_ethread *th = emu->cur_thread; - struct ovni_chan *chan_th = &th->chan[CHAN_NANOS6_SUBSYSTEM]; - - dbg("pre_ss chan id %d st=%d\n", chan_th->id, st); - - switch (emu->cur_ev->header.value) { - case '[': - chan_push(chan_th, st); - break; - case ']': - chan_pop(chan_th, st); - break; - default: - edie(emu, "unexpected value '%c' (expecting '[' or ']')\n", - emu->cur_ev->header.value); - } -} - -static void -check_affinity(struct ovni_emu *emu) -{ - struct ovni_ethread *th = emu->cur_thread; - struct ovni_cpu *cpu = th->cpu; - - if (!cpu || cpu->virtual) - return; - - if (cpu->nrunning_threads > 1) { - eerr(emu, "cpu %s has more than one thread running\n", cpu->name); - - /* Only abort in linter mode so we can still see the - * trace to find out what was happening */ - if (emu->enable_linter) - abort(); - } -} - -void -hook_pre_nanos6(struct ovni_emu *emu) -{ - if (emu->cur_ev->header.model != '6') - edie(emu, "hook_pre_nanos6: unexpected event with model %c\n", - emu->cur_ev->header.model); - - if (!emu->cur_thread->is_active) { - edie(emu, "hook_pre_nanos6: current thread %d not active\n", - emu->cur_thread->tid); - } - - switch (emu->cur_ev->header.category) { - case 'T': - pre_task(emu); - break; - case 'C': - pre_ss(emu, ST_NANOS6_TASK_CREATING); - break; - case 'Y': - pre_type(emu); - break; - case 'S': - pre_sched(emu); - break; - case 'U': - pre_ss(emu, ST_NANOS6_TASK_SUBMIT); - break; - case 'F': - pre_ss(emu, ST_NANOS6_TASK_SPAWNING); - break; - case 'O': - pre_ss(emu, ST_NANOS6_TASK_FOR); - break; - case 't': - pre_ss(emu, ST_NANOS6_TASK_BODY); - break; - case 'H': - pre_thread(emu); - break; - case 'D': - pre_deps(emu); - break; - case 'B': - pre_blocking(emu); - break; - case 'W': - pre_worker(emu); - break; - case 'M': - pre_memory(emu); - break; - case 'P': - /* Ignore progress events */ - break; - default: - edie(emu, "unknown Nanos6 event category\n"); - } - - check_affinity(emu); -} - -static void -end_lint(struct ovni_emu *emu) -{ - /* Ensure we run out of subsystem states */ - for (size_t i = 0; i < emu->total_nthreads; i++) { - struct ovni_ethread *th = emu->global_thread[i]; - struct ovni_chan *ch = &th->chan[CHAN_NANOS6_SUBSYSTEM]; - if (ch->n != 1) { - int top = ch->stack[ch->n - 1]; - - struct pcf_value_label *pv; - char *name = "(unknown)"; - for (pv = &nanos6_ss_values[0]; pv->label; pv++) { - if (pv->value == top) { - name = pv->label; - break; - } - } - - die("thread %d ended with %d extra stacked nanos6 subsystems, top=\"%s\"\n", - th->tid, ch->n - 1, name); - } - } -} - -void -hook_end_nanos6(struct ovni_emu *emu) -{ - /* Emit types for all channel types and processes */ - for (enum chan_type ct = 0; ct < CHAN_MAXTYPE; ct++) { - struct pcf_file *pcf = &emu->pcf[ct]; - int typeid = chan_to_prvtype[CHAN_NANOS6_TYPE]; - struct pcf_type *pcftype = pcf_find_type(pcf, typeid); - - for (size_t i = 0; i < emu->trace.nlooms; i++) { - struct ovni_loom *loom = &emu->trace.loom[i]; - for (size_t j = 0; j < loom->nprocs; j++) { - struct ovni_eproc *proc = &loom->proc[j]; - task_create_pcf_types(pcftype, proc->nanos6_task_info.types); - } - } - } - - /* When running in linter mode perform additional checks */ - if (emu->enable_linter) - end_lint(emu); -} diff --git a/src/emu/ovni.c b/src/emu/ovni.c deleted file mode 100644 index 5d53c44..0000000 --- a/src/emu/ovni.c +++ /dev/null @@ -1,620 +0,0 @@ -/* Copyright (c) 2021 Barcelona Supercomputing Center (BSC) - * SPDX-License-Identifier: GPL-3.0-or-later */ - -#include "chan.h" -#include "emu.h" -#include "ovni.h" -#include "prv.h" -#include "utlist.h" - -/* The emulator ovni module provides the execution model by tracking the thread - * state and which threads run in each CPU */ - -/* --------------------------- init ------------------------------- */ - -void -hook_init_ovni(struct ovni_emu *emu) -{ - int64_t *clock = &emu->delta_time; - FILE *prv_th = emu->prv_thread; - FILE *prv_cpu = emu->prv_cpu; - - /* Init the ovni channels in all threads */ - for (size_t i = 0; i < emu->total_nthreads; i++) { - struct ovni_ethread *th = emu->global_thread[i]; - int row = th->gindex + 1; - struct ovni_chan **uth = &emu->th_chan; - - chan_th_init(th, uth, CHAN_OVNI_TID, CHAN_TRACK_TH_RUNNING, th->tid, 0, 1, row, prv_th, clock); - chan_th_init(th, uth, CHAN_OVNI_PID, CHAN_TRACK_TH_RUNNING, th->proc->pid, 0, 1, row, prv_th, clock); - chan_th_init(th, uth, CHAN_OVNI_CPU, CHAN_TRACK_NONE, -1, 0, 1, row, prv_th, clock); - chan_th_init(th, uth, CHAN_OVNI_STATE, CHAN_TRACK_NONE, TH_ST_UNKNOWN, 1, 1, row, prv_th, clock); - chan_th_init(th, uth, CHAN_OVNI_FLUSH, CHAN_TRACK_NONE, ST_NULL, 1, 1, row, prv_th, clock); - } - - /* Init the ovni channels in all cpus */ - for (size_t i = 0; i < emu->total_ncpus; i++) { - struct ovni_cpu *cpu = emu->global_cpu[i]; - int row = cpu->gindex + 1; - struct ovni_chan **ucpu = &emu->cpu_chan; - - chan_cpu_init(cpu, ucpu, CHAN_OVNI_TID, CHAN_TRACK_TH_RUNNING, 0, 1, 1, row, prv_cpu, clock); - chan_cpu_init(cpu, ucpu, CHAN_OVNI_PID, CHAN_TRACK_TH_RUNNING, 0, 1, 1, row, prv_cpu, clock); - chan_cpu_init(cpu, ucpu, CHAN_OVNI_NRTHREADS, CHAN_TRACK_NONE, 0, 1, 1, row, prv_cpu, clock); - chan_cpu_init(cpu, ucpu, CHAN_OVNI_FLUSH, CHAN_TRACK_TH_RUNNING, 0, 0, 1, row, prv_cpu, clock); - } -} - -/* --------------------------- pre ------------------------------- */ - -/* Update the tracking channel if needed */ -static void -chan_tracking_update(struct ovni_chan *chan, struct ovni_ethread *th) -{ - int enabled = 0; - - if (th == NULL) - die("chan_tracking_update: thread is NULL"); - - switch (chan->track) { - case CHAN_TRACK_TH_RUNNING: - enabled = th->is_running; - break; - case CHAN_TRACK_TH_ACTIVE: - enabled = th->is_active; - break; - default: - dbg("ignoring thread %d chan %d with track=%d\n", - th->tid, chan->id, chan->track); - return; - } - - /* The channel is already in the proper state */ - if (chan_is_enabled(chan) == enabled) - return; - - dbg("thread %d changes state to %d: chan %d enabled=%d\n", - th->tid, th->state, chan->id, enabled); - - chan_enable(chan, enabled); -} - -/* Sets the state of the thread and updates the thread tracking channels */ -static void -thread_set_state(struct ovni_ethread *th, enum ethread_state state) -{ - /* The state must be updated when a cpu is set */ - if (th->cpu == NULL) - die("thread_set_state: thread %d doesn't have a CPU\n", - th->tid); - - dbg("thread_set_state: setting thread %d state %d\n", - th->tid, state); - - th->state = state; - - th->is_running = (state == TH_ST_RUNNING) ? 1 : 0; - - th->is_active = (state == TH_ST_RUNNING - || state == TH_ST_COOLING - || state == TH_ST_WARMING) - ? 1 - : 0; - - chan_set(&th->chan[CHAN_OVNI_STATE], th->state); - - /* Enable or disable the thread channels that track the thread state */ - for (int i = 0; i < CHAN_MAX; i++) - chan_tracking_update(&th->chan[i], th); - - dbg("thread_set_state: done\n"); -} - -static void -cpu_update_th_stats(struct ovni_cpu *cpu) -{ - struct ovni_ethread *th = NULL; - struct ovni_ethread *th_running = NULL; - struct ovni_ethread *th_active = NULL; - int active = 0, running = 0; - - DL_FOREACH(cpu->thread, th) - { - if (th->state == TH_ST_RUNNING) { - th_running = th; - running++; - th_active = th; - active++; - } else if (th->state == TH_ST_COOLING || th->state == TH_ST_WARMING) { - th_active = th; - active++; - } - } - - cpu->nrunning_threads = running; - cpu->nactive_threads = active; - cpu->th_running = th_running; - cpu->th_active = th_active; -} - -static void -update_cpu(struct ovni_cpu *cpu) -{ - dbg("updating cpu %s\n", cpu->name); - - /* Update the running and active threads first */ - cpu_update_th_stats(cpu); - - /* From the CPU channels we only need to manually update the number of - * threads running in the CPU */ - if (chan_get_st(&cpu->chan[CHAN_OVNI_NRTHREADS]) != (int) cpu->nrunning_threads) - chan_set(&cpu->chan[CHAN_OVNI_NRTHREADS], (int) cpu->nrunning_threads); - - /* Update all tracking channels */ - for (int i = 0; i < CHAN_MAX; i++) - emu_cpu_update_chan(cpu, &cpu->chan[i]); - - dbg("updating cpu %s complete!\n", cpu->name); -} - -struct ovni_cpu * -emu_get_cpu(struct ovni_loom *loom, int cpuid) -{ - if (cpuid >= (int) loom->ncpus) - die("emu_get_cpu: CPU index out of bounds\n"); - - if (cpuid < 0) - return &loom->vcpu; - - return &loom->cpu[cpuid]; -} - -static struct ovni_ethread * -emu_cpu_find_thread(struct ovni_cpu *cpu, struct ovni_ethread *thread) -{ - struct ovni_ethread *p = NULL; - - DL_FOREACH(cpu->thread, p) - { - if (p == thread) - return p; - } - - return NULL; -} - -/* Add the given thread to the list of threads assigned to the CPU */ -static void -cpu_add_thread(struct ovni_cpu *cpu, struct ovni_ethread *thread) -{ - /* Found, abort */ - if (emu_cpu_find_thread(cpu, thread) != NULL) { - err("The thread %d is already assigned to %s\n", - thread->tid, cpu->name); - abort(); - } - - DL_APPEND(cpu->thread, thread); - cpu->nthreads++; - - update_cpu(cpu); -} - -static void -cpu_remove_thread(struct ovni_cpu *cpu, struct ovni_ethread *thread) -{ - struct ovni_ethread *p = emu_cpu_find_thread(cpu, thread); - - /* Not found, abort */ - if (p == NULL) { - err("cannot remove missing thread %d from cpu %s\n", - thread->tid, cpu->name); - abort(); - } - - DL_DELETE(cpu->thread, thread); - cpu->nthreads--; - - update_cpu(cpu); -} - -static void -cpu_migrate_thread(struct ovni_cpu *cpu, - struct ovni_ethread *thread, - struct ovni_cpu *newcpu) -{ - cpu_remove_thread(cpu, thread); - cpu_add_thread(newcpu, thread); -} - -/* Sets the thread assigned CPU to the given one. - * Precondition: the thread CPU must be null */ -static void -thread_set_cpu(struct ovni_ethread *th, struct ovni_cpu *cpu) -{ - if (th->cpu != NULL) - die("thread_set_cpu: thread %d already has a CPU\n", - th->tid); - - dbg("thread_set_cpu: setting thread %d cpu to %s\n", - th->tid, cpu->name); - th->cpu = cpu; - - chan_enable(&th->chan[CHAN_OVNI_CPU], 1); - chan_set(&th->chan[CHAN_OVNI_CPU], cpu->gindex + 1); -} - -/* Unsets the thread assigned CPU. - * Precondition: the thread CPU must be not null */ -static void -thread_unset_cpu(struct ovni_ethread *th) -{ - if (th->cpu == NULL) - die("thread_unset_cpu: thread %d doesn't have a CPU\n", - th->tid); - - th->cpu = NULL; - - chan_enable(&th->chan[CHAN_OVNI_CPU], 0); -} - -/* Migrates the thread assigned CPU to the given one. - * Precondition: the thread CPU must be not null */ -static void -thread_migrate_cpu(struct ovni_ethread *th, struct ovni_cpu *cpu) -{ - if (th->cpu == NULL) - die("thread_migrate_cpu: thread %d doesn't have a CPU\n", - th->tid); - th->cpu = cpu; - - chan_set(&th->chan[CHAN_OVNI_CPU], cpu->gindex + 1); -} - -static void -pre_thread_execute(struct ovni_emu *emu, struct ovni_ethread *th) -{ - /* The thread cannot be already running */ - if (th->state == TH_ST_RUNNING) - edie(emu, "pre_thread_execute: thread %d already running\n", - th->tid); - - int cpuid = emu->cur_ev->payload.i32[0]; - - struct ovni_cpu *cpu = emu_get_cpu(emu->cur_loom, cpuid); - dbg("pre_thread_execute: thread %d runs in CPU %s\n", th->tid, cpu->name); - - /* First set the CPU in the thread */ - thread_set_cpu(th, cpu); - - /* Then set the thread to running state */ - thread_set_state(th, TH_ST_RUNNING); - - /* And then add the thread to the CPU, so tracking channels see the - * updated thread state */ - cpu_add_thread(cpu, th); -} - -static void -pre_thread_end(struct ovni_ethread *th) -{ - if (th->state != TH_ST_RUNNING && th->state != TH_ST_COOLING) - die("pre_thread_end: thread %d not running or cooling\n", - th->tid); - - if (th->cpu == NULL) - die("pre_thread_end: thread %d doesn't have a CPU\n", - th->tid); - - /* First update the thread state */ - thread_set_state(th, TH_ST_DEAD); - - /* Then remove it from the cpu, so channels are properly updated */ - cpu_remove_thread(th->cpu, th); - - thread_unset_cpu(th); -} - -static void -pre_thread_pause(struct ovni_ethread *th) -{ - if (th->state != TH_ST_RUNNING && th->state != TH_ST_COOLING) - die("pre_thread_pause: thread %d not running or cooling\n", - th->tid); - - if (th->cpu == NULL) - die("pre_thread_pause: thread %d doesn't have a CPU\n", - th->tid); - - thread_set_state(th, TH_ST_PAUSED); - update_cpu(th->cpu); -} - -static void -pre_thread_resume(struct ovni_ethread *th) -{ - if (th->state != TH_ST_PAUSED && th->state != TH_ST_WARMING) - die("pre_thread_resume: thread %d not paused or warming\n", - th->tid); - - if (th->cpu == NULL) - die("pre_thread_resume: thread %d doesn't have a CPU\n", - th->tid); - - thread_set_state(th, TH_ST_RUNNING); - update_cpu(th->cpu); -} - -static void -pre_thread_cool(struct ovni_ethread *th) -{ - if (th->state != TH_ST_RUNNING) - die("pre_thread_cool: thread %d not running\n", - th->tid); - - if (th->cpu == NULL) - die("pre_thread_cool: thread %d doesn't have a CPU\n", - th->tid); - - thread_set_state(th, TH_ST_COOLING); - update_cpu(th->cpu); -} - -static void -pre_thread_warm(struct ovni_ethread *th) -{ - if (th->state != TH_ST_PAUSED) - die("pre_thread_warm: thread %d not paused\n", - th->tid); - - if (th->cpu == NULL) - die("pre_thread_warm: thread %d doesn't have a CPU\n", - th->tid); - - thread_set_state(th, TH_ST_WARMING); - update_cpu(th->cpu); -} - -static void -pre_thread(struct ovni_emu *emu) -{ - struct ovni_ethread *th = emu->cur_thread; - struct ovni_ev *ev = emu->cur_ev; - - switch (ev->header.value) { - case 'C': /* create */ - dbg("thread %d creates a new thread at cpu=%d with args=%x %x\n", - th->tid, - ev->payload.u32[0], - ev->payload.u32[1], - ev->payload.u32[2]); - - break; - case 'x': - pre_thread_execute(emu, th); - break; - case 'e': - pre_thread_end(th); - break; - case 'p': - pre_thread_pause(th); - break; - case 'r': - pre_thread_resume(th); - break; - case 'c': - pre_thread_cool(th); - break; - case 'w': - pre_thread_warm(th); - break; - default: - err("unknown thread event value %c\n", - ev->header.value); - exit(EXIT_FAILURE); - } -} - -static void -pre_affinity_set(struct ovni_emu *emu) -{ - struct ovni_ethread *th = emu->cur_thread; - int cpuid = emu->cur_ev->payload.i32[0]; - - if (th->cpu == NULL) - edie(emu, "pre_affinity_set: thread %d doesn't have a CPU\n", - th->tid); - - if (!th->is_active) - edie(emu, "pre_affinity_set: thread %d is not active\n", - th->tid); - - /* Migrate current cpu to the one at cpuid */ - struct ovni_cpu *newcpu = emu_get_cpu(emu->cur_loom, cpuid); - - /* The CPU is already properly set, return */ - if (th->cpu == newcpu) - return; - - cpu_migrate_thread(th->cpu, th, newcpu); - thread_migrate_cpu(th, newcpu); - - // dbg("cpu %d now runs %d\n", cpuid, th->tid); -} - -static void -pre_affinity_remote(struct ovni_emu *emu) -{ - int32_t cpuid = emu->cur_ev->payload.i32[0]; - int32_t tid = emu->cur_ev->payload.i32[1]; - - struct ovni_ethread *remote_th = emu_get_thread(emu->cur_proc, tid); - - if (remote_th == NULL) { - /* Search the thread in other processes of the loom if - * not found in the current one */ - struct ovni_loom *loom = emu->cur_loom; - - for (size_t i = 0; i < loom->nprocs; i++) { - struct ovni_eproc *proc = &loom->proc[i]; - - /* Skip the current process */ - if (proc == emu->cur_proc) - continue; - - remote_th = emu_get_thread(proc, tid); - - if (remote_th) - break; - } - - if (remote_th == NULL) { - err("thread tid %d not found: cannot set affinity remotely\n", - tid); - abort(); - } - } - - /* The remote_th cannot be in states dead or unknown */ - if (remote_th->state == TH_ST_DEAD) - edie(emu, "pre_affinity_remote: remote thread %d in state DEAD\n", - remote_th->tid); - - if (remote_th->state == TH_ST_UNKNOWN) - edie(emu, "pre_affinity_remote: remote thread %d in state UNKNOWN\n", - remote_th->tid); - - /* It must have an assigned CPU */ - if (remote_th->cpu == NULL) - edie(emu, "pre_affinity_remote: remote thread %d has no CPU\n", - remote_th->tid); - - /* Migrate current cpu to the one at cpuid */ - struct ovni_cpu *newcpu = emu_get_cpu(emu->cur_loom, cpuid); - - cpu_migrate_thread(remote_th->cpu, remote_th, newcpu); - thread_migrate_cpu(remote_th, newcpu); - - // dbg("remote_th %d switches to cpu %d by remote petition\n", tid, - // cpuid); -} - -static void -pre_affinity(struct ovni_emu *emu) -{ - // emu_emit(emu); - switch (emu->cur_ev->header.value) { - case 's': - pre_affinity_set(emu); - break; - case 'r': - pre_affinity_remote(emu); - break; - default: - dbg("unknown affinity event value %c\n", - emu->cur_ev->header.value); - break; - } -} - -static int -compare_int64(const void *a, const void *b) -{ - int64_t aa = *(const int64_t *) a; - int64_t bb = *(const int64_t *) b; - - if (aa < bb) - return -1; - else if (aa > bb) - return +1; - else - return 0; -} - -static void -pre_burst(struct ovni_emu *emu) -{ - int64_t dt = 0; - - UNUSED(dt); - - struct ovni_ethread *th = emu->cur_thread; - - if (th->nbursts >= MAX_BURSTS) { - err("too many bursts: ignored\n"); - return; - } - - th->burst_time[th->nbursts++] = emu->delta_time; - if (th->nbursts == MAX_BURSTS) { - int n = MAX_BURSTS - 1; - int64_t deltas[MAX_BURSTS - 1]; - for (int i = 0; i < n; i++) { - deltas[i] = th->burst_time[i + 1] - th->burst_time[i]; - } - - qsort(deltas, n, sizeof(int64_t), compare_int64); - - double avg = 0.0; - double maxdelta = 0; - for (int i = 0; i < n; i++) { - if (deltas[i] > maxdelta) - maxdelta = deltas[i]; - avg += deltas[i]; - } - - avg /= (double) n; - double median = deltas[n / 2]; - - err("%s burst stats: median %.0f ns, avg %.1f ns, max %.0f ns\n", - emu->cur_loom->dname, median, avg, maxdelta); - - th->nbursts = 0; - } -} - -static void -pre_flush(struct ovni_emu *emu) -{ - struct ovni_ethread *th = emu->cur_thread; - struct ovni_chan *chan_th = &th->chan[CHAN_OVNI_FLUSH]; - - switch (emu->cur_ev->header.value) { - case '[': - chan_push(chan_th, ST_OVNI_FLUSHING); - break; - case ']': - chan_pop(chan_th, ST_OVNI_FLUSHING); - break; - default: - err("unexpected value '%c' (expecting '[' or ']')\n", - emu->cur_ev->header.value); - abort(); - } -} - -void -hook_pre_ovni(struct ovni_emu *emu) -{ - if (emu->cur_ev->header.model != 'O') - return; - - switch (emu->cur_ev->header.category) { - case 'H': - pre_thread(emu); - break; - case 'A': - pre_affinity(emu); - break; - case 'B': - pre_burst(emu); - break; - case 'F': - pre_flush(emu); - break; - default: - dbg("unknown ovni event category %c\n", - emu->cur_ev->header.category); - break; - } -}