chip_power_monitor.c

Go to the documentation of this file.

/*
 * Copyright (c) 2017 The University of Manchester
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     https://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
 
 
#include <spin1_api.h>
#include <spinn_extra.h>
#include <simulation.h>
#include <spinnaker.h>
#include <recording.h>
#include <debug.h>
#include <data_specification.h>
 
#define NUM_RANDOM_BITS 12
 
enum {
    SYSTEM = 0,  
    CONFIG = 1,  
    RECORDING = 2
};
 
struct sample_params {
    uint32_t count_limit;
    uint32_t frequency;
};
 
struct recording {
    uint32_t time;
    uint32_t core_counters[NUM_CPUS];
};
 
static const uint32_t RECORDING_CHANNEL_ID = 0;
 
enum {
    TIMER = 0, 
    SDP = 1,   
    DMA = 2    
};
 
static uint32_t simulation_ticks = 0;
static uint32_t infinite_run = 0;
static uint32_t time;
static uint32_t timer = 0;
 
static struct recording recording;
static uint32_t sample_count;
static uint32_t sample_count_limit;
static uint32_t recording_flags;
static uint32_t sample_frequency;
 
static inline uint32_t get_sample(void) {
    return system_control->cpu_sleep.status;
}
 
static inline uint32_t get_random_busy(void) {
    return (spin1_rand() >> 4) & ((1 << NUM_RANDOM_BITS) - 1);
}
 
static inline void record_aggregate_sample(void) {
    recording.time = time;
    recording_record(
            RECORDING_CHANNEL_ID, &recording, sizeof(recording));
}
 
static inline void reset_core_counters(void) {
    for (uint32_t i = 0 ; i < NUM_CPUS ; i++) {
        recording.core_counters[i] = 0;
    }
    sample_count = 0;
}
 
static inline void rescale_sim_ticks(void) {
    simulation_ticks = (simulation_ticks * timer) / sample_frequency;
    log_info("resume total_sim_ticks = %d timer %d sample_frequency %d time %d",
            simulation_ticks, timer, sample_frequency, time);
}
 
static void resume_callback(void) {
    // change simulation ticks to be a number related to sampling frequency
    if (time == UINT32_MAX) {
        log_debug("resume_skipped as time still zero");
    } else {
        rescale_sim_ticks();
        // Also rescale time appropriately
        reset_core_counters();
        time++;
        time = (time * timer) / sample_frequency;
        // Subtract 1 again now so that this starts at the "correct" value on the next tick
        time--;
        log_info("resume total_sim_ticks = %d timer %d sample_frequency %d time %d",
                simulation_ticks, timer, sample_frequency, time);
        recording_reset();
        log_debug("resume_callback");
    }
}
 
static inline void count_core_states(void) {
    uint32_t sample = get_sample();
 
    for (uint32_t i = 0, j = 1 ; i < NUM_CPUS ; i++, j <<= 1) {
        if (!(sample & j)) {
            recording.core_counters[i]++;
        }
    }
}
 
static void sample_in_slot(UNUSED uint unused0, UNUSED uint unused1) {
    time++;
 
    // handle the situation when the first time update is sent
    if (time == 0) {
        rescale_sim_ticks();
    }
    // check if the simulation has run to completion
    if (simulation_is_finished()) {
        simulation_handle_pause_resume(resume_callback);
 
        if (sample_count > 0) {
            record_aggregate_sample();
        }
 
        recording_finalise();
 
        // Invert the time calculation so that any time read is correct
        time = (time * sample_frequency) / timer;
        simulation_ready_to_read();
 
        return;
    }
 
    uint32_t count = ++sample_count;
    uint32_t offset = get_random_busy();
    while (offset --> 0) {
        // Do nothing
    }
 
    count_core_states();
    if (count >= sample_count_limit) {
        record_aggregate_sample();
        reset_core_counters();
    }
}
 
static bool read_parameters(struct sample_params *sample_params) {
    sample_count_limit = sample_params->count_limit;
    sample_frequency = sample_params->frequency;
    log_info("count limit %d", sample_count_limit);
    log_info("sample frequency %d", sample_frequency);
    return true;
}
 
static bool initialize(void) {
    data_specification_metadata_t *ds_regions =
            data_specification_get_data_address();
    if (!data_specification_read_header(ds_regions)) {
        return false;
    }
    if (!simulation_initialise(
            data_specification_get_region(SYSTEM, ds_regions),
            APPLICATION_NAME_HASH, &timer, &simulation_ticks,
            &infinite_run, &time, SDP, DMA)) {
        return false;
    }
    if (!read_parameters(
            data_specification_get_region(CONFIG, ds_regions))) {
        return false;
    }
 
    void *recording_region =
            data_specification_get_region(RECORDING, ds_regions);
    return recording_initialize(&recording_region, &recording_flags);
}
 
void c_main(void) {
    if (!initialize()) {
        log_error("failed to initialise");
        rt_error(RTE_SWERR);
    }
 
    reset_core_counters();
 
    spin1_set_timer_tick(sample_frequency);
    spin1_callback_on(TIMER_TICK, sample_in_slot, TIMER);
    time = UINT32_MAX;
    simulation_run();
}