Changeset 778abb for src


Ignore:
Timestamp:
May 4, 2012, 2:19:07 PM (13 years ago)
Author:
Frederik Heber <heber@…>
Branches:
Action_Thermostats, Add_AtomRandomPerturbation, Add_FitFragmentPartialChargesAction, Add_RotateAroundBondAction, Add_SelectAtomByNameAction, Added_ParseSaveFragmentResults, AddingActions_SaveParseParticleParameters, Adding_Graph_to_ChangeBondActions, Adding_MD_integration_tests, Adding_ParticleName_to_Atom, Adding_StructOpt_integration_tests, AtomFragments, Automaking_mpqc_open, AutomationFragmentation_failures, Candidate_v1.5.4, Candidate_v1.6.0, Candidate_v1.6.1, ChangeBugEmailaddress, ChangingTestPorts, ChemicalSpaceEvaluator, CombiningParticlePotentialParsing, Combining_Subpackages, Debian_Package_split, Debian_package_split_molecuildergui_only, Disabling_MemDebug, Docu_Python_wait, EmpiricalPotential_contain_HomologyGraph, EmpiricalPotential_contain_HomologyGraph_documentation, Enable_parallel_make_install, Enhance_userguide, Enhanced_StructuralOptimization, Enhanced_StructuralOptimization_continued, Example_ManyWaysToTranslateAtom, Exclude_Hydrogens_annealWithBondGraph, FitPartialCharges_GlobalError, Fix_BoundInBox_CenterInBox_MoleculeActions, Fix_ChargeSampling_PBC, Fix_ChronosMutex, Fix_FitPartialCharges, Fix_FitPotential_needs_atomicnumbers, Fix_ForceAnnealing, Fix_IndependentFragmentGrids, Fix_ParseParticles, Fix_ParseParticles_split_forward_backward_Actions, Fix_PopActions, Fix_QtFragmentList_sorted_selection, Fix_Restrictedkeyset_FragmentMolecule, Fix_StatusMsg, Fix_StepWorldTime_single_argument, Fix_Verbose_Codepatterns, Fix_fitting_potentials, Fixes, ForceAnnealing_goodresults, ForceAnnealing_oldresults, ForceAnnealing_tocheck, ForceAnnealing_with_BondGraph, ForceAnnealing_with_BondGraph_continued, ForceAnnealing_with_BondGraph_continued_betteresults, ForceAnnealing_with_BondGraph_contraction-expansion, FragmentAction_writes_AtomFragments, FragmentMolecule_checks_bonddegrees, GeometryObjects, Gui_Fixes, Gui_displays_atomic_force_velocity, ImplicitCharges, IndependentFragmentGrids, IndependentFragmentGrids_IndividualZeroInstances, IndependentFragmentGrids_IntegrationTest, IndependentFragmentGrids_Sole_NN_Calculation, JobMarket_RobustOnKillsSegFaults, JobMarket_StableWorkerPool, JobMarket_unresolvable_hostname_fix, MoreRobust_FragmentAutomation, ODR_violation_mpqc_open, PartialCharges_OrthogonalSummation, PdbParser_setsAtomName, PythonUI_with_named_parameters, QtGui_reactivate_TimeChanged_changes, Recreated_GuiChecks, Rewrite_FitPartialCharges, RotateToPrincipalAxisSystem_UndoRedo, SaturateAtoms_findBestMatching, SaturateAtoms_singleDegree, StoppableMakroAction, Subpackage_CodePatterns, Subpackage_JobMarket, Subpackage_LinearAlgebra, Subpackage_levmar, Subpackage_mpqc_open, Subpackage_vmg, Switchable_LogView, ThirdParty_MPQC_rebuilt_buildsystem, TrajectoryDependenant_MaxOrder, TremoloParser_IncreasedPrecision, TremoloParser_MultipleTimesteps, TremoloParser_setsAtomName, Ubuntu_1604_changes, stable
Children:
e70b9d
Parents:
b9c486
git-author:
Frederik Heber <heber@…> (12/09/11 18:18:14)
git-committer:
Frederik Heber <heber@…> (05/04/12 14:19:07)
Message:

Added ResultGetter and capabilities to receive calculated results to FragmentController.

  • Added enum (and file) ControllerChoices that defines the state of FragmentScheduler.
  • depending on what is desired the Scheduler switches between these states and either receives or sends information. Requires new member variable choice because receival is of course asynchronous (see note in previous commit).
  • FragmentController has additional functions connect_get() and handle_connect_get() to receive results.
  • connect_calc() and connect_check() now just the choice whereas the actual sending and receiving is done in handle_... functions.
  • handle_FinishOperation() is the common final callback function for all three of these functions.
  • FragmentScheduler contains an internal list of delivered results.
  • FragmentScheduler only initiates worker socket when jobs are present.
  • FIX: FragmentScheduler does only send results that are done and only once.
  • TESTFIX: Removed third Worker that receives NoJob as socket is powered down before because queue has run empty and we haven't add new jobs.
Location:
src/Fragmentation/Automation
Files:
2 added
7 edited

Legend:

Unmodified
Added
Removed

  • src/Fragmentation/Automation/FragmentController.cpp

    rb9c486 r778abb  
    2424
    2525#include <boost/bind.hpp>
     26#include <boost/foreach.hpp>
    2627#include <iostream>
    2728#include <vector>
    … …  
    3233#include "FragmentJob.hpp"
    3334#include "FragmentResult.hpp"
     35#include "ControllerChoices.hpp"
    3436
    3537#include "FragmentController.hpp"
    … …  
    7072  if (!e)
    7173  {
    72     // Successfully established connection. Start operation to read the vector
    73     // of jobs. The connection::async_write() function will automatically
    74     // encode the data that is written to the underlying socket.
    75     LOG(1, "INFO: Sending "+toString(jobs.size())+" jobs ...");
    76     connection_.async_write(jobs,
     74    // Successfully established connection. Give choice.
     75    enum ControllerChoices choice = ReceiveJobs;
     76    connection_.async_write(choice,
    7777      boost::bind(&FragmentController::handle_SendJobs, this,
    7878      boost::asio::placeholders::error));
    … …  
    104104  if (!e)
    105105  {
    106     // Successfully established connection. Start operation to read the vector
    107     // of jobs. The connection::async_write() function will automatically
    108     // encode the data that is written to the underlying socket.
    109     LOG(1, "INFO: Checking number of done jobs ...");
    110     connection_.async_read(doneJobs,
     106    // Successfully established connection. Give choice.
     107    enum ControllerChoices choice = CheckState;
     108    connection_.async_write(choice,
    111109      boost::bind(&FragmentController::handle_ReceiveDoneJobs, this,
    112110      boost::asio::placeholders::error));
    … …  
    127125}
    128126
    129 /** Callback function when jobs have been sent.
    130  *
    131  * \param e error code if something went wrong
    132  */
    133 void FragmentController::handle_SendJobs(const boost::system::error_code& e)
    134 {
    135   Info info(__FUNCTION__);
    136   if (!e)
    137   {
    138     LOG(1, "INFO: Sent jobs ...");
     127/** Handle completion of a connect operation.
     128 *
     129 * \param e error code if something went wrong
     130 * \param endpoint_iterator endpoint of the connection
     131 */
     132void FragmentController::handle_connect_get(const boost::system::error_code& e,
     133    boost::asio::ip::tcp::resolver::iterator endpoint_iterator)
     134{
     135  Info info(__FUNCTION__);
     136  if (!e)
     137  {
     138    // Successfully established connection. Give choice.
     139    enum ControllerChoices choice = SendResults;
     140    connection_.async_write(choice,
     141      boost::bind(&FragmentController::handle_ReceivingResults, this,
     142      boost::asio::placeholders::error));
     143  } else if (endpoint_iterator != boost::asio::ip::tcp::resolver::iterator()) {
     144    // Try the next endpoint.
     145    connection_.socket().close();
     146    boost::asio::ip::tcp::endpoint endpoint = *endpoint_iterator;
     147    connection_.socket().async_connect(endpoint,
     148      boost::bind(&FragmentController::handle_connect_check, this,
     149      boost::asio::placeholders::error, ++endpoint_iterator));
     150  } else {
     151    // An error occurred. Log it and return. Since we are not starting a new
     152    // operation the io_service will run out of work to do and the client will
     153    // exit.
     154    Exitflag = ErrorFlag;
     155    ELOG(1, e.message());
     156  }
     157}
     158
     159/** Callback function when operation has been completed.
     160 *
     161 * \param e error code if something went wrong
     162 */
     163void FragmentController::handle_FinishOperation(const boost::system::error_code& e)
     164{
     165  Info info(__FUNCTION__);
     166  if (!e)
     167  {
     168    LOG(1, "INFO: Operation completed.");
    139169  }
    140170  else
    … …  
    149179}
    150180
     181/** Callback function when jobs have been sent.
     182 *
     183 * \param e error code if something went wrong
     184 */
     185void FragmentController::handle_SendJobs(const boost::system::error_code& e)
     186{
     187  Info info(__FUNCTION__);
     188  if (!e)
     189  {
     190    // Successfully established connection. Start operation to read the vector
     191    // of jobs. The connection::async_write() function will automatically
     192    // encode the data that is written to the underlying socket.
     193    LOG(1, "INFO: Sending "+toString(jobs.size())+" jobs ...");
     194    connection_.async_write(jobs,
     195      boost::bind(&FragmentController::handle_FinishOperation, this,
     196      boost::asio::placeholders::error));
     197  }
     198  else
     199  {
     200    // An error occurred.
     201    Exitflag = ErrorFlag;
     202    ELOG(1, e.message());
     203  }
     204
     205  // Since we are not starting a new operation the io_service will run out of
     206  // work to do and the client will exit.
     207}
     208
     209/** Callback function when results have been received.
     210 *
     211 * \param e error code if something went wrong
     212 */
     213void FragmentController::handle_ReceivingResults(const boost::system::error_code& e)
     214{
     215  Info info(__FUNCTION__);
     216  if (!e)
     217  {
     218    // The connection::async_read() function will automatically
     219    // decode the data that is written to the underlying socket.
     220    connection_.async_read(results,
     221      boost::bind(&FragmentController::handle_ReceivedResults, this,
     222      boost::asio::placeholders::error));
     223  }
     224  else
     225  {
     226    // An error occurred.
     227    Exitflag = ErrorFlag;
     228    ELOG(1, e.message());
     229  }
     230
     231  // Since we are not starting a new operation the io_service will run out of
     232  // work to do and the client will exit.
     233}
     234
    151235/** Callback function when doneJobs have been received.
    152236 *
    153237 * \param e error code if something went wrong
    154238 */
     239void FragmentController::handle_ReceivedResults(const boost::system::error_code& e)
     240{
     241  Info info(__FUNCTION__);
     242
     243  LOG(1, "INFO: Received "+toString(results.size())+" results ...");
     244
     245  handle_FinishOperation(e);
     246}
     247
     248/** Callback function when doneJobs have been received.
     249 *
     250 * \param e error code if something went wrong
     251 */
    155252void FragmentController::handle_ReceiveDoneJobs(const boost::system::error_code& e)
    156253{
    157254  Info info(__FUNCTION__);
    158   // Nothing to do.
    159   LOG(1, "INFO: "+toString(doneJobs)+" jobs are currently done.");
     255  if (!e)
     256  {
     257    // The connection::async_read() function will automatically
     258    // decode the data that is written to the underlying socket.
     259    LOG(1, "INFO: Checking number of done jobs ...");
     260    connection_.async_read(doneJobs,
     261      boost::bind(&FragmentController::handle_FinishOperation, this,
     262      boost::asio::placeholders::error));
     263  }
     264  else
     265  {
     266    // An error occurred.
     267    Exitflag = ErrorFlag;
     268    ELOG(1, e.message());
     269  }
    160270}
    161271
    … …  
    211321}
    212322
     323/** Internal function to connect to the endpoint of the server asynchronuously.
     324 *
     325 * We require internal connetion_ and host and service to be set up for this.
     326 */
     327void FragmentController::connect_get()
     328{
     329  Info info(__FUNCTION__);
     330  // Resolve the host name into an IP address.
     331  boost::asio::ip::tcp::resolver::iterator endpoint_iterator = getEndpointIterator();
     332  boost::asio::ip::tcp::endpoint endpoint = *endpoint_iterator;
     333
     334  // Start an asynchronous connect operation.
     335  std::cout << "Connecting to endpoint " << endpoint << " to get results " << std::endl;
     336  connection_.socket().async_connect(endpoint,
     337    boost::bind(&FragmentController::handle_connect_get, this,
     338      boost::asio::placeholders::error, ++endpoint_iterator));
     339}
     340
    213341/** Internal function to disconnect connection_ correctly.
    214342 *
    … …  
    225353void FragmentController::addJobs(const std::vector<FragmentJob> &_jobs)
    226354{
    227   jobs = _jobs;
     355  jobs.reserve(jobs.size()+_jobs.size());
     356  BOOST_FOREACH(FragmentJob job, _jobs) {
     357    jobs.push_back(job);
     358  }
    228359}
    229360
    … …  
    250381}
    251382
     383/** Getter for results.
     384 *
     385 * \sa calculateResults()
     386 * \return vector of results for the added jobs (\sa addJobs()).
     387 */
     388std::vector<FragmentResult> FragmentController::getResults()
     389{
     390  Info info(__FUNCTION__);
     391  return results;
     392}
     393
     394/** Function to initiate receival of results.
     395 *
     396 */
     397void FragmentController::obtainResults()
     398{
     399  // connect
     400  connect_get();
     401  //disconnect
     402  disconnect();
     403}
     404
    252405/** Getter for doneJobs.
    253406 *

  • src/Fragmentation/Automation/FragmentController.hpp

    rb9c486 r778abb  
    3737  ~FragmentController();
    3838
    39   /// Handle completion of a accept operation.
     39  /// Handle completion of a calculate operation.
    4040  void handle_connect_calc(const boost::system::error_code& e,
    4141      boost::asio::ip::tcp::resolver::iterator endpoint_iterator);
    4242
    43   /// Handle completion of a accept operation.
     43  /// Handle completion of a CheckResults operation.
    4444  void handle_connect_check(const boost::system::error_code& e,
    4545      boost::asio::ip::tcp::resolver::iterator endpoint_iterator);
     46
     47  /// Handle completion of a GetResults operation.
     48  void handle_connect_get(const boost::system::error_code& e,
     49      boost::asio::ip::tcp::resolver::iterator endpoint_iterator);
     50
     51  /// Handle completion of an operation.
     52  void handle_FinishOperation(const boost::system::error_code& e);
    4653
    4754  /// Callback function when bunch of jobs have been sent.
    … …  
    5057  /// Callback function when doneJobs have been received.
    5158  void handle_ReceiveDoneJobs(const boost::system::error_code& e);
     59
     60  /// Callback function when results are about to be received.
     61  void handle_ReceivingResults(const boost::system::error_code& e);
     62
     63  /// Callback function when results have been received.
     64  void handle_ReceivedResults(const boost::system::error_code& e);
    5265
    5366  /// place number of jobs into this controller
    … …  
    6881  }
    6982
     83  /// prepares the receival of the results
     84  void obtainResults();
     85
     86  /// get the results for the current jobs
     87  std::vector<FragmentResult> getResults();
     88
    7089  /// get the number of finished results for the current jobs
    7190  void checkResults();
    … …  
    7897  boost::asio::ip::tcp::resolver::iterator getEndpointIterator();
    7998
    80   /// internal function to connect to server and send jobs for calculating jobs
     99  /// internal function to connect to server and send jobs for calculation
    81100  void connect_calc();
    82101
    83   /// internal function to connect to server and send jobs for checking donejobs
     102  /// internal function to connect to server and check done jobs
    84103  void connect_check();
     104
     105  /// internal function to connect to server and receive calculated results
     106  void connect_get();
    85107
    86108  /// internal function to disconnect from server
    … …  
    103125  enum Exitflag_t Exitflag;
    104126
     127  /// bunch of results
     128  std::vector<FragmentResult> results;
     129
    105130  /// currently calculated results
    106131  size_t doneJobs;

  • src/Fragmentation/Automation/FragmentScheduler.cpp

    rb9c486 r778abb  
    5757  ),
    5858  result(JobId::NoJob),
     59  choice(NoOperation),
    5960  Exitflag(OkFlag)
    6061{
    6162  Info info(__FUNCTION__);
    6263
    63   initiateWorkerSocket();
     64  // only initiate socket if jobs are already present
     65  if (JobsQueue.isJobPresent()) {
     66    LOG(1, "Listening for workers on port " << workerport << ".");
     67    initiateWorkerSocket();
     68  }
    6469
    6570  initiateControllerSocket();
     71  LOG(1, "Listening for controller on port " << controllerport << ".");
    6672}
    6773
    … …  
    117123        boost::asio::placeholders::error, conn));
    118124
    119       // Start an accept operation for a new Connection only when there
    120       // are still jobs present otherwise we quit.
    121       initiateWorkerSocket();
    122125    } else {
    123126      // send the static NoJob
    … …  
    139142    ELOG(0, e.message());
    140143  }
     144
     145  // Start an accept operation for a new Connection only when there
     146  // are still jobs present
     147  if (JobsQueue.isJobPresent())
     148    initiateWorkerSocket();
    141149}
    142150
    … …  
    169177{
    170178  Info info(__FUNCTION__);
    171   // nothing to do
    172179  LOG(1, "INFO: Received result for job #" << result.getId() << " ...");
    173   // and push into queue
    174180  ASSERT(result.getId() != (JobId_t)JobId::NoJob,
    175181      "FragmentScheduler::handle_ReceiveResultFromWorker() - result received has NoJob id.");
    176182  ASSERT(result.getId() != (JobId_t)JobId::IllegalJob,
    177183      "FragmentScheduler::handle_ReceiveResultFromWorker() - result received has IllegalJob id.");
     184  // place id into expected
    178185  if ((result.getId() != (JobId_t)JobId::NoJob) && (result.getId() != (JobId_t)JobId::IllegalJob))
    179186    JobsQueue.pushResult(result);
    180187  // erase result
    181188  result = FragmentResult(JobId::NoJob);
     189  LOG(1, "INFO: JobsQueue has " << JobsQueue.getDoneJobs() << " results.");
    182190}
    183191
    … …  
    196204  if (!e)
    197205  {
    198     if (JobsQueue.isJobPresent() || !JobsQueue.getDoneJobs()) {
    199       // The connection::async_write() function will automatically
    200       // serialize the data structure for us.
    201       LOG(1, "INFO: Receiving bunch of jobs from a controller ...");
    202       conn->async_read(jobs,
    203         boost::bind(&FragmentScheduler::handle_ReceiveJobs, this,
    204         boost::asio::placeholders::error, conn));
    205     } else {
    206       // we just give a status report ...
    207       // first update number
    208       doneJobs = JobsQueue.getDoneJobs();
    209       // now we accept connections to check for state of calculations
    210       LOG(1, "INFO: Sending state of results to controller ...");
    211       conn->async_write(doneJobs,
    212         boost::bind(&FragmentScheduler::handle_CheckResultState, this,
    213         boost::asio::placeholders::error, conn));
    214     }
     206    conn->async_read(choice,
     207      boost::bind(&FragmentScheduler::handle_ReadChoice, this,
     208      boost::asio::placeholders::error, conn));
    215209  }
    216210  else
    … …  
    224218}
    225219
     220/** Controller callback function to read the choice for next operation.
     221 *
     222 * \param e error code if something went wrong
     223 * \param conn reference with the connection
     224 */
     225void FragmentScheduler::handle_ReadChoice(const boost::system::error_code& e, connection_ptr conn)
     226{
     227  Info info(__FUNCTION__);
     228  if (!e)
     229  {
     230    // switch over the desired choice read previously
     231    switch(choice) {
     232    case NoOperation:
     233    {
     234      ELOG(1, "FragmentScheduler::handle_ReadChoice() - called with NoOperation.");
     235      break;
     236    }
     237    case ReceiveJobs:
     238      {
     239        // The connection::async_write() function will automatically
     240        // serialize the data structure for us.
     241        LOG(1, "INFO: Receiving bunch of jobs from a controller ...");
     242        conn->async_read(jobs,
     243          boost::bind(&FragmentScheduler::handle_ReceiveJobs, this,
     244          boost::asio::placeholders::error, conn));
     245        break;
     246      }
     247    case CheckState:
     248    {
     249      // first update number
     250      doneJobs = JobsQueue.getDoneJobs();
     251      // now we accept connections to check for state of calculations
     252      LOG(1, "INFO: Sending state that "+toString(doneJobs)+" jobs are done to controller ...");
     253      conn->async_write(doneJobs,
     254        boost::bind(&FragmentScheduler::handle_CheckResultState, this,
     255        boost::asio::placeholders::error, conn));
     256
     257      initiateControllerSocket();
     258      break;
     259    }
     260    case SendResults:
     261    {
     262      const std::vector<FragmentResult> results = JobsQueue.getAllResults();
     263      // ... or we give the results
     264      LOG(1, "INFO: Sending "+toString(results.size())+" results to controller ...");
     265      conn->async_write(results,
     266        boost::bind(&FragmentScheduler::handle_SendResults, this,
     267        boost::asio::placeholders::error, conn));
     268
     269      initiateControllerSocket();
     270      break;
     271    }
     272    default:
     273      Exitflag = ControllerErrorFlag;
     274      ELOG(1, "FragmentScheduler::handle_ReadChoice() - called with no valid choice.");
     275      break;
     276    }
     277    // restore NoOperation choice such that choice is not read twice
     278    choice = NoOperation;
     279
     280  }
     281  else
     282  {
     283    // An error occurred. Log it and return. Since we are not starting a new
     284    // accept operation the io_service will run out of work to do and the
     285    // server will exit.
     286    Exitflag = ControllerErrorFlag;
     287    ELOG(0, e.message());
     288  }
     289}
     290
    226291/** Controller callback function when job has been sent.
    227292 *
     293 * We check here whether the worker socket is accepting, if there
     294 * have been no jobs we re-activate it, as it is shut down after
     295 * last job.
     296 *
    228297 * \param e error code if something went wrong
    229298 * \param conn reference with the connection
    … …  
    232301{
    233302  Info info(__FUNCTION__);
     303  bool initiateSocket = !JobsQueue.isJobPresent();
     304
    234305  // jobs are received, hence place in JobsQueue
    235306  if (!jobs.empty()) {
    236307    LOG(1, "INFO: Pushing " << jobs.size() << " jobs into queue.");
    237308    JobsQueue.pushJobs(jobs);
    238   }
    239   // launch new acceptor of queue has been filled/is full
    240   if (JobsQueue.isJobPresent()) {
    241     // Start an accept operation for a new Connection.
     309    // initiate socket if we had no jobs before
     310    if (initiateSocket)
     311      initiateWorkerSocket();
     312    // launch new acceptor of queue has been filled/is full
    242313    initiateControllerSocket();
    243314  } else {
    … …  
    246317
    247318  jobs.clear();
     319
    248320}
    249321
    … …  
    259331  LOG(1, "INFO: Sent that " << doneJobs << " jobs are done.");
    260332}
     333
     334/** Controller callback function when result has been received.
     335 *
     336 * \param e error code if something went wrong
     337 * \param conn reference with the connection
     338 */
     339void FragmentScheduler::handle_SendResults(const boost::system::error_code& e, connection_ptr conn)
     340{
     341  Info info(__FUNCTION__);
     342  // do nothing
     343  LOG(1, "INFO: Results have been sent.");
     344}
     345

  • src/Fragmentation/Automation/FragmentScheduler.hpp

    rb9c486 r778abb  
    2121#include "FragmentQueue.hpp"
    2222#include "FragmentResult.hpp"
     23#include "ControllerChoices.hpp"
     24#include "types.hpp"
    2325
    2426/** FragmentScheduler serves FragmentJobs to Workers.
    … …  
    3436  enum Exitflag_t{
    3537    OkFlag = 0,
     38    QueueError = 128,
    3639    ControllerErrorFlag = 254,
    3740    WorkerErrorFlag = 255
    … …  
    5457  void handle_AcceptController(const boost::system::error_code& e, connection_ptr conn);
    5558
     59  /// Handle completion of controller operation to read choice
     60  void handle_ReadChoice(const boost::system::error_code& e, connection_ptr conn);
     61
    5662  /// Worker callback function when job has been sent.
    5763  void handle_SendJobtoWorker(const boost::system::error_code& e, connection_ptr conn);
    … …  
    6773  /// Controller callback function when checking on state of results.
    6874  void handle_CheckResultState(const boost::system::error_code& e, connection_ptr conn);
     75
     76  /// Controller callback function when result has been received.
     77  void handle_SendResults(const boost::system::error_code& e, connection_ptr conn);
    6978
    7079  /// internal function to prepare worker connections
    … …  
    9099  size_t doneJobs;
    91100
     101  // choice
     102  enum ControllerChoices choice;
     103
    92104  /// Queue with data to be sent to each client.
    93105  FragmentQueue JobsQueue;

  • src/Fragmentation/Automation/Makefile.am

    rb9c486 r778abb  
    4545AM_CPPFLAGS = ${BOOST_CPPFLAGS} ${CodePatterns_CFLAGS}
    4646
    47 bin_PROGRAMS += JobAdder ResultChecker Server Worker
     47bin_PROGRAMS += JobAdder ResultChecker ResultGetter Server Worker
    4848
    4949CONTROLLERSOURCE = \
    … …  
    5252CONTROLLERHEADER = \
    5353  Connection.hpp \
     54  ControllerChoices.hpp \
    5455  FragmentController.hpp
    5556
    … …  
    5960SERVERHEADER = \
    6061  Connection.hpp \
     62  ControllerChoices.hpp \
    6163  FragmentScheduler.hpp
    6264
    … …  
    9395  ${CodePatterns_LIBS}
    9496
     97ResultGetter_SOURCES = $(CONTROLLERSOURCE) $(CONTROLLERHEADER) ResultGetter.cpp
     98ResultGetter_LDFLAGS = $(AM_LDFLAGS) $(BOOST_ASIO_LDFLAGS) $(BOOST_SYSTEM_LDFLAGS) $(BOOST_THREAD_LDFLAGS) $(BOOST_SERIALIZATION_LDFLAGS)
     99ResultGetter_CXXFLAGS = $(AM_CPPFLAGS)
     100ResultGetter_LDADD = \
     101  libMolecuilderFragmentJobs.la \
     102  libMolecuilderFragmentationAutomation.la \
     103  $(BOOST_ASIO_LIBS) \
     104  $(BOOST_SERIALIZATION_LIBS) \
     105  $(BOOST_THREAD_LIBS) \
     106  $(BOOST_SYSTEM_LIBS) \
     107  ${CodePatterns_LIBS}
     108
    95109Server_SOURCES = $(SERVERSOURCE) $(SERVERHEADER) Server.cpp
    96110Server_LDFLAGS = $(AM_LDFLAGS) $(BOOST_ASIO_LDFLAGS) $(BOOST_SYSTEM_LDFLAGS) $(BOOST_THREAD_LDFLAGS) $(BOOST_SERIALIZATION_LDFLAGS)

  • src/Fragmentation/Automation/Server.cpp

    rb9c486 r778abb  
    5353    }
    5454    unsigned short workerport = boost::lexical_cast<unsigned short>(argv[1]);
    55     std::cout << "Listening for workers on port " << workerport << "." << std::endl;
    5655    unsigned short controllerport = boost::lexical_cast<unsigned short>(argv[2]);
    57     std::cout << "Listening for controller on port " << controllerport << "." << std::endl;
    5856
    5957    boost::asio::io_service io_service;

  • src/Fragmentation/Automation/types.hpp

    rb9c486 r778abb  
    1414#endif
    1515
     16//!> type for ids of jobs
    1617typedef size_t JobId_t;
    1718
Note: See TracChangeset for help on using the changeset viewer.