AERA
mdl_controller.h
1 //_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/
2 //_/_/
3 //_/_/ AERA
4 //_/_/ Autocatalytic Endogenous Reflective Architecture
5 //_/_/
6 //_/_/ Copyright (c) 2018-2025 Jeff Thompson
7 //_/_/ Copyright (c) 2018-2025 Kristinn R. Thorisson
8 //_/_/ Copyright (c) 2018-2025 Icelandic Institute for Intelligent Machines
9 //_/_/ Copyright (c) 2018 Thor Tomasarson
10 //_/_/ http://www.iiim.is
11 //_/_/
12 //_/_/ Copyright (c) 2010-2012 Eric Nivel
13 //_/_/ Center for Analysis and Design of Intelligent Agents
14 //_/_/ Reykjavik University, Menntavegur 1, 102 Reykjavik, Iceland
15 //_/_/ http://cadia.ru.is
16 //_/_/
17 //_/_/ Part of this software was developed by Eric Nivel
18 //_/_/ in the HUMANOBS EU research project, which included
19 //_/_/ the following parties:
20 //_/_/
21 //_/_/ Autonomous Systems Laboratory
22 //_/_/ Technical University of Madrid, Spain
23 //_/_/ http://www.aslab.org/
24 //_/_/
25 //_/_/ Communicative Machines
26 //_/_/ Edinburgh, United Kingdom
27 //_/_/ http://www.cmlabs.com/
28 //_/_/
29 //_/_/ Istituto Dalle Molle di Studi sull'Intelligenza Artificiale
30 //_/_/ University of Lugano and SUPSI, Switzerland
31 //_/_/ http://www.idsia.ch/
32 //_/_/
33 //_/_/ Institute of Cognitive Sciences and Technologies
34 //_/_/ Consiglio Nazionale delle Ricerche, Italy
35 //_/_/ http://www.istc.cnr.it/
36 //_/_/
37 //_/_/ Dipartimento di Ingegneria Informatica
38 //_/_/ University of Palermo, Italy
39 //_/_/ http://diid.unipa.it/roboticslab/
40 //_/_/
41 //_/_/
42 //_/_/ --- HUMANOBS Open-Source BSD License, with CADIA Clause v 1.0 ---
43 //_/_/
44 //_/_/ Redistribution and use in source and binary forms, with or without
45 //_/_/ modification, is permitted provided that the following conditions
46 //_/_/ are met:
47 //_/_/ - Redistributions of source code must retain the above copyright
48 //_/_/ and collaboration notice, this list of conditions and the
49 //_/_/ following disclaimer.
50 //_/_/ - Redistributions in binary form must reproduce the above copyright
51 //_/_/ notice, this list of conditions and the following disclaimer
52 //_/_/ in the documentation and/or other materials provided with
53 //_/_/ the distribution.
54 //_/_/
55 //_/_/ - Neither the name of its copyright holders nor the names of its
56 //_/_/ contributors may be used to endorse or promote products
57 //_/_/ derived from this software without specific prior
58 //_/_/ written permission.
59 //_/_/
60 //_/_/ - CADIA Clause: The license granted in and to the software
61 //_/_/ under this agreement is a limited-use license.
62 //_/_/ The software may not be used in furtherance of:
63 //_/_/ (i) intentionally causing bodily injury or severe emotional
64 //_/_/ distress to any person;
65 //_/_/ (ii) invading the personal privacy or violating the human
66 //_/_/ rights of any person; or
67 //_/_/ (iii) committing or preparing for any act of war.
68 //_/_/
69 //_/_/ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
70 //_/_/ CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
71 //_/_/ INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
72 //_/_/ MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
73 //_/_/ DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
74 //_/_/ CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
75 //_/_/ SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
76 //_/_/ BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
77 //_/_/ SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
78 //_/_/ INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
79 //_/_/ WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
80 //_/_/ NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
81 //_/_/ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
82 //_/_/ OF SUCH DAMAGE.
83 //_/_/
84 //_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/
85 
86 #ifndef mdl_controller_h
87 #define mdl_controller_h
88 
89 #include "hlp_overlay.h"
90 #include "hlp_controller.h"
91 #include "p_monitor.h"
92 #include "factory.h"
93 #include "mem.h"
94 
95 
96 namespace r_exec {
97 
98 class MDLOverlay :
99  public HLPOverlay {
100 protected:
101  MDLOverlay(Controller *c, const HLPBindingMap *bindngs);
102 public:
103  ~MDLOverlay();
104 
105  virtual bool reduce(_Fact *input, Fact *f_p_f_imdl, MDLController *req_controller) = 0;
106 };
107 
112 class BindingResult {
113 public:
120  BindingResult(HLPBindingMap* map, Fact* ground, MkRdx* ground_mk_rdx)
121  {
122  map_ = map;
123  ground_ = ground;
124  ground_mk_rdx_ = ground_mk_rdx;
125  }
126 
127  P<HLPBindingMap> map_;
128  Fact* ground_;
129  MkRdx* ground_mk_rdx_;
130 };
131 
132 class PrimaryMDLOverlay :
133  public MDLOverlay {
134 protected:
135  bool check_simulated_chaining(const HLPBindingMap *bm, Fact *f_imdl, Pred *prediction, std::vector<BindingResult>& results);
136 public:
137  PrimaryMDLOverlay(Controller *c, const HLPBindingMap *bindngs);
138  ~PrimaryMDLOverlay();
139 
140  bool reduce(_Fact *input, Fact *f_p_f_imdl, MDLController *req_controller) override;
141 };
142 
143 class SecondaryMDLOverlay :
144  public MDLOverlay {
145 public:
146  SecondaryMDLOverlay(Controller *c, const HLPBindingMap *bindngs);
147  ~SecondaryMDLOverlay();
148 
149  bool reduce(_Fact *input, Fact *f_p_f_imdl, MDLController *req_controller) override;
150 };
151 
152 class MDLController;
153 class Requirements {
154 public:
155  std::unordered_set<P<MDLController>, r_code::PHash<MDLController> > controllers;
156  P<_Fact> f_imdl; // f1 as in f0->pred->f1->imdl.
157  bool chaining_was_allowed;
158 };
159 
160 class RequirementsPair {
161 public:
162  Requirements weak_requirements_;
163  Requirements strong_requirements_;
164 };
165 
187 class MDLController :
188  public HLPController {
189 protected:
190  class RequirementEntry : // use for requirements.
191  public PredictedEvidenceEntry {
192  public:
193  // The reduction which made the requirement.
194  P<MkRdx> mk_rdx_;
195  P<MDLController> controller_; // of the requirement.
196  bool chaining_was_allowed_;
197 
198  RequirementEntry();
199  RequirementEntry(_Fact *f_p_f_imdl, MkRdx* mk_rdx, MDLController *c, bool chaining_was_allowed); // f_imdl is f0 as in f0->pred->f1->imdl.
200 
201  bool is_out_of_range(Timestamp now) const { return (before_<now || after_>now); }
202  };
203 
204  class RequirementCache {
205  public:
206  CriticalSection CS_;
207  r_code::list<RequirementEntry> positive_evidences_;
208  r_code::list<RequirementEntry> negative_evidences_;
209  };
210 
211  RequirementCache requirements_;
212  RequirementCache simulated_requirements_;
213 
214  void _store_requirement(r_code::list<RequirementEntry> *cache, RequirementEntry &e);
215 
216  CriticalSection p_monitorsCS_;
217  r_code::list<P<PMonitor> > p_monitors_;
218 
219  P<r_code::Code> lhs_;
220  P<r_code::Code> rhs_;
221 
222  static const uint32 LHSController = 0;
223  static const uint32 RHSController = 1;
224 
225  typedef enum {
226  NOT_A_REQUIREMENT = 0,
227  WEAK_REQUIREMENT = 1,
228  STRONG_REQUIREMENT = 2
229  } RequirementType;
230 
231  RequirementType requirement_type_;
232  bool is_reuse_;
233  bool is_cmd_;
234 
239  float32 get_success_rate() const;
240 
241  CriticalSection active_requirementsCS_;
242  std::unordered_map<P<_Fact>, RequirementsPair, r_code::PHash<_Fact> > active_requirements_; // Key: P<_Fact>: f1 as in f0->pred->f1->imdl; Value:requirements having allowed the production of prediction.
243 
244  template<class C> void reduce_cache(Fact *f_p_f_imdl, MDLController *controller) { // fwd; controller is the controller of the requirement which produced f_p_f_imdl.
245 
246  BatchReductionJob<C, Fact, MDLController> *j = new BatchReductionJob<C, Fact, MDLController>((C *)this, f_p_f_imdl, controller);
247 #ifdef WITH_DETAIL_OID
248  OUTPUT_LINE((TraceLevel)0, " make BatchReductionJob " << j->get_job_id() << "(" <<
249  j->get_detail_oid() << "), f_p_f_imdl fact(" << f_p_f_imdl->get_detail_oid() <<
250  "), controller(" << get_detail_oid() << ") for " << get_core_object()->get_oid());
251 #endif
252  _Mem::Get()->push_reduction_job(j);
253  }
254 
255  template<class E> void reduce_cache(CriticalSectionList<E> *cache, Fact *f_p_f_imdl, MDLController *controller) {
256 
257  cache->CS_.enter();
258  auto now = Now();
259  typename r_code::list<E>::const_iterator _e;
260  for (_e = cache->list_.begin(); _e != cache->list_.end();) {
261 
262  if ((*_e).is_too_old(now)) // garbage collection.
263  _e = cache->list_.erase(_e);
264  else if ((*_e).evidence_->get_before() <= now)
265  // Skip the evidence if its time interval ends at exactly now. This is a little
266  // more strict than is_too_old() which only checks get_before() < now.
267  ++_e;
268  else {
269 
270  PrimaryMDLOverlay o(this, bindings_);
271  o.reduce((*_e).evidence_, f_p_f_imdl, controller);
272  ++_e;
273  }
274  }
275  cache->CS_.leave();
276  }
277 
278  bool monitor_predictions(_Fact *input);
279 
280  MDLController(r_code::_View *view);
281 public:
282  static MDLController *New(View *view, bool &inject_in_secondary_group);
283 
284  void add_monitor(PMonitor *m);
285  void remove_monitor(PMonitor *m);
286 
287  _Fact *get_lhs() const { return lhs_; }
288  _Fact *get_rhs() const { return rhs_; }
289  Fact *get_f_ihlp(HLPBindingMap *bindings, bool wr_enabled) const override {
290  return bindings->build_f_ihlp(get_object(), Opcodes::IMdl, wr_enabled);
291  }
292 
296  virtual void store_requirement(_Fact *f_p_f_imdl, MkRdx* mk_rdx, MDLController *controller, bool chaining_was_allowed) = 0;
297  ChainingStatus retrieve_imdl_fwd(const HLPBindingMap *bm, Fact *f_imdl, RequirementsPair &r_p, std::vector<BindingResult>& results, MDLController *req_controller, bool &wr_enabled); // checks the requirement instances during fwd; r_p: all wrs in first, all srs in second.
298  ChainingStatus retrieve_imdl_bwd(HLPBindingMap *bm, Fact *f_imdl, Fact *&ground, Fact *&strong_requirement_ground); // checks the requirement instances during bwd; ground is set to the best weak requirement if chaining allowed, NULL otherwise.
299  ChainingStatus retrieve_simulated_imdl_fwd(const HLPBindingMap *bm, Fact *f_imdl, Sim* sim, std::vector<BindingResult>& results);
300  ChainingStatus retrieve_simulated_imdl_bwd(HLPBindingMap *bm, Fact *f_imdl, Sim* prediction_sim, Fact *&ground, Fact *&strong_requirement_ground);
301 
302  virtual void predict(HLPBindingMap *bm, _Fact *input, Fact *f_imdl, bool chaining_was_allowed, RequirementsPair &r_p, Fact *ground,
303  MkRdx* ground_mk_rdx, std::vector<P<_Fact> >& already_predicted) = 0;
304  virtual void register_pred_outcome(Fact *f_pred, r_code::Code* mk_rdx, bool success, _Fact *evidence, float32 confidence, bool rate_failures) = 0;
305  virtual void register_req_outcome(Fact *f_pred, bool success, bool rate_failures) = 0;
306 
307  void add_requirement_to_rhs();
308  void remove_requirement_from_rhs();
309 
310  bool is_requirement() const { return (requirement_type_ != NOT_A_REQUIREMENT); }
311  bool is_reuse() const { return is_reuse_; }
312  bool is_cmd() const { return is_cmd_; }
313 
314  void register_requirement(_Fact *f_pred, RequirementsPair &r_p);
315 
327  static bool get_imdl_template_timings(
328  r_code::Code* imdl, Timestamp& after, Timestamp& before, uint16* after_ts_index = NULL, uint16* before_ts_index = NULL);
329 };
330 
331 class PMDLController :
332  public MDLController {
333 protected:
334  CriticalSection g_monitorsCS_;
335  r_code::list<P<_GMonitor> > g_monitors_;
336  r_code::list<P<_GMonitor> > r_monitors_;
337 
338  virtual uint32 get_rdx_out_group_count() const { return get_out_group_count(); }
339  void inject_goal(HLPBindingMap *bm, Fact *goal, Fact *f_imdl) const;
340  void inject_simulation(Fact *simulation, Timestamp injectionTime) const;
341 
342  bool monitor_goals(_Fact *input);
343 
344  std::chrono::microseconds get_sim_thz(Timestamp now, Timestamp deadline) const;
345 
346  PMDLController(r_code::_View *view);
347 public:
348  void add_g_monitor(_GMonitor *m);
349  void remove_g_monitor(_GMonitor *m);
350  void add_r_monitor(_GMonitor *m);
351  void remove_r_monitor(_GMonitor *m);
352 
353  virtual void register_goal_outcome(Fact *goal, bool success, _Fact *evidence) const = 0;
354  void register_predicted_goal_outcome(Fact *goal, HLPBindingMap *bm, Fact *f_imdl, bool success, bool injected_goal);
355  virtual void register_simulated_goal_outcome(Fact *goal, bool success, _Fact *evidence) const = 0;
356  void inject_simulated_goal_success(Fact* goal, bool success, _Fact* evidence) const;
357 };
358 
382 class TopLevelMDLController :
383  public PMDLController {
384 private:
385  uint32 get_rdx_out_group_count() const override { return get_out_group_count() - 1; } // so that rdx are not injected in the drives host.
386 
387  void abduce(HLPBindingMap *bm, Fact *super_goal, float32 confidence);
388  void abduce_lhs(HLPBindingMap *bm, Fact *super_goal, _Fact *sub_goal_target, Fact *f_imdl, _Fact *evidence);
389 
390  void register_drive_outcome(Fact *goal, bool success) const;
391 
392  void check_last_match_time(bool /* match */) override {}
393 public:
394  TopLevelMDLController(r_code::_View *view);
395 
396  void take_input(r_exec::View *input) override;
397  void reduce(r_exec::View *input);
398 
399  void store_requirement(_Fact *f_p_f_imdl, MkRdx* mk_rdx, MDLController *controller, bool chaining_was_allowed) override; // never called.
400 
401  void predict(HLPBindingMap *bm, _Fact *input, Fact *f_imdl, bool chaining_was_allowed, RequirementsPair &r_p, Fact *ground,
402  MkRdx* ground_mk_rdx, std::vector<P<_Fact> >& already_predicted) override;
403  void register_pred_outcome(Fact *f_pred, r_code::Code* mk_rdx, bool success, _Fact *evidence, float32 confidence, bool rate_failures) override;
404  void register_goal_outcome(Fact *goal, bool success, _Fact *evidence) const override;
405  void register_simulated_goal_outcome(Fact *goal, bool success, _Fact *evidence) const override;
406  void register_req_outcome(Fact *f_pred, bool success, bool rate_failures) override;
407 };
408 
409 class SecondaryMDLController;
410 
429 class PrimaryMDLController :
430  public PMDLController {
431 private:
432  SecondaryMDLController *secondary_;
433 
434  CriticalSection codeCS_;
435  CriticalSection last_match_timeCS_;
436 
437  CriticalSection assumptionsCS_;
438  r_code::list<P<r_code::Code> > assumptions_; // produced by the model; garbage collection at reduce() time..
439 
440  void rate_model(bool success);
441  void kill_views() override; // force res in both primary/secondary to 0.
442  void check_last_match_time(bool match) override; // activate secondary controller if no match after primary_thz;
443 
444  void abduce_lhs(HLPBindingMap *bm, Fact *super_goal, Fact *f_imdl, bool opposite, float32 confidence, Sim *sim, Fact *ground, bool set_before);
445  void abduce_imdl(HLPBindingMap *bm, Fact *super_goal, Fact *f_imdl, bool opposite, float32 confidence, Sim *sim);
446 
455  _Fact* abduce_simulated_lhs(HLPBindingMap *bm, Fact *super_goal, Fact *f_imdl, bool opposite, float32 confidence,
456  Sim *sim, Fact *ground, Fact* goal_requirement = NULL);
457  void abduce_simulated_imdl(HLPBindingMap *bm, Fact *super_goal, Fact *f_imdl, bool opposite, float32 confidence, Sim *sim);
458  void predict_simulated_lhs(HLPBindingMap *bm, bool opposite, float32 confidence, Sim *sim);
459  Fact* predict_simulated_evidence(_Fact *evidence, Sim *sim);
460  void assume(_Fact *input);
461  void assume_lhs(HLPBindingMap *bm, bool opposite, _Fact *input, float32 confidence);
462 
463  bool abduction_allowed(HLPBindingMap *bm);
464 public:
465  PrimaryMDLController(r_code::_View *view);
466 
467  void set_secondary(SecondaryMDLController *secondary);
468 
469  void take_input(r_exec::View *input) override;
470  void reduce(r_exec::View *input);
471  void reduce_batch(Fact *f_p_f_imdl, MDLController *controller);
472 
473  void store_requirement(_Fact *f_p_f_imdl, MkRdx* mk_rdx, MDLController *controller, bool chaining_was_allowed) override;
474 
475  void predict(HLPBindingMap *bm, _Fact *input, Fact *f_imdl, bool chaining_was_allowed, RequirementsPair &r_p, Fact *ground,
476  MkRdx* ground_mk_rdx, std::vector<P<_Fact> >& already_predicted) override;
477  bool inject_prediction(Fact *prediction, Fact *f_imdl, float32 confidence, Timestamp::duration time_to_live, r_code::Code *mk_rdx) const; // here, resilience=time to live, in us; returns true if the prediction has actually been injected.
478 
479  void register_pred_outcome(Fact *f_pred, r_code::Code* mk_rdx, bool success, _Fact *evidence, float32 confidence, bool rate_failures) override;
480  void register_req_outcome(Fact *f_pred, bool success, bool rate_failures) override;
481 
482  void register_goal_outcome(Fact *goal, bool success, _Fact *evidence) const override;
483  void register_simulated_goal_outcome(Fact *goal, bool success, _Fact *evidence) const override;
484 
485  bool check_imdl(Fact *goal, HLPBindingMap *bm);
486 
496  bool check_simulated_imdl(Fact *goal, HLPBindingMap *bm, Sim* prediction_sim);
497 
498  void abduce(HLPBindingMap *bm, Fact *super_goal, bool opposite, float32 confidence);
499 
509  void abduce_no_simulation(Fact *super_goal, bool opposite, float32 confidence, _Fact* f_p_f_success = NULL);
510 
520  bool get_template_timings(HLPBindingMap *bm, Timestamp& after, Timestamp& before);
521 
522  void debug(View *input);
523 };
524 
525 // No backward chaining.
526 // Rating happens only upon the success of predictions.
527 // Requirements are stroed whetwehr they come from a primary or a secondary controller.
528 // Positive requirements are stored into the RHS controller, both kinds (secondary or primary: the latter case is necessary for rating the model).
529 class SecondaryMDLController :
530  public MDLController {
531 private:
532  PrimaryMDLController *primary_;
533 
534  CriticalSection codeCS_;
535  CriticalSection last_match_timeCS_;
536 
537  void rate_model(); // record successes only.
538  void kill_views() override; // force res in both primary/secondary to 0.
539  void check_last_match_time(bool match) override; // kill if no match after secondary_thz;
540 public:
541  SecondaryMDLController(r_code::_View *view);
542 
543  void set_primary(PrimaryMDLController *primary);
544 
545  void take_input(r_exec::View *input) override;
546  void reduce(r_exec::View *input);
547  void reduce_batch(Fact *f_p_f_imdl, MDLController *controller);
548 
549  void store_requirement(_Fact *f_p_f_imdl, MkRdx* mk_rdx, MDLController *controller, bool chaining_was_allowed) override;
550 
551  void predict(HLPBindingMap *bm, _Fact *input, Fact *f_imdl, bool chaining_was_allowed, RequirementsPair &r_p, Fact *ground,
552  MkRdx* ground_mk_rdx, std::vector<P<_Fact> >& already_predicted) override;
553  void register_pred_outcome(Fact *f_pred, r_code::Code* mk_rdx, bool success, _Fact *evidence, float32 confidence, bool rate_failures) override;
554  void register_req_outcome(Fact *f_pred, bool success, bool rate_failures) override;
555 };
556 }
557 
558 
559 #endif
r_code::list::const_iterator
Definition: list.h:266
r_exec::RequirementsPair
Definition: mdl_controller.h:160
r_exec::PrimaryMDLController::abduce_no_simulation
void abduce_no_simulation(Fact *super_goal, bool opposite, float32 confidence, _Fact *f_p_f_success=NULL)
Definition: mdl_controller.cpp:1979
r_exec::BindingResult::BindingResult
BindingResult(HLPBindingMap *map, Fact *ground, MkRdx *ground_mk_rdx)
Definition: mdl_controller.h:120
r_exec::PrimaryMDLController::get_template_timings
bool get_template_timings(HLPBindingMap *bm, Timestamp &after, Timestamp &before)
Definition: mdl_controller.cpp:2698
r_exec::PrimaryMDLController::store_requirement
void store_requirement(_Fact *f_p_f_imdl, MkRdx *mk_rdx, MDLController *controller, bool chaining_was_allowed) override
Definition: mdl_controller.cpp:1492
r_exec::PrimaryMDLOverlay
Definition: mdl_controller.h:133
r_exec::MkRdx
Definition: factory.h:588
r_exec::MDLController::get_success_rate
float32 get_success_rate() const
Definition: mdl_controller.cpp:365
r_code::_View
Definition: r_code/object.h:164
r_exec::MDLController::RequirementEntry
Definition: mdl_controller.h:191
r_exec::MDLController::RequirementCache
Definition: mdl_controller.h:204
r_exec::Sim
Definition: factory.h:248
r_exec::BindingResult
Definition: mdl_controller.h:112
r_exec::PrimaryMDLController::check_simulated_imdl
bool check_simulated_imdl(Fact *goal, HLPBindingMap *bm, Sim *prediction_sim)
Definition: mdl_controller.cpp:2286
r_exec::MDLController::store_requirement
virtual void store_requirement(_Fact *f_p_f_imdl, MkRdx *mk_rdx, MDLController *controller, bool chaining_was_allowed)=0
r_exec::SecondaryMDLController
Definition: mdl_controller.h:530
r_exec::_Fact
Definition: factory.h:155
r_exec::MDLController::get_imdl_template_timings
static bool get_imdl_template_timings(r_code::Code *imdl, Timestamp &after, Timestamp &before, uint16 *after_ts_index=NULL, uint16 *before_ts_index=NULL)
Definition: mdl_controller.cpp:1102
core::P
Definition: base.h:103
r_exec::BatchReductionJob
Definition: reduction_job.h:134
r_code::Code
Definition: r_code/object.h:224
r_exec::TopLevelMDLController::store_requirement
void store_requirement(_Fact *f_p_f_imdl, MkRdx *mk_rdx, MDLController *controller, bool chaining_was_allowed) override
Definition: mdl_controller.cpp:1261
r_exec::HLPController
Definition: hlp_controller.h:106
r_exec::SecondaryMDLController::store_requirement
void store_requirement(_Fact *f_p_f_imdl, MkRdx *mk_rdx, MDLController *controller, bool chaining_was_allowed) override
Definition: mdl_controller.cpp:2810
r_exec::TopLevelMDLController
Definition: mdl_controller.h:383
core::CriticalSection
Definition: submodules/CoreLibrary/CoreLibrary/utils.h:233
r_exec::MDLController
Definition: mdl_controller.h:188
r_exec::View
Definition: view.h:102
r_exec::HLPBindingMap
Definition: binding_map.h:393
r_exec::MDLOverlay
Definition: mdl_controller.h:99
r_exec::Pred
Definition: factory.h:394
r_exec::PrimaryMDLController
Definition: mdl_controller.h:430
r_exec::_GMonitor
Definition: g_monitor.h:97
r_exec::Requirements
Definition: mdl_controller.h:153
r_exec::HLPOverlay
Definition: hlp_overlay.h:98
r_exec::Controller
Definition: controller.h:104
r_code::list
Definition: list.h:99
r_exec::Fact
Definition: factory.h:360
r_code::PHash
Definition: r_code/utils.h:96
r_exec::PMDLController
Definition: mdl_controller.h:332
r_exec::SecondaryMDLOverlay
Definition: mdl_controller.h:144
Generated by   doxygen 1.8.18