int main()
{
Dispatcher disp;
Stub<Broker> broker("broker", "unix:the_broker");
disp.addClient(broker);
if (broker.connect())
{
std::vector<ServiceInfo> services;
if (disp.waitForResponse(broker.listServices(), services))
{
std::cout << "Available services: " << std::endl;
std::for_each(services.begin(), services.end(), printServiceInfo);
std::cout << std::endl;
std::vector<std::string> waiters;
if (disp.waitForResponse(broker.listWaiters(), waiters))
{
std::cout << "Waiters waiting for: " << std::endl;
std::for_each(waiters.begin(), waiters.end(), printWaiterInfo);
std::cout << std::endl;
return EXIT_SUCCESS;
}
}
}
return EXIT_FAILURE;
}
int main(int argc, char* argv[])
{
try{
// 1: Declare application parameter set, model and knowledge broker
KnapModel model;
#ifdef COIN_HAS_MPI
AlpsKnowledgeBrokerMPI broker(argc, argv, model);
#else
AlpsKnowledgeBrokerSerial broker(argc, argv, model);
#endif
// 2: Register model, solution, and tree node
broker.registerClass(AlpsKnowledgeTypeModel, new KnapModel());
broker.registerClass(AlpsKnowledgeTypeSolution,
new KnapSolution(&model));
broker.registerClass(AlpsKnowledgeTypeNode, new KnapTreeNode(&model));
// 4: Solve the problem
broker.search(&model);
// 5: Report the best solution found and its ojective value
broker.printBestSolution();
#ifdef NF_DEBUG
const int numSol = broker.getNumKnowledges(AlpsKnowledgeTypeSolution);
broker.messageHandler()->message(ALPS_SOLUTION_COUNT,
broker.messages())
<< broker.getProcRank() << numSol << CoinMessageEol;
#endif
}
catch(CoinError& er) {
std::cerr << "ERROR:" << er.message() << std::endl
<< " from function " << er.methodName() << std::endl
<< " from class " << er.className() << std::endl;
}
catch(...) {
std::cerr << "Something went wrong!" << std::endl;
}
return 0;
}
int main(int argc, char *argv[])
{
try{
// Set up lp solver
OsiClpSolverInterface lpSolver;
lpSolver.getModelPtr()->setDualBound(1.0e10);
lpSolver.messageHandler()->setLogLevel(0);
// Create BLIS model
BlisModel model;
model.setSolver(&lpSolver);
#ifdef COIN_HAS_MPI
AlpsKnowledgeBrokerMPI broker(argc, argv, model);
#else
AlpsKnowledgeBrokerSerial broker(argc, argv, model);
#endif
// Search for best solution
broker.search(&model);
// Report the best solution found and its ojective value
broker.printBestSolution();
}
catch(CoinError& er) {
std::cerr << "\nBLIS ERROR: \"" << er.message()
<< "\""<< std::endl
<< " from function \"" << er.methodName()
<< "\""<< std::endl
<< " from class \"" << er.className()
<< "\"" << std::endl;
}
catch(...) {
std::cerr << "Something went wrong!" << std::endl;
}
return 0;
}
int main(int argc, char **argv) {
// Command line options
std::string address("0.0.0.0");
example::options opts(argc, argv);
opts.add_value(address, 'a', "address", "listen on URL", "URL");
try {
opts.parse();
broker(address).run();
return 0;
} catch (const example::bad_option& e) {
std::cout << opts << std::endl << e.what() << std::endl;
} catch (const std::exception& e) {
std::cerr << "broker shutdown: " << e.what() << std::endl;
}
return 1;
}
int main(int argc, char **argv) {
// Command line options
proton::url url("0.0.0.0");
options opts(argc, argv);
opts.add_value(url, 'a', "address", "listen on URL", "URL");
try {
opts.parse();
broker broker(url);
proton::container(broker).run();
return 0;
} catch (const bad_option& e) {
std::cout << opts << std::endl << e.what() << std::endl;
} catch (const std::exception& e) {
std::cerr << e.what() << std::endl;
}
return 1;
}
enchant::Dict * EnchantChecker::Private::addSpeller(string const & lang)
{
Speller m;
try {
LYXERR(Debug::FILES, "request enchant speller for language " << lang);
m.speller = broker().request_dict(lang);
}
catch (enchant::Exception & e) {
// FIXME error handling?
const char * what = e.what();
LYXERR(Debug::FILES, "cannot add enchant speller: " <<
((what && *what) ? what : "unspecified enchant exception in request_dict()"));
m.speller = 0;
}
spellers_[lang] = m;
return m.speller;
}
int main(int argc, const char* argv[])
{
// TODO: args & signal handling
ev::default_loop loop(0);
stompede::stomp::Broker broker(loop);
auto domain = broker.createDomain("default");
broker.setDefaultDomain(domain);
broker.setupWorkers(4);
broker.setupListener("0.0.0.0", 61613);
broker.start();
loop.run();
return 0;
}
// .split main task
// While this example runs in a single process, that is just to make
// it easier to start and stop the example. Each thread has its own
// context and conceptually acts as a separate process.
int main() {
zmq::context_t context(1);
zmq::socket_t broker(context, ZMQ_ROUTER);
broker.bind("tcp://*:5671");
srandom((unsigned)time(NULL));
const int NBR_WORKERS = 10;
pthread_t workers[NBR_WORKERS];
for (int worker_nbr = 0; worker_nbr < NBR_WORKERS; ++worker_nbr) {
pthread_create(workers + worker_nbr, NULL, worker_task, (void *)(intptr_t)worker_nbr);
}
// Run for five seconds and then tell workers to end
int64_t end_time = s_clock() + 5000;
int workers_fired = 0;
while (1) {
// Next message gives us least recently used worker
std::string identity = s_recv(broker);
{
s_recv(broker); // Envelope delimiter
s_recv(broker); // Response from worker
}
s_sendmore(broker, identity);
s_sendmore(broker, "");
// Encourage workers until it's time to fire them
if (s_clock() < end_time)
s_send(broker, "Work harder");
else {
s_send(broker, "Fired!");
if (++workers_fired == NBR_WORKERS)
break;
}
}
for (int worker_nbr = 0; worker_nbr < NBR_WORKERS; ++worker_nbr) {
pthread_join(workers[worker_nbr], NULL);
}
return 0;
}
bool EnchantChecker::hasDictionary(Language const * lang) const
{
if (!lang)
return false;
return broker().dict_exists(lang->code());
}
int KnapTreeNode::process(bool isRoot, bool rampUp) {
bool foundSolution = false;
KnapNodeDesc* desc = dynamic_cast<KnapNodeDesc*>(desc_);
const KnapModel* m = dynamic_cast<KnapModel*>(desc->model());
//------------------------------------------------------
// Here, we need to fill in the method for bounding.
// Solve the lp relaxation.
//------------------------------------------------------
int cap = m->getCapacity() - desc->getUsedCapacity();
int val = desc->getUsedValue();
const KnapVarStatus* stati =
dynamic_cast<KnapNodeDesc*>(desc_)->getVarStati();
int i;
const int n = m->getNumItems();
#if defined NF_DEBUG_MORE
std::cout << "Num of items = " << n << std::endl;
#endif
for (i = 0; i < n; ++i) {
if (stati[i] == KnapVarFree) {
cap -= m->getItem(i).first;
val += m->getItem(i).second;
if (cap <= 0)
break;
}
#if defined NF_DEBUG_MORE
std::cout << m->getItem(i).second << " ";
#endif
}
#if defined NF_DEBUG_MORE
std::cout << std::endl;
#endif
// get the best solution so far (for parallel, it is the incumbent)
int bestval = 0;
double valRelax = 0;
// The quality of a solution is the negative of the objective value
// since Alps consideres sols with lower quality values better.
bestval = -static_cast<int>(broker()->getIncumbentValue());
if (cap < 0) {
// The last item dosn't fit fully, but some portion of it has been put
// in (otherwise we'd have stopped at the previous i)
const int size = m->getItem(i).first;
const int cost = m->getItem(i).second;
val -= cost;
cap += size;
valRelax = val + cost*cap/double(size);
if (valRelax <= bestval)
setStatus(AlpsNodeStatusFathomed); // set the status to fathomed
else {
branchedOn_ = i;
setStatus(AlpsNodeStatusPregnant);
}
}
else {
// The last item made it in fully, or no item free to make it fully,
// find a feasible solution and fathom this node
// save the solution if better than the best so far.
valRelax = val;
if (bestval < val) { // Find a better solution
int* sol = new int[n];
for (i = 0; i < n; ++i) {
sol[i] = stati[i] == KnapVarFixedToOne ? 1 : 0;
}
cap = m->getCapacity() - desc->getUsedCapacity();
for (i = 0; i < n; ++i) {
if (stati[i] == KnapVarFree) {
sol[i] = 1;
cap -= m->getItem(i).first;
if (cap == 0)
break;
}
}
foundSolution = true;
KnapSolution* ksol =
new KnapSolution(dynamic_cast<KnapModel*>(desc->model()), n,
sol, val);
broker()->addKnowledge(AlpsKnowledgeTypeSolution, ksol,
-val);
broker()->messageHandler()->
message(ALPS_S_SEARCH_SOL, broker()->messages())
<< (broker()->getProcRank())
<< valRelax << CoinMessageEol;
}
setStatus(AlpsNodeStatusFathomed); // set the status to fathomed
}
quality_ = -valRelax; // Set objective
return foundSolution;
}
int main(int argc, char* argv[])
{
try{
// Declare application parameter, model and knowledge broker
OsiClpSolverInterface solver1;
AbcModel model(solver1);
solver1.getModelPtr()->setDualBound(1.0e10);
//solver1.messageHandler()->setLogLevel(0);
#ifdef COIN_HAS_MPI
AlpsKnowledgeBrokerMPI broker(argc, argv, model);
#else
AlpsKnowledgeBrokerSerial broker(argc, argv, model);
#endif
int AbcLogLevel = model.AbcPar()->entry(AbcParams::logLevel);
model.messageHandler()->setLogLevel(AbcLogLevel);
#if 1 // TURN ON?OFF cut generators
// Set up some cut generators and defaults
// Probing first as gets tight bounds on continuous
CglProbing generator1;
generator1.setUsingObjective(true);
generator1.setMaxPass(3);
generator1.setMaxProbe(100);
generator1.setMaxLook(50);
generator1.setRowCuts(3);
CglGomory generator2;
generator2.setLimit(300); // try larger limit
CglKnapsackCover generator3;
CglOddHole generator4;
generator4.setMinimumViolation(0.005);
generator4.setMinimumViolationPer(0.00002);
generator4.setMaximumEntries(200); // try larger limit
CglFlowCover generator5;
// Add in generators
//model.addCutGenerator(&generator1, -1, "Probing");
//model.addCutGenerator(&generator2, -1, "Gomory");
model.addCutGenerator(&generator3, -1, "Knapsack");
model.addCutGenerator(&generator4, -1, "OddHole");
//model.addCutGenerator(&generator5, -1, "FlowCover");
// Use rounding heuristic
AbcRounding heuristic1(model);
model.addHeuristic(&heuristic1);
#endif
// Register model, solution, and tree node
broker.registerClass(AlpsKnowledgeTypeModel, new AbcModel);
broker.registerClass(AlpsKnowledgeTypeSolution, new AbcSolution);
broker.registerClass(AlpsKnowledgeTypeNode, new AbcTreeNode(&model));
// Formulate the root node
// NOTE: root will be deleted by ALPS
AlpsTreeNode* root = new AbcTreeNode(&model);
// Search for solutions from give root.
broker.rootSearch(root);
}
catch(CoinError& er) {
std::cerr << "ERROR:" << er.message() << std::endl
<< " from function " << er.methodName() << std::endl
<< " from class " << er.className() << std::endl;
}
catch(...) {
std::cerr << "Something went wrong!" << std::endl;
}
return 0;
}
