DBCacheTester.cpp

Go to the documentation of this file.

#ifndef DBCacheTester_CPP
#define DBCacheTester_CPP


#include "common.hpp"
#include "test/io/db_cache/DBCacheTester.hpp"

#include "io/output/normal/BufferedNormalOutput.hpp"
#include "io/input/transaction_reader/brBufferedTransactionReader.hpp"
#include "util/FrequentFilter.cpp"
#include "io/input/transaction_reader/SortedTransactionReader.hpp"


#include "io/db_cache/OrderedVectorDBCache.hpp"
#include "io/db_cache/OrderedArrayDBCache.hpp"
#include "io/db_cache/PrefixArrayListDBCache.hpp"
#include "io/db_cache/RBTreeDBCache.hpp"

#include "datastructures/trie/TrieBase.hpp"
#include "datastructures/trie/edgelist/Edgelist.hpp"
#include "datastructures/trie/edgelist/OrderedEdgelist.hpp"
#include "datastructures/trie/edgelist/OffsetIndexVector.hpp"
#include "datastructures/trie/edgelist/IndexVector.hpp"
#include "datastructures/trie/edgelist/MapRepr.hpp"
#include "io/db_cache/TrieDBCache.hpp"

#include "io/db_cache/BuildTreeDBCache.hpp"

#include <iostream>

//counter_t TrieBase< Bodon::Edgelist< >, counter_t >::def_data = 0;
//counter_t TrieBase< Bodon::OrderedEdgelist< > >::def_data = 0;
//counter_t TrieBase< Bodon::OffsetIndexVector< > >::def_data = 0;
//counter_t TrieBase< Bodon::IndexVector >::def_data = 0;
//counter_t TrieBase< Bodon::MapRepr  >::def_data = 0;

void DBCacheTester::usageDBCacheTester()
{
   std::cerr << "\nUsage: dbcache input_file min_supp nr_of_traversals code_mode output_file cacher [cacher_option]"<<std::endl;
   std::cerr << " code_mode\t {ASC, DESC, NOCARE}"<<std::endl;
   std::cerr << " cacher\t\t {ordered-vector, ordered-array, RB-tree, trie, bracz}"<<std::endl<<std::endl;
   std::cerr << " In case of trie cacher the possible cacher_options are: "<<std::endl;
   std::cerr << " \t\t list,\n\t\t ordered-list,\n\t\t indexvector,\n\t\t offsetindexvector,\n\t\t or map. "<<std::endl;
   std::cerr << " In case of bracz cacher the possible cacher_options are: "<<std::endl;
   std::cerr << " \t\t trie,\n \t\t patricia. "<<std::endl<<std::endl;


}

void DBCacheTester::doTest( int argc, char *argv[] )
{
   if( argc < 5 )
      usageDBCacheTester();
   else
   {
      typedef brBufferedTransactionReader< > T_R;
      T_R::params_t par_i;
      par_i.file_name = argv[1];
      log_info(0,"The name of the input file is: %s", argv[1]);
      par_i.mode=FileReprBase::READ;
      T_R tr_reader(&par_i);
   
      std::vector< std::pair<counter_t, item_t> > freq_items_with_counters;
      counter_t nr_of_transactions;
      counter_t min_supp = atoi(argv[2]);
      log_info(0,"min_supp is set to %d", min_supp);
      int nr_of_traversals = atoi(argv[3]);
      log_info(0,"The transaction cacher will be traversed %d times", nr_of_traversals);
      FrequentFilter<T_R>
         fr_filter(tr_reader);

      std::cout<<"\nFinding frequent items."<<std::flush;
      fr_filter.findFrequentItems( freq_items_with_counters,  
                                   nr_of_transactions, min_supp);
      std::cout<<"\t\t\t\t\tDone!"<<std::endl;

      log_info(0,"The name of the ouput file is: %s", argv[5]);
      std::cout<<"Doing a cache decoder."<<std::flush;
      D::params_t par_d;
      par_d.file_name = argv[5];
      par_d.mode=FileReprBase::WRITE;
      D decoder(&par_d);
      std::cout<<"\t\t\t\t\tDone!"<<std::endl;
      typedef SortedTransactionReader<Coder<T_R, D>, false> S_C;

      char* cacher = argv[6];
      if( strcmp(cacher, "ordered-vector") == 0)
      {
         log_info(0,"Order-vector cacher is chosen");    
         selectMode< OrderedVectorDBCache<S_C, std::vector<item_t> > >(
            argv[4], argv[1], nr_of_traversals, 
            tr_reader.getLargestItem(), &decoder, &freq_items_with_counters);
      }
      else if( strcmp(cacher, "ordered-array") == 0)
      {
         log_info(0,"Order-array cacher is chosen");     
         selectMode< OrderedArrayDBCache<S_C, std::vector<item_t> > >(
            argv[4], argv[1], nr_of_traversals, 
            tr_reader.getLargestItem(), &decoder, &freq_items_with_counters);
      }
/*      else if( strcmp(cacher, "prefix-array") == 0)
      {
         log_info(0,"Prefix-array cacher is chosen");    
         selectMode< PrefixArrayListDBCache<S_C> >(
            argv[4], argv[1], nr_of_traversals, 
            tr_reader.getLargestItem(), &decoder, &freq_items_with_counters);
            }*/
      else if( strcmp(cacher, "RB-tree") == 0)
      {
         log_info(0,"Red-black tree cacher is chosen");  
         selectMode< Bodon::RBTreeDBCache<S_C, std::vector<item_t> > >(
            argv[4], argv[1], nr_of_traversals, 
            tr_reader.getLargestItem(), &decoder, &freq_items_with_counters);
      }
      else if( strcmp(cacher, "trie") == 0) 
      {
         log_info(0,"Trie cacher is chosen");    
         if (argc<8) 
         {
            log_info(0,"No edge representation is chosen for trie cacher");                 log_info(0,"Default (list) is used!");       
            selectMode< TrieDBCache<S_C, Bodon::Edgelist< std::vector<Edge> > > >(
               argv[4], argv[1], nr_of_traversals, 
               tr_reader.getLargestItem(), &decoder, &freq_items_with_counters);
         }
         else if( strcmp(argv[7], "list") == 0)
         {
            log_info(0,"Unordered list edge representation is chosen");  
            selectMode< TrieDBCache<S_C, Bodon::Edgelist< std::vector<Edge> > > >(
               argv[4], argv[1], nr_of_traversals, 
               tr_reader.getLargestItem(), &decoder, &freq_items_with_counters);
         }
         else if( strcmp(argv[7], "ordered-list") == 0)
         {
            log_info(0,"Ordered list edge representation is chosen");    
            selectMode< TrieDBCache<S_C, Bodon::OrderedEdgelist< std::vector<Edge> > > >(
               argv[4], argv[1], nr_of_traversals, 
               tr_reader.getLargestItem(), &decoder, &freq_items_with_counters);
         }
         else if( strcmp(argv[7], "offsetindexvector") == 0)
         {
            log_info(0,"Offsetindex-vector edge representation is chosen");      
            selectMode< TrieDBCache<S_C, Bodon::OffsetIndexVector<std::vector<void*> > > >(
               argv[4], argv[1], nr_of_traversals,
               tr_reader.getLargestItem(), &decoder, &freq_items_with_counters);
         }
         else if( strcmp(argv[7], "map") == 0)
         {
            log_info(0,"Map-based edge representation is chosen");
            selectMode< TrieDBCache<S_C, Bodon::MapRepr> >(
               argv[4], argv[1], nr_of_traversals,
               tr_reader.getLargestItem(), &decoder, &freq_items_with_counters);
         }
         else       
            log_info(0,"Unknown edge representation is chosen: %s", argv[7]);
            

      }
      else if( strcmp(cacher, "bracz") == 0) 
      {
         log_info(0,"Cacher made by bracz is chosen");   
         if (argc<8) 
         {
            log_info(0,"No other option for bracz is given");    
            log_info(0,"Default value (patricia) is used.");     
            selectMode< bracz::BuildTreeDBCache< S_C,  std::vector<item_t>, 
               bracz::EndPatriciaBuildTree<true> > >(
                  argv[4], argv[1], nr_of_traversals,
                  tr_reader.getLargestItem(), &decoder, &freq_items_with_counters);
         }
         else if( strcmp(argv[7], "trie") == 0)
         {
            log_info(0,"Trie cacher is chosen");         
            selectMode< bracz::BuildTreeDBCache< S_C,  std::vector<item_t>, 
               bracz::TrieBuildTree<true> > >(
                  argv[4], argv[1], nr_of_traversals,
                  tr_reader.getLargestItem(), &decoder, &freq_items_with_counters);
         }
         else if( strcmp(argv[7], "patricia") == 0)
         {
            log_info(0,"Patricia cacher is chosen");     
            selectMode< bracz::BuildTreeDBCache< S_C,  std::vector<item_t>, 
               bracz::EndPatriciaBuildTree<true> > >(
                  argv[4], argv[1], nr_of_traversals,
                  tr_reader.getLargestItem(), &decoder, &freq_items_with_counters);
         }
         else
            log_info(0,"Unknown option is chosen: %s", argv[7]);

      }
      else
         usageDBCacheTester();

   }
}


#endif

---