Ignore:
Timestamp:
Jan 10, 2018, 11:06:11 PM (12 months ago)
Author:
faldebey
Message:

Update to CoRE testing system

File:
1 edited

Legend:

Unmodified
Added
Removed
  • icGREP/icgrep-devel/icgrep/combine/core.cpp

    r5613 r5825  
    22#include <vector>
    33#include <fstream>
    4 #include <boost/algorithm/string/classification.hpp> 
     4#include <boost/algorithm/string/classification.hpp>
    55#include <boost/algorithm/string/split.hpp>
     6#include <boost/algorithm/string/replace.hpp>
    67#include <boost/filesystem.hpp>
    78#include <iostream>
    89#include <algorithm>
     10#include <chrono>
    911#include "regexGen.h"
    1012#include "stringGen.h"
    11 #include "pugixml/src/pugixml.hpp"
    1213#include "icgrep-test/icgrep-test.h"
    1314
     15#include <getopt.h>
     16
     17#define likely(x)     __builtin_expect((x),1)
     18
    1419using namespace std;
     20namespace fs=boost::filesystem;
     21
    1522
    1623std::vector<string> vectorizeLine(string line){
     
    2027}
    2128
    22 std::vector<string> setOptions(std::vector<string> header, string xml){
    23         if (!xml.empty()){
    24                 std::vector<string> options;
    25                 pugi::xml_document doc;
    26                 doc.load_file(xml.c_str());
    27                 for (auto op : header){
    28                         bool added = false;
    29                         for (auto parameter : doc.first_child().children()){
    30                                 if (parameter.attribute("name").value() == op){
    31                                         string sch(parameter.child("Switch").child_value());
    32                                         if (sch == "on"){
    33                                                 options.push_back(op);
    34                                                 added =  true;
     29std::size_t directorySize(fs::path path)
     30{
     31        return std::count_if(fs::directory_iterator(path),
     32                         fs::directory_iterator(),
     33                         [](const fs::directory_entry& e) {
     34                          return true;  });
     35}
     36
     37void clearDir(string dir){
     38        fs::path path_to_remove(dir);
     39        for (fs::directory_iterator end_dir_it, it(path_to_remove); it!=end_dir_it; ++it) {
     40                fs::remove_all(it->path());
     41        }
     42}
     43
     44void backup(){
     45        int count = directorySize("core-out/Archive");
     46
     47        fs::path src("core-out/bugs");
     48        fs::path dst("core-out/Archive/test" + to_string(count+1));
     49        if (!fs::create_directory(dst))
     50    {
     51        throw std::runtime_error("Cannot create destination directory " + dst.string());
     52    }
     53
     54        for (const auto& dirEnt : fs::recursive_directory_iterator{src})
     55    {
     56        const auto& path = dirEnt.path();
     57        auto relativePathStr = path.string();
     58        boost::replace_first(relativePathStr, src.string(), "");
     59        fs::copy(path, dst / relativePathStr);
     60    }
     61
     62    clearDir("core-out/bugs/regs");
     63    clearDir("core-out/bugs/files");
     64    remove("core-out/bugs/bugList");
     65}
     66
     67void printElapsedTime(chrono::system_clock::time_point startTime){
     68                chrono::duration<int> timeSpan =
     69                chrono::duration_cast<chrono::duration<int>>(chrono::system_clock::now() - startTime);
     70                auto elapsed = chrono::duration_cast<chrono::minutes>(timeSpan).count();
     71                cout << "Time elapsed: " << elapsed << endl;
     72
     73}
     74
     75int main (int argc, char *argv[]) {
     76        srand (time(0));
     77
     78        string csvInput = "../icgrep/combine/icGrep-output.csv";
     79
     80        bool exhaustive = false;
     81
     82        int opt;
     83
     84        while ((opt = getopt(argc, argv, "eI:")) != -1) {
     85                switch (opt) {
     86                case 'e':
     87                        exhaustive = true;
     88                break;
     89                case 'I':
     90                csvInput = optarg;
     91                break;
     92                default: /* '?' */
     93                cerr << "Usage: " << argv[0] << " [-e] [-I csv file]\n";
     94                exit(EXIT_FAILURE);
     95                }
     96        }
     97
     98
     99        cout << "CSV: " << csvInput << endl;
     100        ifstream file;
     101        file.open(csvInput);
     102        if (!file.is_open()){
     103                cerr << "Could not open input file: " << csvInput << endl;
     104                return 0;
     105        }
     106
     107        string line;
     108        vector<string> row;
     109        vector<string> header;
     110        int rownum = 1;
     111        bool firstLine = true;
     112        int bugCount = 0;
     113
     114        backup();
     115
     116        chrono::system_clock::time_point startTime =
     117                chrono::system_clock::now();
     118
     119        if(exhaustive){
     120
     121                cout << "exhaustive mode selected..." << endl;
     122
     123                chrono::system_clock::time_point endTime =
     124        chrono::system_clock::now() + chrono::hours(24);
     125
     126        while (endTime > chrono::system_clock::now()) {
     127
     128                if(!getline(file, line)){
     129                                file.clear();
     130                                file.seekg(0, ios::beg);
     131                                getline(file, line);
     132                                firstLine = true;
     133                }
     134                if (likely(!line.empty() && line[0] != '#')){
     135                        if (firstLine){
     136                                header = vectorizeLine(line);
     137                                firstLine = false;
     138                        }
     139                        else{
     140                                                row = vectorizeLine(line);
     141                                                RegexGen reGen(header, row);
     142                                                IcgrepTest icTest;
     143                                                bugCount += icTest.buildTest(reGen.RE, reGen.flags, reGen.syntax, reGen.fileType, rownum);
     144                                                if (rownum % 50 == 0){
     145                                                        printElapsedTime(startTime);
     146
     147                                                }
     148                                                ++rownum;
    35149                                        }
    36150                                }
    37151                        }
    38                         if (!added){
    39                                 options.push_back("off");
     152
     153        }
     154        else{
     155                cout << "combinatorial mode selected..." << endl;
     156                while(getline(file, line)){
     157                        if (likely(!line.empty() && line[0] != '#')){
     158                                if (firstLine){
     159                                header = vectorizeLine(line);
     160                                firstLine = false;
     161                        }
     162                        else{
     163                                        row = vectorizeLine(line);
     164                                        RegexGen reGen(header, row);
     165                                        IcgrepTest icTest;
     166                                        bugCount += icTest.buildTest(reGen.RE, reGen.flags, reGen.syntax, reGen.fileType, rownum);
     167                                        if (rownum % 50 == 0){
     168                                                printElapsedTime(startTime);
     169                                        }
     170                                        ++rownum;
     171                                }
    40172                        }
    41                        
    42173                }
    43                 return options;
    44174        }
    45        
    46         return header;
    47        
     175        // ictest.getResult(rownum -1);
     176        file.close();
    48177
    49 }
    50 int main (int argc, char *argv[]) {
    51         if (argc > 3) {
    52                 cout << "incorrect arguments!\n";
    53         cout<< "usage: " << argv[0] << " <combinatorial csv file name> <options xml file name>\n";
    54         return 0;
    55     }
    56         else {
    57                 IcgrepTest ictest;
    58 
    59                 ictest.prepare();
    60 
    61                 string csv = (argc > 1)? argv[1] : "../icgrep/combine/icGrep-output.csv";
    62                 string xml = (argc > 2)? argv[2] : "";
    63 
    64                 ifstream file;
    65                 file.open(csv);
    66                 if (!file.is_open()){
    67                         cerr << "Could not open input file\n";
    68                         return 0;
    69                 }
    70 
    71                 string line;
    72                 vector<string> row;
    73                 getline(file, line);
    74                 vector<string> header = setOptions(vectorizeLine(line), xml);
    75                 int rownum = 1;
    76                 while(getline(file, line)){
    77                         row = vectorizeLine(line);
    78                         RegexGen reGen(header, row);
    79                         ictest.buildTest(reGen.RE, reGen.flags, reGen.syntax, rownum);
    80                         ++rownum;
    81                 }
    82                 ictest.execute();
    83                 ictest.getResult();
    84                 file.close();
    85                
    86         }
    87178        return 0;
    88179}
Note: See TracChangeset for help on using the changeset viewer.