ext/dsent/model/electrical/SeparableAllocator.cc - testing/jenkins-gem5-prod - Git at Google

 /* Copyright (c) 2012 Massachusetts Institute of Technology
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
  * in the Software without restriction, including without limitation the rights
  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  * copies of the Software, and to permit persons to whom the Software is
  * furnished to do so, subject to the following conditions:
  *
  * The above copyright notice and this permission notice shall be included in
  * all copies or substantial portions of the Software.
  *
  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  * THE SOFTWARE.
  */

 #include "model/electrical/SeparableAllocator.h"

 #include "model/ModelGen.h"
 #include "model/timing_graph/ElectricalNet.h"

 namespace DSENT
 {
     SeparableAllocator::SeparableAllocator(const String& instance_name_, const TechModel* tech_model_)
         : ElectricalModel(instance_name_, tech_model_)
     {
         initParameters();
         initProperties();
     }

     SeparableAllocator::~SeparableAllocator()
     {}

     void SeparableAllocator::initParameters()
     {
         addParameterName("NumberRequesters");
         addParameterName("NumberResources");
         addParameterName("IsRequesterFirst", true);
         addParameterName("Stage1->ArbiterModel");
         addParameterName("Stage2->ArbiterModel");
         return;
     }

     void SeparableAllocator::initProperties()
     {
         addPropertyName("P(Request)");
         addPropertyName("Act(Request)");
         addPropertyName("P(CK)");
         addPropertyName("Act(CK)");
         return;
     }

     SeparableAllocator* SeparableAllocator::clone() const
     {
         // TODO
         return NULL;
     }

     void SeparableAllocator::constructModel()
     {
         // Get parameters
         unsigned int number_requesters = getParameter("NumberRequesters").toUInt();
         unsigned int number_resources = getParameter("NumberResources").toUInt();
         bool is_requester_first = getParameter("IsRequesterFirst").toBool();
         const String& stage1_arbiter_model = getParameter("Stage1->ArbiterModel");
         const String& stage2_arbiter_model = getParameter("Stage2->ArbiterModel");

         ASSERT(number_requesters > 0, "[Error] " + getInstanceName() +
                 " -> Number of requesters must be > 0!");
         ASSERT(number_resources > 0, "[Error] " + getInstanceName() +
                 " -> Number of resources must be > 0!");

         // Create area, power, and event results
         createElectricalResults();
         addEventResult(new Result("Allocate"));

         // Create ports
         createInputPort("CK");
         for(unsigned int i = 0; i < number_requesters; ++i)
         {
             createInputPort("Request" + (String)i, makeNetIndex(0, number_resources-1));
             createOutputPort("Grant" + (String)i, makeNetIndex(0, number_resources-1));
         }

         // If is_requester_first is set, requests from the same requester will be arbitrate
         // on stage 1
         if(is_requester_first)
         {
             // Init stage 1 arbiters
             for(unsigned int i = 0; i < number_requesters; ++i)
             {
                 ElectricalModel* arb = (ElectricalModel*)ModelGen::createModel(stage1_arbiter_model, "Stage1Arb" + (String)i, getTechModel());
                 arb->setParameter("NumberRequests", number_resources);
                 arb->construct();

                 addSubInstances(arb, 1.0);
                 addElectricalSubResults(arb, 1.0);

                 getEventResult("Allocate")->addSubResult(arb->getEventResult("Arbitrate"), arb->getInstanceName(), 1.0);

                 createNet("Stage1Arb_In" + (String)i, makeNetIndex(0, number_resources-1));
                 createNet("Stage1Arb_Out" + (String)i, makeNetIndex(0, number_resources-1));

                 portConnect(arb, "CK", "CK");
                 assign("Stage1Arb_In" + (String)i, "Request" + (String)i);
                 for(unsigned int j = 0; j < number_resources; ++j)
                 {
                     portConnect(arb, "Request" + (String)j, "Stage1Arb_In" + (String)i, makeNetIndex(j));
                     portConnect(arb, "Grant" + (String)j, "Stage1Arb_Out" + (String)i, makeNetIndex(j));
                 }
             }

             // Init stage 2 arbiters
             for(unsigned int i = 0; i < number_resources; ++i)
             {
                 ElectricalModel* arb = (ElectricalModel*)ModelGen::createModel(stage2_arbiter_model, "Stage2Arb" + (String)i, getTechModel());
                 arb->setParameter("NumberRequests", number_requesters);
                 arb->construct();

                 addSubInstances(arb, 1.0);
                 addElectricalSubResults(arb, 1.0);

                 getEventResult("Allocate")->addSubResult(arb->getEventResult("Arbitrate"), arb->getInstanceName(), 1.0);

                 createNet("Stage2Arb_In" + (String)i, makeNetIndex(0, number_requesters-1));
                 createNet("Stage2Arb_Out" + (String)i, makeNetIndex(0, number_requesters-1));

                 portConnect(arb, "CK", "CK");
                 for(unsigned int j = 0; j < number_requesters; ++j)
                 {
                     assign("Stage2Arb_In" + (String)i, makeNetIndex(j), "Stage1Arb_Out" + (String)j, makeNetIndex(i));
                     portConnect(arb, "Request" + (String)j, "Stage2Arb_In" + (String)i, makeNetIndex(j));
                     portConnect(arb, "Grant" + (String)j, "Stage2Arb_Out" + (String)i, makeNetIndex(j));
                     assign("Grant" + (String)j, makeNetIndex(i), "Stage2Arb_Out" + (String)i, makeNetIndex(j));
                 }
             }
         }
         else
         {
             // Init stage 1 arbiters
             for(unsigned int i = 0; i < number_resources; ++i)
             {
                 ElectricalModel* arb = (ElectricalModel*)ModelGen::createModel(stage1_arbiter_model, "Stage1Arb" + (String)i, getTechModel());
                 arb->setParameter("NumberRequests", number_requesters);
                 arb->construct();

                 addSubInstances(arb, 1.0);
                 addElectricalSubResults(arb, 1.0);

                 getEventResult("Allocate")->addSubResult(arb->getEventResult("Arbitrate"), arb->getInstanceName(), 1.0);

                 createNet("Stage1Arb_In" + (String)i, makeNetIndex(0, number_requesters-1));
                 createNet("Stage1Arb_Out" + (String)i, makeNetIndex(0, number_requesters-1));

                 portConnect(arb, "CK", "CK");
                 for(unsigned int j = 0; j < number_requesters; ++j)
                 {
                     assign("Stage1Arb_In" + (String)i, makeNetIndex(j), "Request" + (String)j, makeNetIndex(i));
                     portConnect(arb, "Request" + (String)j, "Stage1Arb_In" + (String)i, makeNetIndex(j));
                     portConnect(arb, "Grant" + (String)j, "Stage1Arb_Out" + (String)i, makeNetIndex(j));
                 }
             }

             // Init stage 2 arbiters
             for(unsigned int i = 0; i < number_requesters; ++i)
             {
                 ElectricalModel* arb = (ElectricalModel*)ModelGen::createModel(stage2_arbiter_model, "Stage2Arb" + (String)i, getTechModel());
                 arb->setParameter("NumberRequests", number_requesters);
                 arb->construct();

                 addSubInstances(arb, 1.0);
                 addElectricalSubResults(arb, 1.0);

                 getEventResult("Allocate")->addSubResult(arb->getEventResult("Arbitrate"), arb->getInstanceName(), 1.0);

                 createNet("Stage2Arb_In" + (String)i, makeNetIndex(0, number_resources-1));
                 createNet("Stage2Arb_Out" + (String)i, makeNetIndex(0, number_resources-1));

                 portConnect(arb, "CK", "CK");
                 for(unsigned int j = 0; j < number_resources; ++j)
                 {
                     assign("Stage2Arb_In" + (String)i, makeNetIndex(j), "Stage1Arb_Out" + (String)j, makeNetIndex(i));
                     portConnect(arb, "Request" + (String)j, "Stage2Arb_In", makeNetIndex(j));
                     portConnect(arb, "Grant" + (String)j, "Stage2Arb_Out", makeNetIndex(j));
                 }
                 assign("Grant" + (String)i, "Stage2Arb_Out" + (String)i);
             }
         }
         return;
     }

     void SeparableAllocator::updateModel()
     {
         // Get parameters
         unsigned int number_requesters = getParameter("NumberRequesters").toUInt();
         unsigned int number_resources = getParameter("NumberResources").toUInt();
         bool is_requester_first = getParameter("IsRequesterFirst").toBool();

         // Get probabilities from inputs
         const String& P_request = getProperty("P(Request)");
         const String& act_request = getProperty("Act(Request)");
         const String& P_CK = getProperty("P(CK)");
         const String& act_CK = getProperty("Act(CK)");

         const vector<double>& P_request_vector = LibUtil::castStringVector<double>(P_request.split("[,]"));
         const vector<double>& act_request_vector = LibUtil::castStringVector<double>(act_request.split("[,]"));

         ASSERT(P_request_vector.size() == (number_requesters * number_resources), "[Error] " + getInstanceName() +
                 " -> Expecting " + (String)(number_requesters * number_resources) +
                 " request probabilities, but got " + P_request);
         ASSERT(act_request_vector.size() == (number_requesters * number_resources), "[Error] " + getInstanceName() +
                 " -> Expecting " + (String)(number_requesters * number_resources) +
                 " request actvities multiplier, but got " + act_request);

         vector<double> P_int_request_vector(number_requesters * number_resources, 0.0);
         vector<double> act_int_request_vector(number_requesters * number_resources, 0.0);
         vector<double> P_out_request_vector(number_requesters * number_resources, 0.0);
         vector<double> act_out_request_vector(number_requesters * number_resources, 0.0);
         if(is_requester_first)
         {
             // Update stage1 arbiter
             for(unsigned int i = 0; i < number_requesters; ++i)
             {
                 vector<double> P_arb_request_vector(number_resources, 0.0);
                 vector<double> act_arb_request_vector(number_resources, 0.0);
                 for(unsigned int j = 0; j < number_resources; ++j)
                 {
                     P_arb_request_vector[j] = P_request_vector[i * number_resources + j];
                     act_arb_request_vector[j] = act_request_vector[i * number_resources + j];
                 }

                 Model* arb = getSubInstance("Stage1Arb" + (String)i);
                 arb->setProperty("P(Request)", LibUtil::vectorToString(P_arb_request_vector));
                 arb->setProperty("Act(Request)", LibUtil::vectorToString(act_arb_request_vector));
                 arb->setProperty("P(CK)", P_CK);
                 arb->setProperty("Act(CK)", act_CK);
                 arb->update();

                 const vector<double>& P_arb_out_request_vector = LibUtil::castStringVector<double>(arb->getGenProperties()->get("P(Grant)").split("[,]"));
                 const vector<double>& act_arb_out_request_vector = LibUtil::castStringVector<double>(arb->getGenProperties()->get("Act(Grant)").split("[,]"));
                 for(unsigned int j = 0; j < number_resources; ++j)
                 {
                     P_int_request_vector[i * number_resources + j] = P_arb_out_request_vector[j];
                     act_int_request_vector[i * number_resources + j] = act_arb_out_request_vector[j];
                 }
             }
             // Update stage2 arbiter
             for(unsigned int i = 0; i < number_resources; ++i)
             {
                 vector<double> P_arb_request_vector(number_requesters, 0.0);
                 vector<double> act_arb_request_vector(number_requesters, 0.0);
                 for(unsigned int j = 0; j < number_requesters; ++j)
                 {
                     P_arb_request_vector[j] = P_int_request_vector[j * number_resources + i];
                     act_arb_request_vector[j] = act_int_request_vector[j * number_resources + i];
                 }

                 Model* arb = getSubInstance("Stage2Arb" + (String)i);
                 arb->setProperty("P(Request)", LibUtil::vectorToString(P_arb_request_vector));
                 arb->setProperty("Act(Request)", LibUtil::vectorToString(act_arb_request_vector));
                 arb->setProperty("P(CK)", P_CK);
                 arb->setProperty("Act(CK)", act_CK);
                 arb->update();

                 const vector<double>& P_arb_out_request_vector = LibUtil::castStringVector<double>(arb->getGenProperties()->get("P(Grant)").split("[,]"));
                 const vector<double>& act_arb_out_request_vector = LibUtil::castStringVector<double>(arb->getGenProperties()->get("Act(Grant)").split("[,]"));
                 for(unsigned int j = 0; j < number_requesters; ++j)
                 {
                     P_out_request_vector[j * number_resources + i] = P_arb_out_request_vector[j];
                     act_out_request_vector[j * number_resources + i] = act_arb_out_request_vector[j];
                 }
             }
         }
         else
         {

         }

         // Update output probabilities
         getGenProperties()->set("P(Grant)", LibUtil::vectorToString(P_out_request_vector));
         getGenProperties()->set("Act(Grant)", LibUtil::vectorToString(act_out_request_vector));

         return;
     }
 } // namespace DSENT
	/* Copyright (c) 2012 Massachusetts Institute of Technology
	*
	* Permission is hereby granted, free of charge, to any person obtaining a copy
	* of this software and associated documentation files (the "Software"), to deal
	* in the Software without restriction, including without limitation the rights
	* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
	* copies of the Software, and to permit persons to whom the Software is
	* furnished to do so, subject to the following conditions:
	*
	* The above copyright notice and this permission notice shall be included in
	* all copies or substantial portions of the Software.
	*
	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
	* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
	* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
	* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
	* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
	* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
	* THE SOFTWARE.
	*/

	#include "model/electrical/SeparableAllocator.h"

	#include "model/ModelGen.h"
	#include "model/timing_graph/ElectricalNet.h"

	namespace DSENT
	{
	SeparableAllocator::SeparableAllocator(const String& instance_name_, const TechModel* tech_model_)
	: ElectricalModel(instance_name_, tech_model_)
	{
	initParameters();
	initProperties();
	}

	SeparableAllocator::~SeparableAllocator()
	{}

	void SeparableAllocator::initParameters()
	{
	addParameterName("NumberRequesters");
	addParameterName("NumberResources");
	addParameterName("IsRequesterFirst", true);
	addParameterName("Stage1->ArbiterModel");
	addParameterName("Stage2->ArbiterModel");
	return;
	}

	void SeparableAllocator::initProperties()
	{
	addPropertyName("P(Request)");
	addPropertyName("Act(Request)");
	addPropertyName("P(CK)");
	addPropertyName("Act(CK)");
	return;
	}

	SeparableAllocator* SeparableAllocator::clone() const
	{
	// TODO
	return NULL;
	}

	void SeparableAllocator::constructModel()
	{
	// Get parameters
	unsigned int number_requesters = getParameter("NumberRequesters").toUInt();
	unsigned int number_resources = getParameter("NumberResources").toUInt();
	bool is_requester_first = getParameter("IsRequesterFirst").toBool();
	const String& stage1_arbiter_model = getParameter("Stage1->ArbiterModel");
	const String& stage2_arbiter_model = getParameter("Stage2->ArbiterModel");

	ASSERT(number_requesters > 0, "[Error] " + getInstanceName() +
	" -> Number of requesters must be > 0!");
	ASSERT(number_resources > 0, "[Error] " + getInstanceName() +
	" -> Number of resources must be > 0!");

	// Create area, power, and event results
	createElectricalResults();
	addEventResult(new Result("Allocate"));

	// Create ports
	createInputPort("CK");
	for(unsigned int i = 0; i < number_requesters; ++i)
	{
	createInputPort("Request" + (String)i, makeNetIndex(0, number_resources-1));
	createOutputPort("Grant" + (String)i, makeNetIndex(0, number_resources-1));
	}

	// If is_requester_first is set, requests from the same requester will be arbitrate
	// on stage 1
	if(is_requester_first)
	{
	// Init stage 1 arbiters
	for(unsigned int i = 0; i < number_requesters; ++i)
	{
	ElectricalModel* arb = (ElectricalModel*)ModelGen::createModel(stage1_arbiter_model, "Stage1Arb" + (String)i, getTechModel());
	arb->setParameter("NumberRequests", number_resources);
	arb->construct();

	addSubInstances(arb, 1.0);
	addElectricalSubResults(arb, 1.0);

	getEventResult("Allocate")->addSubResult(arb->getEventResult("Arbitrate"), arb->getInstanceName(), 1.0);

	createNet("Stage1Arb_In" + (String)i, makeNetIndex(0, number_resources-1));
	createNet("Stage1Arb_Out" + (String)i, makeNetIndex(0, number_resources-1));

	portConnect(arb, "CK", "CK");
	assign("Stage1Arb_In" + (String)i, "Request" + (String)i);
	for(unsigned int j = 0; j < number_resources; ++j)
	{
	portConnect(arb, "Request" + (String)j, "Stage1Arb_In" + (String)i, makeNetIndex(j));
	portConnect(arb, "Grant" + (String)j, "Stage1Arb_Out" + (String)i, makeNetIndex(j));
	}
	}

	// Init stage 2 arbiters
	for(unsigned int i = 0; i < number_resources; ++i)
	{
	ElectricalModel* arb = (ElectricalModel*)ModelGen::createModel(stage2_arbiter_model, "Stage2Arb" + (String)i, getTechModel());
	arb->setParameter("NumberRequests", number_requesters);
	arb->construct();

	addSubInstances(arb, 1.0);
	addElectricalSubResults(arb, 1.0);

	getEventResult("Allocate")->addSubResult(arb->getEventResult("Arbitrate"), arb->getInstanceName(), 1.0);

	createNet("Stage2Arb_In" + (String)i, makeNetIndex(0, number_requesters-1));
	createNet("Stage2Arb_Out" + (String)i, makeNetIndex(0, number_requesters-1));

	portConnect(arb, "CK", "CK");
	for(unsigned int j = 0; j < number_requesters; ++j)
	{
	assign("Stage2Arb_In" + (String)i, makeNetIndex(j), "Stage1Arb_Out" + (String)j, makeNetIndex(i));
	portConnect(arb, "Request" + (String)j, "Stage2Arb_In" + (String)i, makeNetIndex(j));
	portConnect(arb, "Grant" + (String)j, "Stage2Arb_Out" + (String)i, makeNetIndex(j));
	assign("Grant" + (String)j, makeNetIndex(i), "Stage2Arb_Out" + (String)i, makeNetIndex(j));
	}
	}
	}
	else
	{
	// Init stage 1 arbiters
	for(unsigned int i = 0; i < number_resources; ++i)
	{
	ElectricalModel* arb = (ElectricalModel*)ModelGen::createModel(stage1_arbiter_model, "Stage1Arb" + (String)i, getTechModel());
	arb->setParameter("NumberRequests", number_requesters);
	arb->construct();

	addSubInstances(arb, 1.0);
	addElectricalSubResults(arb, 1.0);

	getEventResult("Allocate")->addSubResult(arb->getEventResult("Arbitrate"), arb->getInstanceName(), 1.0);

	createNet("Stage1Arb_In" + (String)i, makeNetIndex(0, number_requesters-1));
	createNet("Stage1Arb_Out" + (String)i, makeNetIndex(0, number_requesters-1));

	portConnect(arb, "CK", "CK");
	for(unsigned int j = 0; j < number_requesters; ++j)
	{
	assign("Stage1Arb_In" + (String)i, makeNetIndex(j), "Request" + (String)j, makeNetIndex(i));
	portConnect(arb, "Request" + (String)j, "Stage1Arb_In" + (String)i, makeNetIndex(j));
	portConnect(arb, "Grant" + (String)j, "Stage1Arb_Out" + (String)i, makeNetIndex(j));
	}
	}

	// Init stage 2 arbiters
	for(unsigned int i = 0; i < number_requesters; ++i)
	{
	ElectricalModel* arb = (ElectricalModel*)ModelGen::createModel(stage2_arbiter_model, "Stage2Arb" + (String)i, getTechModel());
	arb->setParameter("NumberRequests", number_requesters);
	arb->construct();

	addSubInstances(arb, 1.0);
	addElectricalSubResults(arb, 1.0);

	getEventResult("Allocate")->addSubResult(arb->getEventResult("Arbitrate"), arb->getInstanceName(), 1.0);

	createNet("Stage2Arb_In" + (String)i, makeNetIndex(0, number_resources-1));
	createNet("Stage2Arb_Out" + (String)i, makeNetIndex(0, number_resources-1));

	portConnect(arb, "CK", "CK");
	for(unsigned int j = 0; j < number_resources; ++j)
	{
	assign("Stage2Arb_In" + (String)i, makeNetIndex(j), "Stage1Arb_Out" + (String)j, makeNetIndex(i));
	portConnect(arb, "Request" + (String)j, "Stage2Arb_In", makeNetIndex(j));
	portConnect(arb, "Grant" + (String)j, "Stage2Arb_Out", makeNetIndex(j));
	}
	assign("Grant" + (String)i, "Stage2Arb_Out" + (String)i);
	}
	}
	return;
	}

	void SeparableAllocator::updateModel()
	{
	// Get parameters
	unsigned int number_requesters = getParameter("NumberRequesters").toUInt();
	unsigned int number_resources = getParameter("NumberResources").toUInt();
	bool is_requester_first = getParameter("IsRequesterFirst").toBool();

	// Get probabilities from inputs
	const String& P_request = getProperty("P(Request)");
	const String& act_request = getProperty("Act(Request)");
	const String& P_CK = getProperty("P(CK)");
	const String& act_CK = getProperty("Act(CK)");

	const vector<double>& P_request_vector = LibUtil::castStringVector<double>(P_request.split("[,]"));
	const vector<double>& act_request_vector = LibUtil::castStringVector<double>(act_request.split("[,]"));

	ASSERT(P_request_vector.size() == (number_requesters * number_resources), "[Error] " + getInstanceName() +
	" -> Expecting " + (String)(number_requesters * number_resources) +
	" request probabilities, but got " + P_request);
	ASSERT(act_request_vector.size() == (number_requesters * number_resources), "[Error] " + getInstanceName() +
	" -> Expecting " + (String)(number_requesters * number_resources) +
	" request actvities multiplier, but got " + act_request);

	vector<double> P_int_request_vector(number_requesters * number_resources, 0.0);
	vector<double> act_int_request_vector(number_requesters * number_resources, 0.0);
	vector<double> P_out_request_vector(number_requesters * number_resources, 0.0);
	vector<double> act_out_request_vector(number_requesters * number_resources, 0.0);
	if(is_requester_first)
	{
	// Update stage1 arbiter
	for(unsigned int i = 0; i < number_requesters; ++i)
	{
	vector<double> P_arb_request_vector(number_resources, 0.0);
	vector<double> act_arb_request_vector(number_resources, 0.0);
	for(unsigned int j = 0; j < number_resources; ++j)
	{
	P_arb_request_vector[j] = P_request_vector[i * number_resources + j];
	act_arb_request_vector[j] = act_request_vector[i * number_resources + j];
	}

	Model* arb = getSubInstance("Stage1Arb" + (String)i);
	arb->setProperty("P(Request)", LibUtil::vectorToString(P_arb_request_vector));
	arb->setProperty("Act(Request)", LibUtil::vectorToString(act_arb_request_vector));
	arb->setProperty("P(CK)", P_CK);
	arb->setProperty("Act(CK)", act_CK);
	arb->update();

	const vector<double>& P_arb_out_request_vector = LibUtil::castStringVector<double>(arb->getGenProperties()->get("P(Grant)").split("[,]"));
	const vector<double>& act_arb_out_request_vector = LibUtil::castStringVector<double>(arb->getGenProperties()->get("Act(Grant)").split("[,]"));
	for(unsigned int j = 0; j < number_resources; ++j)
	{
	P_int_request_vector[i * number_resources + j] = P_arb_out_request_vector[j];
	act_int_request_vector[i * number_resources + j] = act_arb_out_request_vector[j];
	}
	}
	// Update stage2 arbiter
	for(unsigned int i = 0; i < number_resources; ++i)
	{
	vector<double> P_arb_request_vector(number_requesters, 0.0);
	vector<double> act_arb_request_vector(number_requesters, 0.0);
	for(unsigned int j = 0; j < number_requesters; ++j)
	{
	P_arb_request_vector[j] = P_int_request_vector[j * number_resources + i];
	act_arb_request_vector[j] = act_int_request_vector[j * number_resources + i];
	}

	Model* arb = getSubInstance("Stage2Arb" + (String)i);
	arb->setProperty("P(Request)", LibUtil::vectorToString(P_arb_request_vector));
	arb->setProperty("Act(Request)", LibUtil::vectorToString(act_arb_request_vector));
	arb->setProperty("P(CK)", P_CK);
	arb->setProperty("Act(CK)", act_CK);
	arb->update();

	const vector<double>& P_arb_out_request_vector = LibUtil::castStringVector<double>(arb->getGenProperties()->get("P(Grant)").split("[,]"));
	const vector<double>& act_arb_out_request_vector = LibUtil::castStringVector<double>(arb->getGenProperties()->get("Act(Grant)").split("[,]"));
	for(unsigned int j = 0; j < number_requesters; ++j)
	{
	P_out_request_vector[j * number_resources + i] = P_arb_out_request_vector[j];
	act_out_request_vector[j * number_resources + i] = act_arb_out_request_vector[j];
	}
	}
	}
	else
	{

	}

	// Update output probabilities
	getGenProperties()->set("P(Grant)", LibUtil::vectorToString(P_out_request_vector));
	getGenProperties()->set("Act(Grant)", LibUtil::vectorToString(act_out_request_vector));

	return;
	}
	} // namespace DSENT