public PartialSolution SolvePartialProblem(PartialProblem partialProblem, Problem problem)
{
if (partialProblem.Clients.Count != 0)
{
BestSolution = double.MaxValue;
Clients = partialProblem.Clients;
Depots = problem.Depots;
VehicleCapacity = problem.VehiclesCapacity;
VehicleSpeed = problem.VehicleSpeed;
CurrentPath = new List <IDvrpObject>();
var startDepot = Depots.OrderBy(item => item.StartTime).ToList()[0];
CurrentPath.Add(startDepot);
SolveRec(startDepot.StartTime, VehicleCapacity);
}
else
{
BestSolution = 0;
}
return(new PartialSolution
{
Id = partialProblem.Id,
Clients = partialProblem.Clients,
Result = BestSolution
});
}
/// <summary>
/// Creates PartialSolution instance.
/// </summary>
/// <param name="partialProblem">Corresponding partial problem.</param>
/// <param name="data">Solution data.</param>
/// <param name="computationsTime">Foregoing computations time.</param>
/// <param name="timeoutOccured">True if the computations that generated this partial solution were stopped due to the timeout.</param>
public PartialSolution(PartialProblem partialProblem, byte[] data, ulong computationsTime, bool timeoutOccured)
{
PartialProblem = partialProblem;
Data = data;
ComputationsTime = computationsTime;
TimeoutOccured = timeoutOccured;
}
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);
}
/// <summary>
/// Creates PartialSolution instance.
/// </summary>
/// <param name="partialProblem">Corresponding partial problem.</param>
/// <param name="data">Solution data.</param>
/// <param name="computationsTime">Foregoing computations time.</param>
/// <param name="timeoutOccured">True if the computations that generated this partial solution were stopped due to the timeout.</param>
public PartialSolution(PartialProblem partialProblem, byte[] data, ulong computationsTime, bool timeoutOccured)
{
PartialProblem = partialProblem;
Data = data;
ComputationsTime = computationsTime;
TimeoutOccured = timeoutOccured;
}
public byte[] SerializePartialProblem(PartialProblem partialProblem)
{
using (MemoryStream stream = new MemoryStream())
{
formatter.Serialize(stream, partialProblem);
return(stream.ToArray());
}
}
/*******************************************************************/
/************************ 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>
/// Adds new partial problem to the system.
/// </summary>
/// <param name="problemId">ID of the problem instance this partial problem bleongs to.</param>
/// <param name="partialProblemId">ID of the partial problem withing the problem instance.</param>
/// <param name="privateData">Partial problem private data.</param>
public void AddPartialProblem(ulong problemId, ulong partialProblemId, byte[] privateData)
{
// Make sure the corresponding problem instance exists.
Problem problem;
if (!_problems.TryGetValue(problemId, out problem))
{
Logger.Error("Corresponding problem instance doesn't exist.");
return;
}
// Make sure that state of the corresponding problem instance is set to "being divided".
if (problem.State != Problem.ProblemState.BeingDivided)
{
Logger.Error("Corresponding problem's state is invalid.");
return;
}
// Make sure the corresponding problem's property 'NumberOfParts' is set to a positive integer.
if (!problem.NumberOfParts.HasValue || problem.NumberOfParts < 1)
{
Logger.Error("Corresponding problem's 'NumberOfParts' property is not a positive integer.");
return;
}
// Make sure the problem instance's number of partial problems & partial solutions is not greater than 'NumberOfParts' (excluding the partial problem being added).
var ppNum = _partialProblems.Count(pair => pair.Key.Item1 == problemId);
var psNum = _partialSolutions.Count(pair => pair.Key.Item1 == problemId);
if (ppNum + psNum == (int)problem.NumberOfParts - 1)
{
Logger.Info("Got all partial problems (id: " + problem.Id + ").");
problem.State = Problem.ProblemState.AwaitingSolution;
}
else if (ppNum + psNum > (int)problem.NumberOfParts - 1)
{
Logger.Warn("Received more partial problems than expected.");
return;
}
// Create partial problem instance.
var partialProblem = new PartialProblem(partialProblemId, problem, privateData)
{
State = PartialProblem.PartialProblemState.AwaitingComputation,
ComputingNodeId = null
};
// Add partial problem to the set.
var pairId = new Tuple <ulong, ulong>(problemId, partialProblemId);
_partialProblems.Add(pairId, partialProblem);
Logger.Info("Added new partial problem (id: " + problemId + "/" + partialProblemId + ", type: " +
problem.Type + ").");
}
/// <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
}
public void SimpleProblemWithTwoClients()
{
PartialProblem pp = new PartialProblem
{
Id = 1,
SetId = 1,
Clients = new HashSet <Client>
{
new Client
{
RequestSize = 5,
StartTime = 14,
UnloadTime = 1,
X = 0,
Y = 0
},
new Client
{
RequestSize = 5,
StartTime = 14,
UnloadTime = 1,
X = 0,
Y = 1
}
}
};
Problem p = new Problem
{
VehiclesCapacity = 10,
VehicleSpeed = 1,
Depots = new HashSet <Depot>
{
new Depot
{
StartTime = 12,
EndTime = 20,
X = 1,
Y = 1
}
}
};
var ret = problemSolver.SolvePartialProblem(pp, p);
ret.Result.ShouldBe(2 + Math.Sqrt(2));
}
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 SolvePartialProblem(PartialProblemsHelper partialProblemsHelper, PartialProblem partialProblem)
{
var taskSolver = GetProperTaskSolver(partialProblemsHelper.ProblemType, partialProblem.Data);
byte[] solution = taskSolver.Solve(partialProblem.Data, new TimeSpan(100000, 0, 0, 0)); //TODO: Ogarnac te timeouty
bool dziaa = false;
IOThread thread = null;
while (!dziaa)
{
try
{
thread = _runningThreads.FirstOrDefault(x => x.TaskId == partialProblem.TaskId);
thread.State = EState.Idle;
dziaa = true;
}
catch (Exception)
{
}
}
partialProblemsHelper.Solutions.Add(new Solution(partialProblem.TaskId, false, ESolutionType.Partial,
thread.HowLong, solution)); //TODO: Ogarnac te timeouty też
if (partialProblemsHelper.Solutions.Count == partialProblemsHelper.Problems.Count)
//Wszystkie rozwiazania policzone
{
SolutionsMessage solutionsMessage = new SolutionsMessage(partialProblemsHelper.ProblemType,
partialProblemsHelper.ProblemId, partialProblemsHelper.Message.CommonData,
partialProblemsHelper.Solutions);
SendMessage(solutionsMessage.Serialize());
}
lock (_runningThreadsLockObject)
{
_runningThreads.Remove(thread);
}
}
