private void handleSolvePartialProblemsMessage(SolvePartialProblemsMessage message)
{
//number of PartialProblems shouldn't be bigger than the number of idle threads.
int numberOfPartialProblems = message.PartialProblems.Count();
int partialProblemCounter = 0;
for (int i = 0; i < systemTracker.Node.ParallelThreads && partialProblemCounter < numberOfPartialProblems; i++)
{
if (systemTracker.Node.TaskThreads[i].StatusThread.State == StatusThreadState.Idle)
{
DVRPSolver dvrpSolver = new DVRPSolver(message.PartialProblems[partialProblemCounter].Data);
systemTracker.Node.TaskThreads[i].StatusThread.State = StatusThreadState.Busy;
systemTracker.Node.TaskThreads[i].CurrentTask = new Cluster.Task((int)message.Id, message.ProblemType,
message.PartialProblems[i].Data)
{
Status = Cluster.TaskStatus.Solving
};
systemTracker.Node.TaskThreads[i].TaskSolver = dvrpSolver;
systemTracker.Node.TaskThreads[i].Thread = new Thread(new ThreadStart(systemTracker.Node.TaskThreads[i].Start));
systemTracker.Node.TaskThreads[i].Thread.Start();
partialProblemCounter++;
SmartConsole.PrintLine("Thread number: " + i + " is solving partial problemŁ " + partialProblemCounter, SmartConsole.DebugLevel.Advanced);
}
}
///WE SHOULD CHECK HERE WHETHER THERE WAS IDLE THREAD AVALIABLE !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
// start computations
}
public static SolvePartialProblemsMessage CreateSolvePartialProblemsMessage()
{
string problemType = "TSP";
ulong id = 12;
byte[] commonData = { 1, 23, 25, 2, 5, 5, 5, 5, 2, 26, 87 };
ulong solvingTimeout = 1000;
// fields for PartialProblem1
ulong taskId1 = 123;
byte[] data1 = { 24, 252, 6, 43, 57, 88 };
ulong nodeId1 = 1;
PartialProblem partialProblem1 = new PartialProblem(taskId1, data1, nodeId1);
// fields for PartialProblem2
ulong taskId2 = 321;
byte[] data2 = { 24, 252, 6, 43, 57, 88 };
ulong nodeId2 = 2;
PartialProblem partialProblem2 = new PartialProblem(taskId2, data2, nodeId2);
PartialProblem[] partialProblems = { partialProblem1, partialProblem2 };
SolvePartialProblemsMessage expectedMessage = new SolvePartialProblemsMessage(problemType, id, commonData,
solvingTimeout, partialProblems);
return(expectedMessage);
}
/*******************************************************************/
/************************ PRIVATE METHODS **************************/
/*******************************************************************/
/*******************************************************************/
/************************* PUBLIC METHODS **************************/
/*******************************************************************/
public void Start()
{
switch (currentTask.Status)
{
case TaskStatus.Dividing:
byte[][] dividedProblems = taskSolver.DivideProblem(4);
PartialProblem[] partialProblems = new PartialProblem[dividedProblems.Count()];
for (int i = 0; i < dividedProblems.Count(); i++)
{
partialProblems[i] = new PartialProblem((ulong)currentTask.ID, dividedProblems[i], (ulong)NodeID);
}
SolvePartialProblemsMessage solvePartialProblemsMessage = new SolvePartialProblemsMessage(currentTask.Type, (ulong)currentTask.ID, currentTask.CommonData, (ulong)4, partialProblems);
Console.Write(">>Sending solve partial problems message. ");
messageProcessor.Communicate(solvePartialProblemsMessage);
this.statusThread.State = StatusThreadState.Idle;
this.currentTask = null;
break;
case TaskStatus.Solving:
byte[] solvedPartialProblem = taskSolver.Solve(currentTask.BaseData, new TimeSpan(0, 0, 5));
Solution[] solutions = new Solution[1];
//TODO subTask id, timeout checking , computations time
solutions[0] = new Solution((ulong)currentTask.ID, false, SolutionsSolutionType.Partial, 4000, solvedPartialProblem);
SolutionsMessage solutionMessage = new SolutionsMessage(currentTask.Type, (ulong)currentTask.ID, currentTask.CommonData, solutions);
Console.WriteLine(">>Sending solution message. ");
messageProcessor.Communicate(solutionMessage);
statusThread.State = StatusThreadState.Idle;
this.currentTask = null;
break;
case TaskStatus.Merging:
byte[][] partialSolutions = new byte[currentTask.subTasks.Count()][];
for (int i = 0; i < currentTask.subTasks.Count(); i++)
{
partialSolutions[i] = currentTask.subTasks[i].BaseData;
}
byte[] mergedSolution = taskSolver.MergeSolution(partialSolutions);
Solution[] solution = new Solution[1];
//TODO subTask id, timeout checking , computations time
solution[0] = new Solution((ulong)currentTask.ID, false, SolutionsSolutionType.Final, 4000, mergedSolution);
SolutionsMessage finalSolutionMessage = new SolutionsMessage(currentTask.Type, (ulong)currentTask.ID, currentTask.CommonData, solution);
messageProcessor.Communicate(finalSolutionMessage);
this.statusThread.State = StatusThreadState.Idle;
this.currentTask = null;
break;
}
// Implement in private methods:
// Depending on what has to be computed
// run a task solver method.
// TODO collect result.
}
/// <summary>
/// Constructs message by given xml string
/// </summary>
/// <param name="xmlString">
/// xml in string
/// </param>
/// <returns>
/// Message constructed by the xml
/// </returns>
public static Message Construct(string xmlString)
{
xmlString = concCompabilityIssuesStringWojtekIsGay(xmlString);
if (GetMessageName(xmlString) == RegisterMessage.ELEMENT_NAME)
{
return(RegisterMessage.Construct(xmlString));
}
if (GetMessageName(xmlString) == DivideProblemMessage.ELEMENT_NAME)
{
return(DivideProblemMessage.Construct(xmlString));
}
if (GetMessageName(xmlString) == NoOperationMessage.ELEMENT_NAME)
{
return(NoOperationMessage.Construct(xmlString));
}
if (GetMessageName(xmlString) == RegisterResponseMessage.ELEMENT_NAME)
{
return(RegisterResponseMessage.Construct(xmlString));
}
if (GetMessageName(xmlString) == SolutionRequestMessage.ELEMENT_NAME)
{
return(SolutionRequestMessage.Construct(xmlString));
}
if (GetMessageName(xmlString) == SolutionsMessage.ELEMENT_NAME)
{
return(SolutionsMessage.Construct(xmlString));
}
if (GetMessageName(xmlString) == SolvePartialProblemsMessage.ELEMENT_NAME)
{
try
{
//return SolvePartialProblemsMessage.Construct(xmlString);
}
catch (InvalidOperationException e) { return(null); }
Console.WriteLine("******** SOLVE PARTIAL PROBLEM MESSAGE **************");
return(SolvePartialProblemsMessage.Construct(xmlString));
}
if (GetMessageName(xmlString) == SolveRequestMessage.ELEMENT_NAME)
{
return(SolveRequestMessage.Construct(xmlString));
}
if (GetMessageName(xmlString) == SolveRequestResponseMessage.ELEMENT_NAME)
{
return(SolveRequestResponseMessage.Construct(xmlString));
}
if (GetMessageName(xmlString) == StatusMessage.ELEMENT_NAME)
{
return(StatusMessage.Construct(xmlString));
}
return(null);
}
/// <summary>
/// function sending PartialProblems message
/// </summary>
/// <param name="numOfTask"></param>
/// <param name="partialList"></param>
/// <param name="messagePackage"></param>
/// <returns></returns>
private bool SendPartialProblemsMessage(int numOfTask, List <PartialProblem> partialList, MessagePackage messagePackage)
{
PartialProblem[] partialProblems = new PartialProblem[partialList.Count];
for (int j = 0; j < partialList.Count; j++)
{
partialProblems[j] = partialList[j];
}
SolvePartialProblemsMessage solvePartialProblemsMessage = new SolvePartialProblemsMessage(taskTracker.Tasks[numOfTask].Type, (ulong)taskTracker.Tasks[numOfTask].ID, taskTracker.Tasks[numOfTask].CommonData, (ulong)4, partialProblems);
server.Send(messagePackage.Socket, solvePartialProblemsMessage);
SmartConsole.PrintLine("Solve Partial Problems Message has been send (to Computational node). Number of subTasks." + partialList.Count, SmartConsole.DebugLevel.Advanced);
return(true);
}
public void Parse_XMLString_SolvePartialProblemsMessage()
{
/*********** Actual message ***********/
string path = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, @"xml_samples\SolvePartialProblems.xml");
XmlDocument xmlDoc = new XmlDocument();
xmlDoc.Load(path);
string xmlStr = xmlDoc.OuterXml;
string name = Message.GetMessageName(xmlStr);
SolvePartialProblemsMessage actualMessage = null;
if (name == SolvePartialProblemsMessage.ELEMENT_NAME)
{
actualMessage = SolvePartialProblemsMessage.Construct(xmlStr);
}
/*********** Expected message ***********/
string problemType = "TSP";
ulong id = 12;
byte[] commonData = { 1, 23, 25, 2, 5, 5, 5, 5, 2, 26, 87 };
ulong solvingTimeout = 1000;
// fields for PartialProblem1
ulong taskId1 = 123;
byte[] data1 = { 24, 252, 6, 43, 57, 88 };
ulong nodeId1 = 1;
PartialProblem partialProblem1 = new PartialProblem(taskId1, data1, nodeId1);
// fields for PartialProblem2
ulong taskId2 = 321;
byte[] data2 = { 24, 252, 6, 43, 57, 88 };
ulong nodeId2 = 2;
PartialProblem partialProblem2 = new PartialProblem(taskId2, data2, nodeId2);
PartialProblem[] partialProblems = { partialProblem1, partialProblem2 };
SolvePartialProblemsMessage expectedMessage = new SolvePartialProblemsMessage(problemType, id, commonData,
solvingTimeout, partialProblems);
Assert.AreEqual(expectedMessage, actualMessage);
}
public void SolvePartialProblemsSerializationTest()
{
byte[] byteArray = Encoding.UTF8.GetBytes("Test Byte Array");
PartialProblem partialProblem = new PartialProblem
{
Data = byteArray,
TaskId = 123L,
};
List <PartialProblem> partialProblems = new List <PartialProblem>();
partialProblems.Add(partialProblem);
var partialProblemsMessage = new SolvePartialProblemsMessage("Problem Type", 123L, byteArray, 122L, partialProblems);
var result = partialProblemsMessage.SerializeToXml();
Assert.IsNotNull(result);
Assert.AreNotEqual(0, result.Length);
var xmlValidator = new XmlValidator();
var xsdSchemaFile = "SolvePartialProblems.xsd";
var xsdSchemaPath = Path.Combine(_xsdSchemasPath, xsdSchemaFile);
var validationResult = xmlValidator.Validate(result, xsdSchemaPath, true);
var errorsCount = validationResult.Errors.Count + validationResult.Warnings.Count;
Assert.AreEqual(0, errorsCount);
#region ExampleResult
//<?xml version="1.0" encoding="utf-16"?>
//<PartialProblems xmlns="http://www.mini.pw.edu.pl/ucc/">
// <ProblemType>Problem Type</ProblemType>
// <Id>123</Id>
// <CommonData>VGVzdCBCeXRlIEFycmF5</CommonData>
// <SolvingTimeout>122L</SolvingTimeout>
// <PartialProblems>
// <PartialProblem>
// <TaskId>123</TaskId>
// <Data>VGVzdCBCeXRlIEFycmF5</Data>
// </PartialProblem>
// </PartialProblems>
//</PartialProblems>
#endregion
}
protected override void ProcessSolvePartialProblemsMessage(SolvePartialProblemsMessage message)
{
var partialProblemsHelper = new PartialProblemsHelper(message);
foreach (var partialProblem in partialProblemsHelper.Problems)
{
var thread = new IOThread()
{
TaskId = partialProblem.TaskId,
ProblemInstanceId = message.Id,
ProblemType = message.ProblemType,
State = EState.Busy,
RealThread = new Thread(() => SolvePartialProblem(partialProblemsHelper, partialProblem))
};
_runningThreads.Add(thread);
thread.RealThread.Start();
}
}
private void ProcessSolvePartialProblemsMessage(SolvePartialProblemsMessage partialProblemsMsg)
{
var availableNodes = GetComputationalNodesByProblemType(partialProblemsMsg.ProblemType);
var availableNodesCount = availableNodes.Count;
if (availableNodesCount == 0)
{
EventLogger.GetLog().ErrorFormat("Brak node'ów dla problemu {0} - id:{1}", partialProblemsMsg.ProblemType, partialProblemsMsg.Id);
return;
}
var subProblemDivision = new List <List <PartialProblem> >(availableNodesCount); //Lista podproblemow dla kazdego node'a
for (int i = 0; i < availableNodesCount; i++)
{
subProblemDivision.Add(new List <PartialProblem>());
}
var partialProblems = partialProblemsMsg.PartialProblems;
for (int i = 0; i < partialProblems.Count; i++) //przydziel podproblemy
{
subProblemDivision[i % availableNodesCount].Add(partialProblems[i]);
}
for (int i = 0; i < subProblemDivision.Count; i++) //Roześlij
{
var node = availableNodes[i];
var message = new SolvePartialProblemsMessage()
{
CommonData = partialProblemsMsg.CommonData,
Id = partialProblemsMsg.Id,
PartialProblems = subProblemDivision[i],
ProblemType = partialProblemsMsg.ProblemType,
SolvingTimeout = partialProblemsMsg.SolvingTimeout
};
SendMessage(message.Serialize(), node.Client);
//EventLogger.GetLog().InfoFormat("Wysłano {0} partial problemy typu {1} do Computational Noda o id {2}", subProblemDivision[i].Count, partialProblemsMsg.ProblemType, node.Id);
}
}
public void Parse_SolvePartialProblemMessage_XMLString()
{
string path = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, @"xml_samples\SolvePartialProblems.xml");
string problemType = "TSP";
ulong id = 12;
byte[] commonData = { 1, 23, 25, 2, 5, 5, 5, 5, 2, 26, 87 };
ulong solvingTimeout = 1000;
// fields for PartialProblem1
ulong taskId1 = 123;
byte[] data1 = { 24, 252, 6, 43, 57, 88 };
ulong nodeId1 = 1;
PartialProblem partialProblem1 = new PartialProblem(taskId1, data1, nodeId1);
// fields for PartialProblem2
ulong taskId2 = 321;
byte[] data2 = { 24, 252, 6, 43, 57, 88 };
ulong nodeId2 = 2;
PartialProblem partialProblem2 = new PartialProblem(taskId2, data2, nodeId2);
PartialProblem[] partialProblems = { partialProblem1, partialProblem2 };
SolvePartialProblemsMessage message = new SolvePartialProblemsMessage(problemType, id, commonData,
solvingTimeout, partialProblems);
string actualXmlStr = message.ToXmlString();
XmlDocument xmlDoc = new XmlDocument();
xmlDoc.Load(path);
string expectedXmlStr = xmlDoc.OuterXml;
Assert.AreEqual(expectedXmlStr, actualXmlStr);
}
private void DivideProblem(DivideProblemMessage msg, TaskSolver taskSolver)
{
var partialProblemsData = taskSolver.DivideProblem((int)msg.ComputationalNodes);
var messagesList = new List <SolvePartialProblemsMessage>();
for (int i = partialProblemsData.Length - 1; i >= 0; i -= PartialProblemsPackageSize)
{
var packageSize = i + 1 < PartialProblemsPackageSize ? i + 1 : PartialProblemsPackageSize;
var partialProblemsPackage = new byte[packageSize][];
for (int j = 0; j < packageSize; j++)
{
partialProblemsPackage[j] = partialProblemsData[i - j];
}
var partialProblemsObjects = new List <PartialProblem>();
foreach (var partialData in partialProblemsPackage)
{
partialProblemsObjects.Add(new PartialProblem()
{
Data = partialData,
TaskId = ++_maxTaskId
});
}
_problems[msg.Id].PartialProblems.AddRange(partialProblemsObjects);
//TODO: NA PEWNO NIE MILIJON TAJMAŁTUW
var partialProblemsMsg = new SolvePartialProblemsMessage(msg.ProblemType, msg.Id, new byte[0], 100000000, partialProblemsObjects);
messagesList.Add(partialProblemsMsg);
}
foreach (var partialProblemsMessage in messagesList)
{
var serialized = partialProblemsMessage.Serialize();
SendMessage(serialized);
}
var thread = GetThreadByProblemInstanceId(msg.Id);
thread.State = EState.Idle;
}
/// <summary>
/// SolvePartialProblem is sent by TM
/// </summary>
/// <param name="messagePackage"></param>
private void handleSolvePartialProblemsMessage(MessagePackage messagePackage)
{
/* add partial tasks to subTask list in a task */
SolvePartialProblemsMessage message = (SolvePartialProblemsMessage)messagePackage.Message;
InformBackup(message);
Task task = taskTracker.GetTask((int)message.Id);
task.Status = TaskStatus.Divided;
for (int i = 0; i < message.PartialProblems.Count(); i++)
{
Task subTask = new Task((int)message.Id, message.ProblemType, message.PartialProblems[i].Data);
subTask.Status = TaskStatus.New;
task.AddSubTask(subTask);
}
/***********************************************/
if (Server.primaryMode)
{
NoOperationMessage response = new NoOperationMessage(clientTracker.BackupServers);
server.Send(messagePackage.Socket, response);
SmartConsole.PrintLine("Sent a NoOperation Message", SmartConsole.DebugLevel.Basic);
}
}
public PartialProblemsHelper(SolvePartialProblemsMessage message)
{
Message = message;
Solutions = new List <Solution>();
}
static void Main(string[] args)
{
EventLogger.AddAppender(new Log4NetAppender());
var ipAddress = "127.0.0.1";
var port = 8123;
IPEndPoint endPoint = new IPEndPoint(IPAddress.Parse(ipAddress), port);
Console.WriteLine("Choose component: \n"
+ "1 ComputationalClient\n"
+ "2 TaskManager\n"
+ "3 ComputationalNode\n");
Console.WriteLine("Select: ");
int componentType;
int.TryParse(Console.ReadLine(), out componentType);
Component component = new ComputationalClient();
switch (componentType)
{
case 1:
component = new ComputationalClient();
break;
case 2:
component = new TaskManager();
break;
case 3:
component = new ComputationalNode();
break;
}
component.SolvableProblems = new List <string>()
{
"MultiplyProblem", "DVRP"
};
component.Register(endPoint);
var filePath = @"DvrpData\okulD.vrp";
var problem = new DvrpProblem(new DvrpProblemData(filePath));
//var problem = new MultiplyProblem(10, 3, 1000000);
while (true)
{
Common.Abstractions.Message msg = null;
int result;
Console.WriteLine("RegisterMessage was sent\n"
+ "Choose another message: \n"
+ "1 RegisterMessage\n"
+ "2 RegisterResponseMessage\n"
+ "3 StatusMessage\n"
+ "4 SolveRequestMessage\n"
+ "5 SolveRequestResponseMessage\n"
+ "6 DivideProblemMessage\n"
+ "7 SolutionRequestMessage\n"
+ "8 PartialProblemsMessage\n"
+ "9 Solutions message\n"
+ "10 Exit"
);
Console.WriteLine("Choose message to send: ");
if (int.TryParse(Console.ReadLine(), out result) == false || result < 1 || result > 10)
{
Console.WriteLine("\nWrong input\n\n");
continue;
}
switch (result)
{
case 1:
msg = new RegisterMessage(component.Type, 0, component.SolvableProblems);
break;
case 2:
msg = new RegisterResponseMessage(123L, DateTime.Now);
break;
case 3:
msg = new StatusMessage(123L, null);
break;
case 4:
msg = new SolveRequestMessage(problem.ProblemType, problem.SolvingTimeout, problem.Data);
break;
case 5:
msg = new SolveRequestResponseMessage(123L);
break;
case 6:
msg = new DivideProblemMessage("Problem type", 123L, Encoding.UTF8.GetBytes("test1"), 321L);
break;
case 7:
msg = new SolutionRequestMessage(123L);
break;
case 8:
msg = new SolvePartialProblemsMessage("problem type", 123L, Encoding.UTF8.GetBytes("test1"), 333L, null);
break;
case 9:
msg = new SolutionsMessage("problemy type", 123L, Encoding.UTF8.GetBytes("test1"), null);
break;
case 10:
Environment.Exit(0);
break;
}
component.SendMessage(msg.Serialize());
}
//component.SendMessage(Encoding.UTF8.GetBytes("dupa"));
}
protected virtual void ProcessSolvePartialProblemsMessage(SolvePartialProblemsMessage message)
{
}
protected void ProcessMessage(byte[] msg)
{
var encoder = new UTF8Encoding();
string messagesString = encoder.GetString(msg);
_messageParser.ParseMessage(messagesString);
var messagesToProcess = _messageParser.GetMessagesToProcess();
foreach (var xmlMessage in messagesToProcess)
{
Type type = Message.GetMessageType(xmlMessage);
switch (type.Name)
{
case ("RegisterResponseMessage"):
{
var regMsg = Message.Deserialize <RegisterResponseMessage>(xmlMessage);
ProcessRegisterResponseMessage(regMsg);
break;
}
case ("SolveRequestMessage"):
{
throw new NotImplementedException();
break;
}
case ("DivideProblemMessage"):
{
DivideProblemMessage divMsg = Message.Deserialize <DivideProblemMessage>(xmlMessage);
ProcessDivideProblemMessage(divMsg);
break;
}
case ("SolveRequestResponseMessage"):
{
var solveRequestResponseMsg = Message.Deserialize <SolveRequestResponseMessage>(xmlMessage);
ProcessSolveRequestResponseMessage(solveRequestResponseMsg);
break;
}
case ("SolutionRequestMessage"):
{
throw new NotImplementedException();
break;
}
case ("SolutionsMessage"):
{
var solutionsMsg = Message.Deserialize <SolutionsMessage>(xmlMessage);
ProcessSolutionsMessage(solutionsMsg);
break;
}
case ("SolvePartialProblemsMessage"):
{
SolvePartialProblemsMessage _msg = Message.Deserialize <SolvePartialProblemsMessage>(xmlMessage);
ProcessSolvePartialProblemsMessage(_msg);
break;
}
}
}
}
