#endif
fna_operations_t *fna_operations[FNA_MAX_NETWORKS] = {
-#ifdef RTEP_FNA_ENABLED
- &rtep_fna_operations,
+#ifdef FRESCAN_FNA_ENABLED
+ &frescan_fna_operations,
#else
NULL,
#endif
-#ifdef FRESCAN_FNA_ENABLED
- &frescan_fna_operations,
+#ifdef RTEP_FNA_ENABLED
+ &rtep_fna_operations,
#else
- NULL,
+ NULL,
#endif
#ifdef UNIX_FNA_ENABLED
&unix_fna_operations,
*
*/
+#include "frsh.h"
#include "frescan_bwres.h"
#include "frescan_bwres_requests.h"
#include "frescan_bwres_robjs.h"
int frescan_bwres_init(frescan_network_t net)
{
int ret;
- frescan_server_params_t server_params; // TODO: improve this...
- frescan_bwres_sa_init_params_t init_params; // TODO: improve this...
+ frescan_node_t node;
+ frescan_ss_t neg_msg_ss_id;
+ frescan_server_params_t server_params;
+ frescan_bwres_sa_init_params_t init_params;
+ frsh_contract_t neg_msgs_contract;
+ frsh_rel_time_t neg_msgs_budget;
+ frsh_rel_time_t neg_msgs_period;
- init_params.max_prio = 30;
- init_params.min_prio = 1;
+ init_params.min_prio = FRESCAN_BWRES_SS_MIN_PRIO;
+ init_params.max_prio = FRESCAN_BWRES_SS_MAX_PRIO;
if (frescan_data[net].local_node == FRESCAN_BWRES_MASTER_NODE) {
ret = frescan_bwres_sa_init(&frescan_data[net].scenario,
&init_params);
if (ret != 0) return ret;
+
+ // Add contracts for the negotiation messages
+ ret = frsh_contract_init(&neg_msgs_contract);
+ if (ret != 0) return ret;
+
+ neg_msgs_budget = frsh_usec_to_rel_time(
+ (long)FRESCAN_FRAME_TX_TIME_US *
+ FRESCAN_BWRES_NEG_MSG_BUDGET);
+ neg_msgs_period = frsh_usec_to_rel_time(
+ (long)FRESCAN_BWRES_NEG_MSG_PERIOD);
+ ret = frsh_contract_set_preemption_level
+ (&neg_msgs_contract,
+ FRESCAN_BWRES_NEG_MSG_PRIO);
+ if (ret != 0) return ret;
+
+ ret = frsh_contract_set_basic_params(&neg_msgs_contract,
+ &neg_msgs_budget,
+ &neg_msgs_period,
+ FRSH_WT_INDETERMINATE,
+ FRSH_CT_REGULAR);
+ if (ret != 0) return ret;
+
+ for(node=0; node<FRESCAN_MX_NODES; node++) {
+ ret = freelist_init(&frescan_data[net].scenario.
+ ss_id_freelist[node],
+ FRESCAN_MX_IDS);
+ if (ret != 0) return ret;
+
+ ret = freelist_alloc(&frescan_data[net].scenario.
+ ss_id_freelist[node]);
+ if (ret < 0) return -1;
+
+ neg_msg_ss_id = (frescan_ss_t)ret;
+
+ ret = frescan_bwres_sa_add_contract
+ (&frescan_data[net].scenario,
+ neg_msg_ss_id,
+ node,
+ &neg_msgs_contract);
+ if (ret != 0) return ret;
+ }
}
- server_params.budget = 5;
- server_params.period.tv_sec = 1;
- server_params.period.tv_nsec = 0;
- server_params.prio = FRESCAN_BWRES_NEG_MESSAGES_PRIO;
+ server_params.budget = FRESCAN_BWRES_NEG_MSG_BUDGET;
+ server_params.period = frsh_rel_time_to_timespec(
+ frsh_usec_to_rel_time(
+ (long)FRESCAN_BWRES_NEG_MSG_PERIOD));
+ server_params.prio = FRESCAN_BWRES_NEG_MSG_PRIO;
ret = frescan_servers_create(net, &server_params,
&frescan_data[net].neg_messages_ss_id);
if (ret != 0) return ret;
- // TODO: we have to add this negotiation contracts to the sa table
-
ret = frescan_bwres_robjs_init(FRESCAN_BWRES_ROBJS_MX_CEILING);
if (ret != 0) return ret;
req_data->type = FRESCAN_BWRES_REQ_GN;
req_data->req = req;
req_data->request_node = frescan_data[net].local_node;
- req_data->contracts_to_neg = (frsh_contracts_group_t *)
- contracts_to_neg;
- req_data->contracts_to_reneg = (frsh_contracts_group_t *)
- contracts_to_reneg;
- req_data->ss_to_reneg = (frescan_ss_group_t *)ss_to_reneg;
- req_data->ss_to_cancel = (frescan_ss_group_t *)ss_to_cancel;
- req_data->ss_new = ss_new;
+
+ if (contracts_to_neg == NULL) {
+ req_data->contracts_to_neg = &req_data->contracts_to_neg_data;
+ req_data->contracts_to_neg->size = 0;
+ } else {
+ req_data->contracts_to_neg =
+ (frsh_contracts_group_t *)contracts_to_neg;
+ }
+
+ if (contracts_to_reneg == NULL) {
+ req_data->contracts_to_reneg = &req_data->
+ contracts_to_reneg_data;
+ req_data->contracts_to_reneg->size = 0;
+ } else {
+ req_data->contracts_to_reneg = (frsh_contracts_group_t *)
+ contracts_to_reneg;
+ }
+
+ if (ss_to_reneg == NULL) {
+ req_data->ss_to_reneg = &req_data->ss_to_reneg_data;
+ req_data->ss_to_reneg->size = 0;
+ } else {
+ req_data->ss_to_reneg = (frescan_ss_group_t *)ss_to_reneg;
+ }
+
+ if (ss_to_cancel == NULL) {
+ req_data->ss_to_cancel = &req_data->ss_to_cancel_data;
+ req_data->ss_to_cancel->size = 0;
+ } else {
+ req_data->ss_to_cancel = (frescan_ss_group_t *)ss_to_cancel;
+
+ }
+
+ if (ss_new == NULL) {
+ req_data->ss_new = &req_data->ss_new_data;
+ req_data->ss_new->size = 0;
+ } else {
+ req_data->ss_new = ss_new;
+ }
ret = frescan_bwres_robjs_alloc(&req_data->robj, FRESCAN_BWRES_MX_PRIO);
if (ret != 0) return ret;
FRESCAN_MX_NODES*FRESCAN_MX_IDS);
if (ret != 0) return ret;
- fsa_scenario_init_data.min_priority = 1;
- fsa_scenario_init_data.max_priority = 15;
+ fsa_scenario_init_data.min_priority = params->min_prio;
+ fsa_scenario_init_data.max_priority = params->max_prio;
fsa_scenario_init_data.ovhd_data.np =
frsh_rel_time_to_sa_time(frsh_usec_to_rel_time(0));
sa_vres->contract = *contract;
sa_vres->node = node;
sa_vres->ss = ss;
+ sa_vres->old_c = 0;
+ sa_vres->old_t = 0;
+ sa_vres->old_p = 0;
ret = freelist_alloc(&scenario->fsa_vres_global_id_freelist);
if (ret < 0) return -1;
#include "frescan_bwres_messages.h"
#include "frescan_bwres_requests.h"
#include "frescan.h"
+#include "frescan_servers.h"
#include "frescan_data.h"
#include "frescan_config.h"
#include "frescan_debug.h"
DEBUG(FRESCAN_BWRES_MESSAGES_ENABLE_DEBUG, "initialization\n");
send_params[net].net = net;
- send_params[net].channel = FRESCAN_BWRES_NEG_CHANNEL;
+ send_params[net].channel = FRESCAN_BWRES_NEG_MSG_CHAN;
send_params[net].flags = FRESCAN_SS | FRESCAN_ASYNC;
send_params[net].ss = frescan_data[net].neg_messages_ss_id;
send_params[net].to = FRESCAN_BWRES_MASTER_NODE;
recv_params[net].net = net;
- recv_params[net].channel = FRESCAN_BWRES_NEG_CHANNEL;
+ recv_params[net].channel = FRESCAN_BWRES_NEG_MSG_CHAN;
recv_params[net].flags = FRESCAN_SYNC;
return 0;
// NEG-GROUP
DEBUG(FRESCAN_BWRES_MESSAGES_ENABLE_DEBUG,
- "NEG-GROUP num contracts:%u\n", data->contracts_to_neg->size);
+ "NEG-GROUP num contracts:%d\n", data->contracts_to_neg->size);
*((uint8_t *)msg) = (uint8_t)data->contracts_to_neg->size;
bytes_written = sizeof(uint8_t);
// RENEG-GROUP
DEBUG(FRESCAN_BWRES_MESSAGES_ENABLE_DEBUG,
- "RENEG-GROUP num contracts:%u\n",data->contracts_to_reneg->size);
+ "RENEG-GROUP num contracts:%d\n",data->contracts_to_reneg->size);
*((uint8_t *)msg) = (uint8_t)data->contracts_to_reneg->size;
bytes_written = sizeof(uint8_t);
}
// CANCEL-GROUP
- DEBUG(FRESCAN_BWRES_MESSAGES_ENABLE_DEBUG, "CANCEL-GROUP num ss:%u\n",
+ DEBUG(FRESCAN_BWRES_MESSAGES_ENABLE_DEBUG, "CANCEL-GROUP num ss:%d\n",
data->ss_to_cancel->size);
*((uint8_t *)msg) = (uint8_t)data->ss_to_cancel->size;
uint8_t *msg,
size_t *size)
{
+ int i;
uint8_t *msg_begin;
size_t bytes_written;
+ frescan_bwres_vres_t *vres;
msg_begin = msg;
bytes_written = sizeof(uint8_t);
msg = msg + bytes_written;
+ if (data->return_value == FRESCAN_BWRES_REQ_ACCEPTED) {
+ // new ss values
+ for(i=0; i<data->contracts_to_neg->size; i++) {
+ // SS
+ *((uint16_t *)msg) = data->ss_new->ss[i];
+ bytes_written = sizeof(uint16_t);
+ msg = msg + bytes_written;
+
+ // B - T - P
+ vres = &frescan_data[data->net].scenario.
+ vres_pool[data->request_node]
+ [data->ss_new->ss[i]];
+
+ *((frsh_sa_time_t *)msg) = vres->old_c;
+ bytes_written = sizeof(frsh_sa_time_t);
+ msg = msg + bytes_written;
+
+ *((frsh_sa_time_t *)msg) = vres->old_t;
+ bytes_written = sizeof(frsh_sa_time_t);
+ msg = msg + bytes_written;
+
+ *((frsh_sa_prio_t *)msg) = vres->old_p;
+ bytes_written = sizeof(frsh_sa_prio_t);
+ msg = msg + bytes_written;
+ }
+ }
+
*size = msg - msg_begin;
DEBUG(FRESCAN_BWRES_MESSAGES_ENABLE_DEBUG, "size:%u\n", *size);
frescan_bwres_request_data_t *data,
size_t size)
{
+ int ret;
uint8_t *msg;
size_t bytes_read;
+ frescan_ss_t ss;
+ frescan_server_params_t server_params;
msg = (uint8_t *)msg_to_parse;
bytes_read = sizeof(uint8_t);
msg = msg + bytes_read;
+ // create the new sporadic servers
+ data->ss_new->size = 0;
+
+ while(msg < msg_to_parse + size) {
+ // SS
+ data->ss_new->ss[data->ss_new->size] = *((uint16_t *)msg);
+ bytes_read = sizeof(uint16_t);
+ msg = msg + bytes_read;
+
+ // Budget
+ server_params.budget =
+ frsh_rel_time_to_usec
+ (frsh_sa_time_to_rel_time(*((frsh_sa_time_t *)msg))) /
+ FRESCAN_FRAME_TX_TIME_US;
+ bytes_read = sizeof(frsh_sa_time_t);
+ msg = msg + bytes_read;
+
+ // Period
+ server_params.period = frsh_sa_time_to_rel_time
+ (*((frsh_sa_time_t *)msg));
+ bytes_read = sizeof(frsh_sa_time_t);
+ msg = msg + bytes_read;
+
+ // Prio
+ server_params.prio = *((frsh_sa_prio_t *)msg);
+ bytes_read = sizeof(frsh_sa_prio_t);
+ msg = msg + bytes_read;
+
+ // Create server
+ ret = frescan_servers_create(data->net, &server_params, &ss);
+ if (ret != 0) return ret;
+
+ if (ss != data->ss_new->ss[data->ss_new->size]) {
+ FRESCAN_ERROR("ss from master != ss created\n");
+ return -1;
+ }
+
+ data->ss_new->size++;
+ }
+
return 0;
}
static int frescan_bwres_send_mc_messages
(frescan_network_t net,
- frescan_bwres_mode_change_type_t mode_change_type);
+ frescan_bwres_mode_change_type_t mode_change_type,
+ frescan_ss_group_t *ss_to_cancel);
/**
* frescan_bwres_mode_change_protocol() - performs the mode change protocol
[vres->fsa_vres_global_id];
vres->mode_change_type = 0;
+ if ((vres->old_c == 0) &&
+ (vres->old_t == 0) &&
+ (vres->old_p == 0)) {
+ //new vres (transmitted in the reply message)
+ vres->old_c = sa_vres_data->c;
+ vres->old_t = sa_vres_data->t;
+ vres->old_p = sa_vres_data->p;
+ continue;
+ }
+
if (sa_vres_data->c > vres->old_c) {
vres->mode_change_type |= FRESCAN_BWRES_MC_BUDGET_INC;
if (sa_vres_data->t > max_period_in_budget_inc) {
DEBUG(FRESCAN_BWRES_MC_ENABLE_DEBUG, "2.- Budget decrease\n");
ret = frescan_bwres_send_mc_messages(req_data->net,
- FRESCAN_BWRES_MC_BUDGET_DEC);
+ FRESCAN_BWRES_MC_BUDGET_DEC,
+ req_data->ss_to_cancel);
if (ret != 0) return -1;
ret = frescan_bwres_mode_change_local(req_data->net,
- FRESCAN_BWRES_MC_BUDGET_DEC);
+ FRESCAN_BWRES_MC_BUDGET_DEC,
+ req_data->ss_to_cancel);
if (ret != 0) return -1;
DEBUG(FRESCAN_BWRES_MC_ENABLE_DEBUG, "3.- Wait max_period\n");
DEBUG(FRESCAN_BWRES_MC_ENABLE_DEBUG, "4.- Budget increase\n");
ret = frescan_bwres_send_mc_messages(req_data->net,
- FRESCAN_BWRES_MC_BUDGET_INC);
+ FRESCAN_BWRES_MC_BUDGET_INC,
+ NULL);
if (ret != 0) return -1;
ret = frescan_bwres_mode_change_local(req_data->net,
- FRESCAN_BWRES_MC_BUDGET_INC);
+ FRESCAN_BWRES_MC_BUDGET_INC,
+ NULL);
if (ret != 0) return -1;
return 0;
static int frescan_bwres_send_mc_messages
(frescan_network_t net,
- frescan_bwres_mode_change_type_t mode_change_type)
+ frescan_bwres_mode_change_type_t mode_change_type,
+ frescan_ss_group_t *ss_to_cancel)
{
int ret;
frescan_node_t node;
"send MC message to node:%u\n", node);
tmp_req_data.request_node = node;
+ tmp_req_data.ss_to_cancel = ss_to_cancel;
ret = frescan_messages_send_request(&tmp_req_data);
if (ret != 0) return -1;
int frescan_bwres_mode_change_local
(frescan_network_t net,
- frescan_bwres_mode_change_type_t mode_change_type)
+ frescan_bwres_mode_change_type_t mode_change_type,
+ frescan_ss_group_t *ss_to_cancel)
{
- int ret;
+ int ret, i;
frescan_server_params_t server_params;
frescan_bwres_vres_t *vres;
struct timespec start_timestamp, next_activation;
if (mode_change_type == FRESCAN_BWRES_MC_BUDGET_INC) return 0;
+ // for ss cancelled set the perceived capacity to cero
+ if (ss_to_cancel != NULL) {
+ for(i=0; i<ss_to_cancel->size; i++) {
+ server_params.budget = 0;
+ server_params.period = frsh_usec_to_rel_time(0);
+ server_params.prio = 0;
+ ret = frescan_servers_set_perceived
+ (net,
+ &server_params,
+ ss_to_cancel->ss[i]);
+ if (ret != 0) return ret;
+ }
+ }
+
ret = clock_gettime(CLOCK_MONOTONIC, &start_timestamp);
if (ret != 0) return -1;
if (ret != 0) return ret;
}
+ if (ss_to_cancel != NULL) {
+ for(i=0; i<ss_to_cancel->size; i++) {
+ ret = frescan_servers_destroy
+ (net, ss_to_cancel->ss[i]);
+ if (ret != 0) return ret;
+ }
+ }
+
return 0;
}
extern int frescan_bwres_mode_change_local
(frescan_network_t net,
- frescan_bwres_mode_change_type_t mode_change_type);
+ frescan_bwres_mode_change_type_t mode_change_type,
+ frescan_ss_group_t *ss_to_cancel);
#endif // _FRESCAN_BWRES_MODE_CHANGE_H_
static void frescan_manager_req_gn(frescan_bwres_request_data_t *req_data)
{
- int ret;
+ int ret, i;
frescan_node_t me;
bool accepted;
frescan_bwres_sa_scenario_t *scenario;
+ frescan_ss_t ss;
+ frescan_server_params_t server_params;
+ frescan_bwres_vres_t *vres;
me = frescan_data[req_data->net].local_node;
}
if (req_data->request_node == me) {
+ // create servers for new contracts
+ for(i=0; i<req_data->contracts_to_neg->size; i++) {
+ vres = &frescan_data[req_data->net].scenario.
+ vres_pool[me]
+ [req_data->ss_new->ss[i]];
+
+ server_params.budget = frsh_rel_time_to_usec(
+ frsh_sa_time_to_rel_time(vres->old_c)) /
+ FRESCAN_FRAME_TX_TIME_US;
+
+ server_params.period = frsh_sa_time_to_rel_time
+ (vres->old_t);
+ server_params.prio = vres->old_p;
+
+ // Create server
+ ret = frescan_servers_create(req_data->net,
+ &server_params,
+ &ss);
+ assert(ret == 0);
+ assert (req_data->ss_new->ss[i] == ss);
+ }
+
DEBUG(FRESCAN_BWRES_MANAGER_ENABLE_DEBUG, "signal robj\n");
ret = frescan_bwres_robjs_signal(req_data->robj);
assert(ret == 0);
frescan_bwres_request_data_t *req_data)
{
int ret, i;
- frescan_server_params_t server_params;
// NEG-GROUP
- server_params.budget = 0;
- server_params.period.tv_sec = 0;
- server_params.period.tv_nsec = 0;
- server_params.prio = 0;
-
for(i=0; i<req_data->contracts_to_neg->size; i++) {
- ret = frescan_servers_create(req_data->net,
- &server_params,
- &req_data->ss_new->ss[i]);
- assert(ret == 0);
+ ret = freelist_alloc(&frescan_data[req_data->net].scenario.
+ ss_id_freelist[req_data->request_node]);
+ assert(ret >= 0);
+
+ req_data->ss_new->ss[i] = (frescan_ss_t)ret;
ret = frescan_bwres_sa_add_contract
(scenario,
NULL);
assert(ret == 0);
- ret = frescan_servers_destroy(req_data->net,
- req_data->ss_new->ss[i]);
+ ret = freelist_free(&frescan_data[req_data->net].scenario.
+ ss_id_freelist[req_data->request_node],
+ req_data->ss_new->ss[i]);
assert(ret == 0);
}
static void frescan_manager_rep_gn(frescan_bwres_request_data_t *req_data)
{
- int ret;
- frescan_bwres_request_data_t *orig_req_data;
+ int ret, i;
+ frescan_bwres_request_data_t *caller_req;
- ret = frescan_bwres_requests_get_data(req_data->req, &orig_req_data);
+ ret = frescan_bwres_requests_get_data(req_data->req, &caller_req);
assert(ret == 0);
DEBUG(FRESCAN_BWRES_MANAGER_ENABLE_DEBUG,
"reply to gn, return value:%d\n", req_data->return_value);
- orig_req_data->return_value = req_data->return_value;
+ caller_req->return_value = req_data->return_value;
+
+ assert (req_data->ss_new->size == caller_req->contracts_to_neg->size);
+
+ for (i=0; i<req_data->ss_new->size; i++) {
+ caller_req->ss_new->ss[i] = req_data->ss_new->ss[i];
+ }
- ret = frescan_bwres_robjs_signal(orig_req_data->robj);
+ ret = frescan_bwres_robjs_signal(caller_req->robj);
assert(ret == 0);
}
int ret;
ret = frescan_bwres_mode_change_local(req_data->net,
- req_data->mode_change_type);
+ req_data->mode_change_type,
+ req_data->ss_to_cancel);
assert(ret == 0);
}
#define FRESCAN_BROADCAST_ADDR 0xF
#define FRESCAN_MX_IDS 255
#define FRESCAN_MX_PRIOS 32
-#define FRESCAN_REPL_SIGNAL_NUM FOSA_SIGNAL_MIN + 10 // real-time signal
#define FRESCAN_BACKGROUND_PRIO 0
+#define FRESCAN_REPL_SIGNAL_NUM FOSA_SIGNAL_MIN + 10 // real-time signal
#define FRESCAN_REPL_THREAD_PRIO 60
#define FRESCAN_MX_NODES 2
#define FRESCAN_MX_REPL_OPS FRESCAN_MX_IDS*10
#define FRESCAN_BWRES_MX_PRIO 60
#define FRESCAN_BWRES_NEG_THREAD_PRIO 50
#define FRESCAN_BWRES_ACCEPTOR_PRIO FRESCAN_BWRES_NEG_THREAD_PRIO - 1
-#define FRESCAN_BWRES_NEG_MESSAGES_PRIO 8
-#define FRESCAN_BWRES_NEG_CHANNEL 0
+#define FRESCAN_BWRES_NEG_MSG_PRIO 8
+#define FRESCAN_BWRES_NEG_MSG_BUDGET 5 // packets
+#define FRESCAN_BWRES_NEG_MSG_PERIOD 1000000 // us
+#define FRESCAN_BWRES_NEG_MSG_CHAN 0
#define FRESCAN_BWRES_MX_CONTRACTS (FRESCAN_MX_NODES*FRESCAN_MX_IDS)
#define FRESCAN_BWRES_MAX_GROUP_OPS 5
+#define FRESCAN_BWRES_SS_MIN_PRIO 1
+#define FRESCAN_BWRES_SS_MAX_PRIO FRESCAN_MX_PRIOS
// FRESCAN_FRAME_TX_TIME_US: measured transmission time of an 8byte frame
#define FRESCAN_FRAME_TX_TIME_US 200
#define FRESCAN_HW_BUFFER_ENABLE_DEBUG false
#define FRESCAN_REPLENSH_ENABLE_DEBUG false
-#define FRESCAN_BWRES_ENABLE_DEBUG false
+#define FRESCAN_BWRES_ENABLE_DEBUG true
#define FRESCAN_BWRES_ROBJS_ENABLE_DEBUG false
#define FRESCAN_BWRES_REQUESTS_ENABLE_DEBUG false
-#define FRESCAN_BWRES_MANAGER_ENABLE_DEBUG false
-#define FRESCAN_BWRES_ACCEPTOR_ENABLE_DEBUG false
-#define FRESCAN_BWRES_MC_ENABLE_DEBUG false
+#define FRESCAN_BWRES_MANAGER_ENABLE_DEBUG true
+#define FRESCAN_BWRES_ACCEPTOR_ENABLE_DEBUG true
+#define FRESCAN_BWRES_MC_ENABLE_DEBUG true
#define FRESCAN_BWRES_FNA_ENABLE_DEBUG false
-#define FRESCAN_BWRES_MESSAGES_ENABLE_DEBUG false
-#define FRESCAN_BWRES_SA_ENABLE_DEBUG false
+#define FRESCAN_BWRES_MESSAGES_ENABLE_DEBUG true
+#define FRESCAN_BWRES_SA_ENABLE_DEBUG true
/**
* MEASUREMENT FLAGS
frescan_bwres_vres_t vres_pool[FRESCAN_MX_NODES][FRESCAN_MX_IDS];
frescan_bwres_vres_t vres_head; // TODO: use struct list_head
freelist_t fsa_vres_global_id_freelist;
+ freelist_t ss_id_freelist[FRESCAN_MX_NODES];
frsh_sa_scenario_t fsa_scenario;
frsh_contracts_group_t backup_contracts_to_reneg;
frsh_contracts_group_t backup_contracts_to_cancel;
ret = frescan_bwres_init(NETWORK);
if (ret != 0) PUT_ERROR ("could not init BWRES");
+ printf("BWRES Initialized\n");
+
while (1) {
sleep(1);
}
#define NETWORK 0
#define LOCAL_NODE 0
+extern int frescan_fna_network_bytes_to_budget
+ (const frsh_resource_id_t resource_id,
+ const size_t nbytes,
+ frsh_rel_time_t *budget);
+
int main ()
{
int ret;
#define NETWORK 0
#define LOCAL_NODE 1
+extern int frescan_fna_network_bytes_to_budget
+ (const frsh_resource_id_t resource_id,
+ const size_t nbytes,
+ frsh_rel_time_t *budget);
+
int main ()
{
int ret;
int main()
{
int err;
- frescan_robj_id_t id;
+ frescan_bwres_robj_id_t id;
fosa_thread_attr_t th_attr;
fosa_thread_id_t tid;
struct timespec now;
static void *thread_code(void *arg)
{
int err;
- frescan_robj_id_t reply = (frescan_robj_id_t)arg;
+ frescan_bwres_robj_id_t reply = (frescan_bwres_robj_id_t)arg;
printf("Thread signaling\n");
err = frescan_bwres_robjs_signal(reply);
int main()
{
int err;
- frescan_robj_id_t id;
+ frescan_bwres_robj_id_t id;
fosa_thread_attr_t th_attr;
fosa_thread_id_t tid;
static void *thread_code(void *arg)
{
int err;
- frescan_robj_id_t reply = (frescan_robj_id_t)arg;
+ frescan_bwres_robj_id_t reply = (frescan_bwres_robj_id_t)arg;
printf("Thread executing\n");
sleep(2);
-// mgcc test_frescan_send_basic.c -L. -lfrescan -o mprogram_wifi2
-// mgcc test_frescan_send_basic.c -DSENDER -L. -lfrescan -o mprogram_wifi1
-
#include <stdio.h> // perror
#include <stdlib.h> // exit
#include <unistd.h> // sleep
#include "frescan.h"
-#define ERROR(s) {perror (s); exit (-1);}
+#define PUT_ERROR(s) {perror (s); exit (-1);}
#define NETWORK 0
#define LOCAL_NODE 1
init_params.rx_channel_max_prio = NULL;
ret = frescan_init(&init_params);
- if (ret != 0) ERROR ("could not init FRESCAN");
+ if (ret != 0) PUT_ERROR ("could not init FRESCAN");
printf("FRESCAN initialized\n");
#include <stdint.h> // uint32_t
#include "frescan_queues.h"
+#include "frescan_packets.h"
#include "frescan_debug.h"
#include <drivers/can.h>
#include <misc/linux_list.h>
projects / frescor / fna.git / commitdiff