|
kusano |
2b45e8 |
/*********************************************************************/
|
|
kusano |
2b45e8 |
/* Copyright 2009, 2010 The University of Texas at Austin. */
|
|
kusano |
2b45e8 |
/* All rights reserved. */
|
|
kusano |
2b45e8 |
/* */
|
|
kusano |
2b45e8 |
/* Redistribution and use in source and binary forms, with or */
|
|
kusano |
2b45e8 |
/* without modification, are permitted provided that the following */
|
|
kusano |
2b45e8 |
/* conditions are met: */
|
|
kusano |
2b45e8 |
/* */
|
|
kusano |
2b45e8 |
/* 1. Redistributions of source code must retain the above */
|
|
kusano |
2b45e8 |
/* copyright notice, this list of conditions and the following */
|
|
kusano |
2b45e8 |
/* disclaimer. */
|
|
kusano |
2b45e8 |
/* */
|
|
kusano |
2b45e8 |
/* 2. Redistributions in binary form must reproduce the above */
|
|
kusano |
2b45e8 |
/* copyright notice, this list of conditions and the following */
|
|
kusano |
2b45e8 |
/* disclaimer in the documentation and/or other materials */
|
|
kusano |
2b45e8 |
/* provided with the distribution. */
|
|
kusano |
2b45e8 |
/* */
|
|
kusano |
2b45e8 |
/* THIS SOFTWARE IS PROVIDED BY THE UNIVERSITY OF TEXAS AT */
|
|
kusano |
2b45e8 |
/* AUSTIN ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, */
|
|
kusano |
2b45e8 |
/* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF */
|
|
kusano |
2b45e8 |
/* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE */
|
|
kusano |
2b45e8 |
/* DISCLAIMED. IN NO EVENT SHALL THE UNIVERSITY OF TEXAS AT */
|
|
kusano |
2b45e8 |
/* AUSTIN OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, */
|
|
kusano |
2b45e8 |
/* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES */
|
|
kusano |
2b45e8 |
/* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE */
|
|
kusano |
2b45e8 |
/* GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR */
|
|
kusano |
2b45e8 |
/* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF */
|
|
kusano |
2b45e8 |
/* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT */
|
|
kusano |
2b45e8 |
/* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT */
|
|
kusano |
2b45e8 |
/* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE */
|
|
kusano |
2b45e8 |
/* POSSIBILITY OF SUCH DAMAGE. */
|
|
kusano |
2b45e8 |
/* */
|
|
kusano |
2b45e8 |
/* The views and conclusions contained in the software and */
|
|
kusano |
2b45e8 |
/* documentation are those of the authors and should not be */
|
|
kusano |
2b45e8 |
/* interpreted as representing official policies, either expressed */
|
|
kusano |
2b45e8 |
/* or implied, of The University of Texas at Austin. */
|
|
kusano |
2b45e8 |
/*********************************************************************/
|
|
kusano |
2b45e8 |
|
|
kusano |
2b45e8 |
#ifndef CACHE_LINE_SIZE
|
|
kusano |
2b45e8 |
#define CACHE_LINE_SIZE 8
|
|
kusano |
2b45e8 |
#endif
|
|
kusano |
2b45e8 |
|
|
kusano |
2b45e8 |
#ifndef DIVIDE_RATE
|
|
kusano |
2b45e8 |
#define DIVIDE_RATE 2
|
|
kusano |
2b45e8 |
#endif
|
|
kusano |
2b45e8 |
|
|
kusano |
2b45e8 |
#ifndef SWITCH_RATIO
|
|
kusano |
2b45e8 |
#define SWITCH_RATIO 2
|
|
kusano |
2b45e8 |
#endif
|
|
kusano |
2b45e8 |
|
|
kusano |
2b45e8 |
#ifndef SYRK_LOCAL
|
|
kusano |
2b45e8 |
#if !defined(LOWER) && !defined(TRANS)
|
|
kusano |
2b45e8 |
#define SYRK_LOCAL SYRK_UN
|
|
kusano |
2b45e8 |
#elif !defined(LOWER) && defined(TRANS)
|
|
kusano |
2b45e8 |
#define SYRK_LOCAL SYRK_UT
|
|
kusano |
2b45e8 |
#elif defined(LOWER) && !defined(TRANS)
|
|
kusano |
2b45e8 |
#define SYRK_LOCAL SYRK_LN
|
|
kusano |
2b45e8 |
#else
|
|
kusano |
2b45e8 |
#define SYRK_LOCAL SYRK_LT
|
|
kusano |
2b45e8 |
#endif
|
|
kusano |
2b45e8 |
#endif
|
|
kusano |
2b45e8 |
|
|
kusano |
2b45e8 |
typedef struct {
|
|
kusano |
2b45e8 |
volatile BLASLONG working[MAX_CPU_NUMBER][CACHE_LINE_SIZE * DIVIDE_RATE];
|
|
kusano |
2b45e8 |
} job_t;
|
|
kusano |
2b45e8 |
|
|
kusano |
2b45e8 |
|
|
kusano |
2b45e8 |
#ifndef KERNEL_OPERATION
|
|
kusano |
2b45e8 |
#ifndef COMPLEX
|
|
kusano |
2b45e8 |
#define KERNEL_OPERATION(M, N, K, ALPHA, SA, SB, C, LDC, X, Y) \
|
|
kusano |
2b45e8 |
KERNEL_FUNC(M, N, K, ALPHA[0], SA, SB, (FLOAT *)(C) + ((X) + (Y) * LDC) * COMPSIZE, LDC, (X) - (Y))
|
|
kusano |
2b45e8 |
#else
|
|
kusano |
2b45e8 |
#define KERNEL_OPERATION(M, N, K, ALPHA, SA, SB, C, LDC, X, Y) \
|
|
kusano |
2b45e8 |
KERNEL_FUNC(M, N, K, ALPHA[0], ALPHA[1], SA, SB, (FLOAT *)(C) + ((X) + (Y) * LDC) * COMPSIZE, LDC, (X) - (Y))
|
|
kusano |
2b45e8 |
#endif
|
|
kusano |
2b45e8 |
#endif
|
|
kusano |
2b45e8 |
|
|
kusano |
2b45e8 |
#ifndef ICOPY_OPERATION
|
|
kusano |
2b45e8 |
#ifndef TRANS
|
|
kusano |
2b45e8 |
#define ICOPY_OPERATION(M, N, A, LDA, X, Y, BUFFER) GEMM_ITCOPY(M, N, (FLOAT *)(A) + ((Y) + (X) * (LDA)) * COMPSIZE, LDA, BUFFER);
|
|
kusano |
2b45e8 |
#else
|
|
kusano |
2b45e8 |
#define ICOPY_OPERATION(M, N, A, LDA, X, Y, BUFFER) GEMM_INCOPY(M, N, (FLOAT *)(A) + ((X) + (Y) * (LDA)) * COMPSIZE, LDA, BUFFER);
|
|
kusano |
2b45e8 |
#endif
|
|
kusano |
2b45e8 |
#endif
|
|
kusano |
2b45e8 |
|
|
kusano |
2b45e8 |
#ifndef OCOPY_OPERATION
|
|
kusano |
2b45e8 |
#ifdef TRANS
|
|
kusano |
2b45e8 |
#define OCOPY_OPERATION(M, N, A, LDA, X, Y, BUFFER) GEMM_ONCOPY(M, N, (FLOAT *)(A) + ((X) + (Y) * (LDA)) * COMPSIZE, LDA, BUFFER);
|
|
kusano |
2b45e8 |
#else
|
|
kusano |
2b45e8 |
#define OCOPY_OPERATION(M, N, A, LDA, X, Y, BUFFER) GEMM_OTCOPY(M, N, (FLOAT *)(A) + ((Y) + (X) * (LDA)) * COMPSIZE, LDA, BUFFER);
|
|
kusano |
2b45e8 |
#endif
|
|
kusano |
2b45e8 |
#endif
|
|
kusano |
2b45e8 |
|
|
kusano |
2b45e8 |
#ifndef A
|
|
kusano |
2b45e8 |
#define A args -> a
|
|
kusano |
2b45e8 |
#endif
|
|
kusano |
2b45e8 |
#ifndef LDA
|
|
kusano |
2b45e8 |
#define LDA args -> lda
|
|
kusano |
2b45e8 |
#endif
|
|
kusano |
2b45e8 |
#ifndef C
|
|
kusano |
2b45e8 |
#define C args -> c
|
|
kusano |
2b45e8 |
#endif
|
|
kusano |
2b45e8 |
#ifndef LDC
|
|
kusano |
2b45e8 |
#define LDC args -> ldc
|
|
kusano |
2b45e8 |
#endif
|
|
kusano |
2b45e8 |
#ifndef M
|
|
kusano |
2b45e8 |
#define M args -> m
|
|
kusano |
2b45e8 |
#endif
|
|
kusano |
2b45e8 |
#ifndef N
|
|
kusano |
2b45e8 |
#define N args -> n
|
|
kusano |
2b45e8 |
#endif
|
|
kusano |
2b45e8 |
#ifndef K
|
|
kusano |
2b45e8 |
#define K args -> k
|
|
kusano |
2b45e8 |
#endif
|
|
kusano |
2b45e8 |
|
|
kusano |
2b45e8 |
#undef TIMING
|
|
kusano |
2b45e8 |
|
|
kusano |
2b45e8 |
#ifdef TIMING
|
|
kusano |
2b45e8 |
#define START_RPCC() rpcc_counter = rpcc()
|
|
kusano |
2b45e8 |
#define STOP_RPCC(COUNTER) COUNTER += rpcc() - rpcc_counter
|
|
kusano |
2b45e8 |
#else
|
|
kusano |
2b45e8 |
#define START_RPCC()
|
|
kusano |
2b45e8 |
#define STOP_RPCC(COUNTER)
|
|
kusano |
2b45e8 |
#endif
|
|
kusano |
2b45e8 |
|
|
kusano |
2b45e8 |
static int inner_thread(blas_arg_t *args, BLASLONG *range_m, BLASLONG *range_n, FLOAT *sa, FLOAT *sb, BLASLONG mypos){
|
|
kusano |
2b45e8 |
|
|
kusano |
2b45e8 |
FLOAT *buffer[DIVIDE_RATE];
|
|
kusano |
2b45e8 |
|
|
kusano |
2b45e8 |
BLASLONG k, lda, ldc;
|
|
kusano |
2b45e8 |
BLASLONG m_from, m_to, n_from, n_to;
|
|
kusano |
2b45e8 |
|
|
kusano |
2b45e8 |
FLOAT *alpha, *beta;
|
|
kusano |
2b45e8 |
FLOAT *a, *c;
|
|
kusano |
2b45e8 |
job_t *job = (job_t *)args -> common;
|
|
kusano |
2b45e8 |
BLASLONG xxx, bufferside;
|
|
kusano |
2b45e8 |
|
|
kusano |
2b45e8 |
BLASLONG ls, min_l, jjs, min_jj;
|
|
kusano |
2b45e8 |
BLASLONG is, min_i, div_n;
|
|
kusano |
2b45e8 |
|
|
kusano |
2b45e8 |
BLASLONG i, current;
|
|
kusano |
2b45e8 |
#ifdef LOWER
|
|
kusano |
2b45e8 |
BLASLONG start_i;
|
|
kusano |
2b45e8 |
#endif
|
|
kusano |
2b45e8 |
|
|
kusano |
2b45e8 |
#ifdef TIMING
|
|
kusano |
2b45e8 |
BLASLONG rpcc_counter;
|
|
kusano |
2b45e8 |
BLASLONG copy_A = 0;
|
|
kusano |
2b45e8 |
BLASLONG copy_B = 0;
|
|
kusano |
2b45e8 |
BLASLONG kernel = 0;
|
|
kusano |
2b45e8 |
BLASLONG waiting1 = 0;
|
|
kusano |
2b45e8 |
BLASLONG waiting2 = 0;
|
|
kusano |
2b45e8 |
BLASLONG waiting3 = 0;
|
|
kusano |
2b45e8 |
BLASLONG waiting6[MAX_CPU_NUMBER];
|
|
kusano |
2b45e8 |
BLASLONG ops = 0;
|
|
kusano |
2b45e8 |
|
|
kusano |
2b45e8 |
for (i = 0; i < args -> nthreads; i++) waiting6[i] = 0;
|
|
kusano |
2b45e8 |
#endif
|
|
kusano |
2b45e8 |
|
|
kusano |
2b45e8 |
k = K;
|
|
kusano |
2b45e8 |
|
|
kusano |
2b45e8 |
a = (FLOAT *)A;
|
|
kusano |
2b45e8 |
c = (FLOAT *)C;
|
|
kusano |
2b45e8 |
|
|
kusano |
2b45e8 |
lda = LDA;
|
|
kusano |
2b45e8 |
ldc = LDC;
|
|
kusano |
2b45e8 |
|
|
kusano |
2b45e8 |
alpha = (FLOAT *)args -> alpha;
|
|
kusano |
2b45e8 |
beta = (FLOAT *)args -> beta;
|
|
kusano |
2b45e8 |
|
|
kusano |
2b45e8 |
m_from = 0;
|
|
kusano |
2b45e8 |
m_to = N;
|
|
kusano |
2b45e8 |
|
|
kusano |
2b45e8 |
/* Global Range */
|
|
kusano |
2b45e8 |
n_from = 0;
|
|
kusano |
2b45e8 |
n_to = N;
|
|
kusano |
2b45e8 |
|
|
kusano |
2b45e8 |
if (range_n) {
|
|
kusano |
2b45e8 |
m_from = range_n[mypos + 0];
|
|
kusano |
2b45e8 |
m_to = range_n[mypos + 1];
|
|
kusano |
2b45e8 |
|
|
kusano |
2b45e8 |
n_from = range_n[0];
|
|
kusano |
2b45e8 |
n_to = range_n[args -> nthreads];
|
|
kusano |
2b45e8 |
}
|
|
kusano |
2b45e8 |
|
|
kusano |
2b45e8 |
if (beta) {
|
|
kusano |
2b45e8 |
#if !defined(COMPLEX) || defined(HERK)
|
|
kusano |
2b45e8 |
if (beta[0] != ONE)
|
|
kusano |
2b45e8 |
#else
|
|
kusano |
2b45e8 |
if ((beta[0] != ONE) || (beta[1] != ZERO))
|
|
kusano |
2b45e8 |
#endif
|
|
kusano |
2b45e8 |
syrk_beta(m_from, m_to, n_from, n_to, beta, c, ldc);
|
|
kusano |
2b45e8 |
}
|
|
kusano |
2b45e8 |
|
|
kusano |
2b45e8 |
if ((k == 0) || (alpha == NULL)) return 0;
|
|
kusano |
2b45e8 |
|
|
kusano |
2b45e8 |
if ((alpha[0] == ZERO)
|
|
kusano |
2b45e8 |
#if defined(COMPLEX) && !defined(HERK)
|
|
kusano |
2b45e8 |
&& (alpha[1] == ZERO)
|
|
kusano |
2b45e8 |
#endif
|
|
kusano |
2b45e8 |
) return 0;
|
|
kusano |
2b45e8 |
|
|
kusano |
2b45e8 |
#if 0
|
|
kusano |
2b45e8 |
fprintf(stderr, "Thread[%ld] m_from : %ld m_to : %ld n_from : %ld n_to : %ld\n", mypos, m_from, m_to, n_from, n_to);
|
|
kusano |
2b45e8 |
#endif
|
|
kusano |
2b45e8 |
|
|
kusano |
2b45e8 |
div_n = ((m_to - m_from + DIVIDE_RATE - 1) / DIVIDE_RATE
|
|
kusano |
2b45e8 |
+ GEMM_UNROLL_MN - 1) & ~(GEMM_UNROLL_MN - 1);
|
|
kusano |
2b45e8 |
|
|
kusano |
2b45e8 |
buffer[0] = sb;
|
|
kusano |
2b45e8 |
for (i = 1; i < DIVIDE_RATE; i++) {
|
|
kusano |
2b45e8 |
buffer[i] = buffer[i - 1] + GEMM_Q * div_n * COMPSIZE;
|
|
kusano |
2b45e8 |
}
|
|
kusano |
2b45e8 |
|
|
kusano |
2b45e8 |
for(ls = 0; ls < k; ls += min_l){
|
|
kusano |
2b45e8 |
|
|
kusano |
2b45e8 |
min_l = k - ls;
|
|
kusano |
2b45e8 |
if (min_l >= GEMM_Q * 2) {
|
|
kusano |
2b45e8 |
min_l = GEMM_Q;
|
|
kusano |
2b45e8 |
} else {
|
|
kusano |
2b45e8 |
if (min_l > GEMM_Q) min_l = (min_l + 1) / 2;
|
|
kusano |
2b45e8 |
}
|
|
kusano |
2b45e8 |
|
|
kusano |
2b45e8 |
min_i = m_to - m_from;
|
|
kusano |
2b45e8 |
|
|
kusano |
2b45e8 |
if (min_i >= GEMM_P * 2) {
|
|
kusano |
2b45e8 |
min_i = GEMM_P;
|
|
kusano |
2b45e8 |
} else {
|
|
kusano |
2b45e8 |
if (min_i > GEMM_P) {
|
|
kusano |
2b45e8 |
min_i = (min_i / 2 + GEMM_UNROLL_MN - 1) & ~(GEMM_UNROLL_MN - 1);
|
|
kusano |
2b45e8 |
}
|
|
kusano |
2b45e8 |
}
|
|
kusano |
2b45e8 |
|
|
kusano |
2b45e8 |
#ifdef LOWER
|
|
kusano |
2b45e8 |
xxx = (m_to - m_from - min_i) % GEMM_P;
|
|
kusano |
2b45e8 |
|
|
kusano |
2b45e8 |
if (xxx) min_i -= GEMM_P - xxx;
|
|
kusano |
2b45e8 |
#endif
|
|
kusano |
2b45e8 |
|
|
kusano |
2b45e8 |
START_RPCC();
|
|
kusano |
2b45e8 |
|
|
kusano |
2b45e8 |
#ifndef LOWER
|
|
kusano |
2b45e8 |
ICOPY_OPERATION(min_l, min_i, a, lda, ls, m_from, sa);
|
|
kusano |
2b45e8 |
#else
|
|
kusano |
2b45e8 |
ICOPY_OPERATION(min_l, min_i, a, lda, ls, m_to - min_i, sa);
|
|
kusano |
2b45e8 |
#endif
|
|
kusano |
2b45e8 |
|
|
kusano |
2b45e8 |
STOP_RPCC(copy_A);
|
|
kusano |
2b45e8 |
|
|
kusano |
2b45e8 |
div_n = ((m_to - m_from + DIVIDE_RATE - 1) / DIVIDE_RATE
|
|
kusano |
2b45e8 |
+ GEMM_UNROLL_MN - 1) & ~(GEMM_UNROLL_MN - 1);
|
|
kusano |
2b45e8 |
|
|
kusano |
2b45e8 |
for (xxx = m_from, bufferside = 0; xxx < m_to; xxx += div_n, bufferside ++) {
|
|
kusano |
2b45e8 |
|
|
kusano |
2b45e8 |
START_RPCC();
|
|
kusano |
2b45e8 |
|
|
kusano |
2b45e8 |
/* Make sure if no one is using buffer */
|
|
kusano |
2b45e8 |
#ifndef LOWER
|
|
kusano |
2b45e8 |
for (i = 0; i < mypos; i++)
|
|
kusano |
2b45e8 |
#else
|
|
kusano |
2b45e8 |
for (i = mypos + 1; i < args -> nthreads; i++)
|
|
kusano |
2b45e8 |
#endif
|
|
kusano |
2b45e8 |
while (job[mypos].working[i][CACHE_LINE_SIZE * bufferside]) {YIELDING;};
|
|
kusano |
2b45e8 |
|
|
kusano |
2b45e8 |
STOP_RPCC(waiting1);
|
|
kusano |
2b45e8 |
|
|
kusano |
2b45e8 |
#ifndef LOWER
|
|
kusano |
2b45e8 |
|
|
kusano |
2b45e8 |
for(jjs = xxx; jjs < MIN(m_to, xxx + div_n); jjs += min_jj){
|
|
kusano |
2b45e8 |
|
|
kusano |
2b45e8 |
min_jj = MIN(m_to, xxx + div_n) - jjs;
|
|
kusano |
2b45e8 |
|
|
kusano |
2b45e8 |
if (xxx == m_from) {
|
|
kusano |
2b45e8 |
if (min_jj > min_i) min_jj = min_i;
|
|
kusano |
2b45e8 |
} else {
|
|
kusano |
2b45e8 |
if (min_jj > GEMM_UNROLL_MN) min_jj = GEMM_UNROLL_MN;
|
|
kusano |
2b45e8 |
}
|
|
kusano |
2b45e8 |
|
|
kusano |
2b45e8 |
START_RPCC();
|
|
kusano |
2b45e8 |
|
|
kusano |
2b45e8 |
OCOPY_OPERATION(min_l, min_jj, a, lda, ls, jjs,
|
|
kusano |
2b45e8 |
buffer[bufferside] + min_l * (jjs - xxx) * COMPSIZE);
|
|
kusano |
2b45e8 |
|
|
kusano |
2b45e8 |
STOP_RPCC(copy_B);
|
|
kusano |
2b45e8 |
|
|
kusano |
2b45e8 |
START_RPCC();
|
|
kusano |
2b45e8 |
|
|
kusano |
2b45e8 |
KERNEL_OPERATION(min_i, min_jj, min_l, alpha,
|
|
kusano |
2b45e8 |
sa, buffer[bufferside] + min_l * (jjs - xxx) * COMPSIZE,
|
|
kusano |
2b45e8 |
c, ldc, m_from, jjs);
|
|
kusano |
2b45e8 |
|
|
kusano |
2b45e8 |
STOP_RPCC(kernel);
|
|
kusano |
2b45e8 |
|
|
kusano |
2b45e8 |
#ifdef TIMING
|
|
kusano |
2b45e8 |
ops += 2 * min_i * min_jj * min_l;
|
|
kusano |
2b45e8 |
#endif
|
|
kusano |
2b45e8 |
|
|
kusano |
2b45e8 |
}
|
|
kusano |
2b45e8 |
|
|
kusano |
2b45e8 |
#else
|
|
kusano |
2b45e8 |
|
|
kusano |
2b45e8 |
for(jjs = xxx; jjs < MIN(m_to, xxx + div_n); jjs += min_jj){
|
|
kusano |
2b45e8 |
|
|
kusano |
2b45e8 |
min_jj = MIN(m_to, xxx + div_n) - jjs;
|
|
kusano |
2b45e8 |
|
|
kusano |
2b45e8 |
if (min_jj > GEMM_UNROLL_MN) min_jj = GEMM_UNROLL_MN;
|
|
kusano |
2b45e8 |
|
|
kusano |
2b45e8 |
START_RPCC();
|
|
kusano |
2b45e8 |
|
|
kusano |
2b45e8 |
OCOPY_OPERATION(min_l, min_jj, a, lda, ls, jjs,
|
|
kusano |
2b45e8 |
buffer[bufferside] + min_l * (jjs - xxx) * COMPSIZE);
|
|
kusano |
2b45e8 |
|
|
kusano |
2b45e8 |
STOP_RPCC(copy_B);
|
|
kusano |
2b45e8 |
|
|
kusano |
2b45e8 |
START_RPCC();
|
|
kusano |
2b45e8 |
|
|
kusano |
2b45e8 |
KERNEL_OPERATION(min_i, min_jj, min_l, alpha,
|
|
kusano |
2b45e8 |
sa, buffer[bufferside] + min_l * (jjs - xxx) * COMPSIZE,
|
|
kusano |
2b45e8 |
c, ldc, m_to - min_i, jjs);
|
|
kusano |
2b45e8 |
|
|
kusano |
2b45e8 |
STOP_RPCC(kernel);
|
|
kusano |
2b45e8 |
|
|
kusano |
2b45e8 |
#ifdef TIMING
|
|
kusano |
2b45e8 |
ops += 2 * min_i * min_jj * min_l;
|
|
kusano |
2b45e8 |
#endif
|
|
kusano |
2b45e8 |
|
|
kusano |
2b45e8 |
}
|
|
kusano |
2b45e8 |
|
|
kusano |
2b45e8 |
#endif
|
|
kusano |
2b45e8 |
|
|
kusano |
2b45e8 |
#ifndef LOWER
|
|
kusano |
2b45e8 |
for (i = 0; i <= mypos; i++)
|
|
kusano |
2b45e8 |
#else
|
|
kusano |
2b45e8 |
for (i = mypos; i < args -> nthreads; i++)
|
|
kusano |
2b45e8 |
#endif
|
|
kusano |
2b45e8 |
job[mypos].working[i][CACHE_LINE_SIZE * bufferside] = (BLASLONG)buffer[bufferside];
|
|
kusano |
2b45e8 |
|
|
kusano |
2b45e8 |
WMB;
|
|
kusano |
2b45e8 |
}
|
|
kusano |
2b45e8 |
|
|
kusano |
2b45e8 |
|
|
kusano |
2b45e8 |
#ifndef LOWER
|
|
kusano |
2b45e8 |
current = mypos + 1;
|
|
kusano |
2b45e8 |
while (current < args -> nthreads) {
|
|
kusano |
2b45e8 |
#else
|
|
kusano |
2b45e8 |
current = mypos - 1;
|
|
kusano |
2b45e8 |
while (current >= 0) {
|
|
kusano |
2b45e8 |
#endif
|
|
kusano |
2b45e8 |
|
|
kusano |
2b45e8 |
div_n = ((range_n[current + 1] - range_n[current] + DIVIDE_RATE - 1) / DIVIDE_RATE
|
|
kusano |
2b45e8 |
+ GEMM_UNROLL_MN - 1) & ~(GEMM_UNROLL_MN - 1);
|
|
kusano |
2b45e8 |
|
|
kusano |
2b45e8 |
for (xxx = range_n[current], bufferside = 0; xxx < range_n[current + 1]; xxx += div_n, bufferside ++) {
|
|
kusano |
2b45e8 |
|
|
kusano |
2b45e8 |
START_RPCC();
|
|
kusano |
2b45e8 |
|
|
kusano |
2b45e8 |
/* thread has to wait */
|
|
kusano |
2b45e8 |
while(job[current].working[mypos][CACHE_LINE_SIZE * bufferside] == 0) {YIELDING;};
|
|
kusano |
2b45e8 |
|
|
kusano |
2b45e8 |
STOP_RPCC(waiting2);
|
|
kusano |
2b45e8 |
|
|
kusano |
2b45e8 |
START_RPCC();
|
|
kusano |
2b45e8 |
|
|
kusano |
2b45e8 |
#ifndef LOWER
|
|
kusano |
2b45e8 |
KERNEL_OPERATION(min_i, MIN(range_n[current + 1] - xxx, div_n), min_l, alpha,
|
|
kusano |
2b45e8 |
sa, (FLOAT *)job[current].working[mypos][CACHE_LINE_SIZE * bufferside],
|
|
kusano |
2b45e8 |
c, ldc,
|
|
kusano |
2b45e8 |
m_from,
|
|
kusano |
2b45e8 |
xxx);
|
|
kusano |
2b45e8 |
#else
|
|
kusano |
2b45e8 |
KERNEL_OPERATION(min_i, MIN(range_n[current + 1] - xxx, div_n), min_l, alpha,
|
|
kusano |
2b45e8 |
sa, (FLOAT *)job[current].working[mypos][CACHE_LINE_SIZE * bufferside],
|
|
kusano |
2b45e8 |
c, ldc,
|
|
kusano |
2b45e8 |
m_to - min_i,
|
|
kusano |
2b45e8 |
xxx);
|
|
kusano |
2b45e8 |
#endif
|
|
kusano |
2b45e8 |
|
|
kusano |
2b45e8 |
STOP_RPCC(kernel);
|
|
kusano |
2b45e8 |
#ifdef TIMING
|
|
kusano |
2b45e8 |
ops += 2 * min_i * MIN(range_n[current + 1] - xxx, div_n) * min_l;
|
|
kusano |
2b45e8 |
#endif
|
|
kusano |
2b45e8 |
|
|
kusano |
2b45e8 |
if (m_to - m_from == min_i) {
|
|
kusano |
2b45e8 |
job[current].working[mypos][CACHE_LINE_SIZE * bufferside] &= 0;
|
|
kusano |
2b45e8 |
}
|
|
kusano |
2b45e8 |
}
|
|
kusano |
2b45e8 |
|
|
kusano |
2b45e8 |
#ifndef LOWER
|
|
kusano |
2b45e8 |
current ++;
|
|
kusano |
2b45e8 |
#else
|
|
kusano |
2b45e8 |
current --;
|
|
kusano |
2b45e8 |
#endif
|
|
kusano |
2b45e8 |
}
|
|
kusano |
2b45e8 |
|
|
kusano |
2b45e8 |
#ifndef LOWER
|
|
kusano |
2b45e8 |
for(is = m_from + min_i; is < m_to; is += min_i){
|
|
kusano |
2b45e8 |
min_i = m_to - is;
|
|
kusano |
2b45e8 |
#else
|
|
kusano |
2b45e8 |
start_i = min_i;
|
|
kusano |
2b45e8 |
|
|
kusano |
2b45e8 |
for(is = m_from; is < m_to - start_i; is += min_i){
|
|
kusano |
2b45e8 |
min_i = m_to - start_i - is;
|
|
kusano |
2b45e8 |
#endif
|
|
kusano |
2b45e8 |
|
|
kusano |
2b45e8 |
if (min_i >= GEMM_P * 2) {
|
|
kusano |
2b45e8 |
min_i = GEMM_P;
|
|
kusano |
2b45e8 |
} else
|
|
kusano |
2b45e8 |
if (min_i > GEMM_P) {
|
|
kusano |
2b45e8 |
min_i = ((min_i + 1) / 2 + GEMM_UNROLL_MN - 1) & ~(GEMM_UNROLL_MN - 1);
|
|
kusano |
2b45e8 |
}
|
|
kusano |
2b45e8 |
|
|
kusano |
2b45e8 |
START_RPCC();
|
|
kusano |
2b45e8 |
|
|
kusano |
2b45e8 |
ICOPY_OPERATION(min_l, min_i, a, lda, ls, is, sa);
|
|
kusano |
2b45e8 |
|
|
kusano |
2b45e8 |
STOP_RPCC(copy_A);
|
|
kusano |
2b45e8 |
|
|
kusano |
2b45e8 |
current = mypos;
|
|
kusano |
2b45e8 |
|
|
kusano |
2b45e8 |
do {
|
|
kusano |
2b45e8 |
|
|
kusano |
2b45e8 |
div_n = ((range_n[current + 1] - range_n[current] + DIVIDE_RATE - 1) / DIVIDE_RATE
|
|
kusano |
2b45e8 |
+ GEMM_UNROLL_MN - 1) & ~(GEMM_UNROLL_MN - 1);
|
|
kusano |
2b45e8 |
|
|
kusano |
2b45e8 |
for (xxx = range_n[current], bufferside = 0; xxx < range_n[current + 1]; xxx += div_n, bufferside ++) {
|
|
kusano |
2b45e8 |
|
|
kusano |
2b45e8 |
START_RPCC();
|
|
kusano |
2b45e8 |
|
|
kusano |
2b45e8 |
KERNEL_OPERATION(min_i, MIN(range_n[current + 1] - xxx, div_n), min_l, alpha,
|
|
kusano |
2b45e8 |
sa, (FLOAT *)job[current].working[mypos][CACHE_LINE_SIZE * bufferside],
|
|
kusano |
2b45e8 |
c, ldc, is, xxx);
|
|
kusano |
2b45e8 |
|
|
kusano |
2b45e8 |
STOP_RPCC(kernel);
|
|
kusano |
2b45e8 |
|
|
kusano |
2b45e8 |
#ifdef TIMING
|
|
kusano |
2b45e8 |
ops += 2 * min_i * MIN(range_n[current + 1] - xxx, div_n) * min_l;
|
|
kusano |
2b45e8 |
#endif
|
|
kusano |
2b45e8 |
|
|
kusano |
2b45e8 |
#ifndef LOWER
|
|
kusano |
2b45e8 |
if (is + min_i >= m_to) {
|
|
kusano |
2b45e8 |
#else
|
|
kusano |
2b45e8 |
if (is + min_i >= m_to - start_i) {
|
|
kusano |
2b45e8 |
#endif
|
|
kusano |
2b45e8 |
/* Thread doesn't need this buffer any more */
|
|
kusano |
2b45e8 |
job[current].working[mypos][CACHE_LINE_SIZE * bufferside] &= 0;
|
|
kusano |
2b45e8 |
WMB;
|
|
kusano |
2b45e8 |
}
|
|
kusano |
2b45e8 |
}
|
|
kusano |
2b45e8 |
|
|
kusano |
2b45e8 |
#ifndef LOWER
|
|
kusano |
2b45e8 |
current ++;
|
|
kusano |
2b45e8 |
} while (current != args -> nthreads);
|
|
kusano |
2b45e8 |
#else
|
|
kusano |
2b45e8 |
current --;
|
|
kusano |
2b45e8 |
} while (current >= 0);
|
|
kusano |
2b45e8 |
#endif
|
|
kusano |
2b45e8 |
|
|
kusano |
2b45e8 |
|
|
kusano |
2b45e8 |
}
|
|
kusano |
2b45e8 |
}
|
|
kusano |
2b45e8 |
|
|
kusano |
2b45e8 |
START_RPCC();
|
|
kusano |
2b45e8 |
|
|
kusano |
2b45e8 |
for (i = 0; i < args -> nthreads; i++) {
|
|
kusano |
2b45e8 |
if (i != mypos) {
|
|
kusano |
2b45e8 |
for (xxx = 0; xxx < DIVIDE_RATE; xxx++) {
|
|
kusano |
2b45e8 |
while (job[mypos].working[i][CACHE_LINE_SIZE * xxx] ) {YIELDING;};
|
|
kusano |
2b45e8 |
}
|
|
kusano |
2b45e8 |
}
|
|
kusano |
2b45e8 |
}
|
|
kusano |
2b45e8 |
|
|
kusano |
2b45e8 |
STOP_RPCC(waiting3);
|
|
kusano |
2b45e8 |
|
|
kusano |
2b45e8 |
#ifdef TIMING
|
|
kusano |
2b45e8 |
BLASLONG waiting = waiting1 + waiting2 + waiting3;
|
|
kusano |
2b45e8 |
BLASLONG total = copy_A + copy_B + kernel + waiting;
|
|
kusano |
2b45e8 |
|
|
kusano |
2b45e8 |
fprintf(stderr, "GEMM [%2ld] Copy_A : %6.2f Copy_B : %6.2f Wait1 : %6.2f Wait2 : %6.2f Wait3 : %6.2f Kernel : %6.2f",
|
|
kusano |
2b45e8 |
mypos, (double)copy_A /(double)total * 100., (double)copy_B /(double)total * 100.,
|
|
kusano |
2b45e8 |
(double)waiting1 /(double)total * 100.,
|
|
kusano |
2b45e8 |
(double)waiting2 /(double)total * 100.,
|
|
kusano |
2b45e8 |
(double)waiting3 /(double)total * 100.,
|
|
kusano |
2b45e8 |
(double)ops/(double)kernel / 4. * 100.);
|
|
kusano |
2b45e8 |
|
|
kusano |
2b45e8 |
#if 0
|
|
kusano |
2b45e8 |
fprintf(stderr, "GEMM [%2ld] Copy_A : %6.2ld Copy_B : %6.2ld Wait : %6.2ld\n",
|
|
kusano |
2b45e8 |
mypos, copy_A, copy_B, waiting);
|
|
kusano |
2b45e8 |
|
|
kusano |
2b45e8 |
fprintf(stderr, "Waiting[%2ld] %6.2f %6.2f %6.2f\n",
|
|
kusano |
2b45e8 |
mypos,
|
|
kusano |
2b45e8 |
(double)waiting1/(double)waiting * 100.,
|
|
kusano |
2b45e8 |
(double)waiting2/(double)waiting * 100.,
|
|
kusano |
2b45e8 |
(double)waiting3/(double)waiting * 100.);
|
|
kusano |
2b45e8 |
#endif
|
|
kusano |
2b45e8 |
fprintf(stderr, "\n");
|
|
kusano |
2b45e8 |
#endif
|
|
kusano |
2b45e8 |
|
|
kusano |
2b45e8 |
return 0;
|
|
kusano |
2b45e8 |
}
|
|
kusano |
2b45e8 |
|
|
kusano |
2b45e8 |
int CNAME(blas_arg_t *args, BLASLONG *range_m, BLASLONG *range_n, FLOAT *sa, FLOAT *sb, BLASLONG mypos){
|
|
kusano |
2b45e8 |
|
|
kusano |
2b45e8 |
blas_arg_t newarg;
|
|
kusano |
2b45e8 |
|
|
kusano |
2b45e8 |
job_t job[MAX_CPU_NUMBER];
|
|
kusano |
2b45e8 |
blas_queue_t queue[MAX_CPU_NUMBER];
|
|
kusano |
2b45e8 |
|
|
kusano |
2b45e8 |
BLASLONG range[MAX_CPU_NUMBER + 100];
|
|
kusano |
2b45e8 |
|
|
kusano |
2b45e8 |
BLASLONG num_cpu;
|
|
kusano |
2b45e8 |
|
|
kusano |
2b45e8 |
BLASLONG nthreads = args -> nthreads;
|
|
kusano |
2b45e8 |
|
|
kusano |
2b45e8 |
BLASLONG width, i, j, k;
|
|
kusano |
2b45e8 |
BLASLONG n, n_from, n_to;
|
|
kusano |
2b45e8 |
int mode, mask;
|
|
kusano |
2b45e8 |
double dnum;
|
|
kusano |
2b45e8 |
|
|
kusano |
2b45e8 |
if ((nthreads == 1) || (args -> n < nthreads * SWITCH_RATIO)) {
|
|
kusano |
2b45e8 |
SYRK_LOCAL(args, range_m, range_n, sa, sb, 0);
|
|
kusano |
2b45e8 |
return 0;
|
|
kusano |
2b45e8 |
}
|
|
kusano |
2b45e8 |
|
|
kusano |
2b45e8 |
#ifndef COMPLEX
|
|
kusano |
2b45e8 |
#ifdef XDOUBLE
|
|
kusano |
2b45e8 |
mode = BLAS_XDOUBLE | BLAS_REAL;
|
|
kusano |
2b45e8 |
mask = MAX(QGEMM_UNROLL_M, QGEMM_UNROLL_N) - 1;
|
|
kusano |
2b45e8 |
#elif defined(DOUBLE)
|
|
kusano |
2b45e8 |
mode = BLAS_DOUBLE | BLAS_REAL;
|
|
kusano |
2b45e8 |
mask = MAX(DGEMM_UNROLL_M, DGEMM_UNROLL_N) - 1;
|
|
kusano |
2b45e8 |
#else
|
|
kusano |
2b45e8 |
mode = BLAS_SINGLE | BLAS_REAL;
|
|
kusano |
2b45e8 |
mask = MAX(SGEMM_UNROLL_M, SGEMM_UNROLL_N) - 1;
|
|
kusano |
2b45e8 |
#endif
|
|
kusano |
2b45e8 |
#else
|
|
kusano |
2b45e8 |
#ifdef XDOUBLE
|
|
kusano |
2b45e8 |
mode = BLAS_XDOUBLE | BLAS_COMPLEX;
|
|
kusano |
2b45e8 |
mask = MAX(XGEMM_UNROLL_M, XGEMM_UNROLL_N) - 1;
|
|
kusano |
2b45e8 |
#elif defined(DOUBLE)
|
|
kusano |
2b45e8 |
mode = BLAS_DOUBLE | BLAS_COMPLEX;
|
|
kusano |
2b45e8 |
mask = MAX(ZGEMM_UNROLL_M, ZGEMM_UNROLL_N) - 1;
|
|
kusano |
2b45e8 |
#else
|
|
kusano |
2b45e8 |
mode = BLAS_SINGLE | BLAS_COMPLEX;
|
|
kusano |
2b45e8 |
mask = MAX(CGEMM_UNROLL_M, CGEMM_UNROLL_N) - 1;
|
|
kusano |
2b45e8 |
#endif
|
|
kusano |
2b45e8 |
#endif
|
|
kusano |
2b45e8 |
|
|
kusano |
2b45e8 |
newarg.m = args -> m;
|
|
kusano |
2b45e8 |
newarg.n = args -> n;
|
|
kusano |
2b45e8 |
newarg.k = args -> k;
|
|
kusano |
2b45e8 |
newarg.a = args -> a;
|
|
kusano |
2b45e8 |
newarg.b = args -> b;
|
|
kusano |
2b45e8 |
newarg.c = args -> c;
|
|
kusano |
2b45e8 |
newarg.lda = args -> lda;
|
|
kusano |
2b45e8 |
newarg.ldb = args -> ldb;
|
|
kusano |
2b45e8 |
newarg.ldc = args -> ldc;
|
|
kusano |
2b45e8 |
newarg.alpha = args -> alpha;
|
|
kusano |
2b45e8 |
newarg.beta = args -> beta;
|
|
kusano |
2b45e8 |
newarg.common = (void *)job;
|
|
kusano |
2b45e8 |
|
|
kusano |
2b45e8 |
if (!range_n) {
|
|
kusano |
2b45e8 |
n_from = 0;
|
|
kusano |
2b45e8 |
n_to = args -> n;
|
|
kusano |
2b45e8 |
} else {
|
|
kusano |
2b45e8 |
n_from = range_n[0];
|
|
kusano |
2b45e8 |
n_to = range_n[1] - range_n[0];
|
|
kusano |
2b45e8 |
}
|
|
kusano |
2b45e8 |
|
|
kusano |
2b45e8 |
#ifndef LOWER
|
|
kusano |
2b45e8 |
|
|
kusano |
2b45e8 |
range[MAX_CPU_NUMBER] = n_to - n_from;
|
|
kusano |
2b45e8 |
range[0] = 0;
|
|
kusano |
2b45e8 |
num_cpu = 0;
|
|
kusano |
2b45e8 |
i = 0;
|
|
kusano |
2b45e8 |
n = n_to - n_from;
|
|
kusano |
2b45e8 |
|
|
kusano |
2b45e8 |
dnum = (double)n * (double)n /(double)nthreads;
|
|
kusano |
2b45e8 |
|
|
kusano |
2b45e8 |
while (i < n){
|
|
kusano |
2b45e8 |
|
|
kusano |
2b45e8 |
if (nthreads - num_cpu > 1) {
|
|
kusano |
2b45e8 |
|
|
kusano |
2b45e8 |
double di = (double)i;
|
|
kusano |
2b45e8 |
|
|
kusano |
2b45e8 |
width = (((BLASLONG)(sqrt(di * di + dnum) - di) + mask) & ~mask);
|
|
kusano |
2b45e8 |
|
|
kusano |
2b45e8 |
if (num_cpu == 0) width = n - ((n - width) & ~mask);
|
|
kusano |
2b45e8 |
|
|
kusano |
2b45e8 |
if ((width > n - i) || (width < mask)) width = n - i;
|
|
kusano |
2b45e8 |
|
|
kusano |
2b45e8 |
} else {
|
|
kusano |
2b45e8 |
width = n - i;
|
|
kusano |
2b45e8 |
}
|
|
kusano |
2b45e8 |
|
|
kusano |
2b45e8 |
range[MAX_CPU_NUMBER - num_cpu - 1] = range[MAX_CPU_NUMBER - num_cpu] - width;
|
|
kusano |
2b45e8 |
|
|
kusano |
2b45e8 |
queue[num_cpu].mode = mode;
|
|
kusano |
2b45e8 |
queue[num_cpu].routine = inner_thread;
|
|
kusano |
2b45e8 |
queue[num_cpu].args = &newarg;
|
|
kusano |
2b45e8 |
queue[num_cpu].range_m = range_m;
|
|
kusano |
2b45e8 |
|
|
kusano |
2b45e8 |
queue[num_cpu].sa = NULL;
|
|
kusano |
2b45e8 |
queue[num_cpu].sb = NULL;
|
|
kusano |
2b45e8 |
queue[num_cpu].next = &queue[num_cpu + 1];
|
|
kusano |
2b45e8 |
|
|
kusano |
2b45e8 |
num_cpu ++;
|
|
kusano |
2b45e8 |
i += width;
|
|
kusano |
2b45e8 |
}
|
|
kusano |
2b45e8 |
|
|
kusano |
2b45e8 |
for (i = 0; i < num_cpu; i ++) queue[i].range_n = &range[MAX_CPU_NUMBER - num_cpu];
|
|
kusano |
2b45e8 |
|
|
kusano |
2b45e8 |
#else
|
|
kusano |
2b45e8 |
|
|
kusano |
2b45e8 |
range[0] = 0;
|
|
kusano |
2b45e8 |
num_cpu = 0;
|
|
kusano |
2b45e8 |
i = 0;
|
|
kusano |
2b45e8 |
n = n_to - n_from;
|
|
kusano |
2b45e8 |
|
|
kusano |
2b45e8 |
dnum = (double)n * (double)n /(double)nthreads;
|
|
kusano |
2b45e8 |
|
|
kusano |
2b45e8 |
while (i < n){
|
|
kusano |
2b45e8 |
|
|
kusano |
2b45e8 |
if (nthreads - num_cpu > 1) {
|
|
kusano |
2b45e8 |
|
|
kusano |
2b45e8 |
double di = (double)i;
|
|
kusano |
2b45e8 |
|
|
kusano |
2b45e8 |
width = (((BLASLONG)(sqrt(di * di + dnum) - di) + mask) & ~mask);
|
|
kusano |
2b45e8 |
|
|
kusano |
2b45e8 |
if ((width > n - i) || (width < mask)) width = n - i;
|
|
kusano |
2b45e8 |
|
|
kusano |
2b45e8 |
} else {
|
|
kusano |
2b45e8 |
width = n - i;
|
|
kusano |
2b45e8 |
}
|
|
kusano |
2b45e8 |
|
|
kusano |
2b45e8 |
range[num_cpu + 1] = range[num_cpu] + width;
|
|
kusano |
2b45e8 |
|
|
kusano |
2b45e8 |
queue[num_cpu].mode = mode;
|
|
kusano |
2b45e8 |
queue[num_cpu].routine = inner_thread;
|
|
kusano |
2b45e8 |
queue[num_cpu].args = &newarg;
|
|
kusano |
2b45e8 |
queue[num_cpu].range_m = range_m;
|
|
kusano |
2b45e8 |
queue[num_cpu].range_n = range;
|
|
kusano |
2b45e8 |
queue[num_cpu].sa = NULL;
|
|
kusano |
2b45e8 |
queue[num_cpu].sb = NULL;
|
|
kusano |
2b45e8 |
queue[num_cpu].next = &queue[num_cpu + 1];
|
|
kusano |
2b45e8 |
|
|
kusano |
2b45e8 |
num_cpu ++;
|
|
kusano |
2b45e8 |
i += width;
|
|
kusano |
2b45e8 |
}
|
|
kusano |
2b45e8 |
|
|
kusano |
2b45e8 |
#endif
|
|
kusano |
2b45e8 |
|
|
kusano |
2b45e8 |
newarg.nthreads = num_cpu;
|
|
kusano |
2b45e8 |
|
|
kusano |
2b45e8 |
if (num_cpu) {
|
|
kusano |
2b45e8 |
|
|
kusano |
2b45e8 |
for (j = 0; j < num_cpu; j++) {
|
|
kusano |
2b45e8 |
for (i = 0; i < num_cpu; i++) {
|
|
kusano |
2b45e8 |
for (k = 0; k < DIVIDE_RATE; k++) {
|
|
kusano |
2b45e8 |
job[j].working[i][CACHE_LINE_SIZE * k] = 0;
|
|
kusano |
2b45e8 |
}
|
|
kusano |
2b45e8 |
}
|
|
kusano |
2b45e8 |
}
|
|
kusano |
2b45e8 |
|
|
kusano |
2b45e8 |
queue[0].sa = sa;
|
|
kusano |
2b45e8 |
queue[0].sb = sb;
|
|
kusano |
2b45e8 |
queue[num_cpu - 1].next = NULL;
|
|
kusano |
2b45e8 |
|
|
kusano |
2b45e8 |
exec_blas(num_cpu, queue);
|
|
kusano |
2b45e8 |
}
|
|
kusano |
2b45e8 |
|
|
kusano |
2b45e8 |
|
|
kusano |
2b45e8 |
return 0;
|
|
kusano |
2b45e8 |
}
|