rename to csp

Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com>

src/ast/csp_decl_plugin.h

@@ -0,0 +1,143 @@
+/*++
+Copyright (c) 2018 Microsoft Corporation
+
+Module Name:
+
+    csp_decl_plugin.h
+
+Abstract:
+
+    Declarations used for a job-shop scheduling domain.
+
+    The job-shop domain comprises of constants job(j), resource(r)
+
+    It finds values to variables:
+    - start(j), end(j), job2resource(j)
+
+    It assumes a background of:
+    - resources : Job -> Resource -> Int * LoadPct - time to run job j on resource r assuming LoadPct
+    - runtime   : Job -> Int                       - time to run job j if not associated with any resource
+    - capacity  : Resource -> Int -> LoadPct       - capacity of resource r at time t, given as sequence of time intervals
+    // assume each job has at least one resource associated with it.    
+    // introduce a dummy resource if needed.
+
+    // Theory:
+    end(j) - start(j) = time-to-execute(j)
+    time-to-execute(j) := time-to-execute(j, resource(j))  otherwise
+
+    time-to-execute(j, r) := (T - start(j)) 
+            where capacity(j,r) = sum_{t = start(j)}^{T} load(loadpct(j,r), r, t)
+
+    capacity(j, r) := cap where (cap, loadpct) = resources j r
+    loadpct(j, r)  := loadpct where (cap, loadpct) = resources j r
+
+    load(loadpct, r, t) := min(capacity r t, loadpct) / loadpct
+
+    capacity(r, t) >= sum_{j | job-on-resource(j, r, t) } min(capacity r t, loadpct(j, r))
+
+    // Macros:
+    job-on-resource(j, r)              := r = resource(j);
+    job-on-resource(j, r, t)           := (job-on-resource(j, r) & start(j) <= t <= end(j));
+    start_min(j, t)                    := start(j) >= t;
+    end_max(j, t)                      := end(j) <= t;
+    job_link(j1, j2, startstart, hard) := start(j1) = start(j2);
+    job_link(j1, j2, startstart, soft) := start(j1) <= start(j2);
+    job_link(j1, j2, endend, hard)     := end(j1) =  end(j2);
+    job_link(j1, j2, endend, soft)     := end(j2) <= end(j1);
+    job_link(j1, j2, endstart, hard)   := end(j1) =  start(j2);
+    job_link(j1, j2, endstart, soft)   := end(j2) <= start(j1);
+    job_link(j1, j2, startend, hard)   := end(j2) =  start(j1);
+    job_link(j1, j2, startend, soft)   := end(j1) <= start(j2);
+    job_delay(j1, j2, t)               := end(j1) + t <= end(j2);
+    job_on_same_resource(j1, j2)       := resource(j1) = resource(j2);
+    job_not_on_same_resource(j1, j2)   := resource(j1) != resource(j2);
+    job_time_intersect(j1, j2)         := start(j1) <= end(j2) <= end(j1) || start(j2) <= end(j1) <= end(j2);
+    
+    job-on-resource(j, r, t) => job-property(j) = null or job_property(j) in working_time_property(r, t);
+        
+Author:
+
+    Nikolaj Bjorner (nbjorner) 2018-8-9 
+
+Revision History:
+
+
+--*/
+#pragma once;
+#include "ast/ast.h"
+
+enum js_sort_kind {
+    JOB_SORT,
+    RESOURCE_SORT,
+    ALIST_SORT
+};
+
+enum js_op_kind {
+    OP_JS_JOB,               // value of type job
+    OP_JS_RESOURCE,          // value of type resource
+    OP_JS_START,             // start time of a job
+    OP_JS_END,               // end time of a job
+    OP_JS_JOB2RESOURCE,      // resource associated with job
+    OP_JS_MODEL,             // jobscheduler model
+    OP_JS_JOB_RESOURCE,
+    OP_JS_JOB_PREEMPTABLE,
+    OP_JS_RESOURCE_AVAILABLE
+};
+
+class csp_decl_plugin : public decl_plugin {
+public:
+    csp_decl_plugin() {}
+    ~csp_decl_plugin() override {}
+    void finalize() override;
+    void set_manager(ast_manager* m, family_id fid) override;
+    decl_plugin * mk_fresh() override { return alloc(csp_decl_plugin); }
+    sort * mk_sort(decl_kind k, unsigned num_parameters, parameter const * parameters) override;
+    func_decl * mk_func_decl(decl_kind k, unsigned num_parameters, parameter const * parameters,
+                             unsigned arity, sort * const * domain, sort * range) override;	
+    bool is_value(app * e) const override;
+    bool is_unique_value(app * e) const override { return is_value(e); }
+    void get_op_names(svector<builtin_name> & op_names, symbol const & logic) override;
+    void get_sort_names(svector<builtin_name> & sort_names, symbol const & logic) override;
+    expr * get_some_value(sort * s) override;
+    sort * mk_job_sort() const { return m_job_sort; }
+    sort * mk_resource_sort() const { return m_resource_sort; }
+    sort * mk_alist_sort() const { return m_alist_sort; }
+private:
+    sort* m_job_sort;
+    sort* m_resource_sort;
+    sort* m_alist_sort;
+    sort* m_int_sort;
+
+    void check_arity(unsigned arity);
+    void check_index1(unsigned n, parameter const* ps);
+    void check_index2(unsigned n, parameter const* ps);
+};
+
+class csp_util {
+    ast_manager&         m;
+    family_id            m_fid;
+    csp_decl_plugin* m_plugin;
+public:
+    csp_util(ast_manager& m);
+    sort* mk_job_sort();
+    sort* mk_resource_sort();
+
+    app* mk_job(unsigned j);
+    bool is_job(expr* e, unsigned& j);
+    unsigned job2id(expr* j);
+
+    app* mk_resource(unsigned r);
+    bool is_resource(expr* e, unsigned& r);
+    unsigned resource2id(expr* r);
+
+    app* mk_start(unsigned j);
+    app* mk_end(unsigned j);
+    app* mk_job2resource(unsigned j);
+
+    bool is_add_resource_available(expr * e, expr *& res, unsigned& loadpct, uint64_t& start, uint64_t& end);
+    bool is_add_job_resource(expr * e, expr *& job, expr*& res, unsigned& loadpct, uint64_t& capacity, uint64_t& end); 
+    bool is_set_preemptable(expr* e, expr *& job);
+
+    bool is_model(expr* e) const { return is_app_of(e, m_fid, OP_JS_MODEL); }
+
+};