Z3 sources

Signed-off-by: Leonardo de Moura <leonardo@microsoft.com>

lib/dl_costs.cpp

@@ -0,0 +1,160 @@
+/*++
+Copyright (c) 2006 Microsoft Corporation
+
+Module Name:
+
+    dl_costs.cpp
+
+Abstract:
+
+    <abstract>
+
+Author:
+
+    Krystof Hoder (t-khoder) 2010-09-20.
+
+Revision History:
+
+--*/
+
+#include "debug.h"
+#include "stopwatch.h"
+#include "dl_context.h"
+#include "dl_rule.h"
+#include "dl_costs.h"
+
+namespace datalog {
+
+    // -----------------------------------
+    //
+    // costs
+    //
+    // -----------------------------------
+
+    costs::costs() : milliseconds(0), instructions(0) {}
+
+    bool costs::empty() const { 
+        return !milliseconds && !instructions;
+    }
+
+    void costs::reset() {
+        milliseconds = 0;
+        instructions = 0;
+    }
+
+    costs costs::operator-(const costs & o) const {
+        costs res(*this);
+        SASSERT(milliseconds>o.milliseconds);
+        res.milliseconds-=o.milliseconds;
+        SASSERT(instructions>o.instructions);
+        res.instructions-=o.instructions;
+        return res;
+    }
+
+    void costs::operator+=(const costs & o) {
+        milliseconds+=o.milliseconds;
+        instructions+=o.instructions;
+    }
+
+    bool costs::passes_thresholds(context & ctx) const {
+        return milliseconds >= ctx.dl_profile_milliseconds_threshold();
+    }
+
+    void costs::output(std::ostream & out) const {
+        out << "instr: " << instructions << "  time: " << milliseconds << "ms";
+    }
+
+
+    // -----------------------------------
+    //
+    // accounted_object
+    //
+    // -----------------------------------
+
+    accounted_object::~accounted_object() {
+        if(m_parent_object) {
+            SASSERT(m_context);
+            m_context->get_rule_manager().dec_ref(m_parent_object);
+        }
+    }
+
+    void accounted_object::set_accounting_parent_object(context & ctx, rule * parent) {
+        if(m_parent_object) {
+            SASSERT(m_context);
+            SASSERT(m_context==&ctx);
+            m_context->get_rule_manager().dec_ref(m_parent_object);
+        }
+        m_context = &ctx;
+        m_parent_object = parent;
+        m_context->get_rule_manager().inc_ref(m_parent_object);
+    }
+
+    void accounted_object::process_costs() {
+        costs delta = get_current_costs();
+        if(delta.empty()) {
+            return;
+        }
+        get_current_costs().reset();
+        accounted_object * obj = this;
+        do {
+            obj->m_processed_cost+=delta;
+            obj=obj->m_parent_object;
+        } while(obj);
+    }
+
+    void accounted_object::get_total_cost(costs & result) const {
+        result.reset();
+        result+=m_current_cost;
+        result+=m_processed_cost;
+    }
+
+    bool accounted_object::passes_output_thresholds(context & ctx) const {
+        costs c;
+        get_total_cost(c);
+        return c.passes_thresholds(ctx);
+    }
+
+
+    void accounted_object::output_profile(context & ctx, std::ostream & out) const {
+        costs c;
+        get_total_cost(c);
+        c.output(out);
+    }
+
+
+    // -----------------------------------
+    //
+    // cost_recorder
+    //
+    // -----------------------------------
+
+    cost_recorder::cost_recorder() : m_obj(0) {
+        m_stopwatch = alloc(stopwatch);
+        m_stopwatch->start();
+    }
+    
+    cost_recorder::~cost_recorder() { 
+        if(m_obj) {
+            finish();
+        }
+        dealloc(m_stopwatch);
+    }
+
+    void cost_recorder::start(accounted_object * obj) {
+        uint64 curr_time = static_cast<uint64>(m_stopwatch->get_current_seconds()*1000);
+        if(m_obj) {
+            costs::time_type time_delta = static_cast<costs::time_type>(curr_time-m_last_time);
+            costs & c = m_obj->get_current_costs();
+            c.instructions++;
+            c.milliseconds+=time_delta;
+            m_obj->m_being_recorded = false;
+        }
+        m_running = obj!=0;
+        m_obj = obj;
+        m_last_time = curr_time;
+        if(obj) {
+            m_obj->m_being_recorded = true;
+        }
+    }
+
+};