/*!
 * \file    v3.cpp
 * \brief   vv3 part of the exercise.
 *
 * \author
 *    Christos Choutouridis AEM:8997
 *    <cchoutou@ece.auth.gr>
 */
#include <v3.h>

//   for (int i=0 ; i<A.size() ; ++i) {
//      for (int j = A.col_ptr[i]; j<A.col_ptr[i+1] ; ++j) {
//         int j_idx = A.rows[j];
//         for (int k = A.col_ptr[j_idx] ; k<A.col_ptr[j_idx+1] ; ++k) {
//            int k_idx = A.rows[k];
//            if (A.get(k_idx, i)) {
//               ++c[i];
//            }
//         }
//      }
//   }

namespace v3 {

#if defined CILK

// export CILK_NWORKERS=<num>
int nworkers() {
   if (session.max_threads)
      return (session.max_threads < __cilkrts_get_nworkers()) ?
            session.max_threads : __cilkrts_get_nworkers();
   else
      return __cilkrts_get_nworkers();
}

std::vector<value_t> triang_v(matrix& A) {
   std::vector<value_t> c(A.size());

   cilk_for (int i=0 ; i<A.size() ; ++i) {
      for (auto j = A.getCol(i); j.index() != j.end() ; ++j)               // j list all the edges with i
         for (auto k = A.getCol(j.index()); k.index() != k.end() ; ++k)    // k list all the edges with j
            if (A.get(k.index(), i))                                       // search for i-k edge
               ++c[i];
   }
   if (session.makeSymmetric)
      std::transform (c.begin(), c.end(), c.begin(), [] (value_t& x) {
         return x/2;
      });
   return c;
}

void do_sum (value_t& out_sum, std::vector<value_t>& v, index_t begin, index_t end) {
   for (auto i =begin ; i != end ; ++i)
      out_sum += v[i];
}

value_t sum (std::vector<value_t>& v) {
   int n = nworkers();
   std::vector<value_t> sum_v(n, 0);

   for (index_t i =0 ; i < n ; ++i) {
      cilk_spawn do_sum(sum_v[i], v, i*v.size()/n, (i+1)*v.size()/n);
   }
   cilk_sync;

   value_t s =0;
   for (auto& it : sum_v) s += it;
   return s;
}

#elif defined OMP

/*
// export OMP_NUM_THREADS=<num>
 */
int nworkers() {
   if (session.max_threads && session.max_threads < (size_t)omp_get_max_threads()) {
      omp_set_dynamic(0);
      omp_set_num_threads(session.max_threads);
      return session.max_threads;
   }
   else {
      omp_set_dynamic(1);
      return omp_get_max_threads();
   }
}

std::vector<value_t> triang_v(matrix& A) {
   std::vector<value_t> c(A.size());

   #pragma omp parallel for shared(c)
   for (int i=0 ; i<A.size() ; ++i) {
      for (auto j = A.getCol(i); j.index() != j.end() ; ++j)               // j list all the edges with i
         for (auto k = A.getCol(j.index()); k.index() != k.end() ; ++k)    // k list all the edges with j
            if (A.get(k.index(), i))                                       // search for i-k edge
               ++c[i];
   }
   if (session.makeSymmetric)
      std::transform (c.begin(), c.end(), c.begin(), [] (value_t& x) {
         return x/2;
      });
   return c;
}

value_t sum (std::vector<value_t>& v) {
   value_t s =0;

   #pragma omp parallel for reduction(+:s)
   for (auto i =0u ; i<v.size() ; ++i)
      s += v[i];
   return s;
}

#else

int nworkers() { return 1; }

std::vector<value_t> triang_v(matrix& A) {
   std::vector<value_t> c(A.size());

   for (int i=0 ; i<A.size() ; ++i) {
      for (auto j = A.getCol(i); j.index() != j.end() ; ++j)               // j list all the edges with i
         for (auto k = A.getCol(j.index()); k.index() != k.end() ; ++k)    // k list all the edges with j
            if (A.get(k.index(), i))                                       // search for i-k edge
               ++c[i];
   }
   if (session.makeSymmetric)
      std::transform (c.begin(), c.end(), c.begin(), [] (value_t& x) {
         return x/2;
      });
   return c;
}

value_t sum (std::vector<value_t>& v) {
   value_t s =0;
   for (auto& it : v)
      s += it;
   return s;
}

#endif


value_t triang_count (std::vector<value_t>& c) {
   return (session.makeSymmetric) ? sum(c)/3 : sum(c);
}

}