--- /dev/null
+#include <stdio.h> // perror
+#include <stdlib.h> // exit
+#include <unistd.h> // sleep
+#include <assert.h>
+
+#include "frsh.h"
+
+#include "frescan.h"
+#include "frescan_bwres.h"
+#include "frescan_servers.h"
+
+#define ENABLE_MEASURES
+
+#ifdef ENABLE_MEASURES
+#include <misc/time_measurement_hwtime.h>
+#include <misc/logger.h>
+
+static const trace_point_id_t BEGIN_GN_NEG = 0;
+static const trace_point_id_t END_GN_NEG = 1;
+#endif
+
+#define NETWORK 0
+#define LOCAL_NODE 0
+#define NUM_CONTRACTS 2 // 1 .. FRESCAN_BWRES_MAX_GROUP_OPS
+
+// #define USE_GN
+
+#if 0
+#include <stdio.h>
+#define DEBUG(x,args...) printf("%s: " x, __func__ , ##args)
+#else
+#define DEBUG(x,args...)
+#endif
+
+extern int frescan_fna_network_bytes_to_budget
+ (const frsh_resource_id_t resource_id,
+ const size_t nbytes,
+ frsh_rel_time_t *budget);
+
+static void create_contract(frsh_contract_t *contract);
+
+int main ()
+{
+ int ret, i;
+ frescan_init_params_t init_params;
+ frescan_ss_group_t ss_new;
+ frsh_contracts_group_t contracts_to_neg;
+ bool accepted;
+
+ init_params.net = NETWORK;
+ init_params.node = LOCAL_NODE;
+ init_params.tx_fp_max_prio = 10;
+ init_params.rx_num_of_channels = 10;
+ init_params.rx_channel_max_prio = NULL;
+
+#ifdef ENABLE_MEASURES
+ ret = logger_init(LOG_ETHERNET);
+ assert(ret == 0);
+
+#if (LOCAL_NODE == 0)
+ ret = time_measure_hwtime_init(BEGIN_GN_NEG, "master_begin");
+ assert(ret == 0);
+ ret = time_measure_hwtime_init(END_GN_NEG, "master_end");
+ assert(ret == 0);
+#else
+ ret = time_measure_hwtime_init(BEGIN_GN_NEG, "slave_begin");
+ assert(ret == 0);
+ ret = time_measure_hwtime_init(END_GN_NEG, "slave_end");
+ assert(ret == 0);
+#endif
+#endif
+
+ DEBUG("Initializing FRESCAN\n");
+ ret = frescan_init(&init_params);
+ assert(ret == 0);
+
+ DEBUG("Initializing BWRES\n");
+ ret = frescan_bwres_init(NETWORK);
+ assert(ret == 0);
+
+ DEBUG("Creating contracts\n");
+ for(i=0; i<NUM_CONTRACTS; i++) {
+ contracts_to_neg.size = i + 1;
+ DEBUG("Creating contract %d\n", contracts_to_neg.size);
+ create_contract(&contracts_to_neg.contracts[i]);
+ }
+
+#ifdef ENABLE_MEASURES
+ time_measure_hwtime_set_timestamp(BEGIN_GN_NEG);
+#endif
+
+#ifdef USE_GN
+ DEBUG("Negotiating GN\n");
+ ret = frescan_bwres_group_change_mode_sync(NETWORK, &contracts_to_neg,
+ NULL, NULL, NULL, &ss_new,
+ &accepted);
+ assert(ret == 0);
+ assert(accepted == true);
+#else
+ for(i=0; i<NUM_CONTRACTS; i++) {
+ DEBUG("Negotiating contract %d\n", contracts_to_neg.size);
+ ret = frescan_bwres_negotiate(NETWORK,
+ &contracts_to_neg.contracts[i],
+ &ss_new.ss[i],
+ &accepted);
+ assert(ret == 0);
+ assert(accepted == true);
+ }
+#endif
+
+#ifdef ENABLE_MEASURES
+ time_measure_hwtime_set_timestamp(END_GN_NEG);
+
+ ret = time_measure_hwtime_write_membuffer(BEGIN_GN_NEG);
+ assert(ret == 0);
+
+ ret = time_measure_hwtime_write_membuffer(END_GN_NEG);
+ assert(ret == 0);
+
+ while (logger_manual_call() > 0);
+#endif
+
+ DEBUG("MAIN DONE\n");
+ while(1) sleep(10);
+}
+
+static void create_contract(frsh_contract_t *contract)
+{
+ int ret;
+ frsh_rel_time_t budget_min, period_max;
+
+ ret = frsh_contract_init(contract);
+ assert(ret == 0);
+
+ ret = frescan_fna_network_bytes_to_budget (NETWORK, 10, &budget_min);
+ assert(ret == 0);
+
+ period_max = frsh_msec_to_rel_time(3369); // 3,369 secs
+
+ ret = frsh_contract_set_basic_params
+ (contract,
+ &budget_min,
+ &period_max,
+ FRSH_WT_INDETERMINATE,
+ FRSH_CT_REGULAR);
+ assert(ret == 0);
+
+// DEBUG("Setting preemption level manually to the contract\n");
+// ret = frsh_contract_set_preemption_level(contract, 7);
+// assert(ret == 0);
+}
--- /dev/null
+#include <stdio.h> // perror
+#include <stdlib.h> // exit
+#include <unistd.h> // sleep
+#include <assert.h>
+
+#include "frsh.h"
+#include "frescan.h"
+#include "frescan_types.h"
+#include "frescan_bwres_requests.h"
+#include "frescan_bwres_robjs.h"
+#include "frescan_bwres_fna.h"
+
+#define NETWORK 0
+#define LOCAL_NODE 1
+
+#if 0
+#include <stdio.h>
+#define DEBUG(x,args...) printf("%s: " x, __func__ , ##args)
+#else
+#define DEBUG(x,args...)
+#endif
+
+#include <misc/time_measurement_hwtime.h>
+#include <misc/logger.h>
+static const trace_point_id_t BEGIN_MEASURE = 0;
+static const trace_point_id_t END_MEASURE = 1;
+
+static int frescan_request_to_gn_message
+ (const frescan_bwres_request_data_t *data,
+ uint8_t *msg,
+ size_t *size);
+
+static int frescan_gn_message_to_request(const uint8_t *msg_to_parse,
+ frescan_bwres_request_data_t *data,
+ size_t size);
+
+static void create_contract(frsh_contract_t *contract);
+
+#define FRESCAN_BWRES_MX_MSG_SIZE 5000 // TODO: adjust to the accurate value
+
+int main ()
+{
+ int ret, i, j;
+ frescan_init_params_t init_params;
+ uint8_t msg[FRESCAN_BWRES_MX_MSG_SIZE];
+ size_t size;
+ frescan_bwres_request_data_t *req_in;
+ frescan_bwres_request_id_t req;
+ frescan_send_params_t send_params;
+ frescan_node_t from;
+ frescan_prio_t prio;
+ size_t recv_bytes;
+ frescan_recv_params_t recv_params;
+ frescan_bwres_request_data_t *req_out;
+ uint8_t *msg_to_parse;
+
+ ret = logger_init(LOG_ETHERNET);
+ assert(ret == 0);
+
+ ret = time_measure_hwtime_init(BEGIN_MEASURE, "measure_begin");
+ assert(ret == 0);
+
+ ret = time_measure_hwtime_init(END_MEASURE, "measure_end");
+ assert(ret == 0);
+
+ DEBUG("TEST for FRESCAN messages (NODE: %d)\n", LOCAL_NODE);
+
+ init_params.net = NETWORK;
+ init_params.node = LOCAL_NODE;
+ init_params.tx_fp_max_prio = 10;
+ init_params.rx_num_of_channels = 10;
+ init_params.rx_channel_max_prio = NULL;
+
+ recv_params.net = 0;
+ recv_params.channel = 5;
+ recv_params.flags = FRESCAN_SYNC;
+
+ send_params.net = 0;
+ send_params.to = 1;
+ send_params.channel = 5;
+ send_params.flags = FRESCAN_FP | FRESCAN_ASYNC;;
+ send_params.prio = 3;
+
+ DEBUG("Calling frescan_init\n");
+
+ ret = frescan_init(&init_params);
+ assert(ret == 0);
+
+ ret = frescan_bwres_robjs_init(FRESCAN_BWRES_ROBJS_MX_CEILING);
+ assert(ret == 0);
+
+ ret = frescan_bwres_requests_init(FRESCAN_BWRES_REQ_MX_CEILING);
+ assert(ret == 0);
+
+ if (LOCAL_NODE == 0) {
+ DEBUG("Preparing a GN request\n");
+
+ ret = frescan_bwres_requests_alloc(&req);
+ assert(ret == 0);
+
+ ret = frescan_bwres_requests_get_data(req, &req_in);
+ assert(ret == 0);
+
+ req_in->net = NETWORK;
+ req_in->type = FRESCAN_BWRES_REQ_GN;
+ req_in->req = req;
+ req_in->request_node = LOCAL_NODE;
+
+ for(i=0;i<FRESCAN_BWRES_MAX_GROUP_OPS;i++) {
+ time_measure_hwtime_set_timestamp(BEGIN_MEASURE);
+
+ req_in->contracts_to_neg = &req_in->contracts_to_neg_data;
+
+ req_in->contracts_to_neg->size = i + 1;
+ for(j=0; j<req_in->contracts_to_neg->size; j++) {
+ create_contract(&req_in->contracts_to_neg->contracts[j]);
+ }
+
+ req_in->contracts_to_reneg = &req_in->contracts_to_reneg_data;
+ req_in->contracts_to_reneg->size = 0;
+
+ req_in->ss_to_reneg = &req_in->ss_to_reneg_data;
+ req_in->ss_to_reneg->size = 0;
+
+ req_in->ss_to_cancel = &req_in->ss_to_cancel_data;
+ req_in->ss_to_cancel->size = 0;
+
+ req_in->ss_new = &req_in->ss_new_data;
+ req_in->ss_new->size = 0;
+
+ ret = frescan_bwres_robjs_alloc(&req_in->robj, FRESCAN_BWRES_MX_PRIO);
+ assert(ret == 0);
+
+ ret = frescan_request_to_gn_message(req_in, msg, &size);
+ assert(ret == 0);
+
+ ret = frescan_bwres_robjs_free(req_in->robj);
+ assert(ret == 0);
+
+ frescan_bwres_requests_free(req);
+
+ ret = frescan_send(&send_params, msg, size);
+ assert(ret == 0);
+
+ DEBUG("Receiving reply\n");
+
+ ret = frescan_recv(&recv_params,
+ msg,
+ sizeof(msg),
+ &recv_bytes,
+ &from,
+ &prio);
+ assert(ret == 0);
+
+ DEBUG("Reply received, sleep\n");
+
+ time_measure_hwtime_set_timestamp(END_MEASURE);
+
+ sleep(2);
+ }
+
+ ret = time_measure_hwtime_write_membuffer(BEGIN_MEASURE);
+ assert(ret == 0);
+
+ ret = time_measure_hwtime_write_membuffer(END_MEASURE);
+ assert(ret == 0);
+
+ while (logger_manual_call() > 0);
+ } else {
+ while(1) {
+ DEBUG("Blocking to receive the GN request\n");
+
+ ret = frescan_recv(&recv_params,
+ msg,
+ sizeof(msg),
+ &recv_bytes,
+ &from,
+ &prio);
+ assert(ret == 0);
+
+ ret = frescan_bwres_requests_alloc(&req);
+ assert(ret == 0);
+
+ ret = frescan_bwres_requests_get_data(req, &req_out);
+ assert(ret == 0);
+
+ req_out->type = *((uint8_t *)msg);
+ msg_to_parse = msg + sizeof(uint8_t);
+ recv_bytes = recv_bytes - sizeof(uint8_t);
+
+ ret = frescan_gn_message_to_request(msg_to_parse,
+ req_out,
+ recv_bytes);
+ assert(ret == 0);
+
+ DEBUG("PARSING the GN request\n");
+
+ assert(req_out->type == FRESCAN_BWRES_REQ_GN);
+
+ DEBUG("req: %d\n", req_out->req);
+
+ DEBUG("num new contracts: %d\n", req_out->contracts_to_neg->size);
+
+ DEBUG("send reply\n");
+ send_params.to = from;
+ ret = frescan_send(&send_params, msg, recv_bytes);
+ assert(ret == 0);
+ }
+ }
+
+ DEBUG("TEST OK\n");
+
+ while (1) sleep(1);
+
+ return 0;
+}
+
+/**
+ * FRESCAN_BWRES_REQ_GN (COPY AND PASTE FROM frescan_bwres_messages.c)
+ */
+
+static int frescan_request_to_gn_message
+ (const frescan_bwres_request_data_t *data,
+ uint8_t *msg,
+ size_t *size)
+{
+ int ret, i;
+ uint8_t *msg_begin, *msg_tmp;
+ size_t bytes_written;
+
+ msg_begin = msg;
+
+ // type: FRESCAN_GN_MESSAGE
+ *((uint8_t *)msg) = (uint8_t)FRESCAN_BWRES_REQ_GN;
+ bytes_written = sizeof(uint8_t);
+ msg = msg + bytes_written;
+
+ // req
+ *((frescan_bwres_request_id_t *)msg) = data->req;
+ bytes_written = sizeof(frescan_bwres_request_id_t);
+ msg = msg + bytes_written;
+
+ DEBUG("GN message req:%u\n", data->req);
+
+ // NEG-GROUP
+ DEBUG("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);
+ msg = msg + bytes_written;
+
+ for (i=0; i<data->contracts_to_neg->size; i++) {
+ // reserve 2 bytes for the size of the marshalled contract
+ msg_tmp = msg;
+ msg = msg + sizeof(uint16_t);
+ // marshal the contract
+ ret = frsh_contract_marshal
+ (&data->contracts_to_neg->contracts[i],
+ msg,
+ FRESCAN_BWRES_MX_MSG_SIZE - (msg - msg_begin),
+ &bytes_written);
+ assert(ret == 0);
+
+ // write the size and update the message pointer msg
+ *((uint16_t *)msg_tmp) = (uint16_t)bytes_written;
+ msg = msg + bytes_written;
+
+ DEBUG("contract[%d].size:%u\n", i, bytes_written);
+ }
+
+ // RENEG-GROUP
+ DEBUG("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);
+ msg = msg + bytes_written;
+
+ for (i=0; i<data->contracts_to_reneg->size; i++) {
+ // write the ss
+ *((uint16_t *)msg) = (uint16_t)data->ss_to_reneg->ss[i];
+ bytes_written = sizeof(uint16_t);
+ msg = msg + bytes_written;
+ // reserve 2 bytes for the size of the marshalled contract
+ msg_tmp = msg;
+ msg = msg + sizeof(uint16_t);
+ // marshal the contract
+ ret = frsh_contract_marshal
+ (&data->contracts_to_reneg->contracts[i],
+ msg,
+ FRESCAN_BWRES_MX_MSG_SIZE - (msg - msg_begin),
+ &bytes_written);
+ assert(ret == 0);
+
+ // write the size and update the message pointer msg
+ *((uint16_t *)msg_tmp) = (uint16_t)bytes_written;
+ msg = msg + bytes_written;
+
+ DEBUG("contract[%d].size:%u ss[%d]:%u\n",
+ i, bytes_written, i, data->ss_to_reneg->ss[i]);
+ }
+
+ // CANCEL-GROUP
+ DEBUG("CANCEL-GROUP num ss:%d\n", data->ss_to_cancel->size);
+
+ *((uint8_t *)msg) = (uint8_t)data->ss_to_cancel->size;
+ bytes_written = sizeof(uint8_t);
+ msg = msg + bytes_written;
+
+ for (i=0; i<data->ss_to_cancel->size; i++) {
+ // write the ss
+ *((uint16_t *)msg) = (uint16_t)data->ss_to_cancel->ss[i];
+ bytes_written = sizeof(uint16_t);
+ msg = msg + bytes_written;
+
+ DEBUG("ss[%d]:%u\n", i, data->ss_to_cancel->ss[i]);
+ }
+
+ *size = msg - msg_begin;
+
+ DEBUG("size:%u\n", *size);
+
+ return 0;
+}
+
+static int frescan_gn_message_to_request(const uint8_t *msg_to_parse,
+ frescan_bwres_request_data_t *data,
+ size_t size)
+{
+ int ret, i;
+ uint8_t *msg;
+ size_t bytes_read, contract_size;
+
+ msg = (uint8_t *)msg_to_parse;
+
+ data->contracts_to_neg = &data->contracts_to_neg_data;
+ data->contracts_to_reneg = &data->contracts_to_reneg_data;
+ data->ss_to_reneg = &data->ss_to_reneg_data;
+ data->ss_to_cancel = &data->ss_to_cancel_data;
+ data->ss_new = &data->ss_new_data;
+
+ // req
+ data->req = *((frescan_bwres_request_id_t *)msg);
+ bytes_read = sizeof(frescan_bwres_request_id_t);
+ msg = msg + bytes_read;
+
+ DEBUG("GN message req:%u\n", data->req);
+
+ // NEG-GROUP
+ data->contracts_to_neg->size = *((uint8_t *)msg);
+ bytes_read = sizeof(uint8_t);
+ msg = msg + bytes_read;
+
+ DEBUG("NEG-GROUP num contracts:%u\n", data->contracts_to_neg->size);
+
+ for (i=0; i<data->contracts_to_neg->size; i++) {
+ contract_size = *((uint16_t *)msg);
+ bytes_read = sizeof(uint16_t);
+ msg = msg + bytes_read;
+
+ // unmarshal the contract
+ ret = frsh_contract_unmarshal
+ (&data->contracts_to_neg->contracts[i],
+ msg,
+ contract_size);
+ assert(ret == 0);
+
+ bytes_read = contract_size;
+ msg = msg + bytes_read;
+
+ DEBUG("contract[%d].size:%u\n", i, contract_size);
+ }
+
+ // RENEG-GROUP
+ data->contracts_to_reneg->size = *((uint8_t *)msg);
+ bytes_read = sizeof(uint8_t);
+ msg = msg + bytes_read;
+
+ DEBUG("RENEG-GROUP num contracts:%u\n",data->contracts_to_reneg->size);
+
+ for (i=0; i<data->contracts_to_reneg->size; i++) {
+ data->ss_to_reneg->ss[i] = *((uint16_t *)msg);
+ bytes_read = sizeof(uint16_t);
+ msg = msg + bytes_read;
+
+ contract_size = *((uint16_t *)msg);
+ bytes_read = sizeof(uint16_t);
+ msg = msg + bytes_read;
+
+ // unmarshal the contract
+ ret = frsh_contract_unmarshal
+ (&data->contracts_to_reneg->contracts[i],
+ msg,
+ contract_size);
+ assert(ret == 0);
+
+ bytes_read = contract_size;
+ msg = msg + bytes_read;
+
+ DEBUG("contract[%d].size:%u ss[%d]:%u\n",
+ i, contract_size, i, data->ss_to_reneg->ss[i]);
+ }
+
+ // CANCEL-GROUP
+ data->ss_to_cancel->size = *((uint8_t *)msg);
+ bytes_read = sizeof(uint8_t);
+ msg = msg + bytes_read;
+
+ DEBUG("CANCEL-GROUP num ss:%u\n", data->ss_to_cancel->size);
+
+ for (i=0; i<data->ss_to_cancel->size; i++) {
+ // write the ss
+ data->ss_to_cancel->ss[i] = *((uint16_t *)msg);
+ bytes_read = sizeof(uint16_t);
+ msg = msg + bytes_read;
+
+ DEBUG("ss[%d]:%u\n", i, data->ss_to_cancel->ss[i]);
+ }
+
+ return 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);
+
+static void create_contract(frsh_contract_t *contract)
+{
+ int ret;
+ frsh_rel_time_t budget_min, period_max;
+
+ DEBUG("Creating contract\n");
+
+ ret = frsh_contract_init(contract);
+ assert(ret == 0);
+
+ ret = frescan_fna_network_bytes_to_budget (NETWORK, 10, &budget_min);
+ assert(ret == 0);
+
+ period_max = frsh_msec_to_rel_time(3369); // 3,369 secs
+
+ ret = frsh_contract_set_basic_params
+ (contract,
+ &budget_min,
+ &period_max,
+ FRSH_WT_INDETERMINATE,
+ FRSH_CT_REGULAR);
+ assert(ret == 0);
+
+ DEBUG("Setting preemption level manually to the contract\n");
+ ret = frsh_contract_set_preemption_level(contract, 7);
+ assert(ret == 0);
+}
+
--- /dev/null
+#include <stdio.h> // perror
+#include <stdlib.h> // exit
+#include <unistd.h> // sleep
+#include <assert.h>
+
+#include <drivers/console_switcher.h>
+#include <misc/logger.h>
+
+#include "frescan.h"
+#include "frescan_servers.h"
+
+#define PUT_ERROR(s) {perror (s); exit (-1);}
+
+#define NETWORK 0
+// #define SENDER
+
+#ifdef SENDER
+
+#define LOCAL_NODE 0
+
+static void pause(){
+ char key;
+ printf(" press Enter...");
+ key = getchar();
+}
+
+int main ()
+{
+ int i, ret;
+ frescan_send_params_t params;
+ char msg[200];
+ frescan_init_params_t init_params;
+ frescan_server_params_t server_params;
+
+ ret = logger_init(LOG_ETHERNET);
+ assert(ret == 0);
+
+// MEMBUFFER_CONSOLE_INIT();
+
+ printf(">> Initializing FRESCAN\n");
+
+ init_params.net = NETWORK;
+ init_params.node = LOCAL_NODE;
+ init_params.tx_fp_max_prio = 10;
+ init_params.rx_num_of_channels = 5;
+ init_params.rx_channel_max_prio = NULL;
+
+ ret = frescan_init(&init_params);
+ if (ret != 0) PUT_ERROR ("could not init FRESCAN");
+
+ printf(">> Creating a Server\n");
+
+ server_params.budget = 4;
+ server_params.period.tv_sec = 3;
+ server_params.period.tv_nsec = 0;
+ server_params.prio = 5;
+
+ ret = frescan_servers_create(NETWORK,
+ &server_params,
+ ¶ms.ss);
+ if (ret != 0) PUT_ERROR ("could not create server");
+
+ printf(">> Enter in loop for sending packets\n");
+
+ params.net = NETWORK;
+ params.to = 1;
+ params.channel = 2;
+ params.flags = FRESCAN_SS | FRESCAN_ASYNC;
+
+ while(1) {
+ pause();
+ for (i=0; i<2; i++) {
+ *((uint8_t *)msg) = (uint8_t)i;
+ ret = frescan_send(¶ms, (uint8_t *)msg, 3);
+ if (ret != 0) PUT_ERROR ("could not send message\n");
+ while (logger_manual_call() > 0);
+ printf("SENT\n");
+ }
+ }
+
+ return 0;
+}
+
+#else
+
+#define LOCAL_NODE 1
+
+int main ()
+{
+ int ret;
+ frescan_recv_params_t params;
+ uint8_t msg[3000];
+ size_t recv_bytes;
+ frescan_node_t from;
+ frescan_init_params_t init_params;
+ frescan_prio_t prio;
+
+ init_params.net = NETWORK;
+ init_params.node = LOCAL_NODE;
+ init_params.tx_fp_max_prio = 10;
+ init_params.rx_num_of_channels = 5;
+ init_params.rx_channel_max_prio = NULL;
+
+ ret = frescan_init(&init_params);
+ if (ret != 0) PUT_ERROR ("could not init FRESCAN");
+
+ printf("FRESCAN initialized\n");
+
+ params.net = NETWORK;
+ params.channel = 2;
+ params.flags = FRESCAN_SYNC;
+
+ while (1) {
+ printf("RECEIVING...\n");
+ ret = frescan_recv(¶ms, (uint8_t *)msg, sizeof(msg),
+ &recv_bytes, &from, &prio);
+ if (ret != 0) PUT_ERROR ("could not send message");
+
+ printf("RECEIVED msg %u with prio:%u\n", msg[0], prio);
+
+// for (i=0; i<recv_bytes; i++) {
+// printf("msg[%d] = 0x%X;\n", i, msg[i]);
+// }
+ }
+
+ return 0;
+}
+
+#endif