command_sender_multicast_source.c

Go to the documentation of this file.

/*
 * Copyright (c) 2015 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 <common-typedefs.h>
#include <data_specification.h>
#include <debug.h>
#include <simulation.h>
#include <stdbool.h>
 
typedef struct command {
    uint32_t key;
    bool has_payload;
    uint32_t payload;
    uint32_t repeats;
    uint32_t delay;
} command;
 
typedef struct timed_command {
    uint32_t time;   
    command command; 
} timed_command;
 
typedef struct command_list {
    uint32_t size;      
    command commands[]; 
} command_list;
 
typedef struct timed_command_list {
    uint32_t size;            
    timed_command commands[]; 
} timed_command_list;
 
// Globals
static uint32_t time;
static uint32_t simulation_ticks;
static uint32_t infinite_run;
static timed_command *timed_commands;
static command *start_resume_commands;
static command *pause_stop_commands;
static uint32_t n_timed_commands;
static uint32_t n_start_resume_commands;
static uint32_t n_pause_stop_commands;
static uint32_t next_timed_command;
static bool resume = true;
static uint32_t n_commands_sent;
 
typedef enum callback_priorities {
    SDP = 0,   
    DMA = 1,   
    TIMER = 2  
} callback_priorities;
 
typedef enum region_identifiers {
    SYSTEM_REGION = 0,
    COMMANDS_WITH_ARBITRARY_TIMES,
    COMMANDS_AT_START_RESUME,
    COMMANDS_AT_STOP_PAUSE,
    PROVENANCE_REGION
} region_identifiers;
 
typedef struct cs_provenance_t {
    uint32_t n_commands_sent;
} cs_provenance_t;
 
enum {
    FIRST_TIME = 0
};
 
static void transmit_command(command *command_to_send) {
    // check for repeats
    if (command_to_send->repeats != 0) {
        for (uint32_t repeat_count = 0;
                repeat_count <= command_to_send->repeats;
                repeat_count++) {
            if (command_to_send->has_payload) {
                log_debug("Sending %08x, %08x at time %u with %u repeats and "
                        "%u delay",
                        command_to_send->key, command_to_send->payload, time,
                        command_to_send->repeats, command_to_send->delay);
                spin1_send_mc_packet(
                        command_to_send->key, command_to_send->payload,
                        WITH_PAYLOAD);
            } else {
                log_debug("Sending %08x at time %u with %u repeats and "
                        "%u delay",
                        command_to_send->key, time, command_to_send->repeats,
                        command_to_send->delay);
                spin1_send_mc_packet(command_to_send->key, 0, NO_PAYLOAD);
            }
            n_commands_sent++;
 
            // if the delay is 0, don't call delay
            if (command_to_send->delay > 0) {
                spin1_delay_us(command_to_send->delay);
            }
        }
    } else {
        if (command_to_send->has_payload) {
            log_debug("Sending %08x, %08x at time %u",
                    command_to_send->key, command_to_send->payload, time);
 
            //if no repeats, then just send the message
            spin1_send_mc_packet(
                    command_to_send->key, command_to_send->payload,
                    WITH_PAYLOAD);
        } else {
            log_debug("Sending %08x at time %u", command_to_send->key, time);
            spin1_send_mc_packet(command_to_send->key, 0, NO_PAYLOAD);
        }
        n_commands_sent++;
    }
}
 
static void run_stop_pause_commands(void) {
    log_info("Transmit pause/stop commands");
    for (uint32_t i = 0; i < n_pause_stop_commands; i++) {
        transmit_command(&pause_stop_commands[i]);
    }
}
 
static void run_start_resume_commands(void) {
    log_info("Transmit start/resume commands");
    for (uint32_t i = 0; i < n_start_resume_commands; i++) {
        transmit_command(&start_resume_commands[i]);
    }
}
 
static bool read_scheduled_parameters(timed_command_list *sdram_timed_commands) {
    n_timed_commands = sdram_timed_commands->size;
    log_info("%d timed commands", n_timed_commands);
 
    // if no data, do not read it in
    if (n_timed_commands == 0) {
        return true;
    }
 
    // Allocate the space for the scheduled_commands
    timed_commands = spin1_malloc(n_timed_commands * sizeof(timed_command));
 
    if (timed_commands == NULL) {
        log_error("Could not allocate the scheduled commands");
        return false;
    }
 
    spin1_memcpy(timed_commands, sdram_timed_commands->commands,
            n_timed_commands * sizeof(timed_command));
 
    log_info("Schedule commands starts at time %u",
            timed_commands[FIRST_TIME].time);
    return true;
}
 
static bool read_start_resume_commands(command_list *sdram_commands) {
    n_start_resume_commands = sdram_commands->size;
    log_info("%u start/resume commands", n_start_resume_commands);
 
    if (n_start_resume_commands == 0) {
        return true;
    }
 
    // Allocate the space for the start resume
    start_resume_commands =
            spin1_malloc(n_start_resume_commands * sizeof(command));
    if (start_resume_commands == NULL) {
        log_error("Could not allocate the start/resume commands");
        return false;
    }
 
    spin1_memcpy(start_resume_commands, sdram_commands->commands,
            n_start_resume_commands * sizeof(command));
    return true;
}
 
static bool read_pause_stop_commands(command_list *sdram_commands) {
    n_pause_stop_commands = sdram_commands->size;
    log_info("%u pause/stop commands", n_pause_stop_commands);
 
    if (n_pause_stop_commands == 0) {
        return true;
    }
 
    // Allocate the space for the start resume
    pause_stop_commands =
            spin1_malloc(n_pause_stop_commands * sizeof(command));
    if (pause_stop_commands == NULL) {
        log_error("Could not allocate the pause/stop commands");
        return false;
    }
 
    spin1_memcpy(pause_stop_commands, sdram_commands->commands,
            n_pause_stop_commands * sizeof(command));
    return true;
}
 
// Callbacks
static void timer_callback(UNUSED uint unused0, UNUSED uint unused1) {
    time++;
 
    if (resume) {
        log_info("running first start resume commands");
        run_start_resume_commands();
        resume = false;
    }
 
    if (simulation_is_finished()) {
        run_stop_pause_commands();
 
        simulation_handle_pause_resume(NULL);
 
        log_info("in pause resume mode");
        resume = true;
 
        // Subtract 1 from the time so this tick gets done again on the next
        // run
        time--;
 
        simulation_ready_to_read();
        return;
    }
 
    while ((next_timed_command < n_timed_commands) &&
            (timed_commands[next_timed_command].time == time)) {
        transmit_command(&timed_commands[next_timed_command].command);
        ++next_timed_command;
    }
}
 
static void write_provenance(address_t address) {
    cs_provenance_t *sdram_prov = (void *) address;
    sdram_prov->n_commands_sent = n_commands_sent;
}
 
static bool initialize(uint32_t *timer_period) {
    // Get the address this core's DTCM data starts at from SRAM
    data_specification_metadata_t *ds_regions =
            data_specification_get_data_address();
 
    // Read the header
    if (!data_specification_read_header(ds_regions)) {
        return false;
    }
 
    // Get the timing details and set up the simulation interface
    if (!simulation_initialise(
            data_specification_get_region(SYSTEM_REGION, ds_regions),
            APPLICATION_NAME_HASH, timer_period, &simulation_ticks,
            &infinite_run, &time, SDP, DMA)) {
        return false;
    }
    simulation_set_provenance_function(
            write_provenance,
            data_specification_get_region(PROVENANCE_REGION, ds_regions));
    simulation_set_exit_function(run_stop_pause_commands);
 
    // Read the parameters
    bool success;
    success = read_scheduled_parameters(data_specification_get_region(
            COMMANDS_WITH_ARBITRARY_TIMES, ds_regions));
    success &= read_start_resume_commands(data_specification_get_region(
            COMMANDS_AT_START_RESUME, ds_regions));
    success &= read_pause_stop_commands(data_specification_get_region(
            COMMANDS_AT_STOP_PAUSE, ds_regions));
    return success;
}
 
void c_main(void) {
    // Configure system
    uint32_t timer_period = 0;
    if (!initialize(&timer_period)) {
        log_error("Error in initialisation - exiting!");
        rt_error(RTE_SWERR);
    }
 
    // Set timer_callback
    spin1_set_timer_tick(timer_period);
 
    // Register callbacks
    spin1_callback_on(TIMER_TICK, timer_callback, TIMER);
 
    // Start the time at "-1" so that the first tick will be 0
    time = UINT32_MAX;
    simulation_run();
}