added message to notify a budget increase or decrease (due to spare capacity)

git-svn-id: http://www.frescor.org/private/svn/frescor/fna/trunk@1308 35b4ef3e-fd22-0410-ab77-dab3279adceb

diff --git a/src_frescan/frescan_bwres_messages.c b/src_frescan/frescan_bwres_messages.c
index 4c899723a6d0a284c623bbd4e53577d70c9a3112..4dff677007a2535475205ee333d644e669ed1b45 100644 (file)
--- a/src_frescan/frescan_bwres_messages.c
+++ b/src_frescan/frescan_bwres_messages.c
@@ -316,59 +316,97 @@ static int frescan_cancel_message_to_request(const uint8_t *msg,
 
 /**
  *
- *  FRESCAN_REP_CHANGE MESSAGE
- *  ==========================
- *  This message is sent from the MASTER to a slave as a reply to a
- *  FRESCAN_REQ_NEG or a FRESCAN_REQ_RENEG, to say if they were admited.
- *  It contains the type 'REPNEG', the request ID of the slave, a
- *  return value to say if the contract is admited or not, and the final
- *  values if it was admited
+ *  FRESCAN_REP_INC_BUDGET / FRESCAN_REP_DEC_BUDGET
+ *  ===============================================
+ *  This message is sent from the MASTER to a slave when there is a change
+ *  in the budget value assigned by the spare capacity algorithm.
  *
- *  +----------------------------------------------+
- *  | 'REPNEG' | REQ | RETURN_VALUE | FINAL_VALUES |
- *  +----------------------------------------------+
+ *  +---------------------------------------------------+
+ *  | 'INC/DEC' | SS | NEW_B | SS | NEW_B |  SS | NEW_B |
+ *  +---------------------------------------------------+
  *
  */
 
-struct frescan_rep_neg_message_t {
-        frescan_request_type_t    type;
-        frescan_request_id_t      req;
-        frescan_request_retval_t  return_value;
-        frescan_server_params_t   final_values;
-}  __attribute__ ((packed));
-
-static int frescan_request_to_repneg_message(const frescan_request_data_t *data,
-                                             uint8_t *msg)
+static int frescan_request_to_repchange_message
+                (const frescan_request_data_t *data, uint8_t *msg)
 {
-        struct frescan_rep_neg_message_t *repneg_msg;
+        int bytes_written;
+        struct list_head *the_mode_change_list;
+        frescan_sa_vres_t *vres;
+        uint8_t *msg_begin;
+
+        if (data->type == FRESCAN_REP_INC_BUDGET) {
+                the_mode_change_list = &the_networks[data->net].
+                                        mode_change_budget_inc_list_head
+                                                        [data->request_node];
+        } else {
+                the_mode_change_list = &the_networks[data->net].
+                                mode_change_budget_dec_list_head
+                                                        [data->request_node];
+        }
 
-        repneg_msg = (struct frescan_rep_neg_message_t *)msg;
+        if (list_empty(the_mode_change_list)) {
+                return 0; // nothing to send
+        }
 
-        repneg_msg->type         = FRESCAN_REP_NEG;
-        repneg_msg->req          = data->req;
-        repneg_msg->return_value = data->return_value;
-        repneg_msg->final_values = data->final_values;
+        msg_begin = msg;
 
-        DEBUG(FRESCAN_MESSAGES_ENABLE_DEBUG, "type:%d req:%d ret:%d\n",
-              repneg_msg->type, repneg_msg->req, repneg_msg->return_value);
+        *((frescan_request_type_t *)msg) = data->type;
+        bytes_written = sizeof(frescan_request_type_t);
+        msg = msg + bytes_written;
 
-        return sizeof(struct frescan_rep_neg_message_t);
+        list_for_each_entry(vres,
+                            the_mode_change_list,
+                            mode_change_list)
+        {
+                *((frescan_ss_t *)msg) = vres->ss;
+                bytes_written = sizeof(frescan_ss_t);
+                msg = msg + bytes_written;
+
+                *((frsh_sa_time_t *)msg) = vres->old_c;
+                bytes_written = sizeof(frsh_sa_time_t);
+                msg = msg + bytes_written;
+        }
+
+        return (msg - msg_begin);
 }
 
-static int frescan_repneg_message_to_request(const uint8_t *msg,
-                                             frescan_request_data_t *data)
+static int frescan_repchange_message_to_request(const uint8_t *msg,
+                                                frescan_request_data_t *data,
+                                                size_t size)
 {
-        struct frescan_rep_neg_message_t *repneg_msg;
+        struct list_head *the_mode_change_list;
+        frescan_node_t me = the_networks[data->net].local_node;
+        frescan_sa_vres_t *vres;
+        int bytes_read;
+        uint8_t *msg_pointer;
+        frescan_ss_t ss;
+
+        data->type = *((frescan_request_type_t *)msg);
+
+        if (data->type == FRESCAN_REP_INC_BUDGET) {
+                the_mode_change_list = &the_networks[data->net].
+                                        mode_change_budget_inc_list_head[me];
+        } else {
+                the_mode_change_list = &the_networks[data->net].
+                                        mode_change_budget_dec_list_head[me];
+        }
 
-        repneg_msg = (struct frescan_rep_neg_message_t *)msg;
+        INIT_LIST_HEAD(the_mode_change_list);
 
-        data->type         = FRESCAN_REP_NEG;
-        data->req          = repneg_msg->req;
-        data->return_value = repneg_msg->return_value;
-        data->final_values = repneg_msg->final_values;
+        msg_pointer = (uint8_t *)msg;
 
-        DEBUG(FRESCAN_MESSAGES_ENABLE_DEBUG, "type:%d req:%d ret:%d\n",
-              data->type, data->req, data->return_value);
+        while(msg_pointer < msg + size) {
+                ss = *((frescan_ss_t *)msg_pointer);
+                bytes_read = sizeof(frescan_ss_t);
+                msg_pointer = msg_pointer + bytes_read;
+
+                vres = &the_networks[data->net].scenario.vres_pool[me][ss];
+
+                vres->old_c = *((frsh_sa_time_t *)msg_pointer);
+                bytes_read = sizeof(frsh_sa_time_t);
+                msg_pointer = msg_pointer + bytes_read;
+        }
 
         return 0;
 }
@@ -463,8 +501,10 @@ int frescan_messages_send_request(const frescan_request_data_t *req_data)
                         size = frescan_request_to_cancel_message(req_data, msg);
                         send_params[req_data->net].to = FRESCAN_NEG_MASTER_NODE;
                         break;
-                case FRESCAN_REP_CHANGE:
-                        size = frescan_request_to_repchange_message(req_data, msg);
+                case FRESCAN_REP_DEC_BUDGET:
+                case FRESCAN_REP_INC_BUDGET:
+                        size = frescan_request_to_repchange_message
+                                        (req_data, msg);
                         send_params[req_data->net].to = req_data->request_node;
                         break;
                 case FRESCAN_REP_NEG:
@@ -538,8 +578,11 @@ int frescan_messages_recv_request(frescan_network_t    net,
                                                                 recv_bytes);
                 case FRESCAN_REQ_CANCEL:
                         return frescan_cancel_message_to_request(msg, req_data);
-                case FRESCAN_REP_CHANGE:
-                        return frescan_repchange_message_to_request(msg, req_data);
+                case FRESCAN_REP_DEC_BUDGET:
+                case FRESCAN_REP_INC_BUDGET:
+                        return frescan_repchange_message_to_request(msg,
+                                                                    req_data,
+                                                                    recv_bytes);
                 case FRESCAN_REP_NEG:
                         return frescan_repneg_message_to_request(msg, req_data);
                 default:

diff --git a/src_frescan/frescan_bwres_mode_change.c b/src_frescan/frescan_bwres_mode_change.c
index 30328c429e5289795a1ed0cbed35e0cf3426d358..1d44ea1f02437dc3ab9d2dd8084fe1e3c76869d2 100644 (file)
--- a/src_frescan/frescan_bwres_mode_change.c
+++ b/src_frescan/frescan_bwres_mode_change.c
@@ -150,7 +150,7 @@ int frescan_bwres_mode_change_protocol(frescan_request_data_t *req_data)
         }
 
         // mode change for B- members
-        for(node=FRESCAN_MX_NODES-1; node>=0; node--) {
+        for(node=0; node<FRESCAN_MX_NODES; node++) { // TODO: end with master
                 list_for_each_entry(vres,
                                     &the_networks[req_data->net].
                                      mode_change_budget_dec_list_head[node],

diff --git a/src_frescan/frescan_bwres_requests.h b/src_frescan/frescan_bwres_requests.h
index d6834c9f3e1ab6d5f0252feb8c4002b3b3ef0a70..002dd913a1b16f5f54e033486b2da38b25863ff5 100644 (file)
--- a/src_frescan/frescan_bwres_requests.h
+++ b/src_frescan/frescan_bwres_requests.h
@@ -95,8 +95,9 @@ typedef enum {
         FRESCAN_REQ_NEG    =  0,  // Negotiate a contract
         FRESCAN_REQ_RENEG  =  1,  // Renegotiate a contract
         FRESCAN_REQ_CANCEL =  2,  // Cancel a contract
-        FRESCAN_REP_CHANGE =  3,  // Change values due to spare capacity dist
-        FRESCAN_REP_NEG    =  4,  // Reply to (Re)Negotiate a contract
+        FRESCAN_REP_DEC_BUDGET =  3,  // Mode Change B-
+        FRESCAN_REP_INC_BUDGET =  4,  // Mode Change B+
+        FRESCAN_REP_NEG    =  5,  // Reply to (Re)Negotiate a contract
 } frescan_request_type_t;
 
 typedef enum {

diff --git a/src_frescan/frescan_bwres_threads.c b/src_frescan/frescan_bwres_threads.c
index e4efcc426df8049c1bb65b91345d6e60786ba79e..d23582fdf910546515a82eee20cb8bccc9cc5f58 100644 (file)
--- a/src_frescan/frescan_bwres_threads.c
+++ b/src_frescan/frescan_bwres_threads.c
@@ -223,41 +223,34 @@ static void frescan_manager_neg(frescan_request_data_t *req_data)
 {
         int ret;
         bool accepted;
+        frescan_sa_scenario_t *scenario;
 
         DEBUG(FRESCAN_MANAGER_ENABLE_DEBUG, "negotiation request\n");
 
+        scenario = &the_networks[req_data->net].scenario;
+
         if (the_networks[req_data->net].local_node == FRESCAN_NEG_MASTER_NODE) {
                 DEBUG(FRESCAN_MANAGER_ENABLE_DEBUG,
                       "add contract to scenario\n");
 
                 ret = frescan_sa_add_contract
-                                (&the_networks[req_data->net].scenario,
+                                (scenario,
                                  req_data->ss,
                                  req_data->request_node,
                                  req_data->contract);
                 assert(ret == 0);
 
-                DEBUG(FRESCAN_MANAGER_ENABLE_DEBUG,
-                      "assign priorities\n");
-
-                ret = frsh_sa_assign_priorities
-                                (&the_networks[req_data->net].scenario);
-                assert(ret == 0);
-
                 DEBUG(FRESCAN_MANAGER_ENABLE_DEBUG,
                       "perform sched analysis\n");
 
-                ret = frescan_sa_sched_test
-                                (&the_networks[req_data->net].scenario,
-                                 &accepted);
+                ret = frescan_sa_sched_test(scenario, &accepted);
                 assert(ret == 0);
 
                 if (accepted) {
                         DEBUG(FRESCAN_MANAGER_ENABLE_DEBUG,
                               "schedulable! distribute spare capacity\n");
 
-                        ret = frescan_sa_spare_capacity
-                                       (&the_networks[req_data->net].scenario);
+                        ret = frescan_sa_spare_capacity(scenario);
                         assert(ret == 0);
 
                         req_data->return_value = FRESCAN_REQ_ACCEPTED;
@@ -272,7 +265,7 @@ static void frescan_manager_neg(frescan_request_data_t *req_data)
                               "not schedulable!\n");
 
                         ret = frescan_sa_remove_contract
-                                        (&the_networks[req_data->net].scenario,
+                                        (scenario,
                                          req_data->ss,
                                          req_data->request_node);
                         assert(ret == 0);
@@ -309,40 +302,33 @@ static void frescan_manager_reneg(frescan_request_data_t *req_data)
         int ret;
         bool is_schedulable;
         frsh_contract_t old_contract;
+        frescan_sa_scenario_t *scenario;
 
         DEBUG(FRESCAN_MANAGER_ENABLE_DEBUG, "renegotiation request\n");
 
+        scenario = &the_networks[req_data->net].scenario;
+
         if (the_networks[req_data->net].local_node == FRESCAN_NEG_MASTER_NODE) {
                 // scheduling analysis
                 ret = frescan_sa_update_contract
-                                (&the_networks[req_data->net].scenario,
+                                (scenario,
                                  req_data->ss,
                                  req_data->request_node,
                                  req_data->contract,
                                  &old_contract);
                 assert(ret == 0);
 
-                DEBUG(FRESCAN_MANAGER_ENABLE_DEBUG,
-                      "assign priorities\n");
-
-                ret = frsh_sa_assign_priorities
-                                (&the_networks[req_data->net].scenario);
-                assert(ret == 0);
-
                 DEBUG(FRESCAN_MANAGER_ENABLE_DEBUG,
                       "perform sched analysis\n");
 
-                ret = frescan_sa_sched_test
-                                (&the_networks[req_data->net].scenario,
-                                 &is_schedulable);
+                ret = frescan_sa_sched_test(scenario, &is_schedulable);
                 assert(ret == 0);
 
-                if (accepted) {
+                if (is_schedulable) {
                         DEBUG(FRESCAN_MANAGER_ENABLE_DEBUG,
                               "schedulable! distribute spare capacity\n");
 
-                        ret = frescan_sa_spare_capacity
-                                        (&the_networks[req_data->net].scenario);
+                        ret = frescan_sa_spare_capacity(scenario);
                         assert(ret == 0);
 
                         req_data->return_value = FRESCAN_REQ_ACCEPTED;
@@ -354,7 +340,7 @@ static void frescan_manager_reneg(frescan_request_data_t *req_data)
                         assert(ret == 0);
                 } else {
                         ret = frescan_sa_update_contract
-                                        (&the_networks[req_data->net].scenario,
+                                        (scenario,
                                          req_data->ss,
                                          req_data->request_node,
                                          &old_contract,
@@ -385,12 +371,15 @@ static void frescan_manager_cancel(frescan_request_data_t *req_data)
 {
         int ret;
         bool is_schedulable;
+        frescan_sa_scenario_t *scenario;
 
         DEBUG(FRESCAN_MANAGER_ENABLE_DEBUG, "cancel request\n");
 
+        scenario = &the_networks[req_data->net].scenario;
+
         if (the_networks[req_data->net].local_node == FRESCAN_NEG_MASTER_NODE) {
                 ret = frescan_sa_remove_contract
-                                (&the_networks[req_data->net].scenario,
+                                (scenario,
                                  req_data->ss,
                                  req_data->request_node);
                 assert(ret == 0);
@@ -398,16 +387,10 @@ static void frescan_manager_cancel(frescan_request_data_t *req_data)
                 DEBUG(FRESCAN_MANAGER_ENABLE_DEBUG,
                       "assign priorities\n");
 
-                ret = frsh_sa_assign_priorities
-                                (&the_networks[req_data->net].scenario);
-                assert(ret == 0);
-
                 DEBUG(FRESCAN_MANAGER_ENABLE_DEBUG,
                       "perform sched analysis\n");
 
-                ret = frescan_sa_sched_test
-                                (&the_networks[req_data->net].scenario,
-                                 &is_schedulable);
+                ret = frescan_sa_sched_test(scenario, &is_schedulable);
                 assert(ret == 0);
 
                 assert(is_schedulable == true);
@@ -415,8 +398,7 @@ static void frescan_manager_cancel(frescan_request_data_t *req_data)
                 DEBUG(FRESCAN_MANAGER_ENABLE_DEBUG,
                       "redistribute spare capacity\n");
 
-                ret = frescan_sa_spare_capacity
-                                (&the_networks[req_data->net].scenario);
+                ret = frescan_sa_spare_capacity(scenario);
                 assert(ret == 0);
 
                 ret = frescan_bwres_mode_change_protocol(req_data);