Merge pull request #27 from kwrx/dev

Conforme alla teoria

Author: kwrx

CMakeLists.txt

@@ -15,14 +15,14 @@ set(HAVE_CLASP      0)
 
 ## QASP
 set(HAVE_THREADS            1)
-set(HAVE_ITERATIONS         1)
 
 ## Wasp
 set(HAVE_WASP_ASSUMPTIONS   1)
 set(HAVE_WASP_RESET         1)
 
 ## Logger
 set(HAVE_PRETTY_LOGGER      1)
+set(HAVE_PERFORMANCE        1)
 
 ######################################
 

README.md

@@ -10,7 +10,7 @@ $ cmake -DCMAKE_BUILD_TYPE=Release -B build
 $ cmake --build build
 $ cmake --install build
 ```
-**NOTE:** [CMake](https://cmake.org/) >= 3.11 and [Boost C++ Libraries](https://www.boost.org/) >= 1.72.0 are required.
+**NOTE:** [CMake](https://cmake.org/) >= 3.20 and [Boost C++ Libraries](https://www.boost.org/) >= 1.72.0 are required.
 
 ## Usage
 Open your terminal and type:
@@ -19,7 +19,7 @@ $ qasp [OPTIONS] SOURCES...
 ```
 Or read from *stdin*
 ```shell script
-$ cat SOURCES | qasp
+$ cat SOURCE | qasp
 ```
 **NOTE:** type ```qasp --help``` for more information.
 
@@ -34,7 +34,7 @@ d :- b.
 %@constraints
 :- c, not d.
 ```
-Calculate if exists an *answer set* of **@exists fragment** such that for each *answer set* of **@forall fragmemt** is a *coherent* solution.
+Calculate if exists an *answer set* of **@exists program** such that for each *answer set* of **@forall program** is a *coherent* solution.
 ```shell script
 $ qasp program.asp
 ```

config.h.in

@@ -27,10 +27,10 @@
 #cmakedefine HAVE_GRINGO            @HAVE_GRINGO@
 #cmakedefine HAVE_CLASP             @HAVE_CLASP@
 #cmakedefine HAVE_THREADS           @HAVE_THREADS@
-#cmakedefine HAVE_ITERATIONS        @HAVE_ITERATIONS@
 #cmakedefine HAVE_WASP_ASSUMPTIONS  @HAVE_WASP_ASSUMPTIONS@
 #cmakedefine HAVE_WASP_RESET        @HAVE_WASP_RESET@
 #cmakedefine HAVE_PRETTY_LOGGER     @HAVE_PRETTY_LOGGER@
+#cmakedefine HAVE_PERFORMANCE       @HAVE_PERFORMANCE@
 
 
 #define QASP_PROGRAM_NAME       "@CMAKE_PROJECT_NAME@"

include/qasp/qasp.h

@@ -47,17 +47,14 @@ namespace qasp {
 
         uint16_t quiet;
         uint16_t cpus;
-        qasp_iteration_t iterations;
 
         Options(uint16_t quiet, uint16_t cpus, qasp_iteration_t iterations)
             : quiet(quiet)
-            , cpus(cpus)
-            , iterations(iterations) {}
+            , cpus(cpus) {}
 
         Options()
             : quiet(QASP_OPTIONS_DEFAULT_QUIET)
-            , cpus(QASP_OPTIONS_DEFAULT_CPUS)
-            , iterations(QASP_OPTIONS_DEFAULT_ITERATIONS) {}
+            , cpus(QASP_OPTIONS_DEFAULT_CPUS) {}
 
     };
 

src/main.cc

@@ -36,7 +36,6 @@ static void show_usage(int argc, char** argv) {
         << "Use: " << QASP_PROGRAM_NAME << " [OPTIONS] SOURCES...\n"
         << "Process qasp SOURCES and blabla...\n\n"
         << "    -j N, --parallel=N          allow N jobs at once.\n"
-        << "    -n N, --iterations=N        iterate solving N times (infinite: N <= 0).\n"
         << "    -q, --quiet                 hide log information.\n"
         << "        --help                  print this message and exit.\n"
         << "        --version               print version info and exit.\n";
@@ -85,7 +84,7 @@ int main(int argc, char** argv) {
     qasp::Options options;
 
     int c, idx;
-    while((c = getopt_long(argc, argv, "qj:n:hv", long_options, &idx)) != -1) {
+    while((c = getopt_long(argc, argv, "qj:hv", long_options, &idx)) != -1) {
 
         switch(c) {
             case 'q':
@@ -94,9 +93,6 @@ int main(int argc, char** argv) {
             case 'j':
                 options.cpus = atoi(optarg);
                 break;
-            case 'n':
-                options.iterations = atoll(optarg);
-                break;
             case 'v':
                 show_version(argc, argv);
                 break;
@@ -112,12 +108,7 @@ int main(int argc, char** argv) {
 
 
     if(unlikely(options.cpus < 1)) {
-        std::cerr << QASP_PROGRAM_NAME << ": error: invalid parallel value" << std::endl;
-        abort();
-    }
-
-    if(unlikely(options.iterations <= 0)) {
-        options.iterations = std::numeric_limits<decltype(options.iterations)>().max();
+        options.cpus = std::numeric_limits<decltype(options.cpus)>().max();
     }
 
 
@@ -163,6 +154,7 @@ int main(int argc, char** argv) {
 
     }
 
+
     return EXIT_SUCCESS;
 
 }

src/qasp/AnswerSet.hpp

@@ -21,6 +21,7 @@
 #pragma once
 
 #include "Atom.hpp"
+#include "utils/Performance.hpp"
 
 #include <iostream>
 #include <vector>
@@ -34,7 +35,7 @@ namespace qasp {
     class AnswerSet : public std::vector<Atom> {
         public:
 
-            inline friend bool operator==(const AnswerSet& a, const AnswerSet& b) {
+            inline friend bool operator==(const AnswerSet& a, const AnswerSet& b) { __PERF_TIMING(answerset_comparing);
 
                 if(a.size() != b.size())
                     return false;

src/qasp/Program.cpp

@@ -23,6 +23,7 @@
 #include "AnswerSet.hpp"
 #include "grounder/Grounder.hpp"
 #include "solver/Solver.hpp"
+#include "utils/Performance.hpp"
 
 #include <iostream>
 #include <sstream>
@@ -49,7 +50,7 @@ using namespace qasp::solver;
 
 
 
-const Program& Program::groundize(Assumptions assumptions) {
+const Program& Program::groundize(Assumptions assumptions) { __PERF_TIMING(grounding);
 
     LOG(__FILE__, INFO) << "Generating ground for program #" << id() << " with:"
                         << " assumptions(" << assumptions << ")" << std::endl;
@@ -115,7 +116,7 @@ const Program& Program::groundize(Assumptions assumptions) {
 }
 
 
-std::tuple<ProgramModel, std::vector<AnswerSet>> Program::solve(const AnswerSet& answer) const {
+std::tuple<ProgramModel, std::vector<AnswerSet>> Program::solve(const AnswerSet& answer) const { __PERF_TIMING(solving);
 
     assert(!ground().empty());
 

src/qasp/Program.hpp

@@ -23,6 +23,7 @@
 #include "Atom.hpp"
 #include "Assumptions.hpp"
 #include "AnswerSet.hpp"
+#include "utils/Performance.hpp"
 
 #include <string>
 #include <vector>
@@ -94,6 +95,15 @@ namespace qasp {
                 return this->__assumptions = std::move(assumptions), *this;
             }
 
+
+            inline const auto& last() const {
+                return this->__last;
+            }
+
+            inline void last(bool last) {
+                this->__last = std::move(last);
+            }
+
             const Program& groundize(Assumptions assumptions = {});
             std::tuple<ProgramModel, std::vector<AnswerSet>> solve(const AnswerSet& answer = {}) const;
 
@@ -104,13 +114,15 @@ namespace qasp {
             ProgramType __type;
             std::string __source;
             std::string __ground;
-            Assumptions __assumptions;
             std::vector<Program> __subprograms;
-            std::unordered_map<std::string, Atom> __atoms;
-            atom_index_t __atoms_index_offset;
+
+            std::unordered_map<std::string, Atom> __atoms {};
+            atom_index_t __atoms_index_offset = 0;
+            Assumptions __assumptions {};
+            bool __last = false;
 
 
-            inline const atom_index_t map_index(const Atom& atom) const {
+            inline const atom_index_t map_index(const Atom& atom) const { __PERF_INC(mapping);
 
                 const auto& found = atoms().find(atom.predicate());
 

src/qasp/Qasp.cpp

@@ -45,13 +45,19 @@ std::string Qasp::run() {
 
 
     QaspSolver qasp(*this, program);
-    
-    if(qasp.run()) {
+
+    bool result = qasp.run();
+
+
+
+    __PERF_PRINT_ALL();
+
+    if(result) {
 
         std::ostringstream output;
 
         for(const auto& answer : qasp.solution())
-            output << answer.second << std::endl;
+            output << answer << std::endl;
 
         return output.str();