include/drake/platform.h

Go to the documentation of this file.

/*
 Copyright 2015 Nicolas Melot

 This file is part of Drake.

 Drake is free software: you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation, either version 3 of the License, or
 (at your option) any later version.

 Drake 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 Drake. If not, see <http://www.gnu.org/licenses/>.

*/


#include <stddef.h>

#include <drake/task.h>
#include <drake/schedule.h>

#ifndef DRAKE_PLATFORM_H
#define DRAKE_PLATFORM_H

#define drake_platform_stream_create(stream, application) \
void* (drake_function(application))(size_t id, task_status_t state); \
void (drake_schedule_init(application))(drake_schedule_t*); \
void (drake_schedule_destroy(application))(drake_schedule_t*); \
int (drake_task_number(application))(); \
char* (drake_task_name(application))(size_t); \
drake_platform_stream_create_explicit(stream, PELIB_##CONCAT_2(drake_schedule_init_, application), PELIB_##CONCAT_2(drake_schedule_destroy_, application), PELIB_CONCAT_2(drake_function_, application))

typedef struct drake_time *drake_time_t;
typedef struct drake_platform *drake_platform_t;
typedef struct drake_power *drake_power_t;
size_t drake_platform_shared_size();
size_t drake_platform_shared_align();
size_t drake_platform_private_size();
drake_platform_t drake_platform_init(void*);
int drake_platform_destroy(drake_platform_t);
volatile void* drake_platform_shared_malloc(size_t size, size_t core);
volatile void* drake_platform_shared_malloc_mailbox(size_t size, size_t core);
void drake_platform_shared_free(volatile void* addr, size_t core);
void* drake_platform_store_malloc(size_t size);
void drake_platform_store_free(void*);
void* drake_platform_private_malloc(size_t size);
void drake_platform_private_free(void*);
void* drake_remote_addr(void* addr, size_t core);
int drake_platform_pull(volatile void* addr);
int drake_platform_commit(volatile void* addr);
size_t drake_platform_core_id();
size_t drake_platform_core_size();
size_t drake_platform_core_max();
void drake_platform_barrier(void*);
void drake_platform_exclusive_begin();
void drake_platform_exclusive_end();
int drake_platform_set_frequency(int frequency /* in KHz */);
int drake_platform_set_frequency_autoscale(int frequency);
int drake_platform_set_voltage(float voltage);
int drake_platform_set_voltage_frequency(drake_platform_t, size_t frequency);
size_t drake_platform_get_frequency(drake_platform_t);
float drake_platform_get_voltage();
int drake_platform_time_get(drake_time_t);
int drake_platform_time_subtract(drake_time_t res, drake_time_t t1, drake_time_t t2);
int drake_platform_time_add(drake_time_t res, drake_time_t t1, drake_time_t t2);
int drake_platform_time_greater(drake_time_t t1, drake_time_t t2);
int drake_platform_time_equals(drake_time_t t1, drake_time_t t2);
int drake_platform_time_init(drake_time_t t, double ms);
FILE* drake_platform_time_printf(FILE* stream, drake_time_t);
void drake_platform_time_destroy(drake_time_t time);
drake_time_t drake_platform_time_alloc();
int drake_platform_sleep(drake_time_t period);
enum drake_power_monitor {DRAKE_POWER_CHIP, DRAKE_POWER_MEMORY_CONTROLLER, DRAKE_POWER_CORE};
drake_power_t drake_platform_power_init(drake_platform_t pt, size_t samples, int measurement);
void drake_platform_power_begin(drake_power_t pwr);
size_t drake_platform_power_end(drake_power_t);
FILE* drake_platform_power_printf(FILE* stream, drake_power_t, char* separator);
FILE* drake_platform_power_printf_line(FILE* stream, drake_power_t, size_t line, char* separator);
FILE* drake_platform_power_printf_cumulate(FILE* stream, drake_power_t, int metrics, char *separator);
FILE* drake_platform_power_printf_line_cumulate(FILE* stream, drake_power_t, size_t line, int metrics, char *separator);
void drake_platform_power_destroy(drake_power_t);

int drake_platform_stream_create_explicit(drake_platform_t stream, void (*schedule_init)(drake_schedule_t*), void (*schedule_destroy)(drake_schedule_t*), void* (*task_function)(size_t id, task_status_t status));
int drake_platform_stream_init(drake_platform_t stream, void* arg);
int drake_platform_stream_run(drake_platform_t);
int drake_platform_stream_destroy(drake_platform_t);

void drake_platform_core_disable(drake_platform_t pt, size_t core);
void drake_platform_core_enable(drake_platform_t pt, size_t core);
void drake_platform_sleep_disable(drake_platform_t pt, size_t core);
void drake_platform_sleep_enable(drake_platform_t pt, size_t core);

#endif // DRAKE_PLATFORM_H