#include "mat_mul.h"

#include <cstdlib>
#include <cstdio>
#include <pthread.h>


#define min(a, b) (((a) < (b)) ? (a) : (b))

static float *A, *B, *C;
static int M, N, K;
static int num_threads;

static void* mat_mul_thread(void *data) {
  // TODO: parallelize & optimize matrix multiplication
  // for (int i = 0; i < M; ++i) {
  //     for (int j = 0; j < N; ++j) {
  //       for (int k = 0; k < K; ++k) {
  //         C[i * N + j] += A[i * K + k] * B[k * N + j];
  //       }
  //   }
  // }

  // for (int i = 0; i < M; ++i) {
  //     for (int j = 0; j < N; ++j) {
  //       for (int k = 0; k < K; ++k) {
  //         C[i * N + j] += A[i * K + k] * B[k * N + j];
  //         //printf("loop : %d %d %d\n",i,j,k);
  //         printf("loop : %2.1f %2.1f %2.1f\n",A,B,C);
  //       }
  //   }
  // }
  // return NULL;

//   int pid = * (int *) data;

//   int slice = M / num_threads;
//   int start = pid * slice;
//   int end = pid == num_threads - 1 ? M : (pid + 1) * slice;
  
//   float Aik;
//   int bs = 1024;
//   for (int kk = 0; kk < K; kk += bs) {
//     for (int jj = 0; jj < N; jj += bs) {
//       for (int i = start; i < end; ++i) {
//         for (int k = kk; k < min(kk + bs, K); ++k) {
//           Aik = A[i * K + k];
//           for (int j = jj; j < min(jj + bs, N); ++j) {
// //            C[i * N + j] += Aik * B[k * N + j];
//           }
//         }
//       }
//     }
//   }


  int pid = * (int *) data;

  int slice = M / num_threads;
  int start = pid * slice;
  int end = pid == num_threads - 1 ? M : (pid + 1) * slice;
  //int unroll = 8;
  float Aik;
  int bs = 50;
  //int jj = 0;
  for (int kk = 0; kk < K; kk += bs) {
    //for (int jj = 0; jj < N; jj += bs) {
      for (int i = start; i < end; ++i) {
        for (int k = kk; k < min(kk + bs, K); ++k) {
          Aik = A[i * K + k];
          int j=0;
//          for (; j < N - 8; j+=8) {
//            C[i * N + j] += Aik * B[k * N + j];
//            C[i * N + (j + 0)] += Aik * B[k * N + (j + 0)];
//            C[i * N + (j + 1)] += Aik * B[k * N + (j + 1)];
//            C[i * N + (j + 2)] += Aik * B[k * N + (j + 2)];
//            C[i * N + (j + 3)] += Aik * B[k * N + (j + 3)];
//            C[i * N + (j + 4)] += Aik * B[k * N + (j + 4)];
//            C[i * N + (j + 5)] += Aik * B[k * N + (j + 5)];
//            C[i * N + (j + 6)] += Aik * B[k * N + (j + 6)];
//            C[i * N + (j + 7)] += Aik * B[k * N + (j + 7)];
//          }
          for(; j < N; ++j) {
            C[i * N + j] += Aik * B[k * N + j];
          }
        }
      }
    //}
  }

  return NULL;


}

void mat_mul(float *_A, float *_B, float *_C, int _M, int _N, int _K, int _num_threads) {
  A = _A, B = _B, C = _C;
  M = _M, N = _N, K = _K;
  num_threads = _num_threads;

  // TODO: create '_num_threads' pthreads
  //pthread_t thread;
  // pthread_create(&thread, NULL, mat_mul_thread, NULL);
  // pthread_join(thread, NULL);

pthread_t * threads;
threads = (pthread_t *) malloc(sizeof(pthread_t) * num_threads);

for (int i = 0; i < num_threads; i++) {
  int * pid = (int *) malloc(sizeof(int));
  *pid = i;
  pthread_create(&threads[i], NULL, mat_mul_thread, pid);
}

for (int i = 0; i < num_threads; i++) {
  pthread_join(threads[i], NULL);
}

}