#include "mate_sw.h"


// 初始化mate sw计算相关的数据
void init_msw_data(msw_data_t* msw, int n_threads, int msw_batch_size) {
#define _alloc_msw_num(data, num, data_type) ((data) = calloc(num, sizeof(data_type)))
#define _alloc_msw(data, data_type) ((data) = calloc(n_threads, sizeof(data_type)))
    int i = 0, j = 0;

    _alloc_msw(msw->t_msw_tasks, msw_task_v*);
    for (i = 0; i < n_threads; ++i) {
        _alloc_msw_num(msw->t_msw_tasks[i], 2, msw_task_v);
    }

    _alloc_msw(msw->t_msw_buf, msw_buf_t);
    _alloc_msw(msw->t_msw_stats, msw_stats_t);
    _alloc_msw(msw->t_msw_ref_buf, byte_vv);
    _alloc_msw(msw->t_msw_seq_buf, byte_vv);

    _alloc_msw(msw->t_msw_1_refs, msw_ref_v);
    _alloc_msw(msw->t_msw_1_seqs, msw_seq_v);
    _alloc_msw(msw->t_msw_1_xtras, int_v);
    _alloc_msw(msw->t_msw_1_kswrs, msw_kswr_v);

    _alloc_msw(msw->t_msw_2_refs, msw_ref_v);
    _alloc_msw(msw->t_msw_2_seqs, msw_seq_v);
    _alloc_msw(msw->t_msw_2_xtras, int_v);
    _alloc_msw(msw->t_msw_2_kswrs, msw_kswr_v);

    // 初始化缓存空间
    msw_ref_t init_ref = {0};
    msw_seq_t init_seq = {0};
    kswr_avx_t init_kswr = {0};
    byte_v init_byte_v = {0};

    for (i = 0; i < n_threads; ++i) {
        for (j = 0; j < msw_batch_size; ++j) {
            // for ref seq buf
            kv_push(byte_v, msw->t_msw_ref_buf[i], init_byte_v);
            kv_push(byte_v, msw->t_msw_seq_buf[i], init_byte_v);

            // for msw第一阶段
            kv_push(msw_ref_t, msw->t_msw_1_refs[i], init_ref);
            kv_push(msw_seq_t, msw->t_msw_1_seqs[i], init_seq);
            kv_push(int, msw->t_msw_1_xtras[i], 0);
            kv_push(kswr_avx_t, msw->t_msw_1_kswrs[i], init_kswr);

            // for msw第二阶段
            kv_push(msw_ref_t, msw->t_msw_2_refs[i], init_ref);
            kv_push(msw_seq_t, msw->t_msw_2_seqs[i], init_seq);
            kv_push(int, msw->t_msw_2_xtras[i], 0);
            kv_push(kswr_avx_t, msw->t_msw_2_kswrs[i], init_kswr);
        }
    }
}

void calc_msw_mem_size(msw_data_t* msw, int n_threads, int64_t* total_bytes) {
    int i;
     //j, k;
    int64_t bytes = 0;
    double gb_d = 1024.0 * 1024 * 1024;
    // 1. t_msw_tasks
    for (i = 0; i < n_threads; ++i) {
        msw_task_v* v = msw->t_msw_tasks[i];
        bytes += sizeof(msw_task_v*);
        bytes += v[0].m * sizeof(msw_task_t); // u8
        bytes += v[1].m * sizeof(msw_task_t);  // i16
    }
    fprintf(stderr, "t_msw_tasks: %f GB\n", bytes / gb_d);
    *total_bytes += bytes;

    // 2. p_msw_tasks
    bytes = 0;
    bytes += msw->p_msw_tasks_u8.m * sizeof(msw_task_t*);
    bytes += msw->p_msw_tasks_i16.m * sizeof(msw_task_t*);
    fprintf(stderr, "p_msw_tasks: %f GB\n", bytes / gb_d);
    *total_bytes += bytes;

    // 3. t_msw_buf
    bytes = 0;
    for (i = 0; i < n_threads; ++i) {
        msw_buf_t* v = &msw->t_msw_buf[i];
        bytes += sizeof(msw_buf_t);
        bytes += v->ref_len * 64 * 2;  // refArr + rowMax;
        bytes += v->seq_len * 64 * 5; // seqArr, H0, H1, Hmax, F
    }
    fprintf(stderr, "t_msw_buf: %f GB\n", bytes / gb_d);
    *total_bytes += bytes;

    // 4. t_msw_stats
}