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; } } } }