// File: /workspace/github_cpp_makefile_star2_O3/Pyboon[P]sage/./Eigen/src/Core/products/GeneralBlockPanelKernel.h
// Function: void Eigen::internal::evaluateProductBlockingSizesHeuristic<std::complex<double>, std::complex<double>, 1, long>(long&, long&, long&, long)
void evaluateProductBlockingSizesHeuristic(Index& k, Index& m, Index& n, Index num_threads = 1)
{
  typedef gebp_traits<LhsScalar,RhsScalar> Traits;

  // Explanations:
  // Let's recall that the product algorithms form mc x kc vertical panels A' on the lhs and
  // kc x nc blocks B' on the rhs. B' has to fit into L2/L3 cache. Moreover, A' is processed
  // per mr x kc horizontal small panels where mr is the blocking size along the m dimension
  // at the register level. This small horizontal panel has to stay within L1 cache.
  std::ptrdiff_t l1, l2, l3;
  manage_caching_sizes(GetAction, &l1, &l2, &l3);

  if (num_threads > 1) {
    typedef typename Traits::ResScalar ResScalar;
    enum {
      kdiv = KcFactor * (Traits::mr * sizeof(LhsScalar) + Traits::nr * sizeof(RhsScalar)),
      ksub = Traits::mr * Traits::nr * sizeof(ResScalar),
      kr = 8,
      mr = Traits::mr,
      nr = Traits::nr
    };
    // Increasing k gives us more time to prefetch the content of the "C"
    // registers. However once the latency is hidden there is no point in
    // increasing the value of k, so we'll cap it at 320 (value determined
    // experimentally).
    const Index k_cache = (numext::mini<Index>)((l1-ksub)/kdiv, 320);
    if (k_cache < k) {
      k = k_cache - (k_cache % kr);
      eigen_internal_assert(k > 0);
    }

    const Index n_cache = (l2-l1) / (nr * sizeof(RhsScalar) * k);
    const Index n_per_thread = numext::div_ceil(n, num_threads);
    if (n_cache <= n_per_thread) {
      // Don't exceed the capacity of the l2 cache.
      eigen_internal_assert(n_cache >= static_cast<Index>(nr));
      n = n_cache - (n_cache % nr);
      eigen_internal_assert(n > 0);
    } else {
      n = (numext::mini<Index>)(n, (n_per_thread + nr - 1) - ((n_per_thread + nr - 1) % nr));
    }

    if (l3 > l2) {
      // l3 is shared between all cores, so we'll give each thread its own chunk of l3.
      const Index m_cache = (l3-l2) / (sizeof(LhsScalar) * k * num_threads);
      const Index m_per_thread = numext::div_ceil(m, num_threads);
      if(m_cache < m_per_thread && m_cache >= static_cast<Index>(mr)) {
        m = m_cache - (m_cache % mr);
        eigen_internal_assert(m > 0);
      } else {
        m = (numext::mini<Index>)(m, (m_per_thread + mr - 1) - ((m_per_thread + mr - 1) % mr));
      }
    }
  }
  else {
    // In unit tests we do not want to use extra large matrices,
    // so we reduce the cache size to check the blocking strategy is not flawed
#ifdef EIGEN_DEBUG_SMALL_PRODUCT_BLOCKS
    l1 = 9*1024;
    l2 = 32*1024;
    l3 = 512*1024;
#endif

    // Early return for small problems because the computation below are time consuming for small problems.
    // Perhaps it would make more sense to consider k*n*m??
    // Note that for very tiny problem, this function should be bypassed anyway
    // because we use the coefficient-based implementation for them.
    if((numext::maxi)(k,(numext::maxi)(m,n))<48)
      return;

    typedef typename Traits::ResScalar ResScalar;
    enum {
      k_peeling = 8,
      k_div = KcFactor * (Traits::mr * sizeof(LhsScalar) + Traits::nr * sizeof(RhsScalar)),
      k_sub = Traits::mr * Traits::nr * sizeof(ResScalar)
    };

    // ---- 1st level of blocking on L1, yields kc ----

    // Blocking on the third dimension (i.e., k) is chosen so that an horizontal panel
    // of size mr x kc of the lhs plus a vertical panel of kc x nr of the rhs both fits within L1 cache.
    // We also include a register-level block of the result (mx x nr).
    // (In an ideal world only the lhs panel would stay in L1)
    // Moreover, kc has to be a multiple of 8 to be compatible with loop peeling, leading to a maximum blocking size of:
    const Index max_kc = numext::maxi<Index>(((l1-k_sub)/k_div) & (~(k_peeling-1)),1);
    const Index old_k = k;
    if(k>max_kc)
    {
      // We are really blocking on the third dimension:
      // -> reduce blocking size to make sure the last block is as large as possible
      //    while keeping the same number of sweeps over the result.
      k = (k%max_kc)==0 ? max_kc
                        : max_kc - k_peeling * ((max_kc-1-(k%max_kc))/(k_peeling*(k/max_kc+1)));

      eigen_internal_assert(((old_k/k) == (old_k/max_kc)) && "the number of sweeps has to remain the same");
    }

    // ---- 2nd level of blocking on max(L2,L3), yields nc ----

    // TODO find a reliable way to get the actual amount of cache per core to use for 2nd level blocking, that is:
    //      actual_l2 = max(l2, l3/nb_core_sharing_l3)
    // The number below is quite conservative: it is better to underestimate the cache size rather than overestimating it)
    // For instance, it corresponds to 6MB of L3 shared among 4 cores.
    #ifdef EIGEN_DEBUG_SMALL_PRODUCT_BLOCKS
    const Index actual_l2 = l3;
    #else
    const Index actual_l2 = 1572864; // == 1.5 MB
    #endif

    // Here, nc is chosen such that a block of kc x nc of the rhs fit within half of L2.
    // The second half is implicitly reserved to access the result and lhs coefficients.
    // When k<max_kc, then nc can arbitrarily growth. In practice, it seems to be fruitful
    // to limit this growth: we bound nc to growth by a factor x1.5.
    // However, if the entire lhs block fit within L1, then we are not going to block on the rows at all,
    // and it becomes fruitful to keep the packed rhs blocks in L1 if there is enough remaining space.
    Index max_nc;
    const Index lhs_bytes = m * k * sizeof(LhsScalar);
    const Index remaining_l1 = l1- k_sub - lhs_bytes;
    if(remaining_l1 >= Index(Traits::nr*sizeof(RhsScalar))*k)
    {
      // L1 blocking
      max_nc = remaining_l1 / (k*sizeof(RhsScalar));
    }
    else
    {
      // L2 blocking
      max_nc = (3*actual_l2)/(2*2*max_kc*sizeof(RhsScalar));
    }
    // WARNING Below, we assume that Traits::nr is a power of two.
    Index nc = numext::mini<Index>(actual_l2/(2*k*sizeof(RhsScalar)), max_nc) & (~(Traits::nr-1));
    if(n>nc)
    {
      // We are really blocking over the columns:
      // -> reduce blocking size to make sure the last block is as large as possible
      //    while keeping the same number of sweeps over the packed lhs.
      //    Here we allow one more sweep if this gives us a perfect match, thus the commented "-1"
      n = (n%nc)==0 ? nc
                    : (nc - Traits::nr * ((nc/*-1*/-(n%nc))/(Traits::nr*(n/nc+1))));
    }
    else if(old_k==k)
    {
      // So far, no blocking at all, i.e., kc==k, and nc==n.
      // In this case, let's perform a blocking over the rows such that the packed lhs data is kept in cache L1/L2
      // TODO: part of this blocking strategy is now implemented within the kernel itself, so the L1-based heuristic here should be obsolete.
      Index problem_size = k*n*sizeof(LhsScalar);
      Index actual_lm = actual_l2;
      Index max_mc = m;
      if(problem_size<=1024)
      {
        // problem is small enough to keep in L1
        // Let's choose m such that lhs's block fit in 1/3 of L1
        actual_lm = l1;
      }
      else if(l3!=0 && problem_size<=32768)
      {
        // we have both L2 and L3, and problem is small enough to be kept in L2
        // Let's choose m such that lhs's block fit in 1/3 of L2
        actual_lm = l2;
        max_mc = (numext::mini<Index>)(576,max_mc);
      }
      Index mc = (numext::mini<Index>)(actual_lm/(3*k*sizeof(LhsScalar)), max_mc);
      if (mc > Traits::mr) mc -= mc % Traits::mr;
      else if (mc==0) return;
      m = (m%mc)==0 ? mc
                    : (mc - Traits::mr * ((mc/*-1*/-(m%mc))/(Traits::mr*(m/mc+1))));
    }
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r12
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movb 0x1d4e3(%rip), %al      # 0x2f298
testb %al, %al
je 0x12090
movq 0x1d4bc(%rip), %rdi     # 0x2f280
movq 0x1d4bd(%rip), %r11     # 0x2f288
movq 0x1d4be(%rip), %rcx     # 0x2f290
movq (%r15), %rsi
cmpq $0x2, %r12
jl 0x11e6a
leaq -0x40(%rdi), %rax
movabsq $0x6666666666666667, %rdx # imm = 0x6666666666666667
imulq %rdx
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0x5, %rdx
addq %rax, %rdx
movl $0x140, %eax            # imm = 0x140
cmpq %rax, %rdx
cmovgeq %rax, %rdx
cmpq %rsi, %rdx
jge 0x11e21
leaq 0x7(%rdx), %rsi
testq %rdx, %rdx
cmovnsq %rdx, %rsi
andq $-0x8, %rsi
movq %rsi, (%r15)
movq %r11, %rax
subq %rdi, %rax
shlq $0x6, %rsi
xorl %edx, %edx
divq %rsi
movq %rax, %rsi
movq (%r14), %rdi
leaq (%r12,%rdi), %rax
decq %rax
cqto
idivq %r12
cmpq %rax, %rsi
jle 0x11f1f
leaq 0x3(%rax), %rdx
addq $0x6, %rax
testq %rdx, %rdx
cmovnsq %rdx, %rax
andq $-0x4, %rax
cmpq %rdi, %rax
cmovgeq %rdi, %rax
jmp 0x11f2e
movq (%rbx), %r8
movq (%r14), %rax
cmpq %rax, %r8
cmovgq %r8, %rax
cmpq %rax, %rsi
cmovgq %rsi, %rax
cmpq $0x30, %rax
jl 0x12084
leaq -0x40(%rdi), %r9
movabsq $0x6666666666666667, %rdx # imm = 0x6666666666666667
movq %r9, %rax
imulq %rdx
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0x5, %rdx
addq %rax, %rdx
andq $-0x8, %rdx
cmpq $0x2, %rdx
movl $0x1, %r10d
cmovgeq %rdx, %r10
movq %rsi, %r12
cmpq %r10, %rsi
jle 0x11efa
movq %rsi, %rax
xorl %edx, %edx
divq %r10
movq %r10, %r12
testq %rdx, %rdx
je 0x11ef4
notq %rdx
addq %r10, %rdx
leaq 0x8(,%rax,8), %r8
movq %rdx, %rax
cqto
idivq %r8
shlq $0x3, %rax
movq %r10, %r12
subq %rax, %r12
movq %r12, (%r15)
movq (%rbx), %r8
movq %r8, %rax
imulq %r12, %rax
shlq $0x4, %rax
subq %rax, %r9
movq %r12, %rax
shlq $0x6, %rax
cmpq %rax, %r9
jge 0x11f7d
shlq $0x6, %r10
movl $0x480000, %eax         # imm = 0x480000
jmp 0x11f87
leaq 0x3(%rsi), %rax
testq %rsi, %rsi
cmovnsq %rsi, %rax
andq $-0x4, %rax
movq %rax, (%r14)
subq %r11, %rcx
jle 0x12084
leaq -0x1(%r12), %rsi
movq (%r15), %rdi
imulq %r12, %rdi
shlq $0x4, %rdi
movq %rcx, %rax
xorl %edx, %edx
divq %rdi
movq %rax, %rcx
movq (%rbx), %rdi
addq %rdi, %rsi
movq %rsi, %rax
cqto
idivq %r12
cmpq %rax, %rcx
setge %dl
testq %rcx, %rcx
setle %sil
orb %dl, %sil
jne 0x11fe5
movq %rcx, (%rbx)
jmp 0x12084
movq %r12, %r10
shlq $0x4, %r10
movq %r9, %rax
xorl %edx, %edx
divq %r10
movq %rax, %r10
movq %r12, %r9
shlq $0x5, %r9
movl $0x180000, %eax         # imm = 0x180000
xorl %edx, %edx
divq %r9
movq %rax, %r9
cmpq %rax, %r10
cmovlq %r10, %r9
andq $-0x4, %r9
movq (%r14), %rax
cmpq %r9, %rax
jle 0x11ff4
cqto
idivq %r9
testq %rdx, %rdx
je 0x11fdd
movq %r9, %rcx
subq %rdx, %rcx
leaq 0x4(,%rax,4), %rsi
movq %rcx, %rax
cqto
idivq %rsi
shlq $0x2, %rax
subq %rax, %r9
movq %r9, (%r14)
jmp 0x12084
cmpq %rdi, %rax
cmovlq %rax, %rdi
movq %rdi, (%rbx)
jmp 0x12084
cmpq %r12, %rsi
jne 0x12084
imulq %rsi, %rax
shlq $0x4, %rax
movq %r8, %r9
cmpq $0x401, %rax            # imm = 0x401
jl 0x1203b
testq %rcx, %rcx
sete %cl
cmpq $0x8001, %rax           # imm = 0x8001
setae %al
movl $0x180000, %edi         # imm = 0x180000
orb %cl, %al
movq %r8, %r9
jne 0x1203b
movl $0x240, %r9d            # imm = 0x240
cmpq %r9, %r8
cmovlq %r8, %r9
movq %r11, %rdi
shlq $0x4, %rsi
leaq (%rsi,%rsi,2), %rcx
movq %rdi, %rax
xorl %edx, %edx
divq %rcx
movq %rax, %rcx
cmpq %rax, %r9
cmovlq %r9, %rcx
testq %rcx, %rcx
je 0x12084
movq %r8, %rax
cqto
idivq %rcx
testq %rdx, %rdx
je 0x11f75
movq %rax, %rsi
movq %rcx, %rax
subq %rdx, %rax
incq %rsi
cqto
idivq %rsi
subq %rax, %rcx
jmp 0x11f75
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x1d201(%rip), %rdi     # 0x2f298
callq 0x3470
testl %eax, %eax
je 0x11dbd
leaq 0x1d1d5(%rip), %rdi     # 0x2f280
callq 0x120d8
leaq 0x1d1e1(%rip), %rdi     # 0x2f298
callq 0x31a0
jmp 0x11dbd
movq %rax, %rbx
leaq 0x1d1cd(%rip), %rdi     # 0x2f298
callq 0x3190
movq %rbx, %rdi
callq 0x3450